Repository: SimulaVR/godot-haskell Branch: master Commit: cabc06451292 Files: 788 Total size: 11.0 MB Directory structure: gitextract_kt3cl1ny/ ├── .gitignore ├── .gitmodules ├── .hlint.yaml ├── .travis.yml ├── .vscode/ │ └── tasks.json ├── LICENSE ├── README.md ├── Setup.hs ├── cbits/ │ └── util.h ├── classgen/ │ ├── README.md │ ├── app-classgen/ │ │ └── Main.hs │ ├── default.nix │ ├── godot-haskell-classgen.cabal │ ├── package.yaml │ ├── release.nix │ ├── src-classgen/ │ │ └── Classgen/ │ │ ├── Docs.hs │ │ ├── Module.hs │ │ ├── Spec.hs │ │ └── Utils.hs │ └── stack.yaml ├── default.nix ├── examples/ │ ├── dodge-the-creeps/ │ │ ├── .gitignore │ │ ├── ChangeLog.md │ │ ├── LICENSE │ │ ├── Makefile │ │ ├── README.md │ │ ├── Support.hs │ │ ├── ffi/ │ │ │ ├── cbits/ │ │ │ │ └── flib.c │ │ │ └── flib/ │ │ │ └── FLib.hs │ │ ├── game/ │ │ │ ├── HUD.gdns │ │ │ ├── HUD.tres │ │ │ ├── HUD.tscn │ │ │ ├── Main.gdns │ │ │ ├── Main.tscn │ │ │ ├── Mob.gdns │ │ │ ├── Mob.tscn │ │ │ ├── Player.gdns │ │ │ ├── Player.tscn │ │ │ ├── dodge_assets/ │ │ │ │ ├── art/ │ │ │ │ │ └── House In a Forest Loop.ogg │ │ │ │ └── fonts/ │ │ │ │ ├── FONTLOG.txt │ │ │ │ └── LICENSE.txt │ │ │ ├── lib/ │ │ │ │ └── libmyproject.gdnlib │ │ │ └── project.godot │ │ ├── godot-haskell.nix │ │ ├── hie.yaml │ │ ├── myproject.cabal │ │ ├── package.yaml │ │ ├── pinned-nixpkgs.nix │ │ ├── shell.nix │ │ ├── src/ │ │ │ ├── Game/ │ │ │ │ ├── HUD.hs │ │ │ │ ├── Main.hs │ │ │ │ ├── Mob.hs │ │ │ │ └── Player.hs │ │ │ ├── Lib.hs │ │ │ └── Project/ │ │ │ ├── Requirements.hs │ │ │ ├── Scenes/ │ │ │ │ ├── HUD.hs │ │ │ │ ├── Main.hs │ │ │ │ ├── Mob.hs │ │ │ │ └── Player.hs │ │ │ ├── Scenes.hs │ │ │ └── Support.hs │ │ ├── stack-shell.nix │ │ └── stack.yaml │ ├── rss-reader/ │ │ ├── .gitignore │ │ ├── ChangeLog.md │ │ ├── LICENSE │ │ ├── Makefile │ │ ├── README.md │ │ ├── Support.hs │ │ ├── ffi/ │ │ │ ├── cbits/ │ │ │ │ └── flib.c │ │ │ └── flib/ │ │ │ └── FLib.hs │ │ ├── game/ │ │ │ ├── Rss_reader.gdns │ │ │ ├── Rss_reader.tscn │ │ │ ├── export_presets.cfg │ │ │ ├── lib/ │ │ │ │ └── libmyproject.gdnlib │ │ │ └── project.godot │ │ ├── godot-haskell.nix │ │ ├── hie.yaml │ │ ├── myproject.cabal │ │ ├── package.yaml │ │ ├── pinned-nixpkgs.nix │ │ ├── shell.nix │ │ ├── src/ │ │ │ ├── Game/ │ │ │ │ ├── RSSReader.hs │ │ │ │ └── q │ │ │ ├── Lib.hs │ │ │ └── Project/ │ │ │ ├── Requirements.hs │ │ │ ├── Scenes/ │ │ │ │ └── Rss_reader.hs │ │ │ ├── Scenes.hs │ │ │ └── Support.hs │ │ ├── stack-shell.nix │ │ └── stack.yaml │ └── top-down-ten-minutes/ │ ├── .gitignore │ ├── ChangeLog.md │ ├── LICENSE │ ├── Makefile │ ├── README.md │ ├── ffi/ │ │ ├── cbits/ │ │ │ └── flib.c │ │ └── flib/ │ │ └── FLib.hs │ ├── game/ │ │ ├── Bullet.gdns │ │ ├── Bullet.tscn │ │ ├── Enemy.gdns │ │ ├── Enemy.tscn │ │ ├── Explosion.tscn │ │ ├── Player.gdns │ │ ├── lib/ │ │ │ └── libtop-down-ten-minutes.gdnlib │ │ ├── project.godot │ │ ├── wall.tres │ │ └── world.tscn │ ├── godot-haskell.nix │ ├── hie.yaml │ ├── package.yaml │ ├── pinned-nixpkgs.nix │ ├── shell.nix │ ├── src/ │ │ ├── Game/ │ │ │ └── World.hs │ │ ├── Lib.hs │ │ └── Project/ │ │ ├── Requirements.hs │ │ ├── Scenes/ │ │ │ ├── Bullet.hs │ │ │ ├── Enemy.hs │ │ │ ├── Explosion.hs │ │ │ └── World.hs │ │ ├── Scenes.hs │ │ └── Support.hs │ ├── stack-shell.nix │ ├── stack.yaml │ └── top-down-ten-minutes.cabal ├── godot-haskell.cabal ├── hie.yaml ├── nix/ │ ├── pinned/ │ │ ├── all-hies.json │ │ ├── default.nix │ │ ├── hie.nix │ │ └── nixpkgs.json │ └── spacemacs-hie.nix ├── nixpkgs-version.json ├── package.yaml ├── pinned-nixpkgs.nix ├── project-generator/ │ └── Main.hs ├── release.nix ├── shell-spacemacs-hie.nix ├── shell.nix ├── src/ │ ├── Godot/ │ │ ├── Api/ │ │ │ └── Types.hs │ │ ├── Api.hs │ │ ├── Core/ │ │ │ ├── ARVRAnchor.hs │ │ │ ├── ARVRCamera.hs │ │ │ ├── ARVRController.hs │ │ │ ├── ARVRInterface.hs │ │ │ ├── ARVRInterfaceGDNative.hs │ │ │ ├── ARVROrigin.hs │ │ │ ├── ARVRPositionalTracker.hs │ │ │ ├── ARVRServer.hs │ │ │ ├── AStar.hs │ │ │ ├── AStar2D.hs │ │ │ ├── AcceptDialog.hs │ │ │ ├── AnimatedSprite.hs │ │ │ ├── AnimatedSprite3D.hs │ │ │ ├── AnimatedTexture.hs │ │ │ ├── Animation.hs │ │ │ ├── AnimationNode.hs │ │ │ ├── AnimationNodeAdd2.hs │ │ │ ├── AnimationNodeAdd3.hs │ │ │ ├── AnimationNodeAnimation.hs │ │ │ ├── AnimationNodeBlend2.hs │ │ │ ├── AnimationNodeBlend3.hs │ │ │ ├── AnimationNodeBlendSpace1D.hs │ │ │ ├── AnimationNodeBlendSpace2D.hs │ │ │ ├── AnimationNodeBlendTree.hs │ │ │ ├── AnimationNodeOneShot.hs │ │ │ ├── AnimationNodeOutput.hs │ │ │ ├── AnimationNodeStateMachine.hs │ │ │ ├── AnimationNodeStateMachinePlayback.hs │ │ │ ├── AnimationNodeStateMachineTransition.hs │ │ │ ├── AnimationNodeTimeScale.hs │ │ │ ├── AnimationNodeTimeSeek.hs │ │ │ ├── AnimationNodeTransition.hs │ │ │ ├── AnimationPlayer.hs │ │ │ ├── AnimationRootNode.hs │ │ │ ├── AnimationTree.hs │ │ │ ├── AnimationTreePlayer.hs │ │ │ ├── Area.hs │ │ │ ├── Area2D.hs │ │ │ ├── ArrayMesh.hs │ │ │ ├── AtlasTexture.hs │ │ │ ├── AudioBusLayout.hs │ │ │ ├── AudioEffect.hs │ │ │ ├── AudioEffectAmplify.hs │ │ │ ├── AudioEffectBandLimitFilter.hs │ │ │ ├── AudioEffectBandPassFilter.hs │ │ │ ├── AudioEffectChorus.hs │ │ │ ├── AudioEffectCompressor.hs │ │ │ ├── AudioEffectDelay.hs │ │ │ ├── AudioEffectDistortion.hs │ │ │ ├── AudioEffectEQ.hs │ │ │ ├── AudioEffectEQ10.hs │ │ │ ├── AudioEffectEQ21.hs │ │ │ ├── AudioEffectEQ6.hs │ │ │ ├── AudioEffectFilter.hs │ │ │ ├── AudioEffectHighPassFilter.hs │ │ │ ├── AudioEffectHighShelfFilter.hs │ │ │ ├── AudioEffectInstance.hs │ │ │ ├── AudioEffectLimiter.hs │ │ │ ├── AudioEffectLowPassFilter.hs │ │ │ ├── AudioEffectLowShelfFilter.hs │ │ │ ├── AudioEffectNotchFilter.hs │ │ │ ├── AudioEffectPanner.hs │ │ │ ├── AudioEffectPhaser.hs │ │ │ ├── AudioEffectPitchShift.hs │ │ │ ├── AudioEffectRecord.hs │ │ │ ├── AudioEffectReverb.hs │ │ │ ├── AudioEffectSpectrumAnalyzer.hs │ │ │ ├── AudioEffectSpectrumAnalyzerInstance.hs │ │ │ ├── AudioEffectStereoEnhance.hs │ │ │ ├── AudioServer.hs │ │ │ ├── AudioStream.hs │ │ │ ├── AudioStreamGenerator.hs │ │ │ ├── AudioStreamGeneratorPlayback.hs │ │ │ ├── AudioStreamMicrophone.hs │ │ │ ├── AudioStreamOGGVorbis.hs │ │ │ ├── AudioStreamPlayback.hs │ │ │ ├── AudioStreamPlaybackResampled.hs │ │ │ ├── AudioStreamPlayer.hs │ │ │ ├── AudioStreamPlayer2D.hs │ │ │ ├── AudioStreamPlayer3D.hs │ │ │ ├── AudioStreamRandomPitch.hs │ │ │ ├── AudioStreamSample.hs │ │ │ ├── BackBufferCopy.hs │ │ │ ├── BakedLightmap.hs │ │ │ ├── BakedLightmapData.hs │ │ │ ├── BaseButton.hs │ │ │ ├── BitMap.hs │ │ │ ├── BitmapFont.hs │ │ │ ├── Bone2D.hs │ │ │ ├── BoneAttachment.hs │ │ │ ├── BoxContainer.hs │ │ │ ├── BoxShape.hs │ │ │ ├── BulletPhysicsDirectBodyState.hs │ │ │ ├── BulletPhysicsServer.hs │ │ │ ├── Button.hs │ │ │ ├── ButtonGroup.hs │ │ │ ├── CPUParticles.hs │ │ │ ├── CPUParticles2D.hs │ │ │ ├── CSGBox.hs │ │ │ ├── CSGCombiner.hs │ │ │ ├── CSGCylinder.hs │ │ │ ├── CSGMesh.hs │ │ │ ├── CSGPolygon.hs │ │ │ ├── CSGPrimitive.hs │ │ │ ├── CSGShape.hs │ │ │ ├── CSGSphere.hs │ │ │ ├── CSGTorus.hs │ │ │ ├── Camera.hs │ │ │ ├── Camera2D.hs │ │ │ ├── CameraFeed.hs │ │ │ ├── CameraServer.hs │ │ │ ├── CameraTexture.hs │ │ │ ├── CanvasItem.hs │ │ │ ├── CanvasItemMaterial.hs │ │ │ ├── CanvasLayer.hs │ │ │ ├── CanvasModulate.hs │ │ │ ├── CapsuleMesh.hs │ │ │ ├── CapsuleShape.hs │ │ │ ├── CapsuleShape2D.hs │ │ │ ├── CenterContainer.hs │ │ │ ├── CharFXTransform.hs │ │ │ ├── CheckBox.hs │ │ │ ├── CheckButton.hs │ │ │ ├── CircleShape2D.hs │ │ │ ├── ClassDB.hs │ │ │ ├── ClippedCamera.hs │ │ │ ├── CollisionObject.hs │ │ │ ├── CollisionObject2D.hs │ │ │ ├── CollisionPolygon.hs │ │ │ ├── CollisionPolygon2D.hs │ │ │ ├── CollisionShape.hs │ │ │ ├── CollisionShape2D.hs │ │ │ ├── ColorPicker.hs │ │ │ ├── ColorPickerButton.hs │ │ │ ├── ColorRect.hs │ │ │ ├── ConcavePolygonShape.hs │ │ │ ├── ConcavePolygonShape2D.hs │ │ │ ├── ConeTwistJoint.hs │ │ │ ├── ConfigFile.hs │ │ │ ├── ConfirmationDialog.hs │ │ │ ├── Container.hs │ │ │ ├── Control.hs │ │ │ ├── ConvexPolygonShape.hs │ │ │ ├── ConvexPolygonShape2D.hs │ │ │ ├── Crypto.hs │ │ │ ├── CryptoKey.hs │ │ │ ├── CubeMap.hs │ │ │ ├── CubeMesh.hs │ │ │ ├── Curve.hs │ │ │ ├── Curve2D.hs │ │ │ ├── Curve3D.hs │ │ │ ├── CurveTexture.hs │ │ │ ├── CylinderMesh.hs │ │ │ ├── CylinderShape.hs │ │ │ ├── DampedSpringJoint2D.hs │ │ │ ├── DirectionalLight.hs │ │ │ ├── Directory.hs │ │ │ ├── DynamicFont.hs │ │ │ ├── DynamicFontData.hs │ │ │ ├── EncodedObjectAsID.hs │ │ │ ├── Engine.hs │ │ │ ├── Environment.hs │ │ │ ├── Expression.hs │ │ │ ├── File.hs │ │ │ ├── FileDialog.hs │ │ │ ├── Font.hs │ │ │ ├── FuncRef.hs │ │ │ ├── GDNative.hs │ │ │ ├── GDNativeLibrary.hs │ │ │ ├── GDScript.hs │ │ │ ├── GDScriptFunctionState.hs │ │ │ ├── GIProbe.hs │ │ │ ├── GIProbeData.hs │ │ │ ├── Generic6DOFJoint.hs │ │ │ ├── Geometry.hs │ │ │ ├── GeometryInstance.hs │ │ │ ├── GlobalConstants.hs │ │ │ ├── Gradient.hs │ │ │ ├── GradientTexture.hs │ │ │ ├── GraphEdit.hs │ │ │ ├── GraphNode.hs │ │ │ ├── GridContainer.hs │ │ │ ├── GridMap.hs │ │ │ ├── GrooveJoint2D.hs │ │ │ ├── HBoxContainer.hs │ │ │ ├── HScrollBar.hs │ │ │ ├── HSeparator.hs │ │ │ ├── HSlider.hs │ │ │ ├── HSplitContainer.hs │ │ │ ├── HTTPClient.hs │ │ │ ├── HTTPRequest.hs │ │ │ ├── HashingContext.hs │ │ │ ├── HeightMapShape.hs │ │ │ ├── HingeJoint.hs │ │ │ ├── IP.hs │ │ │ ├── IP_Unix.hs │ │ │ ├── Image.hs │ │ │ ├── ImageTexture.hs │ │ │ ├── ImmediateGeometry.hs │ │ │ ├── Input.hs │ │ │ ├── InputDefault.hs │ │ │ ├── InputEvent.hs │ │ │ ├── InputEventAction.hs │ │ │ ├── InputEventGesture.hs │ │ │ ├── InputEventJoypadButton.hs │ │ │ ├── InputEventJoypadMotion.hs │ │ │ ├── InputEventKey.hs │ │ │ ├── InputEventMIDI.hs │ │ │ ├── InputEventMagnifyGesture.hs │ │ │ ├── InputEventMouse.hs │ │ │ ├── InputEventMouseButton.hs │ │ │ ├── InputEventMouseMotion.hs │ │ │ ├── InputEventPanGesture.hs │ │ │ ├── InputEventScreenDrag.hs │ │ │ ├── InputEventScreenTouch.hs │ │ │ ├── InputEventWithModifiers.hs │ │ │ ├── InputMap.hs │ │ │ ├── InstancePlaceholder.hs │ │ │ ├── InterpolatedCamera.hs │ │ │ ├── ItemList.hs │ │ │ ├── JSON.hs │ │ │ ├── JSONParseResult.hs │ │ │ ├── JSONRPC.hs │ │ │ ├── JavaClass.hs │ │ │ ├── JavaClassWrapper.hs │ │ │ ├── JavaScript.hs │ │ │ ├── Joint.hs │ │ │ ├── Joint2D.hs │ │ │ ├── KinematicBody.hs │ │ │ ├── KinematicBody2D.hs │ │ │ ├── KinematicCollision.hs │ │ │ ├── KinematicCollision2D.hs │ │ │ ├── Label.hs │ │ │ ├── LargeTexture.hs │ │ │ ├── Light.hs │ │ │ ├── Light2D.hs │ │ │ ├── LightOccluder2D.hs │ │ │ ├── Line2D.hs │ │ │ ├── LineEdit.hs │ │ │ ├── LineShape2D.hs │ │ │ ├── LinkButton.hs │ │ │ ├── Listener.hs │ │ │ ├── MainLoop.hs │ │ │ ├── MarginContainer.hs │ │ │ ├── Marshalls.hs │ │ │ ├── Material.hs │ │ │ ├── MenuButton.hs │ │ │ ├── Mesh.hs │ │ │ ├── MeshDataTool.hs │ │ │ ├── MeshInstance.hs │ │ │ ├── MeshInstance2D.hs │ │ │ ├── MeshLibrary.hs │ │ │ ├── MeshTexture.hs │ │ │ ├── MobileVRInterface.hs │ │ │ ├── MultiMesh.hs │ │ │ ├── MultiMeshInstance.hs │ │ │ ├── MultiMeshInstance2D.hs │ │ │ ├── MultiplayerAPI.hs │ │ │ ├── MultiplayerPeerGDNative.hs │ │ │ ├── Mutex.hs │ │ │ ├── NativeScript.hs │ │ │ ├── Navigation.hs │ │ │ ├── Navigation2D.hs │ │ │ ├── NavigationMesh.hs │ │ │ ├── NavigationMeshInstance.hs │ │ │ ├── NavigationPolygon.hs │ │ │ ├── NavigationPolygonInstance.hs │ │ │ ├── NetworkedMultiplayerENet.hs │ │ │ ├── NetworkedMultiplayerPeer.hs │ │ │ ├── NinePatchRect.hs │ │ │ ├── Node.hs │ │ │ ├── Node2D.hs │ │ │ ├── NoiseTexture.hs │ │ │ ├── OS.hs │ │ │ ├── Object.hs │ │ │ ├── OccluderPolygon2D.hs │ │ │ ├── OmniLight.hs │ │ │ ├── OpenSimplexNoise.hs │ │ │ ├── OptionButton.hs │ │ │ ├── PCKPacker.hs │ │ │ ├── PHashTranslation.hs │ │ │ ├── PackedDataContainer.hs │ │ │ ├── PackedDataContainerRef.hs │ │ │ ├── PackedScene.hs │ │ │ ├── PacketPeer.hs │ │ │ ├── PacketPeerGDNative.hs │ │ │ ├── PacketPeerStream.hs │ │ │ ├── PacketPeerUDP.hs │ │ │ ├── Panel.hs │ │ │ ├── PanelContainer.hs │ │ │ ├── PanoramaSky.hs │ │ │ ├── ParallaxBackground.hs │ │ │ ├── ParallaxLayer.hs │ │ │ ├── Particles.hs │ │ │ ├── Particles2D.hs │ │ │ ├── ParticlesMaterial.hs │ │ │ ├── Path.hs │ │ │ ├── Path2D.hs │ │ │ ├── PathFollow.hs │ │ │ ├── PathFollow2D.hs │ │ │ ├── Performance.hs │ │ │ ├── PhysicalBone.hs │ │ │ ├── Physics2DDirectBodyState.hs │ │ │ ├── Physics2DDirectBodyStateSW.hs │ │ │ ├── Physics2DDirectSpaceState.hs │ │ │ ├── Physics2DServer.hs │ │ │ ├── Physics2DServerSW.hs │ │ │ ├── Physics2DShapeQueryParameters.hs │ │ │ ├── Physics2DShapeQueryResult.hs │ │ │ ├── Physics2DTestMotionResult.hs │ │ │ ├── PhysicsBody.hs │ │ │ ├── PhysicsBody2D.hs │ │ │ ├── PhysicsDirectBodyState.hs │ │ │ ├── PhysicsDirectSpaceState.hs │ │ │ ├── PhysicsMaterial.hs │ │ │ ├── PhysicsServer.hs │ │ │ ├── PhysicsShapeQueryParameters.hs │ │ │ ├── PhysicsShapeQueryResult.hs │ │ │ ├── PinJoint.hs │ │ │ ├── PinJoint2D.hs │ │ │ ├── PlaneMesh.hs │ │ │ ├── PlaneShape.hs │ │ │ ├── PluginScript.hs │ │ │ ├── PointMesh.hs │ │ │ ├── Polygon2D.hs │ │ │ ├── PolygonPathFinder.hs │ │ │ ├── Popup.hs │ │ │ ├── PopupDialog.hs │ │ │ ├── PopupMenu.hs │ │ │ ├── PopupPanel.hs │ │ │ ├── Position2D.hs │ │ │ ├── Position3D.hs │ │ │ ├── PrimitiveMesh.hs │ │ │ ├── PrismMesh.hs │ │ │ ├── ProceduralSky.hs │ │ │ ├── ProgressBar.hs │ │ │ ├── ProjectSettings.hs │ │ │ ├── ProximityGroup.hs │ │ │ ├── ProxyTexture.hs │ │ │ ├── QuadMesh.hs │ │ │ ├── RandomNumberGenerator.hs │ │ │ ├── Range.hs │ │ │ ├── RayCast.hs │ │ │ ├── RayCast2D.hs │ │ │ ├── RayShape.hs │ │ │ ├── RayShape2D.hs │ │ │ ├── RectangleShape2D.hs │ │ │ ├── Reference.hs │ │ │ ├── ReferenceRect.hs │ │ │ ├── ReflectionProbe.hs │ │ │ ├── RegEx.hs │ │ │ ├── RegExMatch.hs │ │ │ ├── RemoteTransform.hs │ │ │ ├── RemoteTransform2D.hs │ │ │ ├── Resource.hs │ │ │ ├── ResourceFormatLoader.hs │ │ │ ├── ResourceFormatLoaderCrypto.hs │ │ │ ├── ResourceFormatSaver.hs │ │ │ ├── ResourceFormatSaverCrypto.hs │ │ │ ├── ResourceImporter.hs │ │ │ ├── ResourceInteractiveLoader.hs │ │ │ ├── ResourceLoader.hs │ │ │ ├── ResourcePreloader.hs │ │ │ ├── ResourceSaver.hs │ │ │ ├── RichTextEffect.hs │ │ │ ├── RichTextLabel.hs │ │ │ ├── RigidBody.hs │ │ │ ├── RigidBody2D.hs │ │ │ ├── RootMotionView.hs │ │ │ ├── SceneState.hs │ │ │ ├── SceneTree.hs │ │ │ ├── SceneTreeTimer.hs │ │ │ ├── Script.hs │ │ │ ├── ScrollBar.hs │ │ │ ├── ScrollContainer.hs │ │ │ ├── SegmentShape2D.hs │ │ │ ├── Semaphore.hs │ │ │ ├── Separator.hs │ │ │ ├── Shader.hs │ │ │ ├── ShaderMaterial.hs │ │ │ ├── Shape.hs │ │ │ ├── Shape2D.hs │ │ │ ├── ShortCut.hs │ │ │ ├── Skeleton.hs │ │ │ ├── Skeleton2D.hs │ │ │ ├── SkeletonIK.hs │ │ │ ├── Skin.hs │ │ │ ├── SkinReference.hs │ │ │ ├── Sky.hs │ │ │ ├── Slider.hs │ │ │ ├── SliderJoint.hs │ │ │ ├── SoftBody.hs │ │ │ ├── Spatial.hs │ │ │ ├── SpatialGizmo.hs │ │ │ ├── SpatialMaterial.hs │ │ │ ├── SpatialVelocityTracker.hs │ │ │ ├── SphereMesh.hs │ │ │ ├── SphereShape.hs │ │ │ ├── SpinBox.hs │ │ │ ├── SplitContainer.hs │ │ │ ├── SpotLight.hs │ │ │ ├── SpringArm.hs │ │ │ ├── Sprite.hs │ │ │ ├── Sprite3D.hs │ │ │ ├── SpriteBase3D.hs │ │ │ ├── SpriteFrames.hs │ │ │ ├── StaticBody.hs │ │ │ ├── StaticBody2D.hs │ │ │ ├── StreamPeer.hs │ │ │ ├── StreamPeerBuffer.hs │ │ │ ├── StreamPeerGDNative.hs │ │ │ ├── StreamPeerSSL.hs │ │ │ ├── StreamPeerTCP.hs │ │ │ ├── StreamTexture.hs │ │ │ ├── StyleBox.hs │ │ │ ├── StyleBoxEmpty.hs │ │ │ ├── StyleBoxFlat.hs │ │ │ ├── StyleBoxLine.hs │ │ │ ├── StyleBoxTexture.hs │ │ │ ├── SurfaceTool.hs │ │ │ ├── TCP_Server.hs │ │ │ ├── TabContainer.hs │ │ │ ├── Tabs.hs │ │ │ ├── TextEdit.hs │ │ │ ├── TextFile.hs │ │ │ ├── Texture.hs │ │ │ ├── Texture3D.hs │ │ │ ├── TextureArray.hs │ │ │ ├── TextureButton.hs │ │ │ ├── TextureLayered.hs │ │ │ ├── TextureProgress.hs │ │ │ ├── TextureRect.hs │ │ │ ├── Theme.hs │ │ │ ├── Thread.hs │ │ │ ├── TileMap.hs │ │ │ ├── TileSet.hs │ │ │ ├── Timer.hs │ │ │ ├── ToolButton.hs │ │ │ ├── TouchScreenButton.hs │ │ │ ├── Translation.hs │ │ │ ├── TranslationServer.hs │ │ │ ├── Tree.hs │ │ │ ├── TreeItem.hs │ │ │ ├── TriangleMesh.hs │ │ │ ├── Tween.hs │ │ │ ├── UPNP.hs │ │ │ ├── UPNPDevice.hs │ │ │ ├── UndoRedo.hs │ │ │ ├── VBoxContainer.hs │ │ │ ├── VScrollBar.hs │ │ │ ├── VSeparator.hs │ │ │ ├── VSlider.hs │ │ │ ├── VSplitContainer.hs │ │ │ ├── VehicleBody.hs │ │ │ ├── VehicleWheel.hs │ │ │ ├── VideoPlayer.hs │ │ │ ├── VideoStream.hs │ │ │ ├── VideoStreamGDNative.hs │ │ │ ├── VideoStreamTheora.hs │ │ │ ├── VideoStreamWebm.hs │ │ │ ├── Viewport.hs │ │ │ ├── ViewportContainer.hs │ │ │ ├── ViewportTexture.hs │ │ │ ├── VisibilityEnabler.hs │ │ │ ├── VisibilityEnabler2D.hs │ │ │ ├── VisibilityNotifier.hs │ │ │ ├── VisibilityNotifier2D.hs │ │ │ ├── VisualInstance.hs │ │ │ ├── VisualScript.hs │ │ │ ├── VisualScriptBasicTypeConstant.hs │ │ │ ├── VisualScriptBuiltinFunc.hs │ │ │ ├── VisualScriptClassConstant.hs │ │ │ ├── VisualScriptComment.hs │ │ │ ├── VisualScriptComposeArray.hs │ │ │ ├── VisualScriptCondition.hs │ │ │ ├── VisualScriptConstant.hs │ │ │ ├── VisualScriptConstructor.hs │ │ │ ├── VisualScriptCustomNode.hs │ │ │ ├── VisualScriptDeconstruct.hs │ │ │ ├── VisualScriptEmitSignal.hs │ │ │ ├── VisualScriptEngineSingleton.hs │ │ │ ├── VisualScriptExpression.hs │ │ │ ├── VisualScriptFunction.hs │ │ │ ├── VisualScriptFunctionCall.hs │ │ │ ├── VisualScriptFunctionState.hs │ │ │ ├── VisualScriptGlobalConstant.hs │ │ │ ├── VisualScriptIndexGet.hs │ │ │ ├── VisualScriptIndexSet.hs │ │ │ ├── VisualScriptInputAction.hs │ │ │ ├── VisualScriptIterator.hs │ │ │ ├── VisualScriptLists.hs │ │ │ ├── VisualScriptLocalVar.hs │ │ │ ├── VisualScriptLocalVarSet.hs │ │ │ ├── VisualScriptMathConstant.hs │ │ │ ├── VisualScriptNode.hs │ │ │ ├── VisualScriptOperator.hs │ │ │ ├── VisualScriptPreload.hs │ │ │ ├── VisualScriptPropertyGet.hs │ │ │ ├── VisualScriptPropertySet.hs │ │ │ ├── VisualScriptResourcePath.hs │ │ │ ├── VisualScriptReturn.hs │ │ │ ├── VisualScriptSceneNode.hs │ │ │ ├── VisualScriptSceneTree.hs │ │ │ ├── VisualScriptSelect.hs │ │ │ ├── VisualScriptSelf.hs │ │ │ ├── VisualScriptSequence.hs │ │ │ ├── VisualScriptSubCall.hs │ │ │ ├── VisualScriptSwitch.hs │ │ │ ├── VisualScriptTypeCast.hs │ │ │ ├── VisualScriptVariableGet.hs │ │ │ ├── VisualScriptVariableSet.hs │ │ │ ├── VisualScriptWhile.hs │ │ │ ├── VisualScriptYield.hs │ │ │ ├── VisualScriptYieldSignal.hs │ │ │ ├── VisualServer.hs │ │ │ ├── VisualShader.hs │ │ │ ├── VisualShaderNode.hs │ │ │ ├── VisualShaderNodeBooleanConstant.hs │ │ │ ├── VisualShaderNodeBooleanUniform.hs │ │ │ ├── VisualShaderNodeColorConstant.hs │ │ │ ├── VisualShaderNodeColorFunc.hs │ │ │ ├── VisualShaderNodeColorOp.hs │ │ │ ├── VisualShaderNodeColorUniform.hs │ │ │ ├── VisualShaderNodeCompare.hs │ │ │ ├── VisualShaderNodeCubeMap.hs │ │ │ ├── VisualShaderNodeCubeMapUniform.hs │ │ │ ├── VisualShaderNodeCustom.hs │ │ │ ├── VisualShaderNodeDeterminant.hs │ │ │ ├── VisualShaderNodeDotProduct.hs │ │ │ ├── VisualShaderNodeExpression.hs │ │ │ ├── VisualShaderNodeFaceForward.hs │ │ │ ├── VisualShaderNodeFresnel.hs │ │ │ ├── VisualShaderNodeGlobalExpression.hs │ │ │ ├── VisualShaderNodeGroupBase.hs │ │ │ ├── VisualShaderNodeIf.hs │ │ │ ├── VisualShaderNodeInput.hs │ │ │ ├── VisualShaderNodeIs.hs │ │ │ ├── VisualShaderNodeOuterProduct.hs │ │ │ ├── VisualShaderNodeOutput.hs │ │ │ ├── VisualShaderNodeScalarClamp.hs │ │ │ ├── VisualShaderNodeScalarConstant.hs │ │ │ ├── VisualShaderNodeScalarDerivativeFunc.hs │ │ │ ├── VisualShaderNodeScalarFunc.hs │ │ │ ├── VisualShaderNodeScalarInterp.hs │ │ │ ├── VisualShaderNodeScalarOp.hs │ │ │ ├── VisualShaderNodeScalarSmoothStep.hs │ │ │ ├── VisualShaderNodeScalarSwitch.hs │ │ │ ├── VisualShaderNodeScalarUniform.hs │ │ │ ├── VisualShaderNodeSwitch.hs │ │ │ ├── VisualShaderNodeTexture.hs │ │ │ ├── VisualShaderNodeTextureUniform.hs │ │ │ ├── VisualShaderNodeTextureUniformTriplanar.hs │ │ │ ├── VisualShaderNodeTransformCompose.hs │ │ │ ├── VisualShaderNodeTransformConstant.hs │ │ │ ├── VisualShaderNodeTransformDecompose.hs │ │ │ ├── VisualShaderNodeTransformFunc.hs │ │ │ ├── VisualShaderNodeTransformMult.hs │ │ │ ├── VisualShaderNodeTransformUniform.hs │ │ │ ├── VisualShaderNodeTransformVecMult.hs │ │ │ ├── VisualShaderNodeUniform.hs │ │ │ ├── VisualShaderNodeVec3Constant.hs │ │ │ ├── VisualShaderNodeVec3Uniform.hs │ │ │ ├── VisualShaderNodeVectorClamp.hs │ │ │ ├── VisualShaderNodeVectorCompose.hs │ │ │ ├── VisualShaderNodeVectorDecompose.hs │ │ │ ├── VisualShaderNodeVectorDerivativeFunc.hs │ │ │ ├── VisualShaderNodeVectorDistance.hs │ │ │ ├── VisualShaderNodeVectorFunc.hs │ │ │ ├── VisualShaderNodeVectorInterp.hs │ │ │ ├── VisualShaderNodeVectorLen.hs │ │ │ ├── VisualShaderNodeVectorOp.hs │ │ │ ├── VisualShaderNodeVectorRefract.hs │ │ │ ├── VisualShaderNodeVectorScalarMix.hs │ │ │ ├── VisualShaderNodeVectorScalarSmoothStep.hs │ │ │ ├── VisualShaderNodeVectorScalarStep.hs │ │ │ ├── VisualShaderNodeVectorSmoothStep.hs │ │ │ ├── WeakRef.hs │ │ │ ├── WebRTCDataChannel.hs │ │ │ ├── WebRTCDataChannelGDNative.hs │ │ │ ├── WebRTCMultiplayer.hs │ │ │ ├── WebRTCPeerConnection.hs │ │ │ ├── WebRTCPeerConnectionGDNative.hs │ │ │ ├── WebSocketClient.hs │ │ │ ├── WebSocketMultiplayerPeer.hs │ │ │ ├── WebSocketPeer.hs │ │ │ ├── WebSocketServer.hs │ │ │ ├── WindowDialog.hs │ │ │ ├── World.hs │ │ │ ├── World2D.hs │ │ │ ├── WorldEnvironment.hs │ │ │ ├── X509Certificate.hs │ │ │ ├── XMLParser.hs │ │ │ └── YSort.hs │ │ ├── Gdnative/ │ │ │ ├── Internal/ │ │ │ │ ├── Api.hs │ │ │ │ ├── Gdnative.chs │ │ │ │ ├── TH.hs │ │ │ │ └── Types.hs │ │ │ └── Internal.hs │ │ ├── Gdnative.hs │ │ ├── Internal/ │ │ │ └── Dispatch.hs │ │ ├── Nativescript.hs │ │ └── Tools/ │ │ ├── AnimationTrackEditPlugin.hs │ │ ├── EditorExportPlugin.hs │ │ ├── EditorFeatureProfile.hs │ │ ├── EditorFileDialog.hs │ │ ├── EditorFileSystem.hs │ │ ├── EditorFileSystemDirectory.hs │ │ ├── EditorImportPlugin.hs │ │ ├── EditorInspector.hs │ │ ├── EditorInspectorPlugin.hs │ │ ├── EditorInterface.hs │ │ ├── EditorNavigationMeshGenerator.hs │ │ ├── EditorPlugin.hs │ │ ├── EditorProperty.hs │ │ ├── EditorResourceConversionPlugin.hs │ │ ├── EditorResourcePreview.hs │ │ ├── EditorResourcePreviewGenerator.hs │ │ ├── EditorSceneImporter.hs │ │ ├── EditorSceneImporterAssimp.hs │ │ ├── EditorScenePostImport.hs │ │ ├── EditorScript.hs │ │ ├── EditorSelection.hs │ │ ├── EditorSettings.hs │ │ ├── EditorSpatialGizmo.hs │ │ ├── EditorSpatialGizmoPlugin.hs │ │ ├── EditorSpinSlider.hs │ │ ├── EditorVCSInterface.hs │ │ ├── ScriptCreateDialog.hs │ │ ├── ScriptEditor.hs │ │ └── VisualScriptEditor.hs │ └── Godot.hs ├── src-generate/ │ ├── Generate.hs │ ├── Spec.hs │ ├── Types/ │ │ └── Internal.hs │ └── Types.hs ├── stack-shell.nix ├── stack.yaml ├── template/ │ ├── README.md │ ├── demo/ │ │ ├── Makefile │ │ ├── ffi/ │ │ │ └── cbits/ │ │ │ └── flib.c │ │ └── game/ │ │ ├── Main.gdns │ │ ├── lib/ │ │ │ └── libdemo.gdnlib │ │ └── project.godot │ ├── godot-haskell.hsfiles │ ├── mkdemo.sh │ └── update-template.sh └── update-nixpkgs.sh ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ dist* *.hi *.o .hsenv* cabal-dev/ .stack-work/ .cabal-sandbox cabal.sandbox.config .DS_Store *.dyn_o *.dyn_hi app/*.cpp src/**/*.cpp src/**/*.c *.so .ghc* #* .#* doc/build/ # osvr_server lighthousedb.json lhr-*/ # emacs TAG file TAGS ================================================ FILE: .gitmodules ================================================ [submodule "godot_headers"] path = godot_headers url = https://github.com/GodotNativeTools/godot_headers/ [submodule "haskell-src-exts-qq"] path = haskell-src-exts-qq url = https://github.com/KaneTW/haskell-src-exts-qq [submodule "haskell-src-exts-sc"] path = haskell-src-exts-sc url = https://github.com/achirkin/haskell-src-exts-sc ================================================ FILE: .hlint.yaml ================================================ - ignore: { name: "Use camelCase" } - ignore: { name: "Use newtype instead of data" } ================================================ FILE: .travis.yml ================================================ # https://docs.haskellstack.org/en/stable/travis_ci/ sudo: false dist: bionic language: generic addons: apt: update: true cache: directories: - $HOME/.stack - $TRAVIS_BUILD_DIR/.stack-work before_install: - mkdir -p ~/.local/bin - export PATH=$HOME/.local/bin:$PATH - travis_retry curl -L https://get.haskellstack.org/stable/linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack' install: - git submodule update --init --recursive - stack build - stack test ================================================ FILE: .vscode/tasks.json ================================================ { // Automatically created by phoityne-vscode extension. "version": "2.0.0", "presentation": { "reveal": "always", "panel": "new" }, "tasks": [ { // F7 "group": { "kind": "build", "isDefault": true }, "label": "haskell build", "type": "shell", //"command": "cabal configure && cabal build" "command": "stack build" }, { // F6 "group": "build", "type": "shell", "label": "haskell clean & build", //"command": "cabal clean && cabal configure && cabal build" "command": "stack clean && stack build" //"command": "stack clean ; stack build" // for powershell }, { // F8 "group": { "kind": "test", "isDefault": true }, "type": "shell", "label": "haskell test", //"command": "cabal test" "command": "stack test" }, { // F6 "isBackground": true, "type": "shell", "label": "haskell watch", "command": "stack build --test --no-run-tests --file-watch" } ] } ================================================ FILE: LICENSE ================================================ Copyright David Kraeutmann (c) 2018 All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of David Kraeutmann nor the names of other contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ================================================ FILE: README.md ================================================ # godot-haskell [![Build Status](https://travis-ci.org/SimulaVR/godot-haskell.svg?branch=master)](https://travis-ci.org/SimulaVR/godot-haskell) Haskell bindings for the Godot game engine. * Low-level (GDNative) in Godot.Gdnative * Nativescript (binding classes/methods/etc) in Godot.Nativescript * High-level (classes generated from the API ) in Godot.Api * Access methods through Godot.Core ## Getting started with the examples The easiest way to get started is to have a look at the demos included in the [examples](https://github.com/SimulaVR/godot-haskell/tree/master/examples) directory. First check out ["Dodge the Creeps!"](https://github.com/SimulaVR/godot-haskell/tree/master/examples/dodge-the-creeps), your first game from the [Godot documentation](https://docs.godotengine.org/en/3.1/getting_started/step_by_step/your_first_game.html). Following along with the documentation and the code should make everything understandable. To build: ```bash git clone --recursive https://github.com/SimulaVR/godot-haskell stack install godot-haskell:exe:godot-haskell-project-generator cd godot-haskell/examples/dodge-the-creeps make ``` To make changes to the game, in two different terminals: ```bash make stack-watch make project-watch ``` The first command will constantly build Haskell code and copy the shared library into the Godot project, demo. The second command will constantly scan the Godot project and build Haskell code out of it. Load up the game by importing `game/project.godot` into the editor, which you can do from the commandline with `godot game/project.godot`. To run the game in the editor press F5, stop it with F8. ### Understanding the examples There are two parts to every project. `examples/dodge-the-creeps/game` which is the Godot project and `examples/dodge-the-creeps/src` which are the Haskell sources. When you run `cd examples/dodge-the-creeps && make stack` to build the demo, it builds the project locally with `stack build` and then does a `cp` to copy the resulting shared library into the right place in `examples/dodge-the-creeps/game`. This way Godot will pick it up. If you just do a `stack build` without copying, your shared library will never update and Godot will run the old code. You must regenerate `examples/dodge-the-creeps/src/Project` any time you modify the Godot project. This directory contains the Godot project mirrored into Haskell, just like @Servant@ provides you with API safety by declaring APIs in Haskell. When you change the name of a node in Godot, this will update a Haskell class instance, which will lead to a type error in your project. You can do this with `stack exec godot-haskell-parse-game game src` which will watch your project for changes. ## Known issues & inconveniences * Script variables only appear in the editor when you reload it. * No type safety for call and call_deferred. * Every time you add a new node which needs a native script you need to manually select the library. It's tedious right now. This is the procedure for adding a new node backed by Haskell code: create the node, right click it, attach a script, select nativescript, the script will open in the editor, in the inspector find the Library subheading under NativeScript, click [empty], pick Load, the file picker will open, open lib, and select libmyproject.dnlib or whatever you've renamed the library to. That's it. Don't edit the empty file that's been opened. Now in Haskell, you can create a class with the same name as the Godot one and that inherits from the same type. See the demo. There is a ticket in Godot to automate this process :( ## Setting up your own project. It's best to start with one of the existing examples, make a copy, and rename the project. If you want to start another project use the stack template `template/godot-haskell.hsroots` Alternatively, fetch it directly from git: ```bash stack new myproject https://raw.githubusercontent.com/SimulaVR/godot-haskell/master/template/godot-haskell.hsfiles ``` ## Changing Godot versions You will need to regenerate the bindings if you switch Godot versions. At present, these are generated for the version that corresponds to the godot_headers submodule included here. This was 3.1 at the time of writing. To regenerate bindings: * Replace godot_headers with a version that corresponds to your install. Instructions are included there, but that generally means either checking out the corresponding files or rebuilding Godot. * Check out a copy of the godot repo and make sure you're on the commit corresponding to your version of godot. You don't need to build this, but you probably will anyway. We need it because documentation files are not included in the api.json file found in godot_headers. * Summarize the documentation xml files into a json file: ```bash # Prerequisite sudo apt-get install jq libcurl4-gnutls-dev # Or equivalent on you OS/Distro cabal install xml-to-json # Generate the JSON xml-to-json godot-install-directory/doc/classes/*.xml | jq -n '[inputs]' &> godot_doc_classes.json ``` * Build the bindings themselves: ```bash cd classgen stack build rm ../src/Godot/Core/* ../src/Godot/Tools/* stack exec godot-haskell-classgen -- ../godot_headers/api.json ../godot_doc_classes.json ../ ``` That's it! The rest of the bindings are fairly lightweight with few dependencies, so you shouldn't see much breakage in the rest of the package. If you want to get an idea of what the Haskell libraries are doing, set the environment variable `HS_GODOT_DEBUG`. ## Questions The primary method of contact is the SimulaVR [Discord server](https://discord.gg/V2NgzZt). Mirrors are available at [![Gitter](https://badges.gitter.im/SimulaVR/Simula.svg)](https://gitter.im/SimulaVR/Simula?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) and in the SimulaVR channel at Matrix. ## Docs Most of the API is documented but the lowest-level bindings, like GDNative functions don't have documentation. They are quite intuitive to use though. ================================================ FILE: Setup.hs ================================================ import Distribution.Simple main = defaultMain ================================================ FILE: cbits/util.h ================================================ #ifndef GODOT_HASKELL_UTIL_H__ #define GODOT_HASKELL_UTIL_H__ #include #endif /* GODOT_HASKELL_UTIL_H__ */ ================================================ FILE: classgen/README.md ================================================ Generate bindings to the Godot API. See the godot-haskell README.md for instructions on use ================================================ FILE: classgen/app-classgen/Main.hs ================================================ import Classgen.Module import Classgen.Spec import Control.Lens import Control.Monad.State import Data.Maybe (mapMaybe) import Data.Aeson import qualified Data.ByteString.Lazy as BL import qualified Data.HashMap.Strict as HM import Language.Haskell.Exts import Language.Haskell.Exts.SimpleComments import System.Directory import System.Environment import System.Exit import System.FilePath import Control.Applicative import qualified Classgen.Docs as D import qualified Data.HashMap.Strict as H import qualified Data.Text as T main :: IO () main = do args <- getArgs when (length args /= 3) $ do putStrLn "See the godot-haskell README.md for instructions" putStrLn "godot-haskell-classgen " exitFailure api <- BL.readFile (args !! 0) let decodeErr x = either error id (eitherDecode x) let (Just classes) = decodeErr api :: Maybe GodotClasses doc <- BL.readFile (args !! 1) let (Just docs) = decodeErr doc :: Maybe D.GodotDocs let godotHaskellRootDir = args !! 2 let docTable = D.toTable docs let state = execState (mapM_ (\cls -> addClass cls (H.lookup (cls ^. Classgen.Spec.name) docTable <|> (T.stripPrefix "Godot_" (cls ^. Classgen.Spec.name) >>= \r -> H.lookup r docTable) <|> (T.stripPrefix "Godot" (cls ^. Classgen.Spec.name) >>= \r -> H.lookup r docTable) <|> (T.stripPrefix "_" (cls ^. Classgen.Spec.name) >>= \r -> H.lookup r docTable) <|> (H.lookup ("_" <> (cls ^. Classgen.Spec.name)) docTable) ) classes) classes) (ClassgenState mempty mempty mempty) writeModule godotHaskellRootDir $ godotApiTypes (state ^. tyDecls) mapM_ (writeModule godotHaskellRootDir) (HM.elems (state ^. modules)) where godotApiTypes decls = Module Nothing (Just $ ModuleHead Nothing (ModuleName Nothing "Godot.Api.Types") Nothing $ Just (classExports decls)) [LanguagePragma Nothing [Ident Nothing "DerivingStrategies" ,Ident Nothing "GeneralizedNewtypeDeriving" ,Ident Nothing "TypeFamilies" ,Ident Nothing "TemplateHaskell"]] classImports (decls ++ mapMaybe fromNewtypeDerivingBase decls) classExports decls = ExportSpecList Nothing $ tcHasBaseClass : mapMaybe fromNewtypeOnly decls tcHasBaseClass = fmap (\_ -> Nothing) $ EThingWith () (EWildcard () 0) (UnQual () (Ident () "HasBaseClass")) [] fromNewtypeOnly decl = case decl of DataDecl _ (NewType _) _ (DHead _ (Ident Nothing ntName)) _ _ -> Just $ EThingWith Nothing (EWildcard Nothing 0) (UnQual Nothing (Ident Nothing ntName)) [] _ -> Nothing fromNewtypeDerivingBase decl = case decl of DataDecl _ (NewType _) _ (DHead _ (Ident Nothing ntName)) _ _ -> Just $ SpliceDecl Nothing (App Nothing (Var Nothing (UnQual Nothing (Ident Nothing "deriveBase"))) (TypQuote Nothing (UnQual Nothing (Ident Nothing ntName)))) _ -> Nothing classImports = map (\n -> ImportDecl Nothing (ModuleName Nothing n) False False False Nothing Nothing Nothing) [ "Data.Coerce", "Foreign.C", "Godot.Internal.Dispatch", "Godot.Gdnative.Internal"] writeModule :: FilePath -> Module (Maybe CodeComment) -> IO () writeModule godotHaskellRootDir mdl@(Module _ (Just (ModuleHead _ (ModuleName Nothing name) _ _)) _ _ _) = do let filepath = godotHaskellRootDir "src/" ++ map replaceDot name ++ ".hs" -- let out = prettyPrint mdl let out = uncurry exactPrint (ppWithComments mdl) createDirectoryIfMissing True (takeDirectory filepath) writeFile filepath out where replaceDot '.' = '/' replaceDot c = c ================================================ FILE: classgen/default.nix ================================================ { mkDerivation, aeson, base, bytestring, c2hs, casing, containers , directory, filepath, hpack , lens, mtl, template-haskell, text, unordered-containers , vector , stdenv, syb, callPackage, haskell, haskellPackages, fetchFromGitHub }: let haskell-src-exts-custom = haskell.lib.dontCheck (haskellPackages.callPackage ({ mkDerivation, array, base, containers, directory, filepath , ghc-prim, happy, mtl, pretty, pretty-show, smallcheck, stdenv , tasty, tasty-golden, tasty-smallcheck }: mkDerivation { pname = "haskell-src-exts"; version = "1.23.0"; sha256 = "09048bhv7ajfsnjlzaz445yb65n2pc4l3yn7nmmrnkdy1f0gn2cm"; libraryHaskellDepends = [ array base ghc-prim pretty ]; libraryToolDepends = [ happy ]; testHaskellDepends = [ base containers directory filepath mtl pretty-show smallcheck tasty tasty-golden tasty-smallcheck ]; doCheck = false; description = "Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer"; license = stdenv.lib.licenses.bsd3; hydraPlatforms = stdenv.lib.platforms.none; }) {}); haskell-src-exts-qq = haskellPackages.callPackage ( { mkDerivation, base, hspec, stdenv, syb, template-haskell }: mkDerivation { pname = "haskell-src-exts-qq"; version = "0.8"; src = fetchFromGitHub { owner = "KaneTW"; repo = "haskell-src-exts-qq"; rev = "a2d9071c9d6a627a253edfaaa64b6b67c9da3534"; sha256 = "1cvk90zi16m3nnz52gxim9b8sm17356jrp756y95is6ky13l2h60"; }; libraryHaskellDepends = [ base haskell-src-exts-custom haskell-src-meta-custom syb template-haskell ]; testHaskellDepends = [ base haskell-src-exts-custom hspec ]; description = "A quasiquoter for haskell-src-exts"; license = stdenv.lib.licenses.bsd3; }) { }; haskell-src-meta-custom = haskell.lib.dontCheck (haskellPackages.callPackage ({ mkDerivation, base, HUnit, pretty, stdenv, syb , template-haskell, test-framework, test-framework-hunit , th-orphans }: mkDerivation { pname = "haskell-src-meta"; version = "0.8.5"; sha256 = "1csqp3n7330rhia9msyw34z7qwwj64gdy5qlv8w4jbm49dap24ik"; revision = "1"; editedCabalFile = "00znr8mrlbyn0n1bw4c82rv82pq5ngkk7kw9cgk13pghf93hwwv7"; libraryHaskellDepends = [ base haskell-src-exts-custom pretty syb template-haskell th-orphans ]; description = "Parse source to template-haskell abstract syntax"; license = stdenv.lib.licenses.bsd3; }) {}); in mkDerivation { pname = "godot-haskell-classgen"; version = "0.1.0.0"; src = ./.; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ aeson base bytestring casing containers haskell-src-exts-qq lens mtl template-haskell text unordered-containers vector ]; libraryToolDepends = [ c2hs hpack ]; executableHaskellDepends = [ aeson base bytestring casing containers directory filepath lens mtl template-haskell text unordered-containers vector ]; executableToolDepends = [ c2hs ]; prePatch = "hpack"; homepage = "https://github.com/KaneTW/godot-haskell#readme"; license = stdenv.lib.licenses.bsd3; } ================================================ FILE: classgen/godot-haskell-classgen.cabal ================================================ cabal-version: 1.12 -- This file has been generated from package.yaml by hpack version 0.31.1. -- -- see: https://github.com/sol/hpack -- -- hash: 35a149339951f4c097aab1ae9ef0e3952109a1273b725ce775c4483b80c67fb6 name: godot-haskell-classgen version: 0.1.0.0 category: Web homepage: https://github.com/KaneTW/godot-haskell#readme bug-reports: https://github.com/KaneTW/godot-haskell/issues author: David Kraeutmann maintainer: kane@kane.cx copyright: 2018 David Kraeutmann license: BSD3 build-type: Simple extra-source-files: README.md source-repository head type: git location: https://github.com/KaneTW/godot-haskell library exposed-modules: Classgen.Docs Classgen.Module Classgen.Spec Classgen.Utils other-modules: Paths_godot_haskell_classgen hs-source-dirs: src-classgen default-extensions: FlexibleContexts FlexibleInstances ScopedTypeVariables TypeApplications StandaloneDeriving DerivingStrategies DefaultSignatures MultiParamTypeClasses FunctionalDependencies TypeFamilies TemplateHaskell TypeOperators TypeInType QuasiQuotes OverloadedStrings PatternSynonyms GeneralizedNewtypeDeriving include-dirs: godot_headers cbits build-tools: c2hs build-depends: aeson , base , bytestring , casing , containers , haskell-src-exts , haskell-src-exts-qq , haskell-src-exts-sc , lens , mtl , template-haskell , text , unordered-containers , vector default-language: Haskell2010 executable godot-haskell-classgen main-is: Main.hs other-modules: Paths_godot_haskell_classgen hs-source-dirs: app-classgen default-extensions: FlexibleContexts FlexibleInstances ScopedTypeVariables TypeApplications StandaloneDeriving DerivingStrategies DefaultSignatures MultiParamTypeClasses FunctionalDependencies TypeFamilies TemplateHaskell TypeOperators TypeInType QuasiQuotes OverloadedStrings PatternSynonyms GeneralizedNewtypeDeriving include-dirs: godot_headers cbits build-tools: c2hs build-depends: aeson , base , bytestring , casing , containers , directory , filepath , godot-haskell-classgen , haskell-src-exts , haskell-src-exts-sc , lens , mtl , template-haskell , text , unordered-containers , vector default-language: Haskell2010 ================================================ FILE: classgen/package.yaml ================================================ name: godot-haskell-classgen version: '0.1.0.0' category: Web author: David Kraeutmann maintainer: kane@kane.cx copyright: 2018 David Kraeutmann license: BSD3 github: KaneTW/godot-haskell extra-source-files: - README.md dependencies: - base - aeson - bytestring - template-haskell - lens - text - casing - vector - containers - unordered-containers - mtl build-tools: - c2hs include-dirs: - godot_headers - cbits default-extensions: - FlexibleContexts - FlexibleInstances - ScopedTypeVariables - TypeApplications - StandaloneDeriving - DerivingStrategies - DefaultSignatures - MultiParamTypeClasses - FunctionalDependencies - TypeFamilies - TemplateHaskell - TypeOperators - TypeInType - QuasiQuotes - OverloadedStrings - PatternSynonyms - GeneralizedNewtypeDeriving library: source-dirs: src-classgen dependencies: - haskell-src-exts - haskell-src-exts-qq - haskell-src-exts-sc executables: godot-haskell-classgen: main: Main.hs source-dirs: app-classgen dependencies: - godot-haskell-classgen - haskell-src-exts - haskell-src-exts-sc - directory - filepath ================================================ FILE: classgen/release.nix ================================================ let pkgs = import { }; in pkgs.haskellPackages.callPackage ./default.nix { } ================================================ FILE: classgen/src-classgen/Classgen/Docs.hs ================================================ {-# LANGUAGE TemplateHaskell, GeneralizedNewtypeDeriving, OverloadedStrings #-} {-# OPTIONS_GHC -Wno-orphans #-} module Classgen.Docs where import Control.Applicative import Control.Lens import Data.Aeson import Data.Aeson.TH import Data.Monoid import Data.Text (Text) import qualified Data.Text as T import Data.Vector (Vector) import qualified Data.Vector as V import Data.HashMap.Strict (HashMap) import qualified Data.Set as S import qualified Data.ByteString.Lazy as BL import qualified Data.HashMap.Strict as H import Text.Casing import Classgen.Utils -- | One of the two values that has been parsed from JSON data AlternativeJSON a b = FirstJSON a | SecondJSON b deriving (Eq, Ord, Show) instance (FromJSON a, FromJSON b) => FromJSON (AlternativeJSON a b) where parseJSON v = FirstJSON <$> parseJSON v <|> SecondJSON <$> parseJSON v alternative1 :: AlternativeJSON a b -> a -> a alternative1 (FirstJSON a) _ = a alternative1 _ a = a alt1 :: AlternativeJSON a b -> Maybe a alt1 (FirstJSON a) = Just a alt1 _ = Nothing type GodotDocTable = HashMap Text GodotDocClass type GodotDocs = Vector GodotDoc newtype Ref a = Ref Text deriving (Show, Eq, FromJSON, ToJSON) data GPrimType = VoidType | BoolType | IntType | FloatType deriving (Show, Eq) instance FromJSON GPrimType where parseJSON = withText "primitive type" $ \t -> case t of "void" -> pure VoidType "bool" -> pure BoolType "int" -> pure IntType "float" -> pure FloatType _ -> fail $ "Unknown type" <> T.unpack t data GType = PrimitiveType !GPrimType | CoreType !Text | CustomType !Text | EnumType !Text deriving (Show, Eq) isCoreType t = t `S.member` S.fromList [ "AABB", "Array", "Basis", "Color", "Dictionary", "GodotError", "NodePath", "Plane", "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray", "Object", "Quat", "Rect2", "RID", "String", "Transform", "Transform2D", "Variant", "Vector2", "Vector3" ] instance FromJSON GType where parseJSON v = PrimitiveType <$> parseJSON v <|> withText "type" (\t -> if isCoreType t then pure $ CoreType t else if "enum." `T.isPrefixOf` t then pure $ EnumType t else pure $ CustomType t) v data GodotDoc = GodotDoc { _gdClass :: !GodotDocClass } deriving (Show, Eq) instance FromJSON GodotDoc where parseJSON (Object x) = GodotDoc <$> x .: "class" parseJSON _ = fail "Expected an Object" data OptionalArray a = OptionalArray { unOption :: Vector a } deriving (Show, Eq) instance FromJSON a => FromJSON (OptionalArray a) where parseJSON x@(Array _) = OptionalArray <$> parseJSON x parseJSON x = OptionalArray . V.singleton <$> parseJSON x data GodotDocClass = GodotDocClass { _gdName :: !Text , _gdVersion :: !Text , _gdBrief_description :: !(AlternativeJSON Text Object) , _gdDescription :: !(AlternativeJSON Text Object) , _gdCategory :: !(Maybe Text) , _gdInherits :: !(Maybe Text) , _gdMembers :: !(Maybe (HashMap Text (OptionalArray GodotProperty))) , _gdConstants :: !(HashMap Text (OptionalArray GodotConstant)) , _gdSignals :: !(Maybe (HashMap Text (OptionalArray GodotSignal))) , _gdMethods :: !(HashMap Text (OptionalArray GodotMethod)) } deriving (Show, Eq) data GodotProperty = GodotProperty { _gpName :: !Text , _gcType :: !GType , _gcGetter :: !Text , _gcSetter :: !Text , _gcValue :: !(Maybe Text) } deriving (Show, Eq) data GodotConstant = GodotConstant { _goName :: !Text , _goValue :: !Text , _goEnum :: !(Maybe Text) } deriving (Show, Eq) data GodotSignal = GodotSignal { _gsName :: !Text , _gsDescription :: !(AlternativeJSON Text Object) , _gsArgument :: !(Maybe (OptionalArray GodotArgument)) } deriving (Show, Eq) data GodotArgument = GodotArgument { _gaName :: !Text , _gaType :: !GType , _gaIndex :: !Text , _gaDefault_ :: !(Maybe Text) } deriving (Show, Eq) instance FromJSON GodotArgument where parseJSON (Object x) = GodotArgument <$> x .: "name" <*> x .: "type" <*> x .: "index" <*> x .:? "default" parseJSON _ = fail "Expected an Object" data GodotMethod = GodotMethod { _gmName :: !Text , _gmDescription :: !(AlternativeJSON Text Object) , _gmReturn :: !(Maybe (HashMap Text GType)) , _gmArgument :: !(Maybe (OptionalArray GodotArgument)) } deriving (Show, Eq) makeLensesWith fixedTypeFields ''GodotDoc makeLensesWith fixedTypeFields ''GodotDocClass makeLensesWith fixedTypeFields ''GodotProperty makeLensesWith fixedTypeFields ''GodotSignal makeLensesWith fixedTypeFields ''GodotArgument makeLensesWith fixedTypeFields ''GodotMethod toTable :: GodotDocs -> GodotDocTable toTable = V.foldl' (\hm d -> H.insert (d ^. class' . name) (d ^. class') hm) H.empty makePrisms ''GType makePrisms ''GPrimType concat <$> mapM (deriveFromJSON defaultOptions { fieldLabelModifier = quietSnake . drop 3, omitNothingFields = True }) [ ''GodotDocClass , ''GodotProperty , ''GodotConstant , ''GodotSignal , ''GodotMethod ] convertDoc = T.replace "]" "@" . T.replace "[" "@" . T.replace "[/code]" "@" . T.replace "[code]" "@" . T.replace "[/codeblock]" "\n@\n" . T.replace "[codeblock]" "\n@\n" . T.replace "[b]" "__" . T.replace "[/b]" "__" . T.replace "[constant " "@" . T.replace "[member " "@" ================================================ FILE: classgen/src-classgen/Classgen/Module.hs ================================================ {-# LANGUAGE NoMonoLocalBinds, NoMonomorphismRestriction #-} module Classgen.Module where import Control.Lens hiding (index) import Control.Applicative import Control.Monad.State import Data.HashMap.Strict (HashMap) import qualified Data.HashMap.Strict as HM import qualified Data.Vector as V import Data.Text (Text) import qualified Data.Text as T import Data.Set (Set) import qualified Data.Set as S import qualified Language.Haskell.Exts as HS import Language.Haskell.Exts.QQ import Language.Haskell.Exts.SimpleComments import Text.Casing import Classgen.Spec import qualified Classgen.Docs as D import Data.Maybe import Data.List --TODO add singleton functions data ClassgenState = ClassgenState { _csModules :: !(HashMap Text (HS.Module (Maybe CodeComment))) , _csMethods :: !(HashMap Text (Set Text)) , _csTyDecls :: !([HS.Decl (Maybe CodeComment)]) } deriving (Show, Eq) makeLensesWith abbreviatedFields ''ClassgenState noComments l = fmap (\_ -> Nothing) l addClass :: MonadState ClassgenState m => GodotClass -> Maybe D.GodotDocClass -> GodotClasses -> m () addClass cls mdoc allClasses = do methods <- mkMethods cls mdoc properties <- mkProperties cls mdoc signals <- mkSignals cls mdoc let dataType = if isCoreType (cls ^. name) then [] else mkDataType cls mdoc tyDecls <>= dataType let classDecls = nub $ (noComments <$> (mkConstants cls ++ mkEnums cls)) ++ signals ++ properties ++ methods modules %= HM.insert (mangleClass $ cls ^. name) (HS.Module Nothing (Just $ classModuleHead classDecls) [HS.LanguagePragma Nothing [HS.Ident Nothing "DerivingStrategies" ,HS.Ident Nothing "GeneralizedNewtypeDeriving" ,HS.Ident Nothing "TypeFamilies" ,HS.Ident Nothing "TypeOperators" ,HS.Ident Nothing "FlexibleContexts" ,HS.Ident Nothing "DataKinds" ,HS.Ident Nothing "MultiParamTypeClasses"]] (noComments <$> classImports) classDecls) where classImports = map (\n -> HS.ImportDecl () (HS.ModuleName () n) False False False Nothing Nothing Nothing) ([ "Data.Coerce", "Foreign.C", "Godot.Internal.Dispatch" , "qualified Data.Vector as V" , "Linear(V2(..),V3(..),M22)", "Data.Colour(withOpacity)", "Data.Colour.SRGB(sRGB)" , "System.IO.Unsafe", "Godot.Gdnative.Internal", "Godot.Api.Types" ] <> maybe [] (:[]) parentModuleImport) classModuleHead decls = HS.ModuleHead Nothing classModuleName Nothing $ Just (classExports decls) classModuleName = noComments $ HS.ModuleName () $ "Godot." ++ (pascal $ T.unpack (cls ^. apiType)) ++ "." ++ (T.unpack $ mangleClass $ cls ^. name) parentModuleImport = case (cls ^. baseClass, V.find (\x -> cls ^. baseClass == x ^. name) allClasses) of ("", Nothing) -> Nothing (_, Nothing) -> error "Can't find base class" (_, Just baseCls) -> Just $ "Godot." ++ (pascal $ T.unpack (baseCls ^. apiType)) ++ "." ++ (T.unpack $ mangleClass $ baseCls ^. name) ++ "()" classExports decls = HS.ExportSpecList Nothing $ mapMaybe (\decl -> case decl of HS.TypeSig _ [name] (HS.TyCon _ (HS.Qual _ _ (HS.Ident _ "MethodBind"))) -> Nothing HS.TypeSig _ [name] (HS.TyCon _ (HS.UnQual _ (HS.Ident _ "MethodBind"))) -> Nothing HS.TypeSig _ [name] _ -> Just $ HS.EVar Nothing (HS.Qual Nothing classModuleName name) _ -> Nothing) decls mkProperties :: MonadState ClassgenState m => GodotClass -> Maybe D.GodotDocClass -> m [HS.Decl (Maybe CodeComment)] mkProperties cls mdoc = concat <$> mapM mkProperty (V.toList $ cls ^. properties) where mkProperty prop = do get <- mkGetter prop set <- mkSetter prop inst <- mkProp prop return (get ++ set ++ [inst]) indexArg prop = if prop ^. index == -1 then V.empty else V.singleton (GodotArgument "param" (PrimitiveType IntType) Nothing) mkGetter prop = mkMethod cls (GodotMethod (prop ^. getter) (gty prop) False False True False False False False (indexArg prop)) (methodDoc (prop ^. getter) mdoc) mkSetter prop | T.null (prop ^. setter) = return [] | otherwise = mkMethod cls (GodotMethod (prop ^. setter) (PrimitiveType VoidType) False False False False False False False (indexArg prop <> V.singleton (GodotArgument (prop ^. name) (gty prop) Nothing))) (methodDoc (prop ^. setter) mdoc) gty prop = case (cls ^. name,prop ^. name) of -- NB These are bugs in api.json ("VisualScriptPropertySet","type_cache") -> CoreType "Dictionary" -- has int ("PhysicsDirectBodyState","transform") -> CoreType "Transform" -- has transform2d ("JSONParseResult","error") -> PrimitiveType IntType -- has Object ("InputEventKey", "echo") -> PrimitiveType BoolType -- has int ("GeometryInstance", "lod_max_distance") -> PrimitiveType FloatType -- has int ("GeometryInstance", "lod_max_hysteresis") -> PrimitiveType FloatType -- has int ("GeometryInstance", "lod_min_distance") -> PrimitiveType FloatType -- has int ("GeometryInstance", "lod_min_hysteresis") -> PrimitiveType FloatType -- has int ("Control", "margin_bottom") -> PrimitiveType FloatType -- has int ("Control", "margin_top") -> PrimitiveType FloatType -- has int ("Control", "margin_left") -> PrimitiveType FloatType -- has int ("Control", "margin_right") -> PrimitiveType FloatType -- has int ("Curve3D", "_data") -> CoreType "Dictionary" -- has int ("Curve2D", "_data") -> CoreType "Dictionary" -- has int ("Curve", "_data") -> CoreType "Array" -- has int ("Polygon2D", "bones") -> CoreType "Array" -- has Bool ("RichTextLabel", "custom_effects") -> CoreType "Array" -- has 17/17:RichTextEffect ("AudioEffectPitchShift", "oversampling") -> PrimitiveType IntType -- has float ("Area2D", "priority") -> PrimitiveType FloatType -- has int ("Area", "priority") -> PrimitiveType FloatType -- has int -- NB These seem to be too specific or generic in api.json ("ARVRServer", "primary_interface") -> CustomType "ARVRInterface" -- has Object ("AnimationTree", "tree_root") -> CustomType "AnimationNode" -- has AnimationRootNode ("Camera2D", "custom_viewport") -> CustomType "Node" -- has Viewport ("CanvasLayer", "custom_viewport") -> CustomType "Node" -- has Viewport ("ConvexPolygonShape", "points") -> CustomType "PoolVector3Array" -- has Array ("ParticlesMaterial","angle_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","angular_velocity_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","anim_offset_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","anim_speed_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","damping_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","hue_variation_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","linear_accel_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","orbit_velocity_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","radial_accel_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","scale_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","tangential_accel_curve") -> CoreType "Texture" -- has CurveTexture ("ParticlesMaterial","color_ramp") -> CoreType "Texture" -- has GradientTexture ("SceneTree","root") -> CoreType "Viewport" -- has Node _ -> prop ^. type' mkProp prop = do pure $ noComments [dec|instance NodeProperty ((cty)) ((n)) ((ty)) ((ro)) where nodeProperty = ( $get , $set , Nothing) |] where cty = clsTy cls n = promotedString $ T.unpack $ prop ^. name ty = toHsType $ gty prop ro = if T.null (prop ^. setter) then HS.TyPromoted () $ HS.PromotedCon () True $ HS.UnQual () $ HS.Ident () "True" else HS.TyPromoted () $ HS.PromotedCon () True $ HS.UnQual () $ HS.Ident () "False" setname = toMethodName (prop ^. setter) getname = toMethodName (prop ^. getter) i :: String = show $ ((prop ^. index)::Int) get = if prop ^. index == -1 then [hs|__getname__|] else [hs|wrapIndexedGetter __i__ __getname__|] set = if prop ^. index == -1 || T.null (prop ^. setter) then if T.null (prop ^. setter) then [hs|()|] else [hs|wrapDroppingSetter __setname__|] else [hs|wrapIndexedSetter __i__ __setname__|] godotObjectTy :: HS.Type () godotObjectTy = HS.TyCon () $ HS.UnQual () $ HS.Ident () "Object" sigCon :: HS.Exp () sigCon = HS.Con () $ HS.Qual () (HS.ModuleName () $ "Godot.Internal.Dispatch") $ HS.Ident () "Signal" sigTy :: HS.Type () sigTy = HS.TyCon () $ HS.Qual () (HS.ModuleName () $ "Godot.Internal.Dispatch") $ HS.Ident () "Signal" clsAsName :: GodotClass -> HS.Name () clsAsName cls = HS.Ident () (T.unpack $ mangleClass $ cls ^. name) clsTy :: GodotClass -> HS.Type () clsTy = HS.TyCon () . HS.UnQual () . clsAsName nameToTyCon = HS.TyCon () . HS.UnQual () . HS.Ident () . T.unpack baseClsTy :: GodotClass -> HS.Type () baseClsTy cls = nameToTyCon (cls ^. baseClass) intTy = HS.TyCon () . HS.UnQual () $ HS.name "Int" promotedString s = HS.TyPromoted () (HS.PromotedString () s s) promotedList l = HS.TyPromoted () (HS.PromotedList () True l) mkDataType cls mdoc = [ HS.DataDecl (case mdoc of Nothing -> Nothing Just d -> case d ^. D.brief_description of D.FirstJSON x -> preComment (T.unpack $ D.convertDoc $ x <> "\n" <> let desc = D.alternative1 (d ^. D.description) "" in case T.stripPrefix x desc of Nothing -> T.strip desc Just r -> r) _ -> Nothing) (HS.NewType Nothing) Nothing (noComments $ HS.DHead () $ clsAsName cls) [noComments $ HS.QualConDecl () Nothing Nothing $ HS.ConDecl () (clsAsName cls) [godotObjectTy]] [noComments $ HS.Deriving () (Just $ HS.DerivNewtype ()) [asVariantRule]] ] ++ if T.null (cls ^. baseClass) then [] else [ noComments $ [dec| instance HasBaseClass ((cty)) where type BaseClass ((cty)) = ((bty)) super = coerce |] ] where asVariantRule = HS.IRule () Nothing Nothing $ HS.IHCon () (HS.UnQual () $ HS.Ident () "AsVariant") cty = clsTy cls bty = baseClsTy cls mkSignals :: MonadState ClassgenState m => GodotClass -> Maybe D.GodotDocClass -> m [HS.Decl (Maybe CodeComment)] mkSignals cls mdoc = return $ concatMap mkSignal (V.toList $ cls ^. signals) where signalDoc :: Text -> Maybe D.GodotDocClass -> Maybe CodeComment signalDoc name mdoc = do doc <- mdoc sigs <- D._gdSignals doc ss <- D.unOption <$> HM.lookup (T.pack "signal") sigs sdoc <- V.find (\e -> e ^. D.name == name) ss d <- D.alt1 $ sdoc ^. D.description preComment (T.unpack $ D.convertDoc d) argToHsType (GodotArgument _ ty _) = toHsType ty mkSignal sig = let sigStr = T.unpack (sig ^. name) sigName = HS.Ident () ("sig_" ++ sigStr) in [ HS.TypeSig (signalDoc (sig ^. name) mdoc) [noComments $ sigName] (noComments $ HS.TyApp () sigTy (clsTy cls)) , noComments $ HS.PatBind () (HS.PVar () sigName) ( HS.UnGuardedRhs () $ HS.App () sigCon $ HS.Lit () $ HS.String () sigStr sigStr ) Nothing , let cty = clsTy cls args = promotedList $ map argToHsType $ V.toList $ sig ^. arguments st = promotedString sigStr in noComments [dec|instance NodeSignal ((cty)) ((st)) ((args))|] ] mkConstants :: GodotClass -> [HS.Decl ()] mkConstants cls = concatMap mkConstant (HM.toList $ cls ^. constants) where mkConstant (cname, cval) = let constName = HS.Ident () $ T.unpack ("_" <> cname) in [ HS.TypeSig () [constName] intTy , HS.FunBind () [HS.Match () constName [] (HS.UnGuardedRhs () (HS.Lit () (HS.Int () (fromIntegral cval) (show cval)))) Nothing] ] mkEnums cls = [] -- TODO Not sure what to do about these methodDoc :: Text -> Maybe D.GodotDocClass -> Maybe CodeComment methodDoc name mdoc = do doc <- mdoc (do ms <- D.unOption <$> HM.lookup (T.pack "method") (D._gdMethods doc) docm <- V.find (\e -> e ^. D.name == name) ms d <- D.alt1 $ docm ^. D.description preComment (T.unpack $ D.convertDoc d)) <|> (do mems <- D.unOption <$> (HM.lookup (T.pack "member") =<< D._gdMembers doc) doc <- V.find (\e -> e ^. D.getter == name || e ^. D.setter == name) mems d <- doc ^. D.value preComment (T.unpack $ D.convertDoc d)) mkMethods :: MonadState ClassgenState m => GodotClass -> Maybe D.GodotDocClass -> m [HS.Decl (Maybe CodeComment)] mkMethods cls mdoc = concat <$> mapM (\m -> mkMethod cls m (methodDoc (m ^. name) mdoc)) (V.toList $ cls ^. methods) mkMethod :: MonadState ClassgenState m => GodotClass -> GodotMethod -> Maybe CodeComment -> m [HS.Decl (Maybe CodeComment)] mkMethod cls method doc = do mtds <- use methods if (method ^. name) `S.member` (HM.lookupDefault mempty (cls ^. name) mtds) then return [] else do methods %= HM.insertWith S.union (mangleClass $ cls ^. name) (S.singleton $ method ^. name) when (T.null $ method ^. name) $ error (show cls ++ "\n" ++ show method) return $ [ noComments $ HS.InlineSig () False Nothing (HS.UnQual () clsMethodBindName) , HS.TypeSig doc [noComments $ clsMethodBindName] (noComments $ HS.TyCon () (HS.UnQual () (HS.Ident () "MethodBind"))) , noComments $ HS.PatBind () (HS.PVar () clsMethodBindName) clsMethodBindRhs Nothing , HS.TypeSig doc [HS.Ident Nothing $ methodName] (noComments [ty|(((clsName)) :< cls, Object :< cls) => cls -> ((methodSig))|]) , noComments $ HS.FunBind () [HS.Match () (HS.Ident () $ methodName) ((HS.PVar () (HS.Ident () "cls") : map (HS.PVar ()) argNames) ++ if method ^. hasVarargs then [HS.PVar () (HS.Ident () "varargs")] else []) runMethodRhs Nothing] , let cty = clsTy cls name = promotedString rawMethodName args = promotedList $ V.toList methodArgs ret = toHsType $ method ^. returnType mname = classModuleName <> "." <> methodName in noComments $ [dec|instance NodeMethod ((cty)) ((name)) ((args)) (IO ((ret)) ) where nodeMethod = __mname__ |] ] where clsName = HS.TyCon () (HS.UnQual () (clsAsName cls)) clsMethodBindName = HS.Ident () $ "bind" ++ (T.unpack $ mangleClass (cls ^. name)) ++ "_" ++ methodName clsMethodBindVar = HS.Var () $ HS.UnQual () clsMethodBindName clsMethodBindRhs = HS.UnGuardedRhs () [hs| unsafePerformIO $ withCString $(HS.strE (T.unpack $ cls ^. name)) $ \clsNamePtr -> withCString $(HS.strE rawMethodName) $ \methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr |] classModuleName = "Godot." ++ (pascal $ T.unpack (cls ^. apiType)) ++ "." ++ (T.unpack $ mangleClass $ cls ^. name) runMethodRhs = HS.UnGuardedRhs () $ HS.App () ( HS.App () (HS.Var () (HS.UnQual () (HS.Ident () "withVariantArray"))) (let a = HS.List () $ zipWith (\a an -> wrapDefault a an) (V.toList $ method ^. arguments) argNames in if method ^. hasVarargs then [hs|$a ++ varargs|] else a)) [hs| \(arrPtr, len) -> godot_method_bind_call $(clsMethodBindVar) (upcast cls) arrPtr len >>= \(err, res) -> throwIfErr err >> fromGodotVariant res |] wrapDefault (GodotArgument _ ty Nothing) v = mkToVariant v wrapDefault (GodotArgument _ ty (Just d)) v = mkDefault ty d (HS.Var () $ HS.UnQual () v) mkDefault :: GType -> Text -> HS.Exp () -> HS.Exp () mkDefault (PrimitiveType IntType) d v = [hs|maybe (VariantInt (__dt__)) toVariant $v |] where dt = T.unpack d mkDefault (PrimitiveType FloatType) d v = [hs|maybe (VariantReal (__dt__)) toVariant $v |] where dt = T.unpack d mkDefault (PrimitiveType BoolType) d v = [hs|maybe (VariantBool __dt__) toVariant $v |] where dt = T.unpack d mkDefault (CoreType "Color") "1,1,1,1" v = [hs|defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) $v |] mkDefault (CoreType "Rect2") "(0, 0, 0, 0)" v = [hs|defaultedVariant VariantRect2 (V2 (V2 0 0) (V2 0 0)) $v |] mkDefault (CoreType "PoolStringArray") "[]" v = [hs|defaultedVariant VariantPoolStringArray V.empty $v |] mkDefault (CoreType "Dictionary") "{}" v = [hs|defaultedVariant VariantDictionary V.empty $v |] mkDefault (CoreType "PoolVector2Array") "[]" v = [hs|defaultedVariant VariantPoolVector2Array V.empty $v |] mkDefault (CoreType "PoolVector3Array") "[]" v = [hs|defaultedVariant VariantPoolVector3Array V.empty $v |] mkDefault (CoreType "PoolIntArray") "[]" v = [hs|defaultedVariant VariantPoolIntArray V.empty $v |] mkDefault (CoreType "PoolRealArray") "[]" v = [hs|defaultedVariant VariantPoolRealArray V.empty $v |] mkDefault (CoreType "PoolColorArray") "[PoolColorArray]" v = [hs|defaultedVariant VariantPoolColorArray V.empty $v |] mkDefault (CoreType "Array") "[]" v = [hs|defaultedVariant VariantArray V.empty $v |] mkDefault (CoreType "Vector2") "(-1, -1)" v = [hs|defaultedVariant VariantVector2 (V2 (-1) (-1)) $v |] mkDefault (CoreType "Vector2") "(0, 0)" v = [hs|defaultedVariant VariantVector2 (V2 0 0) $v |] mkDefault (CoreType "Vector3") "(0, 0, 0)" v = [hs|defaultedVariant VariantVector3 (V3 0 0 0) $v |] mkDefault (CoreType "Transform2D") "((1, 0), (0, 1), (0, 0))" v = [hs|defaultedVariant VariantTransform2d (TF2d (V2 1 0) (V2 0 1) (V2 0 0)) $v |] mkDefault (CoreType "Transform") "1, 0, 0, 0, 1, 0, 0, 0, 1 - 0, 0, 0" v = [hs|defaultedVariant VariantTransform (TF (V3 (V3 1 0 0) (V3 0 1 0) (V3 0 0 1)) (V3 0 0 0)) $v |] -- TODO Is this right? mkDefault (CoreType "RID") "[RID]" v = [hs|maybe VariantNil toVariant $v |] mkDefault (CoreType "String") d v = [hs|defaultedVariant VariantString __dt__ $v |] where dt = "\"" <> T.unpack d <> "\"" mkDefault _ "Null" v = [hs|maybe VariantNil toVariant $v |] mkDefault _ "0" v = [hs|maybe (VariantInt 0) toVariant $v |] mkDefault _ "1" v = [hs|maybe (VariantInt 1) toVariant $v |] mkDefault _ "[Object:null]" v = [hs|maybe VariantNil toVariant $v |] mkDefault t d _ = error $ "Don't know how to make defaults for this type (" ++ show t ++ ") for value (" ++ show d ++ ")" mkToVariant = HS.App () (HS.Var () (HS.UnQual () (HS.Ident () "toVariant"))) . HS.Var () . HS.UnQual () argNames = map (HS.Ident () . ("arg" ++) . show) [1..length (method ^. arguments)] methodSig = foldr (HS.TyFun ()) (HS.TyApp () [ty|IO|] (toHsType $ method ^. returnType)) methodArgs methodArgs = let args = fmap argToHsType (method ^. arguments) in if method ^. hasVarargs then args `V.snoc` [ty|[Variant 'GodotTy]|] else args argToHsType (GodotArgument _ ty (Just _)) = HS.TyApp () (HS.TyCon () $ HS.UnQual () $ HS.Ident () "Maybe") $ toHsType ty argToHsType (GodotArgument _ ty _) = toHsType ty rawMethodName = T.unpack $ method ^. name methodName = toMethodName (method ^. name) toMethodName name = T.unpack (case name of "case" -> "case'" "class" -> "class'" "data" -> "data'" "default" -> "default'" "deriving" -> "deriving'" "do" -> "do'" "else" -> "else'" "forall" -> "forall'" "if" -> "if'" "import" -> "import'" "in" -> "in'" "infix" -> "infix'" "infixl" -> "infixl'" "infixr" -> "infixr'" "instance" -> "instance'" "let" -> "let'" "module" -> "module'" "newtype" -> "newtype'" "of" -> "of'" "qualified" -> "qualified'" "then" -> "then'" "type" -> "type'" "where" -> "where'" "foreign" -> "foreign'" "ccall" -> "ccall'" "as" -> "as'" "safe" -> "safe'" "unsafe" -> "unsafe'" x -> x) mangleClass "String" = "GodotString" mangleClass "Variant" = "GodotVariant" mangleClass c = case T.stripPrefix "_" c of Nothing -> c Just x -> x toHsType :: GType -> HS.Type () toHsType (PrimitiveType VoidType) = [ty| () |] toHsType (PrimitiveType BoolType) = [ty| Bool |] toHsType (PrimitiveType IntType) = [ty| Int |] toHsType (PrimitiveType FloatType) = [ty| Float |] toHsType (CoreType ty) = nameToTyCon $ renameType ty where renameType "RID" = "Rid" renameType "Transform2D" = "Transform2d" renameType "AABB" = "Aabb" renameType "String" = "GodotString" renameType "Variant" = "GodotVariant" renameType x = mangleClass x -- NB: Are these bugs in api.json? Why is the type different from anywhere else? toHsType (CustomType "SpatialMaterial,ShaderMaterial") = nameToTyCon "Material" toHsType (CustomType "ShaderMaterial,CanvasItemMaterial") = nameToTyCon "Material" toHsType (CustomType "ShaderMaterial,SpatialMaterial") = nameToTyCon "Material" toHsType (CustomType "ShaderMaterial,ParticlesMaterial") = nameToTyCon "Material" toHsType (CustomType ty) = nameToTyCon ty toHsType (EnumType _) = [ty| Int |] ================================================ FILE: classgen/src-classgen/Classgen/Spec.hs ================================================ {-# LANGUAGE TemplateHaskell, GeneralizedNewtypeDeriving, OverloadedStrings #-} {-# OPTIONS_GHC -Wno-orphans #-} module Classgen.Spec where import Control.Applicative import Control.Lens import Data.Aeson import Data.Aeson.TH import Data.Monoid import Data.Text (Text) import qualified Data.Text as T import Data.Vector (Vector) import Data.HashMap.Strict (HashMap) import qualified Data.Set as S import Text.Casing import Classgen.Utils type GodotClasses = Vector GodotClass newtype Ref a = Ref Text deriving (Show, Eq, FromJSON, ToJSON) data GPrimType = VoidType | BoolType | IntType | FloatType deriving (Show, Eq) instance FromJSON GPrimType where parseJSON = withText "primitive type" $ \t -> case t of "void" -> pure VoidType "bool" -> pure BoolType "int" -> pure IntType "float" -> pure FloatType _ -> fail $ "Unknown type" <> T.unpack t data GType = PrimitiveType !GPrimType | CoreType !Text | CustomType !Text | EnumType !Text deriving (Show, Eq) isCoreType t = t `S.member` S.fromList [ "AABB", "Array", "Basis", "Color", "Dictionary", "GodotError", "NodePath", "Plane", "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray", "Object", "Quat", "Rect2", "RID", "String", "Transform", "Transform2D", "Variant", "Vector2", "Vector3" ] instance FromJSON GType where parseJSON v = PrimitiveType <$> parseJSON v <|> withText "type" (\t -> if isCoreType t then pure $ CoreType t else if "enum." `T.isPrefixOf` t then pure $ EnumType t else pure $ CustomType t) v data GodotClass = GodotClass { _gcName :: !Text , _gcBaseClass :: !Text , _gcApiType :: !Text , _gcSingleton :: !Bool , _gcInstanciable :: !Bool , _gcIsReference :: !Bool , _gcConstants :: !(HashMap Text Int) , _gcProperties:: !(Vector GodotProperty) , _gcSignals :: !(Vector GodotSignal) , _gcMethods :: !(Vector GodotMethod) , _gcEnums :: !(Vector GodotEnum) } deriving (Show, Eq) data GodotProperty = GodotProperty { _gpName :: !Text , _gcType :: !GType , _gcGetter :: !Text , _gcSetter :: !Text , _gcIndex :: !Int } deriving (Show, Eq) data GodotSignal = GodotSignal { _gsName :: !Text , _gsArguments :: !(Vector GodotArgument) } deriving (Show, Eq) data GodotArgument = GodotArgument { _gaName :: !Text , _gaType :: !GType , _gaDefaultValue :: !(Maybe Text) } deriving (Show, Eq) instance FromJSON GodotArgument where parseJSON = withObject "argument" $ \v -> do hasDefault <- v .:? "has_default_value" maybeDefault <- case hasDefault of Just False -> pure Nothing _ -> Just <$> v .: "default_value" GodotArgument <$> v .: "name" <*> v .: "type" <*> pure maybeDefault data GodotMethod = GodotMethod { _gmName :: !Text , _gmReturnType :: !GType , _gmIsEditor :: !Bool , _gmIsNoscript :: !Bool , _gmIsConst :: !Bool , _gmIsReverse :: !Bool , _gmIsVirtual :: !Bool , _gmHasVarargs :: !Bool , _gmIsFromScript :: !Bool , _gmArguments :: !(Vector GodotArgument) } deriving (Show, Eq) data GodotEnum = GodotEnum { _geName :: !GType , _geValues :: !(HashMap Text Int) } deriving (Show, Eq) makeLensesWith fixedTypeFields ''GodotClass makeLensesWith fixedTypeFields ''GodotProperty makeLensesWith fixedTypeFields ''GodotSignal makeLensesWith fixedTypeFields ''GodotArgument makeLensesWith fixedTypeFields ''GodotMethod makeLensesWith fixedTypeFields ''GodotEnum makePrisms ''GType makePrisms ''GPrimType concat <$> mapM (deriveFromJSON defaultOptions { fieldLabelModifier = quietSnake . drop 3 }) [ ''GodotClass , ''GodotProperty , ''GodotSignal , ''GodotMethod , ''GodotEnum ] ================================================ FILE: classgen/src-classgen/Classgen/Utils.hs ================================================ module Classgen.Utils where import Control.Lens import Language.Haskell.TH fixedTypeFields :: LensRules fixedTypeFields = defaultFieldRules & lensField .~ (\tyn fs f -> map fixDefName $ abbreviatedNamer tyn fs f) where fixDefName (TopName n) = TopName (fixName n) fixDefName (MethodName c n) = MethodName c (fixName n) fixName n = mkName $ case nameBase n of "type" -> "type'" "id" -> "id'" "class" -> "class'" s -> s ================================================ FILE: classgen/stack.yaml ================================================ # This file was automatically generated by 'stack init' # # Some commonly used options have been documented as comments in this file. # For advanced use and comprehensive documentation of the format, please see: # https://docs.haskellstack.org/en/stable/yaml_configuration/ # Resolver to choose a 'specific' stackage snapshot or a compiler version. # A snapshot resolver dictates the compiler version and the set of packages # to be used for project dependencies. For example: # # resolver: lts-3.5 # resolver: nightly-2015-09-21 # resolver: ghc-7.10.2 # resolver: ghcjs-0.1.0_ghc-7.10.2 # resolver: # name: custom-snapshot # location: "./custom-snapshot.yaml" # resolver: lts-11.2 resolver: lts-15.4 # User packages to be built. # Various formats can be used as shown in the example below. # # packages: # - some-directory # - https://example.com/foo/bar/baz-0.0.2.tar.gz # - location: # git: https://github.com/commercialhaskell/stack.git # commit: e7b331f14bcffb8367cd58fbfc8b40ec7642100a # - location: https://github.com/commercialhaskell/stack/commit/e7b331f14bcffb8367cd58fbfc8b40ec7642100a # extra-dep: true # subdirs: # - auto-update # - wai # # A package marked 'extra-dep: true' will only be built if demanded by a # non-dependency (i.e. a user package), and its test suites and benchmarks # will not be run. This is useful for tweaking upstream packages. packages: - . - ../haskell-src-exts-qq - ../haskell-src-exts-sc # Dependency packages to be pulled from upstream that are not in the resolver # (e.g., acme-missiles-0.3) extra-deps: [] # Override default flag values for local packages and extra-deps # flags: {} # Extra package databases containing global packages # extra-package-dbs: [] # Control whether we use the GHC we find on the path # system-ghc: true # # Require a specific version of stack, using version ranges # require-stack-version: -any # Default require-stack-version: ">=1.7" # # Override the architecture used by stack, especially useful on Windows # arch: i386 # arch: x86_64 # # Extra directories used by stack for building # extra-include-dirs: [/path/to/dir] # extra-lib-dirs: [/path/to/dir] # # Allow a newer minor version of GHC than the snapshot specifies # compiler-check: newer-minor ================================================ FILE: default.nix ================================================ { mkDerivation, aeson, ansi-wl-pprint, base, bytestring, c2hs , casing, colour, containers, hpack, lens, linear, mtl, parsec , parsers, stdenv, stm, template-haskell, text , unordered-containers, vector, rsync, api-json ? null, lib, haskellPackages }: let godot-haskell-classgen = haskellPackages.callPackage ./classgen/default.nix { }; modifyGodotApi = lib.optionalString (api-json != null) '' cd classgen echo "Running godot-haskell-classgen on path " ${api-json} godot-haskell-classgen ${api-json} cd .. cp -r src src.bak rsync -a classgen/src/ src/ ''; in mkDerivation { pname = "godot-haskell"; version = "3.1.0.0"; src = ./.; libraryHaskellDepends = [ aeson ansi-wl-pprint base bytestring casing colour containers lens linear mtl parsec parsers stm template-haskell text unordered-containers vector ]; libraryToolDepends = [ c2hs hpack rsync godot-haskell-classgen]; doHaddock = false; preConfigure = '' hpack ${modifyGodotApi} ''; homepage = "https://github.com/KaneTW/godot-haskell#readme"; description = "Haskell bindings for the Godot game engine API"; license = stdenv.lib.licenses.bsd3; } ================================================ FILE: examples/dodge-the-creeps/.gitignore ================================================ dist* *.hi *.o .stack-work/ .stack-work-devel/ *~ \#* *.import result ================================================ FILE: examples/dodge-the-creeps/ChangeLog.md ================================================ # Empty ================================================ FILE: examples/dodge-the-creeps/LICENSE ================================================ BSD 3-Clause License Copyright (c) Andrei Barbu 2019 All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ================================================ FILE: examples/dodge-the-creeps/Makefile ================================================ NAME = myproject STACKLIBFILE = $(shell stack path --local-install-root)/lib/lib$(NAME).so GODOTPROJECT = $(shell stack path --project-root)/game all: stack nix: nix-build shell.nix cp result/lib/ghc-*/lib$(NAME).so $(GODOTPROJECT)/lib stack: stack build --fast --force-dirty cp $(STACKLIBFILE) $(GODOTPROJECT)/lib stack-nix: stack --nix clean $(NAME) stack --nix build cp $(shell stack --nix path --local-install-root)/lib/lib$(NAME).so $(GODOTPROJECT)/lib stack-run: stack build cp $(STACKLIBFILE) $(GODOTPROJECT)/lib godot -e --path ./game stack-watch: stack build --file-watch --fast --exec "cp $(STACKLIBFILE) $(GODOTPROJECT)/lib" project-watch: stack exec godot-haskell-project-generator game src updatelib: cp $(STACKLIBFILE) $(GODOTPROJECT)/lib ================================================ FILE: examples/dodge-the-creeps/README.md ================================================ The official Godot demo from the manual: Dodge the Creeps. Run with `make stack` then `godot game/project.godot` and press F5 to start, F8 to end. Requires Godot 3.1 ================================================ FILE: examples/dodge-the-creeps/Support.hs ================================================ {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, OverloadedLabels, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances #-} module Generated.Support where import Godot import GHC.TypeLits class SceneNode (scene :: Symbol) (s :: Symbol) where type SceneNodeType scene s :: * type SceneNodeName scene s :: Symbol class NodeInScheme (scene :: Symbol) (s :: Symbol) n | scene s -> n, n -> scene s ================================================ FILE: examples/dodge-the-creeps/ffi/cbits/flib.c ================================================ #include "HsFFI.h" static void flib_init() __attribute__((constructor)); static void flib_init() { static char *argv[] = { "libGodotHaskellPlugin.so", 0 }, **argv_ = argv; static int argc = 1; hs_init(&argc, &argv_); } static void flib_fini() __attribute__((destructor)); static void flib_fini() { hs_exit(); } ================================================ FILE: examples/dodge-the-creeps/ffi/flib/FLib.hs ================================================ {-# LANGUAGE ForeignFunctionInterface #-} module FLib where import qualified Foreign import Foreign(nullPtr, Ptr,newForeignPtr_,castPtr) import qualified Godot.Gdnative.Internal as FFI import Godot.Gdnative import Godot.Nativescript import Lib import qualified Data.Text as T import qualified Data.Text.IO as T godot_nativescript_init :: GdnativeHandle -> IO () godot_nativescript_init desc = do defaultExports desc exports desc putStrLn "Haskell NativeScript lib initialized" foreign export ccall godot_nativescript_init :: GdnativeHandle -> IO () godot_gdnative_init :: FFI.GdnativeInitOptionsPtr -> IO () godot_gdnative_init opts = do Foreign.peek opts >>= FFI.initApiStructs foreign export ccall godot_gdnative_init :: FFI.GdnativeInitOptionsPtr -> IO () godot_gdnative_terminate :: FFI.GdnativeTerminateOptionsPtr -> IO () godot_gdnative_terminate handle = pure () foreign export ccall godot_gdnative_terminate :: FFI.GdnativeTerminateOptionsPtr -> IO () ================================================ FILE: examples/dodge-the-creeps/game/HUD.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libmyproject.gdnlib" type="GDNativeLibrary" id=1] [resource] resource_name = "HUD" class_name = "HUD" library = ExtResource( 1 ) ================================================ FILE: examples/dodge-the-creeps/game/HUD.tres ================================================ [gd_resource type="DynamicFont" load_steps=2 format=2] [ext_resource path="res://dodge_assets/fonts/Xolonium-Regular.ttf" type="DynamicFontData" id=1] [resource] size = 64 font_data = ExtResource( 1 ) ================================================ FILE: examples/dodge-the-creeps/game/HUD.tscn ================================================ [gd_scene load_steps=5 format=2] [ext_resource path="res://HUD.gdns" type="Script" id=1] [ext_resource path="res://HUD.tres" type="DynamicFont" id=2] [sub_resource type="InputEventAction" id=1] action = "ui_select" [sub_resource type="ShortCut" id=2] shortcut = SubResource( 1 ) [node name="HUD" type="CanvasLayer"] script = ExtResource( 1 ) [node name="ScoreLabel" type="Label" parent="."] anchor_right = 1.0 margin_bottom = 78.0 custom_fonts/font = ExtResource( 2 ) text = "0" align = 1 __meta__ = { "_edit_use_anchors_": false } [node name="MessageLabel" type="Label" parent="."] anchor_top = 0.5 anchor_right = 1.0 anchor_bottom = 0.5 margin_top = -79.5 margin_bottom = 79.5 custom_fonts/font = ExtResource( 2 ) text = "Dodge the Creeps!" align = 1 [node name="StartButton" type="Button" parent="."] anchor_left = 0.5 anchor_top = 1.0 anchor_right = 0.5 anchor_bottom = 1.0 margin_left = -90.0 margin_top = -200.0 margin_right = 90.0 margin_bottom = -100.0 custom_fonts/font = ExtResource( 2 ) shortcut = SubResource( 2 ) text = "Start" __meta__ = { "_edit_use_anchors_": false } [node name="MessageTimer" type="Timer" parent="."] wait_time = 2.0 one_shot = true [connection signal="pressed" from="StartButton" to="." method="_on_StartButton_pressed"] [connection signal="timeout" from="MessageTimer" to="." method="_on_MessageTimer_timeout"] ================================================ FILE: examples/dodge-the-creeps/game/Main.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libmyproject.gdnlib" type="GDNativeLibrary" id=1] [resource] class_name = "Main" library = ExtResource( 1 ) ================================================ FILE: examples/dodge-the-creeps/game/Main.tscn ================================================ [gd_scene load_steps=6 format=2] [ext_resource path="res://Main.gdns" type="Script" id=1] [ext_resource path="res://Mob.tscn" type="PackedScene" id=2] [ext_resource path="res://Player.tscn" type="PackedScene" id=3] [ext_resource path="res://HUD.tscn" type="PackedScene" id=4] [sub_resource type="Curve2D" id=1] _data = { "points": PoolVector2Array( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 480, 0, 0, 0, 0, 0, 480, 720, 0, 0, 0, 0, 0, 720, 0, 0, 0, 0, 0, 0 ) } [node name="Main" type="Node"] script = ExtResource( 1 ) PackedScene = ExtResource( 2 ) [node name="ColorRect" type="ColorRect" parent="."] margin_right = 480.0 margin_bottom = 720.0 color = Color( 0.229564, 0.339542, 0.394531, 1 ) __meta__ = { "_edit_use_anchors_": false } [node name="Player" parent="." instance=ExtResource( 3 )] [node name="MobTimer" type="Timer" parent="."] wait_time = 0.5 [node name="ScoreTimer" type="Timer" parent="."] [node name="StartTimer" type="Timer" parent="."] wait_time = 2.0 one_shot = true [node name="StartPosition" type="Position2D" parent="."] position = Vector2( 240, 450 ) [node name="MobPath" type="Path2D" parent="."] curve = SubResource( 1 ) [node name="MobSpawnLocation" type="PathFollow2D" parent="MobPath"] [node name="HUD" parent="." instance=ExtResource( 4 )] [connection signal="hit" from="Player" to="." method="game_over"] [connection signal="timeout" from="MobTimer" to="." method="_on_MobTimer_timeout"] [connection signal="timeout" from="ScoreTimer" to="." method="_on_ScoreTimer_timeout"] [connection signal="timeout" from="StartTimer" to="." method="_on_StartTimer_timeout"] [connection signal="start_game" from="HUD" to="." method="new_game"] ================================================ FILE: examples/dodge-the-creeps/game/Mob.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libmyproject.gdnlib" type="GDNativeLibrary" id=1] [resource] resource_name = "Mob" class_name = "Mob" library = ExtResource( 1 ) ================================================ FILE: examples/dodge-the-creeps/game/Mob.tscn ================================================ [gd_scene load_steps=10 format=2] [ext_resource path="res://Mob.gdns" type="Script" id=1] [ext_resource path="res://dodge_assets/art/enemyFlyingAlt_1.png" type="Texture" id=2] [ext_resource path="res://dodge_assets/art/enemyFlyingAlt_2.png" type="Texture" id=3] [ext_resource path="res://dodge_assets/art/enemyWalking_1.png" type="Texture" id=4] [ext_resource path="res://dodge_assets/art/enemyWalking_2.png" type="Texture" id=5] [ext_resource path="res://dodge_assets/art/enemySwimming_1.png" type="Texture" id=6] [ext_resource path="res://dodge_assets/art/enemySwimming_2.png" type="Texture" id=7] [sub_resource type="SpriteFrames" id=1] animations = [ { "frames": [ ExtResource( 2 ), ExtResource( 3 ) ], "loop": true, "name": "fly", "speed": 3.0 }, { "frames": [ ExtResource( 4 ), ExtResource( 5 ) ], "loop": true, "name": "walk", "speed": 4.0 }, { "frames": [ ExtResource( 6 ), ExtResource( 7 ) ], "loop": true, "name": "swim", "speed": 4.0 } ] [sub_resource type="CapsuleShape2D" id=2] radius = 36.0297 height = 27.5338 [node name="Mob" type="RigidBody2D"] collision_mask = 0 gravity_scale = 0.0 script = ExtResource( 1 ) __meta__ = { "_edit_group_": true } [node name="AnimatedSprite" type="AnimatedSprite" parent="."] scale = Vector2( 0.75, 0.75 ) frames = SubResource( 1 ) animation = "swim" frame = 1 playing = true [node name="CollisionShape2D" type="CollisionShape2D" parent="."] rotation = 1.5708 shape = SubResource( 2 ) [node name="VisibilityNotifier2D" type="VisibilityNotifier2D" parent="."] [connection signal="screen_exited" from="VisibilityNotifier2D" to="." method="_on_VisibilityNotifier2D_screen_exited"] ================================================ FILE: examples/dodge-the-creeps/game/Player.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libmyproject.gdnlib" type="GDNativeLibrary" id=1] [resource] resource_name = "Player" class_name = "Player" library = ExtResource( 1 ) ================================================ FILE: examples/dodge-the-creeps/game/Player.tscn ================================================ [gd_scene load_steps=8 format=2] [ext_resource path="res://Player.gdns" type="Script" id=1] [ext_resource path="res://dodge_assets/art/playerGrey_walk1.png" type="Texture" id=2] [ext_resource path="res://dodge_assets/art/playerGrey_walk2.png" type="Texture" id=3] [ext_resource path="res://dodge_assets/art/playerGrey_up1.png" type="Texture" id=4] [ext_resource path="res://dodge_assets/art/playerGrey_up2.png" type="Texture" id=5] [sub_resource type="SpriteFrames" id=1] animations = [ { "frames": [ ExtResource( 2 ), ExtResource( 3 ) ], "loop": true, "name": "right", "speed": 5.0 }, { "frames": [ ExtResource( 4 ), ExtResource( 5 ) ], "loop": true, "name": "up", "speed": 5.0 } ] [sub_resource type="CapsuleShape2D" id=2] radius = 26.892 height = 15.9045 [node name="Player" type="Area2D"] script = ExtResource( 1 ) __meta__ = { "_edit_group_": true } [node name="AnimatedSprite" type="AnimatedSprite" parent="."] position = Vector2( 0, -1 ) scale = Vector2( 0.5, 0.5 ) frames = SubResource( 1 ) animation = "up" [node name="CollisionShape2D" type="CollisionShape2D" parent="."] shape = SubResource( 2 ) [connection signal="body_entered" from="." to="." method="_on_Player_body_entered"] ================================================ FILE: examples/dodge-the-creeps/game/dodge_assets/fonts/FONTLOG.txt ================================================ Please distribute this file along with the Xolonium fonts when possible. Source Find the sourcefiles of Xolonium at Credits Xolonium is created with FontForge , Inkscape , Python , and FontTools . It originated as a custom font for the open-source game Xonotic . With many thanks to the Xonotic community for your support. Supported OpenType features case Provides case sensitive placement of punctuation, brackets, and math symbols for uppercase text. frac Replaces number/number sequences with diagonal fractions. Numbers that touch a slash should not exceed 10 digits. kern Provides kerning for Latin, Greek, and Cyrillic scripts. locl Dutch: Replaces j with a stressed version if it follows í. Sami: Replaces n-form Eng with the preferred N-form version. Romanian and Moldovan: Replaces ŞşŢţ with the preferred ȘșȚț. pnum Replaces monospaced digits with proportional versions. sinf Replaces digits with scientific inferiors below the baseline. subs Replaces digits with subscript versions on the baseline. sups Replaces digits with superscript versions. zero Replaces zero with a slashed version. Supported glyph sets Adobe Latin 3 OpenType W1G ISO 8859-1 Western European ISO 8859-2 Central European ISO 8859-3 South European ISO 8859-4 North European ISO 8859-5 Cyrillic ISO 8859-7 Greek ISO 8859-9 Turkish ISO 8859-10 Nordic ISO 8859-13 Baltic Rim ISO 8859-14 Celtic ISO 8859-15 Western European ISO 8859-16 South-Eastern European Available glyphs !"#$%&'()*+,-./0123456789:;<=>? @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ `abcdefghijklmnopqrstuvwxyz{|}~  ¡¢£¤¥¦§¨©ª«¬ ®¯°±²³´µ¶·¸¹º»¼½¾¿ ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞß àáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ ĀāĂ㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğ ĠġĢģĤĥĦħĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻļĽľ ĿŀŁłŃńŅņŇňŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞş ŠšŢţŤťŦŧŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽž ƒǺǻǼǽǾǿȘșȚțȷ ˆˇˉ˘˙˚˛˜˝ ͺ;΄΅Ά·ΈΉΊΌΎΏΐ ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩΪΫάέήίΰ αβγδεζηθικλμνξοπρςστυφχψωϊϋόύώ ЀЁЂЃЄЅІЇЈЉЊЋЌЍЎЏАБВГДЕЖЗИЙКЛМНОП РСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмноп рстуфхцчшщъыьэюяѐёђѓєѕіїјљњћќѝўџ ѢѣѲѳѴѵҐґҒғҔҕҖҗҘҙҚқҜҝҞҟҠҡҢңҤҥҦҧҨҩ ҪҫҬҭҮүҰұҲҳҴҵҶҷҸҹҺһҼҽӀӁӂӇӈӋӌӏӐӑӒӓ ӔӕӖӗӘәӜӝӞӟӠӡӢӣӤӥӦӧӨөӮӯӰӱӲӳӴӵӶӷӸӹ Ԥԥ ḂḃḊḋḞḟṀṁṖṗṠṡṪṫẀẁẂẃẄẅẞỲỳ      ‒–—―‘’‚‛“”„‟†‡•…‰′″‹›‽‾⁄ ⁰⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ⁿ₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ ₤₦₩₫€₯₱₹₺₽₿ ℅ℓ№℗™Ω℮ ⅛⅜⅝⅞ ←↑→↓ ∂∆∏∑−∕∙√∞∟∫≈≠≤≥ ⌖ ■▬▮▰▲▶▼◀◆◊●◢◣◤◥ ☄★☠☢☣⚙⚛⚠⚡⛔ ❇❈❌❤❰❱❲❳ fffiflffiffl 🌌🌍🌎🌏👽💣🔥🔫 😁😃😄😆😇😈😉😊😎😐😒😕😘 😛😝😞😟😠😣😭😮😲😴😵 🚀 Debugging glyphs  U+EFFD Font version  U+F000 Font hinting indicator Changelog Xolonium 4.1 2016-11-22 Severin Meyer Reverted frac OpenType feature to a more stable implementation Xolonium 4.0 2016-10-08 Severin Meyer Decreased width of most glyphs Thinner vertical stems in Xolonium-Regular Thicker horizontal stems in Xolonium-Bold Revised diagonal stems Lowered middle bars Revised diacritical bars Added glyphs: ӏẞ₿ U+2007 U+2008 U+2009 U+200A U+202F U+EFFD U+F000 Revised glyphs: $&,JKQRXkwxy~¢¤ßǻ˜ζκλμξφЖУжћѴѵ∕₱₺₦₩€ℓ№≈ffffiffl ❤🌍🌎🌏😁😄😇😈😉😊😘😭😮😴🚀 Removed uncommon glyphs: ʼnſʼҌҍҎҏҾҿӃӄӇӈӚӛӪӫӬӭ U+0312 U+0313 U+0326 Simplified OpenType features pnum, zero, and case Removed OpenType feature dlig Revised vertical metrics Merged outlines of composite glyphs in otf version Added ttf version with custom outlines and instructions Added woff and woff2 version Xolonium 3.1 2015-06-10 Severin Meyer Added currency glyphs: ₦₩₫₱₹₺₽ Revised glyph: ₯ Relicensed public release under the SIL Open Font License 1.1 Xolonium 3.0 2015-05-04 Severin Meyer Decreased width of glyphs Decreased descender height Increased height of super/subscript glyphs Revised width of dashes, underscore, and overscore Sharper bends with more circular proportions Decreased stroke thickness of mathematical glyphs Revised diacritical marks Revised diacritical bars Revised Cyrillic hooks Revised glyphs: GQRYjmuwßŊŒſƒǻfffiffiffl ΞΨΩδζιξπςστυφω ЉЄДЛУЭЯбдлэяєљђєћѢѣҨҩҼҽӃӄӘә #$&'()*,/69?@[]{}~¡£¤¥§©®¿ ‹›₤€₯ℓ№℗℮←↑→↓∂∏∑∞≈▰☄❈❰❱❲❳😝 Raised vertical position of mathematical glyphs Unified advance width of numeral and monetary glyphs Unified advance width of mathematical glyphs Revised bearings Rewrote kern feature Bolder Xolonium-Bold with improved proportions Updated glyph names to conform to the AGLFN 1.7 Revised hints and PS Private Dictionary Added glyphs: ӶӷԤԥ Added OpenType features: case frac liga locl pnum sinf subs sups zero Xolonium 2.4 2014-12-23 Severin Meyer Added dingbats: ⛔💣🔥 Revised size and design of emoticons Revised dingbats: ⌖☄☠☣⚙⚛⚠⚡❇❈🌌🌍🌎🌏🔫 Removed dingbat: 💥 Xolonium 2.3 2014-08-14 Severin Meyer Bugfixed ε and έ, thanks to bowzee for the feedback Xolonium 2.2 2014-03-01 Severin Meyer Added dingbats: ⌖◆●❌💥 Revised dingbats: •←↑→↓◊☄★☠☣⚙⚛⚠⚡❇❈❤🌌🌍🌎🌏👽🔫🚀 Removed dingbats: ♻✪💡📡🔋🔧🔭 Xolonium 2.1 2013-10-20 Severin Meyer Added dingbats: ←↑→↓❰❱❲❳■▬▮▰▲▶▼◀◢◣◤◥ ☄★☠☢☣♻⚙⚛⚠⚡✪❇❈❤ 🌌🌍🌎🌏👽💡📡🔋🔧🔫🔭🚀 😁😃😄😆😇😈😉😊😎😐😒😕 😘😛😝😞😟😠😣😭😮😲😴😵 Xolonium 2.0.1 2013-07-12 Severin Meyer Reorganised and simplified files Xolonium 2.0 2012-08-11 Severin Meyer Revised bends Revised thickness of uppercase diagonal stems Revised diacritical marks Revised hints and PS Private Dictionary Revised glyphs: *1469@DPRly{}§©®¶ÐÞƒΘΞαεζνξνυЄЉЊ ЏБЗЛУЧЪЫЬЭЯбзлчъыьэяєљњџ•€∂∙√∞∫≠ Completed glyph sets: Adobe Latin 3 OpenType World Glyph Set 1 (W1G) Ghostscript Standard (ghostscript-fonts-std-8.11) Added OpenType kern feature Added Xolonium-Bold Xolonium 1.2 2011-02-12 Severin Meyer Revised glyphs: D·Ðı Completed glyph sets: ISO 8859-7 (Greek) Unicode Latin Extended-A block Added glyphs: †‡•…‰⁄™∂∑−√∞≠≤≥ Xolonium 1.1 2011-01-17 Severin Meyer Revised placement of cedilla and ogonek in accented glyphs Revised glyphs: ,;DKTjkvwxy¥§Ð˛€ Completed glyph sets: ISO 8859-2 (Central European) ISO 8859-3 (South European, Esperanto) ISO 8859-4 (North European) ISO 8859-5 (Cyrillic) ISO 8859-9 (Turkish) ISO 8859-10 (Nordic) ISO 8859-13 (Baltic Rim) ISO 8859-14 (Celtic) ISO 8859-16 (South-Eastern European) Added glyphs: ȷʼ̒ ЀЍѐѝ‒–—‘’‚‛“”„‟‹› Xolonium 1.0 2011-01-04 Severin Meyer Completed glyph sets: ISO 8859-1 (Western European) ISO 8859-15 (Western European) Added glyphs: ĄĆĘŁŃŚŹŻąćęłńśźżıˆˇ˙˚˛˜ ================================================ FILE: examples/dodge-the-creeps/game/dodge_assets/fonts/LICENSE.txt ================================================ Copyright 2011-2016 Severin Meyer , with Reserved Font Name Xolonium. This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at ----------------------------------------------------------- SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ----------------------------------------------------------- PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. ================================================ FILE: examples/dodge-the-creeps/game/lib/libmyproject.gdnlib ================================================ [general] singleton=false load_once=true symbol_prefix="godot_" reloadable=false [entry] X11.64="res://lib/libmyproject.so" ================================================ FILE: examples/dodge-the-creeps/game/project.godot ================================================ ; Engine configuration file. ; It's best edited using the editor UI and not directly, ; since the parameters that go here are not all obvious. ; ; Format: ; [section] ; section goes between [] ; param=value ; assign values to parameters config_version=4 _global_script_classes=[ ] _global_script_class_icons={ } [application] config/name="myproject" run/main_scene="res://Main.tscn" [audio] default_bus_layout="" [display] window/size/width=480 window/size/height=720 [gdnative] singletons=[ ] ================================================ FILE: examples/dodge-the-creeps/godot-haskell.nix ================================================ { fetchFromGitHub, mkDerivation, aeson, ansi-wl-pprint, base, bytestring, c2hs , casing, colour, containers, hpack, lens, linear, mtl, parsec , parsers, stdenv, stm, template-haskell, text , unordered-containers, vector }: mkDerivation { pname = "godot-haskell"; version = "3.1.0.0"; src = fetchFromGitHub { owner = "SimulaVR"; repo = "godot-haskell"; rev = "b423d4f2fa5a6a3dcfffb82bb36be571adb29d34"; # godot-haskell rev # Use nix-prefetch-git to get the hash sha256 = "0jh2j5rr90dqdxvcipygwnhhj7j2dj4zvm6gbdpg106ll60pyqrp"; fetchSubmodules = true; }; libraryHaskellDepends = [ aeson ansi-wl-pprint base bytestring casing colour containers lens linear mtl parsec parsers stm template-haskell text unordered-containers vector ]; libraryToolDepends = [ c2hs hpack ]; doHaddock = false; preConfigure = "hpack"; homepage = "https://github.com/KaneTW/godot-haskell#readme"; description = "Haskell bindings for the Godot game engine API"; license = stdenv.lib.licenses.bsd3; } ================================================ FILE: examples/dodge-the-creeps/hie.yaml ================================================ cradle: stack: - path: "./src" component: "myproject:lib" - path: "./game" component: "myproject:lib" ================================================ FILE: examples/dodge-the-creeps/myproject.cabal ================================================ cabal-version: 1.12 -- This file has been generated from package.yaml by hpack version 0.33.0. -- -- see: https://github.com/sol/hpack -- -- hash: 98269f1144e3857ceb0d2b7a1ec2c981a99768d91b04e6febe2406912eda49b8 name: myproject version: 0.0.0.0 description: Please see the README on Github at homepage: https://github.com/SimulaVR/godot-haskell#readme bug-reports: https://github.com/SimulaVR/godot-haskell/issues author: Andrei Barbu maintainer: andrei@0xab.com copyright: Andrei Barbu 2019, 2021 license: BSD3 license-file: LICENSE build-type: Simple extra-source-files: ChangeLog.md README.md foreign-library myproject type: native-shared other-modules: FLib hs-source-dirs: ffi/flib c-sources: ffi/cbits/flib.c build-depends: base >= 4.12 && <5 , godot-haskell , myproject , text default-language: Haskell2010 source-repository head type: git location: https://github.com/SimulaVR/godot-haskell library exposed-modules: Lib other-modules: Game.HUD Game.Main Game.Mob Game.Player Project.Requirements Project.Scenes Project.Scenes.HUD Project.Scenes.Main Project.Scenes.Mob Project.Scenes.Player Project.Support Paths_myproject hs-source-dirs: src game default-extensions: FlexibleContexts MultiParamTypeClasses OverloadedStrings TemplateHaskell TypeApplications TypeFamilies DataKinds FlexibleInstances ScopedTypeVariables AllowAmbiguousTypes TupleSections FunctionalDependencies ghc-options: -Wall -Wno-orphans -O0 build-depends: base >=4.12 && <5 , containers , extra , godot-haskell , lens , linear , random , strict-concurrency , template-haskell , text , th-abstraction , vector default-language: Haskell2010 ================================================ FILE: examples/dodge-the-creeps/package.yaml ================================================ name: myproject version: '0.0.0.0' description: Please see the README on Github at author: Andrei Barbu maintainer: andrei@0xab.com copyright: Andrei Barbu 2019, 2021 license: BSD3 github: SimulaVR/godot-haskell extra-source-files: - ChangeLog.md - README.md dependencies: - base >=4.12 && <5 - godot-haskell - linear - random - text - vector - strict-concurrency - lens - template-haskell - th-abstraction - containers - extra library: source-dirs: - src - game default-extensions: - FlexibleContexts - MultiParamTypeClasses - OverloadedStrings - TemplateHaskell - TypeApplications - TypeFamilies - DataKinds - FlexibleInstances - ScopedTypeVariables - AllowAmbiguousTypes - TupleSections - FunctionalDependencies exposed-modules: - Lib ghc-options: -Wall -Wno-orphans -O0 verbatim: | foreign-library myproject type: native-shared other-modules: FLib hs-source-dirs: ffi/flib c-sources: ffi/cbits/flib.c build-depends: base >= 4.12 && <5 , godot-haskell , myproject , text default-language: Haskell2010 ================================================ FILE: examples/dodge-the-creeps/pinned-nixpkgs.nix ================================================ {}: let # 19.03-beta (25 feb) rev = "0c0954781e257b8b0dc49341795a2fe7d96945a3"; # pinned-nixpkgs rev pkgs = import (builtins.fetchTarball { url = "https://github.com/NixOS/nixpkgs/archive/${rev}.tar.gz"; }) {}; in pkgs ================================================ FILE: examples/dodge-the-creeps/shell.nix ================================================ { nixpkgs ? import ./pinned-nixpkgs.nix {} , compiler ? "default" , doBenchmark ? false }: let inherit (nixpkgs) pkgs; haskellPackages = if compiler == "default" then pkgs.haskellPackages else pkgs.haskell.packages.${compiler}; f = { mkDerivation, stdenv, base, godot-haskell, linear, text , vector, stm }: mkDerivation { pname = "myproject"; version = "3.1.0.0"; src = ./.; libraryHaskellDepends = [ base godot-haskell linear text vector stm ]; libraryToolDepends = []; homepage = "https://github.com/abarbu/myproject#readme"; license = stdenv.lib.licenses.bsd3; }; variant = if doBenchmark then pkgs.haskell.lib.doBenchmark else pkgs.lib.id; drv = variant (haskellPackages.callPackage f { godot-haskell = haskellPackages.callPackage ./godot-haskell.nix {fetchFromGitHub = pkgs.fetchFromGitHub;}; }); in if pkgs.lib.inNixShell then drv.env else drv ================================================ FILE: examples/dodge-the-creeps/src/Game/HUD.hs ================================================ module Game.HUD where import Control.Lens import Control.Monad import qualified Data.Text as T import Godot import Godot.Core.CanvasItem as CanvasItem import Godot.Core.Label as Label import Godot.Core.Timer as Timer import Project.Support import Project.Scenes.HUD() data HUD = HUD { _hBase :: CanvasLayer } instance NodeInit HUD where init = pure . HUD instance NodeMethod HUD "_on_MessageTimer_timeout" '[] (IO ()) where nodeMethod self = getNode' @"MessageLabel" self >>= CanvasItem.hide instance NodeMethod HUD "_on_StartButton_pressed" '[] (IO ()) where nodeMethod self = do getNode' @"StartButton" self >>= CanvasItem.hide emit_signal' @"start_game" self [] instance NodeMethod HUD "show_message" '[GodotString] (IO ()) where nodeMethod = show_message instance NodeMethod HUD "show_game_over" '[] (IO ()) where nodeMethod = show_game_over instance NodeMethod HUD "update_score" '[Int] (IO ()) where nodeMethod = update_score instance NodeSignal HUD "start_game" '[] show_message :: HUD -> GodotString -> IO () show_message self text = do messageLabel <- getNode' @"MessageLabel" self set_text messageLabel text CanvasItem.show messageLabel getNode' @"MessageTimer" self >>= (`Timer.start` Nothing) show_game_over :: HUD -> IO () show_game_over self = do show_message self =<< toLowLevel "Game Over" await' @"MessageTimer" @"timeout" self $ \self' -> do messageLabel <- getNode' @"MessageLabel" self' set_text messageLabel =<< toLowLevel "Dodge the\nCreeps!" CanvasItem.show messageLabel getNode' @"StartButton" self' >>= CanvasItem.show pure () update_score :: HUD -> Int -> IO () update_score self score = do set_text <$> getNode' @"ScoreLabel" self <*> toLowLevel (T.pack $ Prelude.show score) & join setupNode ''HUD "HUD" "HUD" deriveBase ''HUD ================================================ FILE: examples/dodge-the-creeps/src/Game/Main.hs ================================================ module Game.Main where import Control.Lens import Control.Monad import Foreign.C.Types import Godot import Godot.Core.Node as Node import Godot.Core.Node2D as Node2D import Godot.Core.Object as Object import Godot.Core.PackedScene as PackedScene import Godot.Core.PathFollow2D as PathFollow2D import Godot.Core.RigidBody2D as RigidBody2D import Godot.Core.Timer as Timer import Godot.Gdnative import Linear.V2 import System.Random import Project.Support import Project.Scenes.Main() import Game.HUD import Game.Mob import Game.Player() data Main = Main { _base :: Node , _score :: MVar Int , _mobScene :: MVar PackedScene } makeFieldsNoPrefix ''Main instance NodeInit Main where init b = Main b <$> newMVar 0 <*> newEmptyMVar instance NodeMethod Main "_on_MobTimer_timeout" '[] (IO ()) where nodeMethod = on_MobTimer_timeout instance NodeMethod Main "_on_StartTimer_timeout" '[] (IO ()) where nodeMethod = on_StartTimer_timeout instance NodeMethod Main "_on_ScoreTimer_timeout" '[] (IO ()) where nodeMethod = on_ScoreTimer_timeout instance NodeMethod Main "game_over" '[] (IO ()) where nodeMethod = game_over instance NodeMethod Main "new_game" '[] (IO ()) where nodeMethod = new_game instance NodeProperty Main "PackedScene" PackedScene 'False where nodeProperty = createMVarProperty' "PackedScene" _mobScene (Left VariantTypeObject) game_over :: Main -> IO () game_over self = do getNode' @"ScoreTimer" self >>= Timer.stop getNode' @"MobTimer" self >>= Timer.stop getNodeNativeScript' @"HUD" self >>= show_game_over & void new_game :: Main -> IO () new_game self = do void $ swapMVar (self ^. score) 0 position <- getNode' @"StartPosition" self >>= get_position void $ call <$> getNodeNativeScript' @"Player" self <*> toLowLevel "_start" <*> pure [toVariant position] & join getNode' @"StartTimer" self >>= start `flip` Nothing hud <- getNodeNativeScript' @"HUD" self update_score hud 0 show_message hud =<< toLowLevel "Get Ready!" on_StartTimer_timeout :: Main -> IO () on_StartTimer_timeout self = do getNode' @"MobTimer" self >>= start `flip` Nothing getNode' @"ScoreTimer" self >>= start `flip` Nothing on_ScoreTimer_timeout :: Main -> IO () on_ScoreTimer_timeout self = do modifyMVar_ (self ^. score) (pure . (+) 1) update_score <$> getNodeNativeScript' @"HUD" self <*> readMVar (self ^. score) & join on_MobTimer_timeout :: Main -> IO () on_MobTimer_timeout self@(Main _ _ mobScene_) = do -- Choose a random location on Path2D. mobSpawnLoc <- getNode' @"MobPath/MobSpawnLocation" self PathFollow2D.set_offset mobSpawnLoc . fromInteger =<< randomIO -- Create a Mob instance and add it to the scene. mob :: Mob <- readMVar mobScene_ >>= (`PackedScene.instance'` Just 0) >>= (asNativeScript . upcast) >>= maybe (error "Couldn't cast mob to NativeScript") pure add_child self (upcast mob) (Just False) -- Set the mob's direction perpendicular to the path direction. direction <- get_rotation mobSpawnLoc <&> (+ pi / 2) -- Set the mob's position to a random location. Node2D.set_position mob =<< get_position mobSpawnLoc -- Add some randomness to the direction. direction' <- (direction +) <$> randomRIO ((-pi) / 4, pi / 4) set_rotation mob direction' -- Set the velocity' (speed & direction). liftM2 (,) (readMVar $ _mMinSpeed mob) (readMVar $ _mMaxSpeed mob) >>= randomRIO >>= (\x -> toLowLevel (V2 x 0)) >>= (`godot_vector2_rotated` CFloat direction') >>= set_linear_velocity mob setupNode ''Main "Main" "Main" deriveBase ''Main ================================================ FILE: examples/dodge-the-creeps/src/Game/Mob.hs ================================================ module Game.Mob where import Godot import Godot.Core.AnimatedSprite as AnimatedSprite import Godot.Core.Node as Node import System.Random import Project.Support import Project.Scenes.Mob() data Mob = Mob { _mBase :: RigidBody2D , _mMinSpeed :: MVar Float , _mMaxSpeed :: MVar Float , _mMobTypes :: MVar [Text] } instance NodeInit Mob where init base = Mob base <$> newMVar 150 <*> newMVar 250 <*> newMVar ["walk", "swim", "fly"] instance NodeMethod Mob "_ready" '[] (IO ()) where nodeMethod self = do let randElem xs = (xs !!) <$> randomRIO (0, length xs - 1) randAnim <- readMVar (_mMobTypes self) >>= randElem >>= toLowLevel getNode' @"AnimatedSprite" self >>= (`set_animation` randAnim) instance NodeMethod Mob "_on_VisibilityNotifier2D_screen_exited" '[] (IO ()) where nodeMethod = queue_free setupNode ''Mob "Mob" "Mob" deriveBase ''Mob ================================================ FILE: examples/dodge-the-creeps/src/Game/Player.hs ================================================ module Game.Player where import Control.Lens import Control.Monad import Godot import Godot.Core.AnimatedSprite as AnimatedSprite import Godot.Core.CanvasItem as CanvasItem import Godot.Core.CollisionShape2D as CollisionShape2D import Godot.Core.Input as Input import Godot.Core.Node2D as Node2D import Godot.Core.Object as Object import Godot.Gdnative import Linear.Metric (normalize) import Linear.V2 import Linear.Vector import Project.Support import Project.Scenes.Player() data Player = Player { _pBase :: Area2D , _pSpeed :: MVar Float , _pScreenSize :: MVar (V2 Float) } instance NodeInit Player where init base = Player base <$> newMVar 400 <*> newMVar zero instance NodeMethod Player "_ready" '[] (IO ()) where nodeMethod = player_ready instance NodeMethod Player "_process" '[Float] (IO ()) where nodeMethod = player_process instance NodeMethod Player "_start" '[Vector2] (IO ()) where nodeMethod = player_start instance NodeMethod Player "_on_Player_body_entered" '[Node] (IO ()) where nodeMethod self _body = do hide self -- Player disappears after being hit. emit_signal' @"hit" self [] getNode' @"CollisionShape2D" self >>= \cSh -> do disable <- toLowLevel "set_disabled" call_deferred cSh disable [VariantBool True] instance NodeProperty Player "Player" Float 'False where nodeProperty = createMVarProperty' "Player" _pSpeed (Right 400) instance NodeSignal Player "hit" '[] player_ready :: Player -> IO () player_ready self = do screenRect <- get_viewport_rect self >>= fromLowLevel void $ swapMVar (_pScreenSize self) (screenRect ^. _y) hide self player_start :: Player -> Vector2 -> IO () player_start self pos = do set_position self pos CanvasItem.show self getNode' @"CollisionShape2D" self >>= (`set_disabled` False) player_process :: Player -> Float -> IO () player_process self delta = do animSprite <- getNode' @"AnimatedSprite" self screenSize <- get_viewport_rect self >>= fromLowLevel <&> (^. _y) [left, right, up, down] <- do Just inp <- getSingleton @Input let isActionPressed = is_action_pressed inp <=< toLowLevel mapM isActionPressed ["ui_left", "ui_right", "ui_up", "ui_down"] let velocity = let bVal b v = if b then v else 0 in V2 (bVal left (-1) + bVal right 1) (bVal up (-1) + bVal down 1) if velocity /= zero then do speed <- readMVar (_pSpeed self) pos <- get_position self >>= fromLowLevel let velocity' = normalize velocity ^* speed pos' = pos + velocity' ^* delta clamp v a b = max a (min b v) newPos = let posX = clamp (pos' ^. _x) 0 (screenSize ^. _x) posY = clamp (pos' ^. _y) 0 (screenSize ^. _y) in V2 posX posY set_position self =<< toLowLevel newPos animationName <- toLowLevel "" play animSprite (Just animationName) Nothing if velocity' ^. _x /= 0 then do set_animation animSprite =<< toLowLevel "right" -- official demo sets flip_v to false but this is better set_flip_v animSprite (velocity' ^. _y > 0) set_flip_h animSprite (velocity' ^. _x < 0) else when (velocity' ^. _y /= 0) $ do set_animation animSprite =<< toLowLevel "up" set_flip_v animSprite (velocity' ^. _y > 0) else stop animSprite setupNode ''Player "Player" "Player" deriveBase ''Player ================================================ FILE: examples/dodge-the-creeps/src/Lib.hs ================================================ module Lib (exports) where import Godot import Game.Mob import Game.Main import Game.Player import Game.HUD import Project.Support import Project.Requirements exports :: GdnativeHandle -> IO () exports = registerAll' @Nodes @'[HUD, Main, Mob, Player] ================================================ FILE: examples/dodge-the-creeps/src/Project/Requirements.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT module Project.Requirements where import Project.Support type Nodes = '[OneResourceNode "HUD" "HUD", OneResourceNode "Main" "Main", OneResourceNode "Mob" "Mob", OneResourceNode "Player" "Player"] ================================================ FILE: examples/dodge-the-creeps/src/Project/Scenes/HUD.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.HUD where import Project.Support import Godot import GHC.TypeLits import Godot.Core.CanvasLayer() import Godot.Core.Label() import Godot.Core.Timer() import Godot.Core.Button() instance SceneResourcePath "HUD" where sceneResourcePath = "res://HUD.tscn" instance SceneRoot "HUD" where type SceneRootNode "HUD" = "HUD" instance SceneNode "HUD" "HUD" where type SceneNodeType "HUD" "HUD" = CanvasLayer type SceneNodeName "HUD" "HUD" = "HUD" type SceneNodeIsHaskell "HUD" "HUD" = 'Just '("HUD", "HUD") instance SceneNode "HUD" "MessageLabel" where type SceneNodeType "HUD" "MessageLabel" = Label type SceneNodeName "HUD" "MessageLabel" = "MessageLabel" type SceneNodeIsHaskell "HUD" "MessageLabel" = 'Nothing instance SceneNode "HUD" "MessageTimer" where type SceneNodeType "HUD" "MessageTimer" = Timer type SceneNodeName "HUD" "MessageTimer" = "MessageTimer" type SceneNodeIsHaskell "HUD" "MessageTimer" = 'Nothing instance SceneNode "HUD" "ScoreLabel" where type SceneNodeType "HUD" "ScoreLabel" = Label type SceneNodeName "HUD" "ScoreLabel" = "ScoreLabel" type SceneNodeIsHaskell "HUD" "ScoreLabel" = 'Nothing instance SceneNode "HUD" "StartButton" where type SceneNodeType "HUD" "StartButton" = Button type SceneNodeName "HUD" "StartButton" = "StartButton" type SceneNodeIsHaskell "HUD" "StartButton" = 'Nothing instance SceneConnection "HUD" "MessageTimer" "timeout" "HUD" "_on_MessageTimer_timeout" instance SceneConnection "HUD" "StartButton" "pressed" "HUD" "_on_StartButton_pressed" ================================================ FILE: examples/dodge-the-creeps/src/Project/Scenes/Main.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.Main where import Project.Support import Godot import GHC.TypeLits import Godot.Core.ColorRect() import Godot.Core.PackedScene() import Godot.Core.Node() import Godot.Core.Path2D() import Godot.Core.PathFollow2D() import Godot.Core.Timer() import Godot.Core.Position2D() instance SceneResourcePath "Main" where sceneResourcePath = "res://Main.tscn" instance SceneRoot "Main" where type SceneRootNode "Main" = "Main" instance SceneNode "Main" "ColorRect" where type SceneNodeType "Main" "ColorRect" = ColorRect type SceneNodeName "Main" "ColorRect" = "ColorRect" type SceneNodeIsHaskell "Main" "ColorRect" = 'Nothing instance SceneNode "Main" "HUD" where type SceneNodeType "Main" "HUD" = PackedScene' "HUD" type SceneNodeName "Main" "HUD" = "HUD" type SceneNodeIsHaskell "Main" "HUD" = 'Just '("HUD", "HUD") instance SceneNode "Main" "Main" where type SceneNodeType "Main" "Main" = Node type SceneNodeName "Main" "Main" = "Main" type SceneNodeIsHaskell "Main" "Main" = 'Just '("Main", "Main") instance SceneNode "Main" "MobPath" where type SceneNodeType "Main" "MobPath" = Path2D type SceneNodeName "Main" "MobPath" = "MobPath" type SceneNodeIsHaskell "Main" "MobPath" = 'Nothing instance SceneNode "Main" "MobPath/MobSpawnLocation" where type SceneNodeType "Main" "MobPath/MobSpawnLocation" = PathFollow2D type SceneNodeName "Main" "MobPath/MobSpawnLocation" = "MobSpawnLocation" type SceneNodeIsHaskell "Main" "MobPath/MobSpawnLocation" = 'Nothing instance SceneNode "Main" "MobTimer" where type SceneNodeType "Main" "MobTimer" = Timer type SceneNodeName "Main" "MobTimer" = "MobTimer" type SceneNodeIsHaskell "Main" "MobTimer" = 'Nothing instance SceneNode "Main" "Player" where type SceneNodeType "Main" "Player" = PackedScene' "Player" type SceneNodeName "Main" "Player" = "Player" type SceneNodeIsHaskell "Main" "Player" = 'Just '("Player", "Player") instance SceneNode "Main" "ScoreTimer" where type SceneNodeType "Main" "ScoreTimer" = Timer type SceneNodeName "Main" "ScoreTimer" = "ScoreTimer" type SceneNodeIsHaskell "Main" "ScoreTimer" = 'Nothing instance SceneNode "Main" "StartPosition" where type SceneNodeType "Main" "StartPosition" = Position2D type SceneNodeName "Main" "StartPosition" = "StartPosition" type SceneNodeIsHaskell "Main" "StartPosition" = 'Nothing instance SceneNode "Main" "StartTimer" where type SceneNodeType "Main" "StartTimer" = Timer type SceneNodeName "Main" "StartTimer" = "StartTimer" type SceneNodeIsHaskell "Main" "StartTimer" = 'Nothing instance SceneConnection "Main" "HUD" "start_game" "Main" "new_game" instance SceneConnection "Main" "StartTimer" "timeout" "Main" "_on_StartTimer_timeout" instance SceneConnection "Main" "ScoreTimer" "timeout" "Main" "_on_ScoreTimer_timeout" instance SceneConnection "Main" "MobTimer" "timeout" "Main" "_on_MobTimer_timeout" instance SceneConnection "Main" "Player" "hit" "Main" "game_over" ================================================ FILE: examples/dodge-the-creeps/src/Project/Scenes/Mob.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.Mob where import Project.Support import Godot import GHC.TypeLits import Godot.Core.AnimatedSprite() import Godot.Core.CollisionShape2D() import Godot.Core.RigidBody2D() import Godot.Core.VisibilityNotifier2D() instance SceneResourcePath "Mob" where sceneResourcePath = "res://Mob.tscn" instance SceneRoot "Mob" where type SceneRootNode "Mob" = "Mob" instance SceneNode "Mob" "AnimatedSprite" where type SceneNodeType "Mob" "AnimatedSprite" = AnimatedSprite type SceneNodeName "Mob" "AnimatedSprite" = "AnimatedSprite" type SceneNodeIsHaskell "Mob" "AnimatedSprite" = 'Nothing instance SceneNode "Mob" "CollisionShape2D" where type SceneNodeType "Mob" "CollisionShape2D" = CollisionShape2D type SceneNodeName "Mob" "CollisionShape2D" = "CollisionShape2D" type SceneNodeIsHaskell "Mob" "CollisionShape2D" = 'Nothing instance SceneNode "Mob" "Mob" where type SceneNodeType "Mob" "Mob" = RigidBody2D type SceneNodeName "Mob" "Mob" = "Mob" type SceneNodeIsHaskell "Mob" "Mob" = 'Just '("Mob", "Mob") instance SceneNode "Mob" "VisibilityNotifier2D" where type SceneNodeType "Mob" "VisibilityNotifier2D" = VisibilityNotifier2D type SceneNodeName "Mob" "VisibilityNotifier2D" = "VisibilityNotifier2D" type SceneNodeIsHaskell "Mob" "VisibilityNotifier2D" = 'Nothing instance SceneConnection "Mob" "VisibilityNotifier2D" "screen_exited" "Mob" "_on_VisibilityNotifier2D_screen_exited" ================================================ FILE: examples/dodge-the-creeps/src/Project/Scenes/Player.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.Player where import Project.Support import Godot import GHC.TypeLits import Godot.Core.AnimatedSprite() import Godot.Core.CollisionShape2D() import Godot.Core.Area2D() instance SceneResourcePath "Player" where sceneResourcePath = "res://Player.tscn" instance SceneRoot "Player" where type SceneRootNode "Player" = "Player" instance SceneNode "Player" "AnimatedSprite" where type SceneNodeType "Player" "AnimatedSprite" = AnimatedSprite type SceneNodeName "Player" "AnimatedSprite" = "AnimatedSprite" type SceneNodeIsHaskell "Player" "AnimatedSprite" = 'Nothing instance SceneNode "Player" "CollisionShape2D" where type SceneNodeType "Player" "CollisionShape2D" = CollisionShape2D type SceneNodeName "Player" "CollisionShape2D" = "CollisionShape2D" type SceneNodeIsHaskell "Player" "CollisionShape2D" = 'Nothing instance SceneNode "Player" "Player" where type SceneNodeType "Player" "Player" = Area2D type SceneNodeName "Player" "Player" = "Player" type SceneNodeIsHaskell "Player" "Player" = 'Just '("Player", "Player") instance SceneConnection "Player" "Player" "body_entered" "Player" "_on_Player_body_entered" ================================================ FILE: examples/dodge-the-creeps/src/Project/Scenes.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT module Project.Scenes (module M) where import qualified Project.Scenes.HUD as M import qualified Project.Scenes.Main as M import qualified Project.Scenes.Mob as M import qualified Project.Scenes.Player as M ================================================ FILE: examples/dodge-the-creeps/src/Project/Support.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} {-# OPTIONS_GHC -Wno-name-shadowing #-} module Project.Support where import Godot.Core.Object import Godot.Internal.Dispatch import Godot.Gdnative.Internal.Types import Data.Typeable import qualified Data.Text as T import qualified Data.Map as M import Language.Haskell.TH import Language.Haskell.TH.Datatype import Control.Lens import Control.Monad import Godot import Godot.Gdnative import GHC.TypeLits import Data.List import Data.Maybe import Data.Coerce import Godot.Core.ResourceLoader import Godot.Core.PackedScene -- * Helper to keep Haskell types in sync with the Godot project. newtype PackedScene' (scene :: Symbol) = PackedScene' PackedScene deriving newtype AsVariant instance HasBaseClass (PackedScene' scene) where type BaseClass (PackedScene' scene) = PackedScene super = coerce deriveBase ''PackedScene' -- | Use this to register all of your classes, it makes sure that you don't -- forget a class that Godot needs. -- -- exports :: GdnativeHandle -> IO () -- exports desc = registerAll' @Nodes @'[HUD, Main, Mob, Player] desc registerAll' :: forall (res :: [*]) (ns :: [*]). ImplementedInHaskell res ns => GdnativeHandle -> IO () registerAll' = fill @res @ns -- | A safe version of getNode; gives you back the Godot object -- getNode' @"MobPath/MobSpawnLocation" self getNode' :: forall label b cls scene name. (Object :< cls, Node :< cls, Node :< b, NodeInScene scene name cls, SceneNode scene label, SceneNodeType scene label ~ b, KnownSymbol label) => cls -> IO b getNode' o = getNode @(SceneNodeType scene label) o (T.pack $ symbolVal (Proxy @label)) -- | A safe version of getNodeNativeScript; gives you back the Haskell object -- getNodeNativeScript' @"HUD" self getNodeNativeScript' :: forall label b cls scene name scene' label'. (NativeScript b, Node :< cls, Object :< cls, NodeInScene scene name cls, SceneNodeIsHaskell scene label ~ 'Just '(scene', label'), NodeInScene scene' label' b, KnownSymbol label) => cls -> IO b getNodeNativeScript' cls = getNodeNativeScript @b cls (T.pack $ symbolVal (Proxy @label)) -- | A safe version of emit_signal; will error at compile time if the signal doesn't exist -- emit_signal' @"hit" self [] -- TODO We don't check arguments yet! emit_signal' :: forall label args cls. (Object :< cls, Object :< cls, NodeSignal cls label args, KnownSymbol label) => cls -> [Variant 'GodotTy] -> IO () emit_signal' cls args = do name <- toLowLevel (T.pack $ symbolVal (Proxy @label)) emit_signal cls name args -- | A safe version of await; will error at compile time if the signal and nodes don't exist -- await' @"MessageTimer" @"timeout" self $ \self' -> pure () await' :: forall (label :: Symbol) (signal :: Symbol) a b cls scene name. (NodeInScene scene name cls, NativeScript cls, KnownSymbol label, KnownSymbol signal, SceneNode scene label, Node :< cls, AsVariant a, Node :< SceneNodeType scene label, NodeSignal b signal '[], SceneNodeType scene label ~ b) => cls -> (cls -> IO a) -> IO () await' o f = do n <- getNode' @label o await o n (T.pack $ symbolVal (Proxy @signal)) f -- | Preload a scene so you can instantiate it later. -- Use this when the scene is known ahead of time. Store scenes in as @PackedScene' "SceneName"@ preloadScene :: forall scene. (KnownSymbol scene, SceneResourcePath scene) => IO (PackedScene' scene) preloadScene = do Just r <- getSingleton @ResourceLoader path <- toLowLevel $ sceneResourcePath @scene PackedScene' <$> (tryCast' =<< load r path Nothing Nothing) -- | Create an instance of a scene from a @PackedScene' "SceneName"@ -- Makes sure that you are getting the type of the scene root. sceneInstance :: forall scene o. (Node :< o, Typeable o, AsVariant o, SceneNodeType scene (SceneRootNode scene) ~ o) => PackedScene' scene -> IO o sceneInstance e = tryCast' =<< instance' e Nothing -- | Combines nodeMethod with getNode' to call functions in a type-safe way -- Provides no additional safety compared to using the two separately, but does clean up code a bit. -- For example: fn @"MyNode" @"hide" self fn :: forall (node :: Symbol) (func :: Symbol) scene name cls args ret b. (Object :< cls, Node :< cls, Node :< SceneNodeType scene node, NodeInScene scene name cls, SceneNode scene node, NodeMethodSuper (SceneNodeType scene node) func args ret, ListToFun args ret ~ IO b, KnownSymbol node) => cls -> IO b fn self = nodeMethod' @_ @func =<< getNode' @node self -- | Get the file path to the scene class SceneResourcePath (scene :: Symbol) where sceneResourcePath :: forall scene. T.Text -- * Internal helpers: You won't use these -- | The root node of a scene class SceneRoot (scene :: Symbol) where type SceneRootNode scene :: Symbol -- | A node in the scene, we know its type and its name, @s@ is the path relate -- to the scene class (Typeable (SceneNodeType scene s), AsVariant (SceneNodeType scene s), Object :< SceneNodeType scene s) => SceneNode (scene :: Symbol) (s :: Symbol) where type SceneNodeType scene s :: * type SceneNodeName scene s :: Symbol type SceneNodeIsHaskell scene s :: Maybe (Symbol, Symbol) -- | You declare this for your types. You offer up a haskell type, @n@, for the -- node. This class verifies that your base class is correct. class (HasBaseClass n, BaseClass n ~ SceneNodeType scene s) => NodeInScene (scene :: Symbol) (s :: Symbol) n | scene s -> n, n -> scene s -- | A connection between nodes in a scene. @from@ and @to@ are paths. -- It connects @signal@ in @from@ to @method@ in @to@. class SceneConnection (scene :: Symbol) (from :: Symbol) (signal :: Symbol) (to :: Symbol) (method :: Symbol) -- | Internal, just for convenience data OneResourceNode (resource :: Symbol) (name :: Symbol) -- | Internal. Don't touch this and don't make instances of it. It's the -- workhorse for making sure that you are implementing all of the classes that -- Godot needs, nothing more and nothing less. class ImplementedInHaskell (a :: [*]) (b :: [*]) where fill :: GdnativeHandle -> IO () instance ImplementedInHaskell '[] '[] where fill _ = pure () registerOne :: forall ty. (NativeScript ty, AsVariant (BaseClass ty)) => GdnativeHandle -> IO () registerOne desc = registerClass $ RegClass desc $ classInit @ty instance (NodeInScene scene name n, NativeScript n, AsVariant (BaseClass n), ImplementedInHaskell t t', SceneNodeIsHaskell scene name ~ 'Just '(resource, name)) => ImplementedInHaskell (OneResourceNode resource name ': t) (n ': t') where fill handle = do registerOne @n handle fill @t @t' handle -- | Create a signal -- TODO args ~ '[] is temproary, we need signeltons to reflect this into a runtime value signal' :: forall cls label args. (NodeSignal cls label args, KnownSymbol label, args ~ '[]) => (Text, [SignalArgument]) signal' = signal (T.pack $ symbolVal (Proxy @label)) [] createMVarProperty' :: (Typeable ty, AsVariant ty) => Text -> (node -> MVar ty) -- ^ We typically can't do IO (for initialisation) when calling this, in -- which case we need to annotate the type without providing a value. -> Either VariantType ty -> (node -> IO ty ,node -> ty -> IO () ,Maybe (Object -> node -> IO GodotVariant ,Object -> node -> GodotVariant -> IO () ,PropertyAttributes)) createMVarProperty' name fieldName tyOrVal = (readMVar . fieldName, \c t -> propertySetter p undefined c =<< toGodotVariant t, Just (propertyGetter p, propertySetter p, propertyAttrs p)) where p = createMVarProperty name fieldName tyOrVal appsT :: Type -> [Type] -> Type appsT t [] = t appsT t (x:xs) = appsT (AppT t x) xs -- | Verify that the signal connects to an endpoint that exists and has the right type. witnessConnection :: forall (scene :: Symbol) (from :: Symbol) (signal :: Symbol) (to :: Symbol) (method :: Symbol) parent sigTy hTy. (SceneNode scene to, NodeSignal parent signal sigTy, -- TODO This the check unsound, but SceneNodeType isn't right for this constraint. What is? -- The warning produced because 'from' is not used is a reminder of this issue. -- parent :< SceneNodeType scene from, NodeMethod hTy method sigTy (IO ()), NodeInScene scene to hTy) => () witnessConnection = () -- | Sets up a class class NodeInit n where init :: BaseClass n -> IO n -- | You never implement this. It's a helper so that we can have a more -- polymorphic call to nodeMethod which will work when the method is implemneted -- for any parent of the current node. class NodeMethodSuper node (name :: Symbol) (args :: [*]) (ret :: *) | node name -> args, node name -> ret where nodeMethod' :: node -> ListToFun args ret -- | An instance that supports calling nodeMethod' on your parents This can lead -- to infinite loops in the type checker on error, so we isolate it in -- NodeMethodSuper instead of NodeMethod. instance {-# OVERLAPPABLE #-} (NodeMethod (BaseClass node) name arg ret, HasBaseClass node) => NodeMethodSuper node name arg ret where nodeMethod' = nodeMethod' @node @name @arg @ret mkProperty' :: forall node (name :: Symbol) ty. (NodeProperty node name ty 'False, KnownSymbol name) => ClassProperty node mkProperty' = ClassProperty (T.pack $ symbolVal (Proxy @name)) a s g where (_,_,Just (g,s,a)) = nodeProperty @node @name @ty @'False -- | You should use this as: -- setupNode ''Ty -- deriveBase ''Ty -- This will instantiate everything that your Object needs setupNode :: Name -> String -> String -> Q [Dec] setupNode ty scene sceneNode = do -- Collect information about all scenes tree <- map unTree . classInstances <$> reify ''(:<) sceneRoots <- M.fromList . map unSceneRootNode . familyInstances <$> reify ''SceneRootNode sceneNodes <- map unSceneNodeType . familyInstances <$> reify ''SceneNodeType haskellNodes <- map unNodeInScene . classInstances <$> reify ''NodeInScene allSignals <- map unNodeSignal . classInstances <$> reify ''NodeSignal -- Collect information about our node rdt <- reifyDatatype ty let base = case datatypeCons rdt of (c:_) -> case (constructorFields c, constructorVariant c) of (ConT baseTy:_, RecordConstructor (baseFn:_)) -> Just (baseTy, baseFn) _ -> Nothing _ -> Nothing -- methods <- filter (\i -> i^._1 == ty) . mapMaybe unNodeMethod . classInstances <$> reify ''NodeMethod properties <- filter (\i -> i^._1 == ty) . mapMaybe unNodeProperty . classInstances <$> reify ''NodeProperty let signals = filter (\i -> i^._1 == ty) allSignals connections <- filter (\i -> i^._1 == scene && i^._4 == sceneNode) . map unConnect . classInstances <$> reify ''SceneConnection -- Helpers let parentsOf cls = map snd $ filter (\(c,_) -> cls == c) tree let nodeToType :: String -> String -> Name nodeToType scene node = case (hty, ty ^. _4) of (Just t, _) -> t (_, Nothing) -> ty ^. _3 (_, Just scene') -> case M.lookup scene' sceneRoots of Nothing -> error $ "Looking up the root of a scene that is lacking one. This is a bug. " ++ show (scene', scene, node) Just node' -> nodeToType scene' node' where ty = fromJust $ find (\n -> n^._1 == scene && n^._2 == node) sceneNodes hty = (^._3) <$> find (\n -> n^._1 == scene && n^._2 == node) haskellNodes let resolveSignalActualClass scene from signal = case mapMaybe (\p -> (p,) <$> find (\s -> s^._2 == signal && s^._1 == p) allSignals) $ parentsOf (nodeToType scene from) of -- The root issue is that the signal might not yet exist. -- If witnessConnection was not unsound, this would not be needed as the error would happen later. [] -> error $ "Class " ++ show from ++ " used in scene " ++ show scene ++ " is lacking a signal named " ++ show signal ++ "\n" ++ show (nodeToType scene from) ++ "\n" ++ show (parentsOf (nodeToType scene from)) (h:_) -> h ^. _1 -- Debug when False $ runIO $ do putStrLn "Regenerating .." print rdt putStrLn "\nScene roots:" print sceneRoots putStrLn "\nScene nodes types:" mapM_ print sceneNodes putStrLn "\nMethods:" mapM_ print methods putStrLn "\nProperties:" mapM_ print properties putStrLn "\nSignals:" mapM_ print allSignals mapM_ print signals putStrLn "\nConnections:" mapM_ print connections putStrLn "\nHaskell nodes:" mapM_ print haskellNodes -- Generate code bi <- case base of Just (baseTy, baseFn) -> [d|instance HasBaseClass $(pure $ PromotedT ty) where type BaseClass $(pure $ PromotedT ty) = $(pure $ PromotedT baseTy) super = $(pure $ VarE baseFn)|] _ -> error "setupNode can only handle records whose first field is the Godot base class. You can still interface with Godot, but you will need to set things up manually." nis <- [d|instance NodeInScene $(pure $ LitT $ StrTyLit scene) $(pure $ LitT $ StrTyLit sceneNode) $(pure $ PromotedT ty)|] ns <- [d|instance NativeScript $(pure $ PromotedT ty) where classInit = Project.Support.init classMethods = $(ListE <$> mapM (\(t,n,argTy,_) -> let m = case nrArguments argTy of 0 -> [e|method0|] 1 -> [e|method1|] 2 -> [e|method2|] 3 -> [e|method3|] 4 -> [e|method4|] 5 -> [e|method5|] n -> error $ "More arguments than we currently impelement, look for 'method5' for more info " ++ show n in [e|$m $(pure $ LitE $ StringL n) (nodeMethod @ $(pure $ PromotedT t) @ $(pure $ LitT $ StrTyLit n))|]) methods) classProperties = $(ListE <$> mapM (\(name,prop,_,_) -> [e|mkProperty' @ $(pure $ PromotedT name) @ $(pure $ LitT $ StrTyLit prop) |]) properties) classSignals = $(ListE <$> mapM (\(ty,name,_) -> [e|signal' @ $(pure $ PromotedT ty) @ $(pure $ LitT $ StrTyLit name)|]) signals)|] let cn = mkName $ "witness_connections_" ++ nameBase ty ws <- (:) <$> (cn `sigD` [t| [()] |]) <*> [d|$(varP cn) = $(ListE <$> mapM (\(scene,from,signal,to,method) -> [e|witnessConnection @ $(pure $ LitT $ StrTyLit scene) @ $(pure $ LitT $ StrTyLit from) @ $(pure $ LitT $ StrTyLit signal) @ $(pure $ LitT $ StrTyLit to) @ $(pure $ LitT $ StrTyLit method) @ $(pure $ PromotedT $ resolveSignalActualClass scene from signal) |]) connections)|] pure $ bi <> nis <> ns <> ws where unTree (InstanceD Nothing [] (AppT (AppT _ parent) child) []) = (unName child, unName parent) unTree p = error $ "I don't understand this parent " ++ show p unName (ConT x) = x unName (AppT (ConT x) _) = x unName x = error $ "I don't know how to extract the name of this type: " ++ show x unSceneRootNode (TySynInstD (TySynEqn Nothing (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit node)))) = (scene,node) unSceneRootNode x = error $ "Don't know how unpack this SceneRootNode: " ++ show x unSceneNodeType (TySynInstD (TySynEqn Nothing (AppT (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit node))) ty)) = (scene,node,unName ty, unpackScene ty) unSceneNodeType x = error $ "Don't know how unpack this SceneNodeType: " ++ show x unpackScene (ConT _) = Nothing unpackScene (AppT (ConT _) (LitT (StrTyLit scene))) = Just scene unpackScene x = error $ "Don't know how unpack this Scene: " ++ show x unNodeMethod (InstanceD Nothing [] (AppT (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) ret) []) = Just (cls, name, arg, ret) unNodeMethod _ = Nothing unNodeProperty (InstanceD Nothing [] (AppT (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) ret) []) = Just (cls, name, arg, ret) unNodeProperty x = error $ show x unNodeInScene (InstanceD Nothing [] (AppT (AppT (AppT (ConT _) (LitT (StrTyLit scene))) (LitT (StrTyLit node))) (ConT hty)) []) = (scene, node, hty) unNodeInScene x = error $ show x unNodeSignal (InstanceD Nothing [] (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) []) = (cls, name, arg) unNodeSignal _ = error "Bad signal" unConnect (InstanceD Nothing [] (AppT (AppT (AppT (AppT (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit from))) (LitT (StrTyLit signal))) (LitT (StrTyLit to))) (LitT (StrTyLit method))) []) = (scene, from, signal, to, method) unConnect x = error $ "Bad signal" ++ show x nrArguments :: Type -> Int nrArguments (AppT _ r) = 1 + nrArguments r nrArguments (SigT PromotedNilT (AppT ListT StarT)) = 0 nrArguments _ = error "Can't compute # of arguments" classInstances :: Info -> [InstanceDec] classInstances (ClassI _ is) = is classInstances _ = error "Bad class" familyInstances :: Info -> [InstanceDec] familyInstances (FamilyI _ is) = is familyInstances _ = error "Bad class" ================================================ FILE: examples/dodge-the-creeps/stack-shell.nix ================================================ { nixpkgs ? import ./pinned-nixpkgs.nix {} , ghc }: with nixpkgs; haskell.lib.buildStackProject { inherit ghc; name = "myproject"; buildInputs = []; } ================================================ FILE: examples/dodge-the-creeps/stack.yaml ================================================ resolver: nightly-2021-02-06 packages: - . extra-deps: - ../../ require-stack-version: ">=1.8" nix: enable: false pure: true packages: [] shell-file: stack-shell.nix nix-shell-options: [] path: [] add-gc-roots: false ================================================ FILE: examples/rss-reader/.gitignore ================================================ dist* *.hi *.o .stack-work/ .stack-work-devel/ *~ \#* *.import result ================================================ FILE: examples/rss-reader/ChangeLog.md ================================================ # Empty ================================================ FILE: examples/rss-reader/LICENSE ================================================ BSD 3-Clause License Copyright (c) Andrei Barbu 2019 All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ================================================ FILE: examples/rss-reader/Makefile ================================================ NAME = myproject STACKLIBFILE = $(shell stack path --local-install-root)/lib/lib$(NAME).so GODOTPROJECT = $(shell stack path --project-root)/game all: stack nix: nix-build shell.nix cp result/lib/ghc-*/lib$(NAME).so $(GODOTPROJECT)/lib stack: stack build --fast --force-dirty cp $(STACKLIBFILE) $(GODOTPROJECT)/lib stack-nix: stack --nix clean $(NAME) stack --nix build cp $(shell stack --nix path --local-install-root)/lib/lib$(NAME).so $(GODOTPROJECT)/lib stack-run: stack build cp $(STACKLIBFILE) $(GODOTPROJECT)/lib godot -e --path ./game stack-watch: stack build --file-watch --fast --exec "cp $(STACKLIBFILE) $(GODOTPROJECT)/lib" project-watch: stack exec godot-haskell-project-generator game src updatelib: cp $(STACKLIBFILE) $(GODOTPROJECT)/lib ================================================ FILE: examples/rss-reader/README.md ================================================ The official Godot demo from the manual: Dodge the Creeps. Run with `make stack` then `godot game/project.godot` and press F5 to start, F8 to end. Requires Godot 3.1 ================================================ FILE: examples/rss-reader/Support.hs ================================================ {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, OverloadedLabels, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances #-} module Generated.Support where import Godot import GHC.TypeLits class SceneNode (scene :: Symbol) (s :: Symbol) where type SceneNodeType scene s :: * type SceneNodeName scene s :: Symbol class NodeInScheme (scene :: Symbol) (s :: Symbol) n | scene s -> n, n -> scene s ================================================ FILE: examples/rss-reader/ffi/cbits/flib.c ================================================ #include "HsFFI.h" static void flib_init() __attribute__((constructor)); static void flib_init() { static char *argv[] = { "libGodotHaskellPlugin.so", 0 }, **argv_ = argv; static int argc = 1; hs_init(&argc, &argv_); } static void flib_fini() __attribute__((destructor)); static void flib_fini() { hs_exit(); } ================================================ FILE: examples/rss-reader/ffi/flib/FLib.hs ================================================ {-# LANGUAGE ForeignFunctionInterface #-} module FLib where import qualified Foreign import Foreign(nullPtr, Ptr,newForeignPtr_,castPtr) import qualified Godot.Gdnative.Internal as FFI import Godot.Gdnative import Godot.Nativescript import Lib import qualified Data.Text as T import qualified Data.Text.IO as T godot_nativescript_init :: GdnativeHandle -> IO () godot_nativescript_init desc = do defaultExports desc exports desc putStrLn "Haskell NativeScript lib initialized" foreign export ccall godot_nativescript_init :: GdnativeHandle -> IO () godot_gdnative_init :: FFI.GdnativeInitOptionsPtr -> IO () godot_gdnative_init opts = do Foreign.peek opts >>= FFI.initApiStructs foreign export ccall godot_gdnative_init :: FFI.GdnativeInitOptionsPtr -> IO () godot_gdnative_terminate :: FFI.GdnativeTerminateOptionsPtr -> IO () godot_gdnative_terminate handle = pure () foreign export ccall godot_gdnative_terminate :: FFI.GdnativeTerminateOptionsPtr -> IO () ================================================ FILE: examples/rss-reader/game/Rss_reader.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libmyproject.gdnlib" type="GDNativeLibrary" id=1] [resource] resource_name = "RSSReader" class_name = "RSSReader" library = ExtResource( 1 ) ================================================ FILE: examples/rss-reader/game/Rss_reader.tscn ================================================ [gd_scene load_steps=2 format=2] [ext_resource path="res://Rss_reader.gdns" type="Script" id=1] [node name="RSSReader" type="Control"] anchor_right = 1.0 anchor_bottom = 1.0 margin_right = 1102.0 margin_bottom = 168.0 script = ExtResource( 1 ) __meta__ = { "_edit_use_anchors_": false } [node name="OpenButton" type="Button" parent="."] margin_left = 34.48 margin_top = 65.522 margin_right = 179.48 margin_bottom = 106.522 text = "Open" __meta__ = { "_edit_use_anchors_": false } [node name="TextEdit" type="TextEdit" parent="."] visible = false margin_left = 20.9119 margin_top = 575.146 margin_right = 585.912 margin_bottom = 868.146 __meta__ = { "_edit_use_anchors_": false } [node name="HTTPRequest" type="HTTPRequest" parent="."] [node name="ItemList" type="ItemList" parent="."] margin_left = 25.0 margin_top = 137.0 margin_right = 850.0 margin_bottom = 490.0 __meta__ = { "_edit_use_anchors_": false } [node name="DescriptionField" type="TextEdit" parent="."] margin_left = 882.0 margin_top = 137.0 margin_right = 1555.0 margin_bottom = 489.0 readonly = true wrap_enabled = true [node name="LinkButton" type="LinkButton" parent="."] margin_left = 29.8409 margin_top = 496.385 margin_right = 1289.84 margin_bottom = 554.385 __meta__ = { "_edit_use_anchors_": false } [node name="SettingsButton" type="Button" parent="."] margin_left = 1416.23 margin_top = 67.6134 margin_right = 1549.23 margin_bottom = 108.613 text = "Settings" __meta__ = { "_edit_use_anchors_": false } [node name="SettingsDialog" type="WindowDialog" parent="."] margin_left = 352.0 margin_top = 256.0 margin_right = 1340.0 margin_bottom = 538.0 __meta__ = { "_edit_use_anchors_": false } [node name="RSSURLText" type="LineEdit" parent="SettingsDialog"] margin_left = 136.409 margin_top = 89.8409 margin_right = 847.409 margin_bottom = 131.841 __meta__ = { "_edit_use_anchors_": false } [node name="Label" type="Label" parent="SettingsDialog"] margin_left = 135.431 margin_top = 42.4543 margin_right = 436.431 margin_bottom = 80.4543 text = "The RSS feed URL " [node name="Button" type="Button" parent="SettingsDialog"] margin_left = 134.283 margin_top = 161.682 margin_right = 200.283 margin_bottom = 196.682 text = "Clear" [node name="SaveButton" type="Button" parent="SettingsDialog"] margin_left = 784.273 margin_top = 159.841 margin_right = 845.273 margin_bottom = 197.841 text = "Save" __meta__ = { "_edit_use_anchors_": false } [connection signal="ready" from="." to="." method="_on_RSSReader_ready"] [connection signal="pressed" from="OpenButton" to="." method="_on_OpenButton_pressed"] [connection signal="request_completed" from="HTTPRequest" to="." method="_on_HTTPRequest_request_completed"] [connection signal="item_selected" from="ItemList" to="." method="_on_ItemList_item_selected"] [connection signal="pressed" from="LinkButton" to="." method="_on_LinkButton_pressed"] [connection signal="pressed" from="SettingsButton" to="." method="_on_SettingsButton_pressed"] [connection signal="pressed" from="SettingsDialog/Button" to="." method="_on_Settings_Clear_Button_pressed"] [connection signal="pressed" from="SettingsDialog/SaveButton" to="." method="_on_SaveButton_pressed"] ================================================ FILE: examples/rss-reader/game/export_presets.cfg ================================================ [preset.0] name="Linux/X11" platform="Linux/X11" runnable=true custom_features="" export_filter="all_resources" include_filter="" exclude_filter="" export_path="../../../../../../../tmp/rssreader.x86_64" patch_list=PoolStringArray( ) script_export_mode=1 script_encryption_key="" [preset.0.options] texture_format/bptc=false texture_format/s3tc=true texture_format/etc=false texture_format/etc2=false texture_format/no_bptc_fallbacks=true binary_format/64_bits=true binary_format/embed_pck=false custom_template/release="" custom_template/debug="" ================================================ FILE: examples/rss-reader/game/lib/libmyproject.gdnlib ================================================ [general] singleton=false load_once=true symbol_prefix="godot_" reloadable=false [entry] X11.64="res://lib/libmyproject.so" ================================================ FILE: examples/rss-reader/game/project.godot ================================================ ; Engine configuration file. ; It's best edited using the editor UI and not directly, ; since the parameters that go here are not all obvious. ; ; Format: ; [section] ; section goes between [] ; param=value ; assign values to parameters config_version=4 _global_script_classes=[ ] _global_script_class_icons={ } [application] config/name="rss-reader" run/main_scene="res://Rss_reader.tscn" [audio] default_bus_layout="" [display] window/size/width=480 window/size/height=720 window/dpi/allow_hidpi=true [gdnative] singletons=[ ] [gui] theme/use_hidpi=true ================================================ FILE: examples/rss-reader/godot-haskell.nix ================================================ { fetchFromGitHub, mkDerivation, aeson, ansi-wl-pprint, base, bytestring, c2hs , casing, colour, containers, hpack, lens, linear, mtl, parsec , parsers, stdenv, stm, template-haskell, text , unordered-containers, vector }: mkDerivation { pname = "godot-haskell"; version = "3.1.0.0"; src = fetchFromGitHub { owner = "SimulaVR"; repo = "godot-haskell"; rev = "b423d4f2fa5a6a3dcfffb82bb36be571adb29d34"; # godot-haskell rev # Use nix-prefetch-git to get the hash sha256 = "0jh2j5rr90dqdxvcipygwnhhj7j2dj4zvm6gbdpg106ll60pyqrp"; fetchSubmodules = true; }; libraryHaskellDepends = [ aeson ansi-wl-pprint base bytestring casing colour containers lens linear mtl parsec parsers stm template-haskell text unordered-containers vector ]; libraryToolDepends = [ c2hs hpack ]; doHaddock = false; preConfigure = "hpack"; homepage = "https://github.com/KaneTW/godot-haskell#readme"; description = "Haskell bindings for the Godot game engine API"; license = stdenv.lib.licenses.bsd3; } ================================================ FILE: examples/rss-reader/hie.yaml ================================================ cradle: stack: - path: "./src" component: "myproject:lib" - path: "./game" component: "myproject:lib" ================================================ FILE: examples/rss-reader/myproject.cabal ================================================ cabal-version: 1.12 -- This file has been generated from package.yaml by hpack version 0.33.0. -- -- see: https://github.com/sol/hpack -- -- hash: b6a0d2a1fc09513a3765e90723389dc19ec4879f3963404979d2a68731de6d6e name: myproject version: 0.0.0.0 description: Please see the README on Github at homepage: https://github.com/SimulaVR/godot-haskell#readme bug-reports: https://github.com/SimulaVR/godot-haskell/issues author: Andrei Barbu maintainer: andrei@0xab.com copyright: Andrei Barbu 2019, 2021 license: BSD3 license-file: LICENSE build-type: Simple extra-source-files: ChangeLog.md README.md foreign-library myproject type: native-shared other-modules: FLib hs-source-dirs: ffi/flib c-sources: ffi/cbits/flib.c build-depends: base >= 4.12 && <5 , godot-haskell , myproject , text default-language: Haskell2010 source-repository head type: git location: https://github.com/SimulaVR/godot-haskell library exposed-modules: Lib other-modules: Game.RSSReader Project.Requirements Project.Scenes Project.Scenes.Rss_reader Project.Support Paths_myproject hs-source-dirs: src game default-extensions: FlexibleContexts MultiParamTypeClasses OverloadedStrings TemplateHaskell TypeApplications TypeFamilies DataKinds FlexibleInstances ScopedTypeVariables AllowAmbiguousTypes TypeOperators TupleSections ghc-options: -Wall -Wno-orphans -O0 build-depends: aeson , base >=4.12 && <5 , containers , directory , extra , godot-haskell , lens , linear , monad-loops , random , strict-concurrency , template-haskell , text , th-abstraction , vector , xeno default-language: Haskell2010 ================================================ FILE: examples/rss-reader/package.yaml ================================================ name: myproject version: '0.0.0.0' description: Please see the README on Github at author: Andrei Barbu maintainer: andrei@0xab.com copyright: Andrei Barbu 2019, 2021 license: BSD3 github: SimulaVR/godot-haskell extra-source-files: - ChangeLog.md - README.md dependencies: - base >=4.12 && <5 - godot-haskell - linear - random - text - vector - strict-concurrency - lens - template-haskell - th-abstraction - containers - extra - monad-loops - xeno - aeson - directory library: source-dirs: - src - game default-extensions: - FlexibleContexts - MultiParamTypeClasses - OverloadedStrings - TemplateHaskell - TypeApplications - TypeFamilies - DataKinds - FlexibleInstances - ScopedTypeVariables - AllowAmbiguousTypes - TypeOperators - TupleSections exposed-modules: - Lib ghc-options: -Wall -Wno-orphans -O0 verbatim: | foreign-library myproject type: native-shared other-modules: FLib hs-source-dirs: ffi/flib c-sources: ffi/cbits/flib.c build-depends: base >= 4.12 && <5 , godot-haskell , myproject , text default-language: Haskell2010 ================================================ FILE: examples/rss-reader/pinned-nixpkgs.nix ================================================ {}: let # 19.03-beta (25 feb) rev = "0c0954781e257b8b0dc49341795a2fe7d96945a3"; # pinned-nixpkgs rev pkgs = import (builtins.fetchTarball { url = "https://github.com/NixOS/nixpkgs/archive/${rev}.tar.gz"; }) {}; in pkgs ================================================ FILE: examples/rss-reader/shell.nix ================================================ { nixpkgs ? import ./pinned-nixpkgs.nix {} , compiler ? "default" , doBenchmark ? false }: let inherit (nixpkgs) pkgs; haskellPackages = if compiler == "default" then pkgs.haskellPackages else pkgs.haskell.packages.${compiler}; f = { mkDerivation, stdenv, base, godot-haskell, linear, text , vector, stm }: mkDerivation { pname = "myproject"; version = "3.1.0.0"; src = ./.; libraryHaskellDepends = [ base godot-haskell linear text vector stm ]; libraryToolDepends = []; homepage = "https://github.com/abarbu/myproject#readme"; license = stdenv.lib.licenses.bsd3; }; variant = if doBenchmark then pkgs.haskell.lib.doBenchmark else pkgs.lib.id; drv = variant (haskellPackages.callPackage f { godot-haskell = haskellPackages.callPackage ./godot-haskell.nix {fetchFromGitHub = pkgs.fetchFromGitHub;}; }); in if pkgs.lib.inNixShell then drv.env else drv ================================================ FILE: examples/rss-reader/src/Game/RSSReader.hs ================================================ {-# LANGUAGE LambdaCase, FunctionalDependencies, DeriveGeneric, UndecidableInstances, ConstraintKinds #-} module Game.RSSReader where import Control.Lens import Control.Monad import Foreign.Ptr import Godot import Godot.Core.HTTPClient as HTTPClient import Godot.Core.OS as OS import Godot.Core.ItemList as ItemList import Godot.Core.HTTPRequest as HTTPRequest import Godot.Core.TextEdit as TextEdit import Godot.Core.LineEdit as LineEdit import Godot.Core.LinkButton as LinkButton import Godot.Core.Popup as Popup import Godot.Gdnative import Project.Scenes.Rss_reader() import Project.Support import qualified Xeno.DOM.Robust as X import qualified Data.Text as T import qualified Data.Text.Encoding as T import Data.List import Data.Maybe import Data.Typeable import GHC.Generics import qualified Data.Aeson as A import System.Directory import qualified Godot.Core.CanvasItem as CanvasItem data Settings = Settings { _url :: Text } deriving (Generic, Show) instance A.FromJSON Settings instance A.ToJSON Settings makeFieldsNoPrefix ''Settings data Story = Story { _storyTitle :: T.Text , _storyDescription :: Maybe T.Text , _storyLink :: T.Text } deriving Show makeFields ''Story data RSSReader = RSSReader { _base :: Control , _feed :: MVar [Story] } makeFieldsNoPrefix ''RSSReader instance NodeInit RSSReader where init base = RSSReader base <$> newMVar [] instance NodeMethod RSSReader "_on_OpenButton_pressed" '[] (IO ()) where nodeMethod = populateEdit instance NodeMethod RSSReader "populateEdit" '[] (IO ()) where nodeMethod = populateEdit instance NodeMethod RSSReader "_on_HTTPRequest_request_completed" [Int, Int, PoolStringArray, PoolByteArray] (IO ()) where nodeMethod self _ _ _ body = do t <- getNode' @"TextEdit" self sz <- godot_pool_byte_array_size body s <- (\x -> godot_string_chars_to_utf8_with_len (castPtr x) sz) =<< godot_pool_byte_array_read_access_ptr =<< godot_pool_byte_array_read body TextEdit.set_text t s contents <- T.encodeUtf8 <$> fromLowLevel s let stories = parseXML contents lst <- getNode' @"ItemList" self void $ swapMVar (self ^. feed) stories mapM_ (\s -> ItemList.add_item lst <$> toLowLevel (s ^. title) <*> pure Nothing <*> pure (Just True) & join) stories instance NodeMethod RSSReader "_on_ItemList_item_selected" '[Int] (IO ()) where nodeMethod self n = do f <- readMVar (self ^. feed) TextEdit.set_text <$> getNode' @"DescriptionField" self <*> toLowLevel (fromMaybe "" $ (f !! n) ^. description) & join LinkButton.set_text <$> getNode' @"LinkButton" self <*> toLowLevel ((f !! n) ^. link) & join pure () instance NodeMethod RSSReader "_on_LinkButton_pressed" '[] (IO ()) where nodeMethod self = do (Just os) <- getSingleton @OS void $ OS.shell_open os =<< LinkButton.get_text =<< getNode' @"LinkButton" self instance NodeMethod RSSReader "_on_SettingsButton_pressed" '[] (IO ()) where nodeMethod self = do d <- getNode' @"SettingsDialog" self Popup.popup d Nothing instance NodeMethod RSSReader "_on_Settings_Clear_Button_pressed" '[] (IO ()) where nodeMethod self = LineEdit.set_text <$> getNode' @"SettingsDialog/RSSURLText" self <*> toLowLevel "" & join instance NodeMethod RSSReader "_on_RSSReader_ready" '[] (IO ()) where nodeMethod self = loadData self instance NodeMethod RSSReader "_on_SaveButton_pressed" '[] (IO ()) where nodeMethod self = do saveData self CanvasItem.hide =<< getNode' @"SettingsDialog" self pure () clearFields (self :: RSSReader) = do void $ swapMVar (self ^. feed) [] ItemList.clear =<< getNode' @"ItemList" self TextEdit.set_text <$> getNode' @"DescriptionField" self <*> toLowLevel "" & join LinkButton.set_text <$> getNode' @"LinkButton" self <*> toLowLevel "" & join pure () saveData self = do putStrLn "Saving data" (Just os) <- getSingleton @OS d <- fromLowLevel =<< OS.get_user_data_dir os t <- fromLowLevel =<< LineEdit.get_text =<< getNode' @"SettingsDialog/RSSURLText" self A.encodeFile (T.unpack d <> "/save_config.json") (Settings t) loadData self = do putStrLn "Loading data" (Just os) <- getSingleton @OS d <- fromLowLevel =<< OS.get_user_data_dir os e <- doesFileExist (T.unpack d <> "/save_config.json") when e $ do r <- A.decodeFileStrict' (T.unpack d <> "/save_config.json") case r of Nothing -> pure () Just (s :: Settings) -> do LineEdit.set_text <$> getNode' @"SettingsDialog/RSSURLText" self <*> toLowLevel (s ^. url) & join parseXML x = case X.parse x of Right xml -> do case X.children xml of [chan] -> do mapMaybe unItem $ X.children chan _ -> error "Unknown RSS" Left a -> [] where head' (h:_) = Just h head' _ = Nothing byName name nodes = head' . nodeData =<< find (\e -> X.name e == name) nodes nodeData = mapMaybe (\case X.Text t -> Just t X.CData t -> Just t _ -> Nothing) . X.contents unItem item = let nodes = X.children item in do t <- byName "title" nodes l <- byName "link" nodes pure $ Story (T.decodeUtf8 t) (T.decodeUtf8 <$> byName "description" nodes) (T.decodeUtf8 l) nothing :: (Object :< a, Typeable a, AsVariant a) => IO a nothing = fromJust <$> tryCast (Object nullPtr) populateEdit :: RSSReader -> IO () populateEdit self = do url <- LineEdit.get_text =<< getNode' @"SettingsDialog/RSSURLText" self void $ HTTPRequest.request <$> getNode' @"HTTPRequest" self <*> pure url <*> (Just <$> godot_pool_string_array_new) <*> pure (Just True) <*> pure (Just HTTPClient._METHOD_GET) <*> pure Nothing & join setupNode ''RSSReader "Rss_reader" "RSSReader" deriveBase ''RSSReader ================================================ FILE: examples/rss-reader/src/Game/q ================================================ {-# LANGUAGE LambdaCase, FunctionalDependencies, DeriveGeneric, UndecidableInstances, ConstraintKinds #-} module Game.RSSReader where import Control.Lens import Control.Monad import Foreign.Ptr import Godot import Godot.Core.HTTPClient as HTTPClient import Godot.Core.OS as OS import Godot.Core.ItemList as ItemList import Godot.Core.HTTPRequest as HTTPRequest import Godot.Core.TextEdit as TextEdit import Godot.Core.LineEdit as LineEdit import Godot.Core.LinkButton as LinkButton import Godot.Core.Popup as Popup import Godot.Gdnative import Project.Scenes.Rss_reader() import Project.Support import qualified Xeno.DOM.Robust as X import qualified Data.Text as T import qualified Data.Text.Encoding as T import Data.List import Data.Maybe import Data.Typeable import GHC.Generics import qualified Data.Aeson as A import System.Directory import qualified Godot.Core.CanvasItem as CanvasItem data Settings = Settings { _url :: Text } deriving (Generic, Show) instance A.FromJSON Settings instance A.ToJSON Settings makeFieldsNoPrefix ''Settings data Story = Story { _storyTitle :: T.Text , _storyDescription :: Maybe T.Text , _storyLink :: T.Text } deriving Show makeFields ''Story data RSSReader = RSSReader { _base :: Control , _feed :: MVar [Story] } makeFieldsNoPrefix ''RSSReader instance NodeInit RSSReader where init base = RSSReader base <$> newMVar [] instance NodeMethod RSSReader "_on_OpenButton_pressed" '[] (IO ()) where nodeMethod = populateEdit instance NodeMethod RSSReader "populateEdit" '[] (IO ()) where nodeMethod = populateEdit instance NodeMethod RSSReader "_on_HTTPRequest_request_completed" [Int, Int, PoolStringArray, PoolByteArray] (IO ()) where nodeMethod self _ _ _ body = do t <- getNode' @"TextEdit" self sz <- godot_pool_byte_array_size body s <- (\x -> godot_string_chars_to_utf8_with_len (castPtr x) sz) =<< godot_pool_byte_array_read_access_ptr =<< godot_pool_byte_array_read body TextEdit.set_text t s contents <- T.encodeUtf8 <$> fromLowLevel s let stories = parseXML contents lst <- getNode' @"ItemList" self void $ swapMVar (self ^. feed) stories mapM_ (\s -> ItemList.add_item lst <$> toLowLevel (s ^. title) <*> pure Nothing <*> pure (Just True) & join) stories instance NodeMethod RSSReader "_on_ItemList_item_selected" '[Int] (IO ()) where nodeMethod = on_ItemList_item_selected instance NodeMethod RSSReader "_on_LinkButton_pressed" '[] (IO ()) where nodeMethod = on_LinkButton_pressed instance NodeMethod RSSReader "_on_SettingsButton_pressed" '[] (IO ()) where nodeMethod = on_SettingsButton_pressed instance NodeMethod RSSReader "_on_Settings_Clear_Button_pressed" '[] (IO ()) where nodeMethod = on_Settings_Clear_Button_pressed instance NodeMethod RSSReader "_on_RSSReader_ready" '[] (IO ()) where nodeMethod = on_RSSReader_ready instance NodeMethod RSSReader "_on_SaveButton_pressed" '[] (IO ()) where nodeMethod = on_SaveButton_pressed on_RSSReader_ready self = do loadData self on_SaveButton_pressed (self :: RSSReader) = do saveData self CanvasItem.hide =<< getNode' @"SettingsDialog" self pure () clearFields (self :: RSSReader) = do void $ swapMVar (self ^. feed) [] ItemList.clear =<< getNode' @"ItemList" self TextEdit.set_text <$> getNode' @"DescriptionField" self <*> toLowLevel "" & join LinkButton.set_text <$> getNode' @"LinkButton" self <*> toLowLevel "" & join pure () saveData self = do putStrLn "Saving data" (Just os) <- getSingleton @OS d <- fromLowLevel =<< OS.get_user_data_dir os t <- fromLowLevel =<< LineEdit.get_text =<< getNode' @"SettingsDialog/RSSURLText" self A.encodeFile (T.unpack d <> "/save_config.json") (Settings t) loadData self = do putStrLn "Loading data" (Just os) <- getSingleton @OS d <- fromLowLevel =<< OS.get_user_data_dir os e <- doesFileExist (T.unpack d <> "/save_config.json") when e $ do r <- A.decodeFileStrict' (T.unpack d <> "/save_config.json") case r of Nothing -> pure () Just (s :: Settings) -> do LineEdit.set_text <$> getNode' @"SettingsDialog/RSSURLText" self <*> toLowLevel (s ^. url) & join on_Settings_Clear_Button_pressed :: RSSReader -> IO () on_Settings_Clear_Button_pressed self = do LineEdit.set_text <$> getNode' @"SettingsDialog/RSSURLText" self <*> toLowLevel "" & join on_SettingsButton_pressed :: RSSReader -> IO () on_SettingsButton_pressed self = do d <- getNode' @"SettingsDialog" self Popup.popup d Nothing on_LinkButton_pressed :: RSSReader -> IO () on_LinkButton_pressed self = do (Just os) <- getSingleton @OS void $ OS.shell_open os =<< LinkButton.get_text =<< getNode' @"LinkButton" self on_ItemList_item_selected :: RSSReader -> Int -> IO () on_ItemList_item_selected self n = do f <- readMVar (self ^. feed) TextEdit.set_text <$> getNode' @"DescriptionField" self <*> toLowLevel (fromMaybe "" $ (f !! n) ^. description) & join LinkButton.set_text <$> getNode' @"LinkButton" self <*> toLowLevel ((f !! n) ^. link) & join pure () parseXML x = case X.parse x of Right xml -> do case X.children xml of [chan] -> do mapMaybe unItem $ X.children chan _ -> error "Unknown RSS" Left a -> [] where head' (h:_) = Just h head' _ = Nothing byName name nodes = head' . nodeData =<< find (\e -> X.name e == name) nodes nodeData = mapMaybe (\case X.Text t -> Just t X.CData t -> Just t _ -> Nothing) . X.contents unItem item = let nodes = X.children item in do t <- byName "title" nodes l <- byName "link" nodes pure $ Story (T.decodeUtf8 t) (T.decodeUtf8 <$> byName "description" nodes) (T.decodeUtf8 l) nothing :: (Object :< a, Typeable a, AsVariant a) => IO a nothing = fromJust <$> tryCast (Object nullPtr) on_HTTPRequest_request_completed :: RSSReader -> Int -> Int -> PoolStringArray -> PoolByteArray -> IO () on_HTTPRequest_request_completed self _ _ _ body = do t <- getNode' @"TextEdit" self sz <- godot_pool_byte_array_size body s <- (\x -> godot_string_chars_to_utf8_with_len (castPtr x) sz) =<< godot_pool_byte_array_read_access_ptr =<< godot_pool_byte_array_read body TextEdit.set_text t s contents <- T.encodeUtf8 <$> fromLowLevel s let stories = parseXML contents lst <- getNode' @"ItemList" self void $ swapMVar (self ^. feed) stories mapM_ (\s -> ItemList.add_item lst <$> toLowLevel (s ^. title) <*> pure Nothing <*> pure (Just True) & join) stories populateEdit :: RSSReader -> IO () populateEdit self = do url <- LineEdit.get_text =<< getNode' @"SettingsDialog/RSSURLText" self void $ HTTPRequest.request <$> getNode' @"HTTPRequest" self <*> pure url <*> (Just <$> godot_pool_string_array_new) <*> pure (Just True) <*> pure (Just HTTPClient._METHOD_GET) <*> pure Nothing & join setupNode ''RSSReader "Rss_reader" "RSSReader" deriveBase ''RSSReader ================================================ FILE: examples/rss-reader/src/Lib.hs ================================================ module Lib (exports) where import Godot import Project.Support import Project.Requirements import Game.RSSReader exports :: GdnativeHandle -> IO () exports = registerAll' @Nodes @'[RSSReader] ================================================ FILE: examples/rss-reader/src/Project/Requirements.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT module Project.Requirements where import Project.Support type Nodes = '[OneResourceNode "Rss_reader" "RSSReader"] ================================================ FILE: examples/rss-reader/src/Project/Scenes/Rss_reader.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.Rss_reader where import Project.Support import Godot import GHC.TypeLits import Godot.Core.Button() import Godot.Core.TextEdit() import Godot.Core.HTTPRequest() import Godot.Core.ItemList() import Godot.Core.Label() import Godot.Core.LinkButton() import Godot.Core.Control() import Godot.Core.LineEdit() import Godot.Core.WindowDialog() instance SceneResourcePath "Rss_reader" where sceneResourcePath = "res://Rss_reader.tscn" instance SceneRoot "Rss_reader" where type SceneRootNode "Rss_reader" = "RSSReader" instance SceneNode "Rss_reader" "SettingsDialog/Button" where type SceneNodeType "Rss_reader" "SettingsDialog/Button" = Button type SceneNodeName "Rss_reader" "SettingsDialog/Button" = "Button" type SceneNodeIsHaskell "Rss_reader" "SettingsDialog/Button" = 'Nothing instance SceneNode "Rss_reader" "DescriptionField" where type SceneNodeType "Rss_reader" "DescriptionField" = TextEdit type SceneNodeName "Rss_reader" "DescriptionField" = "DescriptionField" type SceneNodeIsHaskell "Rss_reader" "DescriptionField" = 'Nothing instance SceneNode "Rss_reader" "HTTPRequest" where type SceneNodeType "Rss_reader" "HTTPRequest" = HTTPRequest type SceneNodeName "Rss_reader" "HTTPRequest" = "HTTPRequest" type SceneNodeIsHaskell "Rss_reader" "HTTPRequest" = 'Nothing instance SceneNode "Rss_reader" "ItemList" where type SceneNodeType "Rss_reader" "ItemList" = ItemList type SceneNodeName "Rss_reader" "ItemList" = "ItemList" type SceneNodeIsHaskell "Rss_reader" "ItemList" = 'Nothing instance SceneNode "Rss_reader" "SettingsDialog/Label" where type SceneNodeType "Rss_reader" "SettingsDialog/Label" = Label type SceneNodeName "Rss_reader" "SettingsDialog/Label" = "Label" type SceneNodeIsHaskell "Rss_reader" "SettingsDialog/Label" = 'Nothing instance SceneNode "Rss_reader" "LinkButton" where type SceneNodeType "Rss_reader" "LinkButton" = LinkButton type SceneNodeName "Rss_reader" "LinkButton" = "LinkButton" type SceneNodeIsHaskell "Rss_reader" "LinkButton" = 'Nothing instance SceneNode "Rss_reader" "OpenButton" where type SceneNodeType "Rss_reader" "OpenButton" = Button type SceneNodeName "Rss_reader" "OpenButton" = "OpenButton" type SceneNodeIsHaskell "Rss_reader" "OpenButton" = 'Nothing instance SceneNode "Rss_reader" "RSSReader" where type SceneNodeType "Rss_reader" "RSSReader" = Control type SceneNodeName "Rss_reader" "RSSReader" = "RSSReader" type SceneNodeIsHaskell "Rss_reader" "RSSReader" = 'Just '("Rss_reader", "RSSReader") instance SceneNode "Rss_reader" "SettingsDialog/RSSURLText" where type SceneNodeType "Rss_reader" "SettingsDialog/RSSURLText" = LineEdit type SceneNodeName "Rss_reader" "SettingsDialog/RSSURLText" = "RSSURLText" type SceneNodeIsHaskell "Rss_reader" "SettingsDialog/RSSURLText" = 'Nothing instance SceneNode "Rss_reader" "SettingsDialog/SaveButton" where type SceneNodeType "Rss_reader" "SettingsDialog/SaveButton" = Button type SceneNodeName "Rss_reader" "SettingsDialog/SaveButton" = "SaveButton" type SceneNodeIsHaskell "Rss_reader" "SettingsDialog/SaveButton" = 'Nothing instance SceneNode "Rss_reader" "SettingsButton" where type SceneNodeType "Rss_reader" "SettingsButton" = Button type SceneNodeName "Rss_reader" "SettingsButton" = "SettingsButton" type SceneNodeIsHaskell "Rss_reader" "SettingsButton" = 'Nothing instance SceneNode "Rss_reader" "SettingsDialog" where type SceneNodeType "Rss_reader" "SettingsDialog" = WindowDialog type SceneNodeName "Rss_reader" "SettingsDialog" = "SettingsDialog" type SceneNodeIsHaskell "Rss_reader" "SettingsDialog" = 'Nothing instance SceneNode "Rss_reader" "TextEdit" where type SceneNodeType "Rss_reader" "TextEdit" = TextEdit type SceneNodeName "Rss_reader" "TextEdit" = "TextEdit" type SceneNodeIsHaskell "Rss_reader" "TextEdit" = 'Nothing instance SceneConnection "Rss_reader" "SettingsDialog/SaveButton" "pressed" "RSSReader" "_on_SaveButton_pressed" instance SceneConnection "Rss_reader" "SettingsDialog/Button" "pressed" "RSSReader" "_on_Settings_Clear_Button_pressed" instance SceneConnection "Rss_reader" "SettingsButton" "pressed" "RSSReader" "_on_SettingsButton_pressed" instance SceneConnection "Rss_reader" "LinkButton" "pressed" "RSSReader" "_on_LinkButton_pressed" instance SceneConnection "Rss_reader" "ItemList" "item_selected" "RSSReader" "_on_ItemList_item_selected" instance SceneConnection "Rss_reader" "HTTPRequest" "request_completed" "RSSReader" "_on_HTTPRequest_request_completed" instance SceneConnection "Rss_reader" "OpenButton" "pressed" "RSSReader" "_on_OpenButton_pressed" instance SceneConnection "Rss_reader" "RSSReader" "ready" "RSSReader" "_on_RSSReader_ready" ================================================ FILE: examples/rss-reader/src/Project/Scenes.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT module Project.Scenes (module M) where import qualified Project.Scenes.Rss_reader as M ================================================ FILE: examples/rss-reader/src/Project/Support.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} {-# OPTIONS_GHC -Wno-name-shadowing #-} module Project.Support where import Godot.Core.Object import Godot.Internal.Dispatch import Godot.Gdnative.Internal.Types import Data.Typeable import qualified Data.Text as T import qualified Data.Map as M import Language.Haskell.TH import Language.Haskell.TH.Datatype import Control.Lens import Control.Monad import Godot import Godot.Gdnative import GHC.TypeLits import Data.List import Data.Maybe import Data.Coerce import Godot.Core.ResourceLoader import Godot.Core.PackedScene -- * Helper to keep Haskell types in sync with the Godot project. newtype PackedScene' (scene :: Symbol) = PackedScene' PackedScene deriving newtype AsVariant instance HasBaseClass (PackedScene' scene) where type BaseClass (PackedScene' scene) = PackedScene super = coerce deriveBase ''PackedScene' -- | Use this to register all of your classes, it makes sure that you don't -- forget a class that Godot needs. -- -- exports :: GdnativeHandle -> IO () -- exports desc = registerAll' @Nodes @'[HUD, Main, Mob, Player] desc registerAll' :: forall (res :: [*]) (ns :: [*]). ImplementedInHaskell res ns => GdnativeHandle -> IO () registerAll' = fill @res @ns -- | A safe version of getNode; gives you back the Godot object -- getNode' @"MobPath/MobSpawnLocation" self getNode' :: forall label b cls scene name. (Object :< cls, Node :< cls, Node :< b, NodeInScene scene name cls, SceneNode scene label, SceneNodeType scene label ~ b, KnownSymbol label) => cls -> IO b getNode' o = getNode @(SceneNodeType scene label) o (T.pack $ symbolVal (Proxy @label)) -- | A safe version of getNodeNativeScript; gives you back the Haskell object -- getNodeNativeScript' @"HUD" self getNodeNativeScript' :: forall label b cls scene name scene' label'. (NativeScript b, Node :< cls, Object :< cls, NodeInScene scene name cls, SceneNodeIsHaskell scene label ~ 'Just '(scene', label'), NodeInScene scene' label' b, KnownSymbol label) => cls -> IO b getNodeNativeScript' cls = getNodeNativeScript @b cls (T.pack $ symbolVal (Proxy @label)) -- | A safe version of emit_signal; will error at compile time if the signal doesn't exist -- emit_signal' @"hit" self [] -- TODO We don't check arguments yet! emit_signal' :: forall label args cls. (Object :< cls, Object :< cls, NodeSignal cls label args, KnownSymbol label) => cls -> [Variant 'GodotTy] -> IO () emit_signal' cls args = do name <- toLowLevel (T.pack $ symbolVal (Proxy @label)) emit_signal cls name args -- | A safe version of await; will error at compile time if the signal and nodes don't exist -- await' @"MessageTimer" @"timeout" self $ \self' -> pure () await' :: forall (label :: Symbol) (signal :: Symbol) a b cls scene name. (NodeInScene scene name cls, NativeScript cls, KnownSymbol label, KnownSymbol signal, SceneNode scene label, Node :< cls, AsVariant a, Node :< SceneNodeType scene label, NodeSignal b signal '[], SceneNodeType scene label ~ b) => cls -> (cls -> IO a) -> IO () await' o f = do n <- getNode' @label o await o n (T.pack $ symbolVal (Proxy @signal)) f -- | Preload a scene so you can instantiate it later. -- Use this when the scene is known ahead of time. Store scenes in as @PackedScene' "SceneName"@ preloadScene :: forall scene. (KnownSymbol scene, SceneResourcePath scene) => IO (PackedScene' scene) preloadScene = do Just r <- getSingleton @ResourceLoader path <- toLowLevel $ sceneResourcePath @scene PackedScene' <$> (tryCast' =<< load r path Nothing Nothing) -- | Create an instance of a scene from a @PackedScene' "SceneName"@ -- Makes sure that you are getting the type of the scene root. sceneInstance :: forall scene o. (Node :< o, Typeable o, AsVariant o, SceneNodeType scene (SceneRootNode scene) ~ o) => PackedScene' scene -> IO o sceneInstance e = tryCast' =<< instance' e Nothing -- | Combines nodeMethod with getNode' to call functions in a type-safe way -- Provides no additional safety compared to using the two separately, but does clean up code a bit. -- For example: fn @"MyNode" @"hide" self fn :: forall (node :: Symbol) (func :: Symbol) scene name cls args ret b. (Object :< cls, Node :< cls, Node :< SceneNodeType scene node, NodeInScene scene name cls, SceneNode scene node, NodeMethodSuper (SceneNodeType scene node) func args ret, ListToFun args ret ~ IO b, KnownSymbol node) => cls -> IO b fn self = nodeMethod' @_ @func =<< getNode' @node self -- | Get the file path to the scene class SceneResourcePath (scene :: Symbol) where sceneResourcePath :: forall scene. T.Text -- * Internal helpers: You won't use these -- | The root node of a scene class SceneRoot (scene :: Symbol) where type SceneRootNode scene :: Symbol -- | A node in the scene, we know its type and its name, @s@ is the path relate -- to the scene class (Typeable (SceneNodeType scene s), AsVariant (SceneNodeType scene s), Object :< SceneNodeType scene s) => SceneNode (scene :: Symbol) (s :: Symbol) where type SceneNodeType scene s :: * type SceneNodeName scene s :: Symbol type SceneNodeIsHaskell scene s :: Maybe (Symbol, Symbol) -- | You declare this for your types. You offer up a haskell type, @n@, for the -- node. This class verifies that your base class is correct. class (HasBaseClass n, BaseClass n ~ SceneNodeType scene s) => NodeInScene (scene :: Symbol) (s :: Symbol) n | scene s -> n, n -> scene s -- | A connection between nodes in a scene. @from@ and @to@ are paths. -- It connects @signal@ in @from@ to @method@ in @to@. class SceneConnection (scene :: Symbol) (from :: Symbol) (signal :: Symbol) (to :: Symbol) (method :: Symbol) -- | Internal, just for convenience data OneResourceNode (resource :: Symbol) (name :: Symbol) -- | Internal. Don't touch this and don't make instances of it. It's the -- workhorse for making sure that you are implementing all of the classes that -- Godot needs, nothing more and nothing less. class ImplementedInHaskell (a :: [*]) (b :: [*]) where fill :: GdnativeHandle -> IO () instance ImplementedInHaskell '[] '[] where fill _ = pure () registerOne :: forall ty. (NativeScript ty, AsVariant (BaseClass ty)) => GdnativeHandle -> IO () registerOne desc = registerClass $ RegClass desc $ classInit @ty instance (NodeInScene scene name n, NativeScript n, AsVariant (BaseClass n), ImplementedInHaskell t t', SceneNodeIsHaskell scene name ~ 'Just '(resource, name)) => ImplementedInHaskell (OneResourceNode resource name ': t) (n ': t') where fill handle = do registerOne @n handle fill @t @t' handle -- | Create a signal -- TODO args ~ '[] is temproary, we need signeltons to reflect this into a runtime value signal' :: forall cls label args. (NodeSignal cls label args, KnownSymbol label, args ~ '[]) => (Text, [SignalArgument]) signal' = signal (T.pack $ symbolVal (Proxy @label)) [] createMVarProperty' :: (Typeable ty, AsVariant ty) => Text -> (node -> MVar ty) -- ^ We typically can't do IO (for initialisation) when calling this, in -- which case we need to annotate the type without providing a value. -> Either VariantType ty -> (node -> IO ty ,node -> ty -> IO () ,Maybe (Object -> node -> IO GodotVariant ,Object -> node -> GodotVariant -> IO () ,PropertyAttributes)) createMVarProperty' name fieldName tyOrVal = (readMVar . fieldName, \c t -> propertySetter p undefined c =<< toGodotVariant t, Just (propertyGetter p, propertySetter p, propertyAttrs p)) where p = createMVarProperty name fieldName tyOrVal appsT :: Type -> [Type] -> Type appsT t [] = t appsT t (x:xs) = appsT (AppT t x) xs -- | Verify that the signal connects to an endpoint that exists and has the right type. witnessConnection :: forall (scene :: Symbol) (from :: Symbol) (signal :: Symbol) (to :: Symbol) (method :: Symbol) parent sigTy hTy. (SceneNode scene to, NodeSignal parent signal sigTy, -- TODO This the check unsound, but SceneNodeType isn't right for this constraint. What is? -- The warning produced because 'from' is not used is a reminder of this issue. -- parent :< SceneNodeType scene from, NodeMethod hTy method sigTy (IO ()), NodeInScene scene to hTy) => () witnessConnection = () -- | Sets up a class class NodeInit n where init :: BaseClass n -> IO n -- | You never implement this. It's a helper so that we can have a more -- polymorphic call to nodeMethod which will work when the method is implemneted -- for any parent of the current node. class NodeMethodSuper node (name :: Symbol) (args :: [*]) (ret :: *) | node name -> args, node name -> ret where nodeMethod' :: node -> ListToFun args ret -- | An instance that supports calling nodeMethod' on your parents This can lead -- to infinite loops in the type checker on error, so we isolate it in -- NodeMethodSuper instead of NodeMethod. instance {-# OVERLAPPABLE #-} (NodeMethod (BaseClass node) name arg ret, HasBaseClass node) => NodeMethodSuper node name arg ret where nodeMethod' = nodeMethod' @node @name @arg @ret mkProperty' :: forall node (name :: Symbol) ty. (NodeProperty node name ty 'False, KnownSymbol name) => ClassProperty node mkProperty' = ClassProperty (T.pack $ symbolVal (Proxy @name)) a s g where (_,_,Just (g,s,a)) = nodeProperty @node @name @ty @'False -- | You should use this as: -- setupNode ''Ty -- deriveBase ''Ty -- This will instantiate everything that your Object needs setupNode :: Name -> String -> String -> Q [Dec] setupNode ty scene sceneNode = do -- Collect information about all scenes tree <- map unTree . classInstances <$> reify ''(:<) sceneRoots <- M.fromList . map unSceneRootNode . familyInstances <$> reify ''SceneRootNode sceneNodes <- map unSceneNodeType . familyInstances <$> reify ''SceneNodeType haskellNodes <- map unNodeInScene . classInstances <$> reify ''NodeInScene allSignals <- map unNodeSignal . classInstances <$> reify ''NodeSignal -- Collect information about our node rdt <- reifyDatatype ty let base = case datatypeCons rdt of (c:_) -> case (constructorFields c, constructorVariant c) of (ConT baseTy:_, RecordConstructor (baseFn:_)) -> Just (baseTy, baseFn) _ -> Nothing _ -> Nothing -- methods <- filter (\i -> i^._1 == ty) . mapMaybe unNodeMethod . classInstances <$> reify ''NodeMethod properties <- filter (\i -> i^._1 == ty) . mapMaybe unNodeProperty . classInstances <$> reify ''NodeProperty let signals = filter (\i -> i^._1 == ty) allSignals connections <- filter (\i -> i^._1 == scene && i^._4 == sceneNode) . map unConnect . classInstances <$> reify ''SceneConnection -- Helpers let parentsOf cls = map snd $ filter (\(c,_) -> cls == c) tree let nodeToType :: String -> String -> Name nodeToType scene node = case (hty, ty ^. _4) of (Just t, _) -> t (_, Nothing) -> ty ^. _3 (_, Just scene') -> case M.lookup scene' sceneRoots of Nothing -> error $ "Looking up the root of a scene that is lacking one. This is a bug. " ++ show (scene', scene, node) Just node' -> nodeToType scene' node' where ty = fromJust $ find (\n -> n^._1 == scene && n^._2 == node) sceneNodes hty = (^._3) <$> find (\n -> n^._1 == scene && n^._2 == node) haskellNodes let resolveSignalActualClass scene from signal = case mapMaybe (\p -> (p,) <$> find (\s -> s^._2 == signal && s^._1 == p) allSignals) $ parentsOf (nodeToType scene from) of -- The root issue is that the signal might not yet exist. -- If witnessConnection was not unsound, this would not be needed as the error would happen later. [] -> error $ "Class " ++ show from ++ " used in scene " ++ show scene ++ " is lacking a signal named " ++ show signal ++ "\n" ++ show (nodeToType scene from) ++ "\n" ++ show (parentsOf (nodeToType scene from)) (h:_) -> h ^. _1 -- Debug when False $ runIO $ do putStrLn "Regenerating .." print rdt putStrLn "\nScene roots:" print sceneRoots putStrLn "\nScene nodes types:" mapM_ print sceneNodes putStrLn "\nMethods:" mapM_ print methods putStrLn "\nProperties:" mapM_ print properties putStrLn "\nSignals:" mapM_ print allSignals mapM_ print signals putStrLn "\nConnections:" mapM_ print connections putStrLn "\nHaskell nodes:" mapM_ print haskellNodes -- Generate code bi <- case base of Just (baseTy, baseFn) -> [d|instance HasBaseClass $(pure $ PromotedT ty) where type BaseClass $(pure $ PromotedT ty) = $(pure $ PromotedT baseTy) super = $(pure $ VarE baseFn)|] _ -> error "setupNode can only handle records whose first field is the Godot base class. You can still interface with Godot, but you will need to set things up manually." nis <- [d|instance NodeInScene $(pure $ LitT $ StrTyLit scene) $(pure $ LitT $ StrTyLit sceneNode) $(pure $ PromotedT ty)|] ns <- [d|instance NativeScript $(pure $ PromotedT ty) where classInit = Project.Support.init classMethods = $(ListE <$> mapM (\(t,n,argTy,_) -> let m = case nrArguments argTy of 0 -> [e|method0|] 1 -> [e|method1|] 2 -> [e|method2|] 3 -> [e|method3|] 4 -> [e|method4|] 5 -> [e|method5|] n -> error $ "More arguments than we currently impelement, look for 'method5' for more info " ++ show n in [e|$m $(pure $ LitE $ StringL n) (nodeMethod @ $(pure $ PromotedT t) @ $(pure $ LitT $ StrTyLit n))|]) methods) classProperties = $(ListE <$> mapM (\(name,prop,_,_) -> [e|mkProperty' @ $(pure $ PromotedT name) @ $(pure $ LitT $ StrTyLit prop) |]) properties) classSignals = $(ListE <$> mapM (\(ty,name,_) -> [e|signal' @ $(pure $ PromotedT ty) @ $(pure $ LitT $ StrTyLit name)|]) signals)|] let cn = mkName $ "witness_connections_" ++ nameBase ty ws <- (:) <$> (cn `sigD` [t| [()] |]) <*> [d|$(varP cn) = $(ListE <$> mapM (\(scene,from,signal,to,method) -> [e|witnessConnection @ $(pure $ LitT $ StrTyLit scene) @ $(pure $ LitT $ StrTyLit from) @ $(pure $ LitT $ StrTyLit signal) @ $(pure $ LitT $ StrTyLit to) @ $(pure $ LitT $ StrTyLit method) @ $(pure $ PromotedT $ resolveSignalActualClass scene from signal) |]) connections)|] pure $ bi <> nis <> ns <> ws where unTree (InstanceD Nothing [] (AppT (AppT _ parent) child) []) = (unName child, unName parent) unTree p = error $ "I don't understand this parent " ++ show p unName (ConT x) = x unName (AppT (ConT x) _) = x unName x = error $ "I don't know how to extract the name of this type: " ++ show x unSceneRootNode (TySynInstD (TySynEqn Nothing (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit node)))) = (scene,node) unSceneRootNode x = error $ "Don't know how unpack this SceneRootNode: " ++ show x unSceneNodeType (TySynInstD (TySynEqn Nothing (AppT (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit node))) ty)) = (scene,node,unName ty, unpackScene ty) unSceneNodeType x = error $ "Don't know how unpack this SceneNodeType: " ++ show x unpackScene (ConT _) = Nothing unpackScene (AppT (ConT _) (LitT (StrTyLit scene))) = Just scene unpackScene x = error $ "Don't know how unpack this Scene: " ++ show x unNodeMethod (InstanceD Nothing [] (AppT (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) ret) []) = Just (cls, name, arg, ret) unNodeMethod _ = Nothing unNodeProperty (InstanceD Nothing [] (AppT (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) ret) []) = Just (cls, name, arg, ret) unNodeProperty x = error $ show x unNodeInScene (InstanceD Nothing [] (AppT (AppT (AppT (ConT _) (LitT (StrTyLit scene))) (LitT (StrTyLit node))) (ConT hty)) []) = (scene, node, hty) unNodeInScene x = error $ show x unNodeSignal (InstanceD Nothing [] (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) []) = (cls, name, arg) unNodeSignal _ = error "Bad signal" unConnect (InstanceD Nothing [] (AppT (AppT (AppT (AppT (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit from))) (LitT (StrTyLit signal))) (LitT (StrTyLit to))) (LitT (StrTyLit method))) []) = (scene, from, signal, to, method) unConnect x = error $ "Bad signal" ++ show x nrArguments :: Type -> Int nrArguments (AppT _ r) = 1 + nrArguments r nrArguments (SigT PromotedNilT (AppT ListT StarT)) = 0 nrArguments _ = error "Can't compute # of arguments" classInstances :: Info -> [InstanceDec] classInstances (ClassI _ is) = is classInstances _ = error "Bad class" familyInstances :: Info -> [InstanceDec] familyInstances (FamilyI _ is) = is familyInstances _ = error "Bad class" ================================================ FILE: examples/rss-reader/stack-shell.nix ================================================ { nixpkgs ? import ./pinned-nixpkgs.nix {} , ghc }: with nixpkgs; haskell.lib.buildStackProject { inherit ghc; name = "myproject"; buildInputs = []; } ================================================ FILE: examples/rss-reader/stack.yaml ================================================ resolver: nightly-2021-02-06 packages: - . extra-deps: - ../../ require-stack-version: ">=1.8" nix: enable: false pure: true packages: [] shell-file: stack-shell.nix nix-shell-options: [] path: [] add-gc-roots: false ================================================ FILE: examples/top-down-ten-minutes/.gitignore ================================================ dist* *.hi *.o .stack-work/ .stack-work-devel/ *~ \#* *.import result ================================================ FILE: examples/top-down-ten-minutes/ChangeLog.md ================================================ # Empty ================================================ FILE: examples/top-down-ten-minutes/LICENSE ================================================ BSD 3-Clause License Copyright (c) Andrei Barbu 2019 All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ================================================ FILE: examples/top-down-ten-minutes/Makefile ================================================ NAME = top-down-ten-minutes STACKLIBFILE = $(shell stack path --local-install-root)/lib/lib$(NAME).so GODOTPROJECT = $(shell stack path --project-root)/game all: stack nix: nix-build shell.nix cp result/lib/ghc-*/lib$(NAME).so $(GODOTPROJECT)/lib stack: stack build --fast --force-dirty cp $(STACKLIBFILE) $(GODOTPROJECT)/lib stack-nix: stack --nix clean $(NAME) stack --nix build cp $(shell stack --nix path --local-install-root)/lib/lib$(NAME).so $(GODOTPROJECT)/lib stack-run: stack build cp $(STACKLIBFILE) $(GODOTPROJECT)/lib godot -e --path ./game stack-watch: stack build --file-watch --fast --exec "cp $(STACKLIBFILE) $(GODOTPROJECT)/lib" project-watch: stack exec godot-haskell-project-generator game src updatelib: cp $(STACKLIBFILE) $(GODOTPROJECT)/lib ================================================ FILE: examples/top-down-ten-minutes/README.md ================================================ The official Godot demo from the manual: Dodge the Creeps. Run with `make stack` then `godot game/project.godot` and press F5 to start, F8 to end. Requires Godot 3.1 ================================================ FILE: examples/top-down-ten-minutes/ffi/cbits/flib.c ================================================ #include "HsFFI.h" static void flib_init() __attribute__((constructor)); static void flib_init() { static char *argv[] = { "libGodotHaskellPlugin.so", 0 }, **argv_ = argv; static int argc = 1; hs_init(&argc, &argv_); } static void flib_fini() __attribute__((destructor)); static void flib_fini() { hs_exit(); } ================================================ FILE: examples/top-down-ten-minutes/ffi/flib/FLib.hs ================================================ {-# LANGUAGE ForeignFunctionInterface #-} module FLib where import qualified Foreign import Foreign(nullPtr, Ptr,newForeignPtr_,castPtr) import qualified Godot.Gdnative.Internal as FFI import Godot.Gdnative import Godot.Nativescript import Lib import qualified Data.Text as T import qualified Data.Text.IO as T godot_nativescript_init :: GdnativeHandle -> IO () godot_nativescript_init desc = do defaultExports desc exports desc putStrLn "Haskell NativeScript lib initialized" foreign export ccall godot_nativescript_init :: GdnativeHandle -> IO () godot_gdnative_init :: FFI.GdnativeInitOptionsPtr -> IO () godot_gdnative_init opts = do Foreign.peek opts >>= FFI.initApiStructs foreign export ccall godot_gdnative_init :: FFI.GdnativeInitOptionsPtr -> IO () godot_gdnative_terminate :: FFI.GdnativeTerminateOptionsPtr -> IO () godot_gdnative_terminate handle = pure () foreign export ccall godot_gdnative_terminate :: FFI.GdnativeTerminateOptionsPtr -> IO () ================================================ FILE: examples/top-down-ten-minutes/game/Bullet.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libtop-down-ten-minutes.gdnlib" type="GDNativeLibrary" id=1] [resource] resource_name = "Bullet" class_name = "Bullet" library = ExtResource( 1 ) ================================================ FILE: examples/top-down-ten-minutes/game/Bullet.tscn ================================================ [gd_scene load_steps=5 format=2] [ext_resource path="res://Player.png" type="Texture" id=1] [ext_resource path="res://Bullet.gdns" type="Script" id=2] [sub_resource type="RectangleShape2D" id=1] extents = Vector2( 4, 1.6 ) [sub_resource type="Animation" id=2] resource_name = "fadeout" length = 0.4 tracks/0/type = "value" tracks/0/path = NodePath("Sprite:modulate") tracks/0/interp = 1 tracks/0/loop_wrap = true tracks/0/imported = false tracks/0/enabled = true tracks/0/keys = { "times": PoolRealArray( 0, 0.3 ), "transitions": PoolRealArray( 1, 1 ), "update": 0, "values": [ Color( 1, 1, 1, 1 ), Color( 0.45098, 0.447059, 0.447059, 0 ) ] } [node name="Bullet" type="RigidBody2D"] collision_layer = 8 continuous_cd = 1 contacts_reported = 1 contact_monitor = true script = ExtResource( 2 ) [node name="CollisionShape2D" type="CollisionShape2D" parent="."] shape = SubResource( 1 ) [node name="Sprite" type="Sprite" parent="."] scale = Vector2( 0.5, 0.2 ) texture = ExtResource( 1 ) [node name="AnimationPlayer" type="AnimationPlayer" parent="."] anims/fadeout = SubResource( 2 ) [connection signal="body_entered" from="." to="." method="_on_Bullet_body_entered"] [connection signal="animation_finished" from="AnimationPlayer" to="." method="_on_AnimationPlayer_animation_finished"] ================================================ FILE: examples/top-down-ten-minutes/game/Enemy.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libtop-down-ten-minutes.gdnlib" type="GDNativeLibrary" id=1] [resource] resource_name = "Enemy" class_name = "Enemy" library = ExtResource( 1 ) ================================================ FILE: examples/top-down-ten-minutes/game/Enemy.tscn ================================================ [gd_scene load_steps=5 format=2] [ext_resource path="res://Player.png" type="Texture" id=1] [ext_resource path="res://Enemy.gdns" type="Script" id=2] [sub_resource type="RectangleShape2D" id=1] extents = Vector2( 6.4, 6.4 ) [sub_resource type="RectangleShape2D" id=2] extents = Vector2( 7.3, 7.3 ) [node name="Enemy" type="KinematicBody2D"] collision_layer = 4 collision_mask = 15 script = ExtResource( 2 ) [node name="CollisionShape2D" type="CollisionShape2D" parent="."] shape = SubResource( 1 ) [node name="Sprite" type="Sprite" parent="."] modulate = Color( 0.709804, 0.180392, 0.180392, 1 ) scale = Vector2( 0.8, 0.8 ) texture = ExtResource( 1 ) [node name="Area2D" type="Area2D" parent="."] priority = 1.0 collision_layer = 0 collision_mask = 8 [node name="CollisionShape2D" type="CollisionShape2D" parent="Area2D"] shape = SubResource( 2 ) [connection signal="body_entered" from="Area2D" to="." method="_on_Area2D_body_entered"] ================================================ FILE: examples/top-down-ten-minutes/game/Explosion.tscn ================================================ [gd_scene load_steps=4 format=2] [sub_resource type="Curve" id=1] _data = [ Vector2( 0, 1 ), 0.0, 0.0, 0, 0, Vector2( 1, 0 ), 0.0, 0.0, 0, 0 ] [sub_resource type="CurveTexture" id=2] curve = SubResource( 1 ) [sub_resource type="ParticlesMaterial" id=3] emission_shape = 1 emission_sphere_radius = 1.0 flag_disable_z = true spread = 180.0 gravity = Vector3( 0, 0, 0 ) initial_velocity = 60.0 initial_velocity_random = 0.75 orbit_velocity = 0.0 orbit_velocity_random = 0.0 tangential_accel = 20.0 tangential_accel_random = 0.3 scale = 5.0 scale_random = 0.4 scale_curve = SubResource( 2 ) color = Color( 0.866667, 0.160784, 0.160784, 1 ) [node name="Particles2D" type="Particles2D"] scale = Vector2( 2, 2 ) emitting = false amount = 30 lifetime = 0.3 one_shot = true explosiveness = 1.0 randomness = 0.5 process_material = SubResource( 3 ) ================================================ FILE: examples/top-down-ten-minutes/game/Player.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libtop-down-ten-minutes.gdnlib" type="GDNativeLibrary" id=1] [resource] resource_name = "Player" class_name = "Player" library = ExtResource( 1 ) ================================================ FILE: examples/top-down-ten-minutes/game/lib/libtop-down-ten-minutes.gdnlib ================================================ [general] singleton=false load_once=false symbol_prefix="godot_" reloadable=true [entry] X11.64="res://lib/libtop-down-ten-minutes.so" [dependencies] X11.64=[ ] ================================================ FILE: examples/top-down-ten-minutes/game/project.godot ================================================ ; Engine configuration file. ; It's best edited using the editor UI and not directly, ; since the parameters that go here are not all obvious. ; ; Format: ; [section] ; section goes between [] ; param=value ; assign values to parameters config_version=4 _global_script_classes=[ ] _global_script_class_icons={ } [application] config/name="Top Down Ten Minutes" run/main_scene="res://world.tscn" [audio] default_bus_layout="" [display] window/dpi/allow_hidpi=true [gdnative] singletons=[ ] [input] right={ "deadzone": 0.5, "events": [ Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"pressed":false,"scancode":68,"unicode":0,"echo":false,"script":null) ] } left={ "deadzone": 0.5, "events": [ Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"pressed":false,"scancode":65,"unicode":0,"echo":false,"script":null) ] } up={ "deadzone": 0.5, "events": [ Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"pressed":false,"scancode":87,"unicode":0,"echo":false,"script":null) ] } down={ "deadzone": 0.5, "events": [ Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"pressed":false,"scancode":83,"unicode":0,"echo":false,"script":null) ] } LMB={ "deadzone": 0.5, "events": [ Object(InputEventMouseButton,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"button_mask":0,"position":Vector2( 0, 0 ),"global_position":Vector2( 0, 0 ),"factor":1.0,"button_index":1,"pressed":false,"doubleclick":false,"script":null) ] } [layer_names] 2d_physics/layer_1="World" 2d_physics/layer_2="Player" 2d_physics/layer_3="Enemies" 2d_physics/layer_4="Bullets" ================================================ FILE: examples/top-down-ten-minutes/game/wall.tres ================================================ [gd_resource type="TileSet" load_steps=4 format=2] [ext_resource path="res://Player.png" type="Texture" id=1] [sub_resource type="OccluderPolygon2D" id=1] polygon = PoolVector2Array( -7.97656, -8.02344, -7.96094, 8.03125, 7.98438, 7.97735, 7.98438, 7.97735, 7.99219, -8.01562 ) [sub_resource type="RectangleShape2D" id=2] extents = Vector2( 8, 8 ) [resource] 0/name = "Sprite" 0/texture = ExtResource( 1 ) 0/tex_offset = Vector2( 0, 0 ) 0/modulate = Color( 0, 0, 0, 1 ) 0/region = Rect2( 0, 0, 16, 16 ) 0/tile_mode = 0 0/occluder_offset = Vector2( 8, 8 ) 0/occluder = SubResource( 1 ) 0/navigation_offset = Vector2( 8, 8 ) 0/shape_offset = Vector2( 8, 8 ) 0/shape_transform = Transform2D( 1, 0, 0, 1, 8, 8 ) 0/shape = SubResource( 2 ) 0/shape_one_way = false 0/shape_one_way_margin = 1.0 0/shapes = [ { "autotile_coord": Vector2( 0, 0 ), "one_way": false, "one_way_margin": 1.0, "shape": SubResource( 2 ), "shape_transform": Transform2D( 1, 0, 0, 1, 8, 8 ) } ] 0/z_index = 0 ================================================ FILE: examples/top-down-ten-minutes/game/world.tscn ================================================ [gd_scene load_steps=8 format=2] [ext_resource path="res://Player.png" type="Texture" id=1] [ext_resource path="res://Player.gdns" type="Script" id=2] [ext_resource path="res://Enemy.tscn" type="PackedScene" id=3] [ext_resource path="res://wall.tres" type="TileSet" id=4] [ext_resource path="res://spotlight.png" type="Texture" id=5] [sub_resource type="RectangleShape2D" id=1] extents = Vector2( 8, 8 ) [sub_resource type="RectangleShape2D" id=2] extents = Vector2( 9, 9 ) [node name="world" type="Node2D"] [node name="Player" type="KinematicBody2D" parent="."] position = Vector2( 330.5, 194.5 ) collision_layer = 2 collision_mask = 5 script = ExtResource( 2 ) [node name="CollisionShape2D" type="CollisionShape2D" parent="Player"] shape = SubResource( 1 ) [node name="Sprite" type="Sprite" parent="Player"] texture = ExtResource( 1 ) [node name="Area2D" type="Area2D" parent="Player"] collision_layer = 2 collision_mask = 4 [node name="CollisionShape2D" type="CollisionShape2D" parent="Player/Area2D"] shape = SubResource( 2 ) [node name="Camera2D" type="Camera2D" parent="Player"] current = true zoom = Vector2( 0.6, 0.6 ) smoothing_enabled = true [node name="Light2D" type="Light2D" parent="Player"] texture = ExtResource( 5 ) texture_scale = 0.5 color = Color( 1, 0.83, 0.83, 1 ) energy = 1.17 shadow_enabled = true shadow_filter = 5 [node name="Enemy1" parent="." instance=ExtResource( 3 )] position = Vector2( 0, 3 ) [node name="Enemy2" parent="." instance=ExtResource( 3 )] position = Vector2( 508.258, 9.2363 ) [node name="Enemy3" parent="." instance=ExtResource( 3 )] position = Vector2( 755.478, 365.833 ) [node name="Enemy4" parent="." instance=ExtResource( 3 )] position = Vector2( 264.783, 538.139 ) [node name="Enemy5" parent="." instance=ExtResource( 3 )] position = Vector2( -97.8076, 440 ) [node name="Enemy6" parent="." instance=ExtResource( 3 )] position = Vector2( 545.715, 259.454 ) [node name="Enemy7" parent="." instance=ExtResource( 3 )] position = Vector2( 800.427, -84.4079 ) [node name="Enemy8" parent="." instance=ExtResource( 3 )] position = Vector2( 827.367, 126.615 ) [node name="Enemy9" parent="." instance=ExtResource( 3 )] position = Vector2( 315.524, 688.968 ) [node name="Enemy10" parent="." instance=ExtResource( 3 )] position = Vector2( -108.767, 152.432 ) [node name="Sprite" type="Sprite" parent="."] modulate = Color( 0.26, 0.0728, 0.0728, 1 ) position = Vector2( 2306.69, 771.311 ) scale = Vector2( 509.45, 336.746 ) z_index = -1 texture = ExtResource( 1 ) [node name="TileMap" type="TileMap" parent="."] tile_set = ExtResource( 4 ) cell_size = Vector2( 16, 16 ) cell_custom_transform = Transform2D( 0, 0, 0, 0, 0, 0 ) format = 1 tile_data = PoolIntArray( -720887, -1073741824, 0, -720886, -1073741824, 0, -720885, -1073741824, 0, -720884, -1073741824, 0, -720883, -1073741824, 0, -720882, -1073741824, 0, -720881, -1073741824, 0, -720880, -1073741824, 0, -720879, -1073741824, 0, -720878, -1073741824, 0, -720877, -1073741824, 0, -720876, -1073741824, 0, -720875, -1073741824, 0, -720874, -1073741824, 0, -720873, -1073741824, 0, -720872, -1073741824, 0, -720871, -1073741824, 0, -720870, -1073741824, 0, -720869, -1073741824, 0, -720868, -1073741824, 0, -720867, -1073741824, 0, -720866, -1073741824, 0, -720865, -1073741824, 0, -720864, -1073741824, 0, -720863, -1073741824, 0, -720862, -1073741824, 0, -720861, -1073741824, 0, -720860, -1073741824, 0, -720859, -1073741824, 0, -720858, -1073741824, 0, -720857, -1073741824, 0, -720856, -1073741824, 0, -720855, -1073741824, 0, -720854, -1073741824, 0, -720853, -1073741824, 0, -720852, -1073741824, 0, -720851, -1073741824, 0, -720850, -1073741824, 0, -720849, -1073741824, 0, -720848, -1073741824, 0, -720847, -1073741824, 0, -720846, -1073741824, 0, -720845, -1073741824, 0, -720844, -1073741824, 0, -720843, -1073741824, 0, -720842, -1073741824, 0, -720841, -1073741824, 0, -655358, -1073741824, 0, -655357, -1073741824, 0, -655356, -1073741824, 0, -655355, -1073741824, 0, -655354, -1073741824, 0, -655353, -1073741824, 0, -655352, -1073741824, 0, -655351, -1073741824, 0, -655305, -1073741824, 0, -589822, -1073741824, 0, -589769, -1073741824, 0, -458759, -1073741824, 0, -458758, -1073741824, 0, -458757, -1073741824, 0, -458756, -1073741824, 0, -458755, -1073741824, 0, -458754, -1073741824, 0, -458753, -1073741824, 0, -524286, -1073741824, 0, -524261, -1073741824, 0, -524260, -1073741824, 0, -524259, -1073741824, 0, -524258, -1073741824, 0, -524257, -1073741824, 0, -524256, -1073741824, 0, -524233, -1073741824, 0, -524232, -1073741824, 0, -393223, -1073741824, 0, -393217, -1073741824, 0, -458752, -1073741824, 0, -458751, -1073741824, 0, -458750, -1073741824, 0, -458720, -1073741824, 0, -458716, -1073741824, 0, -458715, -1073741824, 0, -458710, -1073741824, 0, -458709, -1073741824, 0, -458696, -1073741824, 0, -327687, -1073741824, 0, -393214, -1073741824, 0, -393213, -1073741824, 0, -393184, -1073741824, 0, -393160, -1073741824, 0, -262151, -1073741824, 0, -327677, -1073741824, 0, -327676, -1073741824, 0, -327664, -1073741824, 0, -327663, -1073741824, 0, -327660, -1073741824, 0, -327659, -1073741824, 0, -327648, -1073741824, 0, -327635, -1073741824, 0, -327634, -1073741824, 0, -327633, -1073741824, 0, -327632, -1073741824, 0, -327624, -1073741824, 0, -196615, -1073741824, 0, -262140, -1073741824, 0, -262139, -1073741824, 0, -262127, -1073741824, 0, -262126, -1073741824, 0, -262125, -1073741824, 0, -262124, -1073741824, 0, -262116, -1073741824, 0, -262115, -1073741824, 0, -262114, -1073741824, 0, -262113, -1073741824, 0, -262112, -1073741824, 0, -262096, -1073741824, 0, -262095, -1073741824, 0, -262088, -1073741824, 0, -131079, -1073741824, 0, -196603, -1073741824, 0, -196590, -1073741824, 0, -196589, -1073741824, 0, -196559, -1073741824, 0, -196552, -1073741824, 0, -65543, -1073741824, 0, -131067, -1073741824, 0, -131066, -1073741824, 0, -131055, -1073741824, 0, -131054, -1073741824, 0, -131053, -1073741824, 0, -131052, -1073741824, 0, -131036, -1073741824, 0, -131035, -1073741824, 0, -131034, -1073741824, 0, -131033, -1073741824, 0, -131032, -1073741824, 0, -131023, -1073741824, 0, -131016, -1073741824, 0, -7, -1073741824, 0, -65530, -1073741824, 0, -65529, -1073741824, 0, -65519, -1073741824, 0, -65518, -1073741824, 0, -65517, -1073741824, 0, -65516, -1073741824, 0, -65500, -1073741824, 0, -65480, -1073741824, 0, 65529, -1073741824, 0, 7, -1073741824, 0, 17, -1073741824, 0, 18, -1073741824, 0, 19, -1073741824, 0, 20, -1073741824, 0, 36, -1073741824, 0, 56, -1073741824, 0, 131065, -1073741824, 0, 65553, -1073741824, 0, 65554, -1073741824, 0, 65555, -1073741824, 0, 65556, -1073741824, 0, 65572, -1073741824, 0, 65573, -1073741824, 0, 65574, -1073741824, 0, 65575, -1073741824, 0, 65576, -1073741824, 0, 65582, -1073741824, 0, 65585, -1073741824, 0, 65592, -1073741824, 0, 196601, -1073741824, 0, 131073, -1073741824, 0, 131118, -1073741824, 0, 131119, -1073741824, 0, 131121, -1073741824, 0, 131128, -1073741824, 0, 262137, -1073741824, 0, 196609, -1073741824, 0, 196655, -1073741824, 0, 196656, -1073741824, 0, 196657, -1073741824, 0, 196664, -1073741824, 0, 327673, -1073741824, 0, 262145, -1073741824, 0, 262200, -1073741824, 0, 393209, -1073741824, 0, 327681, -1073741824, 0, 327714, -1073741824, 0, 327715, -1073741824, 0, 327716, -1073741824, 0, 327717, -1073741824, 0, 327718, -1073741824, 0, 327719, -1073741824, 0, 327720, -1073741824, 0, 327721, -1073741824, 0, 327722, -1073741824, 0, 327736, -1073741824, 0, 458742, -1073741824, 0, 458743, -1073741824, 0, 458744, -1073741824, 0, 458745, -1073741824, 0, 458746, -1073741824, 0, 458749, -1073741824, 0, 458750, -1073741824, 0, 458751, -1073741824, 0, 393216, -1073741824, 0, 393217, -1073741824, 0, 393218, -1073741824, 0, 393219, -1073741824, 0, 393220, -1073741824, 0, 393221, -1073741824, 0, 393222, -1073741824, 0, 393223, -1073741824, 0, 393224, -1073741824, 0, 393225, -1073741824, 0, 393232, -1073741824, 0, 393233, -1073741824, 0, 393234, -1073741824, 0, 393236, -1073741824, 0, 393243, -1073741824, 0, 393258, -1073741824, 0, 393272, -1073741824, 0, 524278, -1073741824, 0, 458767, -1073741824, 0, 458768, -1073741824, 0, 458770, -1073741824, 0, 458771, -1073741824, 0, 458772, -1073741824, 0, 458779, -1073741824, 0, 458794, -1073741824, 0, 458808, -1073741824, 0, 589814, -1073741824, 0, 524315, -1073741824, 0, 524330, -1073741824, 0, 524344, -1073741824, 0, 655350, -1073741824, 0, 655359, -1073741824, 0, 589851, -1073741824, 0, 589866, -1073741824, 0, 589880, -1073741824, 0, 720885, -1073741824, 0, 720886, -1073741824, 0, 720895, -1073741824, 0, 655360, -1073741824, 0, 655387, -1073741824, 0, 655402, -1073741824, 0, 655416, -1073741824, 0, 786421, -1073741824, 0, 720896, -1073741824, 0, 720897, -1073741824, 0, 720911, -1073741824, 0, 720912, -1073741824, 0, 720913, -1073741824, 0, 720914, -1073741824, 0, 720915, -1073741824, 0, 720916, -1073741824, 0, 720923, -1073741824, 0, 720938, -1073741824, 0, 720952, -1073741824, 0, 851957, -1073741824, 0, 786433, -1073741824, 0, 786434, -1073741824, 0, 786459, -1073741824, 0, 786474, -1073741824, 0, 786488, -1073741824, 0, 917493, -1073741824, 0, 851995, -1073741824, 0, 851999, -1073741824, 0, 852000, -1073741824, 0, 852003, -1073741824, 0, 852004, -1073741824, 0, 852010, -1073741824, 0, 852013, -1073741824, 0, 852014, -1073741824, 0, 852015, -1073741824, 0, 852016, -1073741824, 0, 852017, -1073741824, 0, 852024, -1073741824, 0, 983029, -1073741824, 0, 917531, -1073741824, 0, 917535, -1073741824, 0, 917536, -1073741824, 0, 917539, -1073741824, 0, 917540, -1073741824, 0, 917546, -1073741824, 0, 917551, -1073741824, 0, 917559, -1073741824, 0, 917560, -1073741824, 0, 1048565, -1073741824, 0, 983047, -1073741824, 0, 983055, -1073741824, 0, 983056, -1073741824, 0, 983057, -1073741824, 0, 983058, -1073741824, 0, 983059, -1073741824, 0, 983060, -1073741824, 0, 983067, -1073741824, 0, 983082, -1073741824, 0, 983087, -1073741824, 0, 983095, -1073741824, 0, 1114100, -1073741824, 0, 1114101, -1073741824, 0, 1048580, -1073741824, 0, 1048581, -1073741824, 0, 1048582, -1073741824, 0, 1048583, -1073741824, 0, 1048603, -1073741824, 0, 1048618, -1073741824, 0, 1048623, -1073741824, 0, 1048631, -1073741824, 0, 1179636, -1073741824, 0, 1179644, -1073741824, 0, 1179645, -1073741824, 0, 1114115, -1073741824, 0, 1114116, -1073741824, 0, 1114139, -1073741824, 0, 1114144, -1073741824, 0, 1114147, -1073741824, 0, 1114154, -1073741824, 0, 1114159, -1073741824, 0, 1114167, -1073741824, 0, 1245172, -1073741824, 0, 1245181, -1073741824, 0, 1245182, -1073741824, 0, 1179650, -1073741824, 0, 1179651, -1073741824, 0, 1179675, -1073741824, 0, 1179680, -1073741824, 0, 1179681, -1073741824, 0, 1179682, -1073741824, 0, 1179683, -1073741824, 0, 1179687, -1073741824, 0, 1179688, -1073741824, 0, 1179689, -1073741824, 0, 1179690, -1073741824, 0, 1179695, -1073741824, 0, 1179703, -1073741824, 0, 1310708, -1073741824, 0, 1310718, -1073741824, 0, 1310719, -1073741824, 0, 1245186, -1073741824, 0, 1245199, -1073741824, 0, 1245200, -1073741824, 0, 1245202, -1073741824, 0, 1245203, -1073741824, 0, 1245204, -1073741824, 0, 1245211, -1073741824, 0, 1245226, -1073741824, 0, 1245239, -1073741824, 0, 1376243, -1073741824, 0, 1376244, -1073741824, 0, 1376255, -1073741824, 0, 1310721, -1073741824, 0, 1310722, -1073741824, 0, 1310736, -1073741824, 0, 1310737, -1073741824, 0, 1310738, -1073741824, 0, 1310740, -1073741824, 0, 1310747, -1073741824, 0, 1310762, -1073741824, 0, 1310775, -1073741824, 0, 1441779, -1073741824, 0, 1441791, -1073741824, 0, 1376256, -1073741824, 0, 1376257, -1073741824, 0, 1376283, -1073741824, 0, 1376298, -1073741824, 0, 1376311, -1073741824, 0, 1507315, -1073741824, 0, 1441792, -1073741824, 0, 1441819, -1073741824, 0, 1441824, -1073741824, 0, 1441834, -1073741824, 0, 1441846, -1073741824, 0, 1441847, -1073741824, 0, 1572851, -1073741824, 0, 1507328, -1073741824, 0, 1507355, -1073741824, 0, 1507360, -1073741824, 0, 1507370, -1073741824, 0, 1507381, -1073741824, 0, 1507382, -1073741824, 0, 1638387, -1073741824, 0, 1638392, -1073741824, 0, 1638393, -1073741824, 0, 1638394, -1073741824, 0, 1572864, -1073741824, 0, 1572896, -1073741824, 0, 1572906, -1073741824, 0, 1572916, -1073741824, 0, 1572917, -1073741824, 0, 1703923, -1073741824, 0, 1638400, -1073741824, 0, 1638436, -1073741824, 0, 1638437, -1073741824, 0, 1638438, -1073741824, 0, 1638439, -1073741824, 0, 1638440, -1073741824, 0, 1638441, -1073741824, 0, 1638442, -1073741824, 0, 1638452, -1073741824, 0, 1769459, -1073741824, 0, 1769471, -1073741824, 0, 1703936, -1073741824, 0, 1703987, -1073741824, 0, 1703988, -1073741824, 0, 1834995, -1073741824, 0, 1835007, -1073741824, 0, 1769484, -1073741824, 0, 1769485, -1073741824, 0, 1769522, -1073741824, 0, 1769523, -1073741824, 0, 1900531, -1073741824, 0, 1900542, -1073741824, 0, 1900543, -1073741824, 0, 1835021, -1073741824, 0, 1835022, -1073741824, 0, 1835023, -1073741824, 0, 1835024, -1073741824, 0, 1835025, -1073741824, 0, 1835026, -1073741824, 0, 1835027, -1073741824, 0, 1835028, -1073741824, 0, 1835029, -1073741824, 0, 1835030, -1073741824, 0, 1835058, -1073741824, 0, 1966066, -1073741824, 0, 1966067, -1073741824, 0, 1966077, -1073741824, 0, 1966078, -1073741824, 0, 1900593, -1073741824, 0, 1900594, -1073741824, 0, 2031602, -1073741824, 0, 2031612, -1073741824, 0, 2031613, -1073741824, 0, 1966128, -1073741824, 0, 1966129, -1073741824, 0, 2097138, -1073741824, 0, 2097148, -1073741824, 0, 2031661, -1073741824, 0, 2031662, -1073741824, 0, 2031663, -1073741824, 0, 2031664, -1073741824, 0, 2162674, -1073741824, 0, 2097196, -1073741824, 0, 2097197, -1073741824, 0, 2228210, -1073741824, 0, 2162730, -1073741824, 0, 2162731, -1073741824, 0, 2162732, -1073741824, 0, 2293746, -1073741824, 0, 2228265, -1073741824, 0, 2228266, -1073741824, 0, 2359282, -1073741824, 0, 2293772, -1073741824, 0, 2293773, -1073741824, 0, 2293774, -1073741824, 0, 2293775, -1073741824, 0, 2293784, -1073741824, 0, 2293785, -1073741824, 0, 2293786, -1073741824, 0, 2293787, -1073741824, 0, 2293800, -1073741824, 0, 2293801, -1073741824, 0, 2424818, -1073741824, 0, 2359305, -1073741824, 0, 2359306, -1073741824, 0, 2359307, -1073741824, 0, 2359308, -1073741824, 0, 2359311, -1073741824, 0, 2359312, -1073741824, 0, 2359319, -1073741824, 0, 2359320, -1073741824, 0, 2359323, -1073741824, 0, 2359324, -1073741824, 0, 2359335, -1073741824, 0, 2359336, -1073741824, 0, 2490354, -1073741824, 0, 2424840, -1073741824, 0, 2424841, -1073741824, 0, 2424848, -1073741824, 0, 2424854, -1073741824, 0, 2424855, -1073741824, 0, 2424860, -1073741824, 0, 2424870, -1073741824, 0, 2424871, -1073741824, 0, 2555890, -1073741824, 0, 2490373, -1073741824, 0, 2490374, -1073741824, 0, 2490375, -1073741824, 0, 2490376, -1073741824, 0, 2490384, -1073741824, 0, 2490385, -1073741824, 0, 2490386, -1073741824, 0, 2490389, -1073741824, 0, 2490390, -1073741824, 0, 2490396, -1073741824, 0, 2490397, -1073741824, 0, 2490404, -1073741824, 0, 2490405, -1073741824, 0, 2490406, -1073741824, 0, 2621426, -1073741824, 0, 2555908, -1073741824, 0, 2555909, -1073741824, 0, 2555922, -1073741824, 0, 2555923, -1073741824, 0, 2555924, -1073741824, 0, 2555925, -1073741824, 0, 2555933, -1073741824, 0, 2555934, -1073741824, 0, 2555940, -1073741824, 0, 2686962, -1073741824, 0, 2621443, -1073741824, 0, 2621444, -1073741824, 0, 2621475, -1073741824, 0, 2621476, -1073741824, 0, 2752498, -1073741824, 0, 2687011, -1073741824, 0, 2818034, -1073741824, 0, 2818035, -1073741824, 0, 2818036, -1073741824, 0, 2818037, -1073741824, 0, 2752539, -1073741824, 0, 2752546, -1073741824, 0, 2752547, -1073741824, 0, 2883573, -1073741824, 0, 2883574, -1073741824, 0, 2883575, -1073741824, 0, 2883576, -1073741824, 0, 2883577, -1073741824, 0, 2883578, -1073741824, 0, 2883579, -1073741824, 0, 2818061, -1073741824, 0, 2818075, -1073741824, 0, 2818082, -1073741824, 0, 2949115, -1073741824, 0, 2949116, -1073741824, 0, 2949117, -1073741824, 0, 2949118, -1073741824, 0, 2949119, -1073741824, 0, 2883584, -1073741824, 0, 2883597, -1073741824, 0, 2883611, -1073741824, 0, 2883612, -1073741824, 0, 2883618, -1073741824, 0, 2949120, -1073741824, 0, 2949121, -1073741824, 0, 2949122, -1073741824, 0, 2949123, -1073741824, 0, 2949124, -1073741824, 0, 2949125, -1073741824, 0, 2949126, -1073741824, 0, 2949127, -1073741824, 0, 2949128, -1073741824, 0, 2949129, -1073741824, 0, 2949130, -1073741824, 0, 2949131, -1073741824, 0, 2949132, -1073741824, 0, 2949133, -1073741824, 0, 2949134, -1073741824, 0, 2949135, -1073741824, 0, 2949136, -1073741824, 0, 2949137, -1073741824, 0, 2949138, -1073741824, 0, 2949139, -1073741824, 0, 2949140, -1073741824, 0, 2949148, -1073741824, 0, 2949151, -1073741824, 0, 2949152, -1073741824, 0, 2949153, -1073741824, 0, 2949154, -1073741824, 0, 3014676, -1073741824, 0, 3014677, -1073741824, 0, 3014678, -1073741824, 0, 3014679, -1073741824, 0, 3014680, -1073741824, 0, 3014684, -1073741824, 0, 3014687, -1073741824, 0, 3080216, -1073741824, 0, 3080217, -1073741824, 0, 3080218, -1073741824, 0, 3080219, -1073741824, 0, 3080220, -1073741824, 0, 3080221, -1073741824, 0, 3080222, -1073741824, 0, 3080223, -1073741824, 0 ) [connection signal="body_entered" from="Player/Area2D" to="Player" method="_on_Area2D_body_entered"] ================================================ FILE: examples/top-down-ten-minutes/godot-haskell.nix ================================================ { fetchFromGitHub, mkDerivation, aeson, ansi-wl-pprint, base, bytestring, c2hs , casing, colour, containers, hpack, lens, linear, mtl, parsec , parsers, stdenv, stm, template-haskell, text , unordered-containers, vector }: mkDerivation { pname = "godot-haskell"; version = "3.1.0.0"; src = fetchFromGitHub { owner = "SimulaVR"; repo = "godot-haskell"; rev = "b423d4f2fa5a6a3dcfffb82bb36be571adb29d34"; # godot-haskell rev # Use nix-prefetch-git to get the hash sha256 = "0jh2j5rr90dqdxvcipygwnhhj7j2dj4zvm6gbdpg106ll60pyqrp"; fetchSubmodules = true; }; libraryHaskellDepends = [ aeson ansi-wl-pprint base bytestring casing colour containers lens linear mtl parsec parsers stm template-haskell text unordered-containers vector ]; libraryToolDepends = [ c2hs hpack ]; doHaddock = false; preConfigure = "hpack"; homepage = "https://github.com/KaneTW/godot-haskell#readme"; description = "Haskell bindings for the Godot game engine API"; license = stdenv.lib.licenses.bsd3; } ================================================ FILE: examples/top-down-ten-minutes/hie.yaml ================================================ cradle: stack: - path: "./src" component: "top-down-ten-minutes:lib" - path: "./game" component: "top-down-ten-minutes:lib" ================================================ FILE: examples/top-down-ten-minutes/package.yaml ================================================ name: top-down-ten-minutes version: '0.0.0.0' description: Please see the README on Github at author: Andrei Barbu maintainer: andrei@0xab.com copyright: Andrei Barbu 2019, 2021 license: BSD3 github: SimulaVR/godot-haskell extra-source-files: - ChangeLog.md - README.md dependencies: - base >=4.12 && <5 - godot-haskell - linear - random - text - vector - strict-concurrency - lens - template-haskell - th-abstraction - containers - extra - mono-traversable library: source-dirs: - src - game default-extensions: - FlexibleContexts - MultiParamTypeClasses - OverloadedStrings - TemplateHaskell - TypeApplications - TypeFamilies - DataKinds - FlexibleInstances - ScopedTypeVariables - AllowAmbiguousTypes - TupleSections - FunctionalDependencies - LambdaCase - TypeOperators exposed-modules: - Lib ghc-options: -Wall -Wno-orphans -O0 -Wno-name-shadowing verbatim: | foreign-library top-down-ten-minutes type: native-shared other-modules: FLib hs-source-dirs: ffi/flib c-sources: ffi/cbits/flib.c build-depends: base >= 4.12 && <5 , godot-haskell , top-down-ten-minutes , text default-language: Haskell2010 ================================================ FILE: examples/top-down-ten-minutes/pinned-nixpkgs.nix ================================================ {}: let # 19.03-beta (25 feb) rev = "0c0954781e257b8b0dc49341795a2fe7d96945a3"; # pinned-nixpkgs rev pkgs = import (builtins.fetchTarball { url = "https://github.com/NixOS/nixpkgs/archive/${rev}.tar.gz"; }) {}; in pkgs ================================================ FILE: examples/top-down-ten-minutes/shell.nix ================================================ { nixpkgs ? import ./pinned-nixpkgs.nix {} , compiler ? "default" , doBenchmark ? false }: let inherit (nixpkgs) pkgs; haskellPackages = if compiler == "default" then pkgs.haskellPackages else pkgs.haskell.packages.${compiler}; f = { mkDerivation, stdenv, base, godot-haskell, linear, text , vector, stm }: mkDerivation { pname = "top-down-ten-minutes"; version = "3.1.0.0"; src = ./.; libraryHaskellDepends = [ base godot-haskell linear text vector stm ]; libraryToolDepends = []; homepage = "https://github.com/abarbu/top-down-ten-minutes#readme"; license = stdenv.lib.licenses.bsd3; }; variant = if doBenchmark then pkgs.haskell.lib.doBenchmark else pkgs.lib.id; drv = variant (haskellPackages.callPackage f { godot-haskell = haskellPackages.callPackage ./godot-haskell.nix {fetchFromGitHub = pkgs.fetchFromGitHub;}; }); in if pkgs.lib.inNixShell then drv.env else drv ================================================ FILE: examples/top-down-ten-minutes/src/Game/World.hs ================================================ {-# LANGUAGE LambdaCase, TypeOperators #-} {-# OPTIONS_GHC -Wno-name-shadowing #-} module Game.World where import Control.Lens import Control.Monad import Control.Monad.Extra import Godot import Godot.Core.Node as Node import qualified Godot.Core.AnimationPlayer as A import Godot.Core.Input as Input import Godot.Core.KinematicBody2D import Godot.Core.Node2D import Godot.Core.Particles2D import Godot.Core.Object import Godot.Core.PathFollow2D import Godot.Core.RigidBody2D import Godot.Core.Timer as Timer import Godot.Core.CanvasItem import Godot.Core.SceneTree import Godot.Gdnative import Linear.V2 import System.Random import Project.Support import Project.Scenes.World() import Project.Scenes.Bullet() import Project.Scenes.Enemy() import Project.Scenes.Explosion() import Data.String import System.IO.Unsafe import qualified Data.Text as T import Data.Coerce import Data.Maybe import Data.Typeable instance IsString GodotString where fromString = unsafePerformIO . toLowLevel . T.pack data Player = Player { _base :: KinematicBody2D , _movespeed :: Float , _bulletspeed :: Float , _bullet :: MVar (PackedScene' "Bullet") } data Enemy = Enemy { _ebase :: KinematicBody2D , _motion :: Vector2 , _explosion :: MVar (PackedScene' "Explosion") } data Bullet = Bullet { _bbase :: RigidBody2D } makeFieldsNoPrefix ''Player makeFieldsNoPrefix ''Enemy makeFieldsNoPrefix ''Bullet -- * Player instance NodeInit Player where init b = do Player b 500 500 <$> newEmptyMVar instance NodeInit Enemy where init b = Enemy b <$> godot_vector2_new 0 0 <*> newEmptyMVar instance NodeInit Bullet where init b = pure $ Bullet b instance NodeMethod Player "_ready" '[] (IO ()) where nodeMethod self = putMVar (self ^. bullet) =<< preloadScene instance NodeMethod Player "_physics_process" '[Float] (IO ()) where nodeMethod self _ = do Just inp <- getSingleton @Input action <- sum <$> mapM (\(c,v) -> (v *). fromIntegral . fromEnum <$> (is_action_pressed inp =<< toLowLevel c)) [("left", V2 (-1) 0) ,("right", V2 1 0) ,("up", V2 0 (-1)) ,("down", V2 0 1)] motion <- godot_vector2_normalized =<< toLowLevel action motion <- godot_vector2_operator_multiply_scalar motion $ realToFrac (self ^. movespeed) void $ move_and_slide self motion Nothing Nothing Nothing Nothing Nothing look_at self =<< get_global_mouse_position self whenM (is_action_just_pressed inp =<< toLowLevel "LMB") $ fire self instance NodeMethod Player "_on_Area2D_body_entered" '[Node] (IO ()) where nodeMethod self body = do n <- fromLowLevel =<< get_name body when ("Enemy" `T.isInfixOf` n) $ kill self fire :: Player -> IO () fire self = do b <- sceneInstance =<< readMVar (self ^. bullet) set_position b =<< get_global_position self set_rotation_degrees b =<< get_rotation_degrees self apply_impulse b <$> toLowLevel (V2 0 0) <*> (godot_vector2_rotated <$> toLowLevel (V2 (self^.bulletspeed) 0) <*> (realToFrac <$> get_rotation self) & join) & join call_deferred <$> (get_root =<< get_tree self) <*> toLowLevel "add_child" <*> pure [toVariant b] & join -- * Enemy instance NodeMethod Enemy "_ready" '[] (IO ()) where nodeMethod self = putMVar (self ^. explosion) =<< preloadScene instance NodeMethod Enemy "_on_Area2D_body_entered" '[Node] (IO ()) where nodeMethod self body = do n <- fromLowLevel =<< get_name body when ("Bullet" `T.isInfixOf` n) $ do ex <- sceneInstance =<< readMVar (self ^. explosion) set_position ex =<< get_position self set_emitting ex True call_deferred <$> (get_root =<< get_tree self) <*> toLowLevel "add_child" <*> pure [toVariant ex] & join queue_free self kill :: Player -> IO () kill self = void . reload_current_scene =<< get_tree self instance NodeMethod Enemy "_physics_process" '[Float] (IO ()) where nodeMethod self _ = do pl <- get_node <$> get_parent self <*> toLowLevel "Player" & join pp <- get_position =<< tryCast' @Node2D pl ps <- get_position self set_position self =<< godot_vector2_operator_add ps =<< (godot_vector2_operator_divide_scalar <$> godot_vector2_operator_subtract pp ps <*> pure 50 & join) look_at self pp void $ move_and_collide self (self ^. motion) Nothing Nothing Nothing -- * Bullet instance NodeMethod Bullet "_on_Bullet_body_entered" '[Node] (IO ()) where nodeMethod self _ = do n <- getNode' @"AnimationPlayer" self A.play n (Just "fadeout") Nothing Nothing Nothing instance NodeMethod Bullet "_on_AnimationPlayer_animation_finished" '[GodotString] (IO ()) where nodeMethod self _ = queue_free self setupNode ''Player "World" "Player" deriveBase ''Player setupNode ''Enemy "Enemy" "Enemy" deriveBase ''Enemy setupNode ''Bullet "Bullet" "Bullet" deriveBase ''Bullet ================================================ FILE: examples/top-down-ten-minutes/src/Lib.hs ================================================ module Lib (exports) where import Godot import Project.Support import Project.Requirements import Game.World exports :: GdnativeHandle -> IO () exports = registerAll' @Nodes @'[Bullet,Enemy,Player] ================================================ FILE: examples/top-down-ten-minutes/src/Project/Requirements.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT module Project.Requirements where import Project.Support type Nodes = '[OneResourceNode "Bullet" "Bullet", OneResourceNode "Enemy" "Enemy", OneResourceNode "Player" "Player"] ================================================ FILE: examples/top-down-ten-minutes/src/Project/Scenes/Bullet.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.Bullet where import Project.Support import Godot import GHC.TypeLits import Godot.Core.AnimationPlayer() import Godot.Core.RigidBody2D() import Godot.Core.CollisionShape2D() import Godot.Core.Sprite() instance SceneResourcePath "Bullet" where sceneResourcePath = "res://Bullet.tscn" instance SceneRoot "Bullet" where type SceneRootNode "Bullet" = "Bullet" instance SceneNode "Bullet" "AnimationPlayer" where type SceneNodeType "Bullet" "AnimationPlayer" = AnimationPlayer type SceneNodeName "Bullet" "AnimationPlayer" = "AnimationPlayer" type SceneNodeIsHaskell "Bullet" "AnimationPlayer" = 'Nothing instance SceneNode "Bullet" "Bullet" where type SceneNodeType "Bullet" "Bullet" = RigidBody2D type SceneNodeName "Bullet" "Bullet" = "Bullet" type SceneNodeIsHaskell "Bullet" "Bullet" = 'Just '("Bullet", "Bullet") instance SceneNode "Bullet" "CollisionShape2D" where type SceneNodeType "Bullet" "CollisionShape2D" = CollisionShape2D type SceneNodeName "Bullet" "CollisionShape2D" = "CollisionShape2D" type SceneNodeIsHaskell "Bullet" "CollisionShape2D" = 'Nothing instance SceneNode "Bullet" "Sprite" where type SceneNodeType "Bullet" "Sprite" = Sprite type SceneNodeName "Bullet" "Sprite" = "Sprite" type SceneNodeIsHaskell "Bullet" "Sprite" = 'Nothing instance SceneConnection "Bullet" "AnimationPlayer" "animation_finished" "Bullet" "_on_AnimationPlayer_animation_finished" instance SceneConnection "Bullet" "Bullet" "body_entered" "Bullet" "_on_Bullet_body_entered" ================================================ FILE: examples/top-down-ten-minutes/src/Project/Scenes/Enemy.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.Enemy where import Project.Support import Godot import GHC.TypeLits import Godot.Core.Area2D() import Godot.Core.CollisionShape2D() import Godot.Core.KinematicBody2D() import Godot.Core.Sprite() instance SceneResourcePath "Enemy" where sceneResourcePath = "res://Enemy.tscn" instance SceneRoot "Enemy" where type SceneRootNode "Enemy" = "Enemy" instance SceneNode "Enemy" "Area2D" where type SceneNodeType "Enemy" "Area2D" = Area2D type SceneNodeName "Enemy" "Area2D" = "Area2D" type SceneNodeIsHaskell "Enemy" "Area2D" = 'Nothing instance SceneNode "Enemy" "Area2D/CollisionShape2D" where type SceneNodeType "Enemy" "Area2D/CollisionShape2D" = CollisionShape2D type SceneNodeName "Enemy" "Area2D/CollisionShape2D" = "CollisionShape2D" type SceneNodeIsHaskell "Enemy" "Area2D/CollisionShape2D" = 'Nothing instance SceneNode "Enemy" "Enemy" where type SceneNodeType "Enemy" "Enemy" = KinematicBody2D type SceneNodeName "Enemy" "Enemy" = "Enemy" type SceneNodeIsHaskell "Enemy" "Enemy" = 'Just '("Enemy", "Enemy") instance SceneNode "Enemy" "Sprite" where type SceneNodeType "Enemy" "Sprite" = Sprite type SceneNodeName "Enemy" "Sprite" = "Sprite" type SceneNodeIsHaskell "Enemy" "Sprite" = 'Nothing instance SceneConnection "Enemy" "Area2D" "body_entered" "Enemy" "_on_Area2D_body_entered" ================================================ FILE: examples/top-down-ten-minutes/src/Project/Scenes/Explosion.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.Explosion where import Project.Support import Godot import GHC.TypeLits import Godot.Core.Particles2D() instance SceneResourcePath "Explosion" where sceneResourcePath = "res://Explosion.tscn" instance SceneRoot "Explosion" where type SceneRootNode "Explosion" = "Particles2D" instance SceneNode "Explosion" "Particles2D" where type SceneNodeType "Explosion" "Particles2D" = Particles2D type SceneNodeName "Explosion" "Particles2D" = "Particles2D" type SceneNodeIsHaskell "Explosion" "Particles2D" = 'Nothing ================================================ FILE: examples/top-down-ten-minutes/src/Project/Scenes/World.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} module Project.Scenes.World where import Project.Support import Godot import GHC.TypeLits import Godot.Core.Area2D() import Godot.Core.Camera2D() import Godot.Core.CollisionShape2D() import Godot.Core.PackedScene() import Godot.Core.Light2D() import Godot.Core.KinematicBody2D() import Godot.Core.Sprite() import Godot.Core.TileMap() import Godot.Core.Node2D() instance SceneResourcePath "World" where sceneResourcePath = "res://world.tscn" instance SceneRoot "World" where type SceneRootNode "World" = "world" instance SceneNode "World" "Player/Area2D" where type SceneNodeType "World" "Player/Area2D" = Area2D type SceneNodeName "World" "Player/Area2D" = "Area2D" type SceneNodeIsHaskell "World" "Player/Area2D" = 'Nothing instance SceneNode "World" "Player/Camera2D" where type SceneNodeType "World" "Player/Camera2D" = Camera2D type SceneNodeName "World" "Player/Camera2D" = "Camera2D" type SceneNodeIsHaskell "World" "Player/Camera2D" = 'Nothing instance SceneNode "World" "Player/Area2D/CollisionShape2D" where type SceneNodeType "World" "Player/Area2D/CollisionShape2D" = CollisionShape2D type SceneNodeName "World" "Player/Area2D/CollisionShape2D" = "CollisionShape2D" type SceneNodeIsHaskell "World" "Player/Area2D/CollisionShape2D" = 'Nothing instance SceneNode "World" "Enemy1" where type SceneNodeType "World" "Enemy1" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy1" = "Enemy1" type SceneNodeIsHaskell "World" "Enemy1" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy10" where type SceneNodeType "World" "Enemy10" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy10" = "Enemy10" type SceneNodeIsHaskell "World" "Enemy10" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy2" where type SceneNodeType "World" "Enemy2" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy2" = "Enemy2" type SceneNodeIsHaskell "World" "Enemy2" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy3" where type SceneNodeType "World" "Enemy3" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy3" = "Enemy3" type SceneNodeIsHaskell "World" "Enemy3" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy4" where type SceneNodeType "World" "Enemy4" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy4" = "Enemy4" type SceneNodeIsHaskell "World" "Enemy4" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy5" where type SceneNodeType "World" "Enemy5" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy5" = "Enemy5" type SceneNodeIsHaskell "World" "Enemy5" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy6" where type SceneNodeType "World" "Enemy6" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy6" = "Enemy6" type SceneNodeIsHaskell "World" "Enemy6" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy7" where type SceneNodeType "World" "Enemy7" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy7" = "Enemy7" type SceneNodeIsHaskell "World" "Enemy7" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy8" where type SceneNodeType "World" "Enemy8" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy8" = "Enemy8" type SceneNodeIsHaskell "World" "Enemy8" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Enemy9" where type SceneNodeType "World" "Enemy9" = PackedScene' "Enemy" type SceneNodeName "World" "Enemy9" = "Enemy9" type SceneNodeIsHaskell "World" "Enemy9" = 'Just '("Enemy", "Enemy") instance SceneNode "World" "Player/Light2D" where type SceneNodeType "World" "Player/Light2D" = Light2D type SceneNodeName "World" "Player/Light2D" = "Light2D" type SceneNodeIsHaskell "World" "Player/Light2D" = 'Nothing instance SceneNode "World" "Player" where type SceneNodeType "World" "Player" = KinematicBody2D type SceneNodeName "World" "Player" = "Player" type SceneNodeIsHaskell "World" "Player" = 'Just '("Player", "Player") instance SceneNode "World" "Sprite" where type SceneNodeType "World" "Sprite" = Sprite type SceneNodeName "World" "Sprite" = "Sprite" type SceneNodeIsHaskell "World" "Sprite" = 'Nothing instance SceneNode "World" "TileMap" where type SceneNodeType "World" "TileMap" = TileMap type SceneNodeName "World" "TileMap" = "TileMap" type SceneNodeIsHaskell "World" "TileMap" = 'Nothing instance SceneNode "World" "world" where type SceneNodeType "World" "world" = Node2D type SceneNodeName "World" "world" = "world" type SceneNodeIsHaskell "World" "world" = 'Nothing instance SceneConnection "World" "Player/Area2D" "body_entered" "Player" "_on_Area2D_body_entered" ================================================ FILE: examples/top-down-ten-minutes/src/Project/Scenes.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT module Project.Scenes (module M) where import qualified Project.Scenes.Bullet as M import qualified Project.Scenes.Enemy as M import qualified Project.Scenes.Explosion as M import qualified Project.Scenes.World as M ================================================ FILE: examples/top-down-ten-minutes/src/Project/Support.hs ================================================ -- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT {-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase #-} {-# OPTIONS_GHC -Wno-name-shadowing #-} module Project.Support where import Godot.Core.Object import Godot.Internal.Dispatch import Godot.Gdnative.Internal.Types import Data.Typeable import qualified Data.Text as T import qualified Data.Map as M import Language.Haskell.TH import Language.Haskell.TH.Datatype import Control.Lens import Control.Monad import Godot import Godot.Gdnative import GHC.TypeLits import Data.List import Data.Maybe import Data.Coerce import Godot.Core.ResourceLoader import Godot.Core.PackedScene -- * Helper to keep Haskell types in sync with the Godot project. newtype PackedScene' (scene :: Symbol) = PackedScene' PackedScene deriving newtype AsVariant instance HasBaseClass (PackedScene' scene) where type BaseClass (PackedScene' scene) = PackedScene super = coerce deriveBase ''PackedScene' -- | Use this to register all of your classes, it makes sure that you don't -- forget a class that Godot needs. -- -- exports :: GdnativeHandle -> IO () -- exports desc = registerAll' @Nodes @'[HUD, Main, Mob, Player] desc registerAll' :: forall (res :: [*]) (ns :: [*]). ImplementedInHaskell res ns => GdnativeHandle -> IO () registerAll' = fill @res @ns -- | A safe version of getNode; gives you back the Godot object -- getNode' @"MobPath/MobSpawnLocation" self getNode' :: forall label b cls scene name. (Object :< cls, Node :< cls, Node :< b, NodeInScene scene name cls, SceneNode scene label, SceneNodeType scene label ~ b, KnownSymbol label) => cls -> IO b getNode' o = getNode @(SceneNodeType scene label) o (T.pack $ symbolVal (Proxy @label)) -- | A safe version of getNodeNativeScript; gives you back the Haskell object -- getNodeNativeScript' @"HUD" self getNodeNativeScript' :: forall label b cls scene name scene' label'. (NativeScript b, Node :< cls, Object :< cls, NodeInScene scene name cls, SceneNodeIsHaskell scene label ~ 'Just '(scene', label'), NodeInScene scene' label' b, KnownSymbol label) => cls -> IO b getNodeNativeScript' cls = getNodeNativeScript @b cls (T.pack $ symbolVal (Proxy @label)) -- | A safe version of emit_signal; will error at compile time if the signal doesn't exist -- emit_signal' @"hit" self [] -- TODO We don't check arguments yet! emit_signal' :: forall label args cls. (Object :< cls, Object :< cls, NodeSignal cls label args, KnownSymbol label) => cls -> [Variant 'GodotTy] -> IO () emit_signal' cls args = do name <- toLowLevel (T.pack $ symbolVal (Proxy @label)) emit_signal cls name args -- | A safe version of await; will error at compile time if the signal and nodes don't exist -- await' @"MessageTimer" @"timeout" self $ \self' -> pure () await' :: forall (label :: Symbol) (signal :: Symbol) a b cls scene name. (NodeInScene scene name cls, NativeScript cls, KnownSymbol label, KnownSymbol signal, SceneNode scene label, Node :< cls, AsVariant a, Node :< SceneNodeType scene label, NodeSignal b signal '[], SceneNodeType scene label ~ b) => cls -> (cls -> IO a) -> IO () await' o f = do n <- getNode' @label o await o n (T.pack $ symbolVal (Proxy @signal)) f -- | Preload a scene so you can instantiate it later. -- Use this when the scene is known ahead of time. Store scenes in as @PackedScene' "SceneName"@ preloadScene :: forall scene. (KnownSymbol scene, SceneResourcePath scene) => IO (PackedScene' scene) preloadScene = do Just r <- getSingleton @ResourceLoader path <- toLowLevel $ sceneResourcePath @scene PackedScene' <$> (tryCast' =<< load r path Nothing Nothing) -- | Create an instance of a scene from a @PackedScene' "SceneName"@ -- Makes sure that you are getting the type of the scene root. sceneInstance :: forall scene o. (Node :< o, Typeable o, AsVariant o, SceneNodeType scene (SceneRootNode scene) ~ o) => PackedScene' scene -> IO o sceneInstance e = tryCast' =<< instance' e Nothing -- | Combines nodeMethod with getNode' to call functions in a type-safe way -- Provides no additional safety compared to using the two separately, but does clean up code a bit. -- For example: fn @"MyNode" @"hide" self fn :: forall (node :: Symbol) (func :: Symbol) scene name cls args ret b. (Object :< cls, Node :< cls, Node :< SceneNodeType scene node, NodeInScene scene name cls, SceneNode scene node, NodeMethodSuper (SceneNodeType scene node) func args ret, ListToFun args ret ~ IO b, KnownSymbol node) => cls -> IO b fn self = nodeMethod' @_ @func =<< getNode' @node self -- | Get the file path to the scene class SceneResourcePath (scene :: Symbol) where sceneResourcePath :: forall scene. T.Text -- * Internal helpers: You won't use these -- | The root node of a scene class SceneRoot (scene :: Symbol) where type SceneRootNode scene :: Symbol -- | A node in the scene, we know its type and its name, @s@ is the path relate -- to the scene class (Typeable (SceneNodeType scene s), AsVariant (SceneNodeType scene s), Object :< SceneNodeType scene s) => SceneNode (scene :: Symbol) (s :: Symbol) where type SceneNodeType scene s :: * type SceneNodeName scene s :: Symbol type SceneNodeIsHaskell scene s :: Maybe (Symbol, Symbol) -- | You declare this for your types. You offer up a haskell type, @n@, for the -- node. This class verifies that your base class is correct. class (HasBaseClass n, BaseClass n ~ SceneNodeType scene s) => NodeInScene (scene :: Symbol) (s :: Symbol) n | scene s -> n, n -> scene s -- | A connection between nodes in a scene. @from@ and @to@ are paths. -- It connects @signal@ in @from@ to @method@ in @to@. class SceneConnection (scene :: Symbol) (from :: Symbol) (signal :: Symbol) (to :: Symbol) (method :: Symbol) -- | Internal, just for convenience data OneResourceNode (resource :: Symbol) (name :: Symbol) -- | Internal. Don't touch this and don't make instances of it. It's the -- workhorse for making sure that you are implementing all of the classes that -- Godot needs, nothing more and nothing less. class ImplementedInHaskell (a :: [*]) (b :: [*]) where fill :: GdnativeHandle -> IO () instance ImplementedInHaskell '[] '[] where fill _ = pure () registerOne :: forall ty. (NativeScript ty, AsVariant (BaseClass ty)) => GdnativeHandle -> IO () registerOne desc = registerClass $ RegClass desc $ classInit @ty instance (NodeInScene scene name n, NativeScript n, AsVariant (BaseClass n), ImplementedInHaskell t t', SceneNodeIsHaskell scene name ~ 'Just '(resource, name)) => ImplementedInHaskell (OneResourceNode resource name ': t) (n ': t') where fill handle = do registerOne @n handle fill @t @t' handle -- | Create a signal -- TODO args ~ '[] is temproary, we need signeltons to reflect this into a runtime value signal' :: forall cls label args. (NodeSignal cls label args, KnownSymbol label, args ~ '[]) => (Text, [SignalArgument]) signal' = signal (T.pack $ symbolVal (Proxy @label)) [] createMVarProperty' :: (Typeable ty, AsVariant ty) => Text -> (node -> MVar ty) -- ^ We typically can't do IO (for initialisation) when calling this, in -- which case we need to annotate the type without providing a value. -> Either VariantType ty -> (node -> IO ty ,node -> ty -> IO () ,Maybe (Object -> node -> IO GodotVariant ,Object -> node -> GodotVariant -> IO () ,PropertyAttributes)) createMVarProperty' name fieldName tyOrVal = (readMVar . fieldName, \c t -> propertySetter p undefined c =<< toGodotVariant t, Just (propertyGetter p, propertySetter p, propertyAttrs p)) where p = createMVarProperty name fieldName tyOrVal appsT :: Type -> [Type] -> Type appsT t [] = t appsT t (x:xs) = appsT (AppT t x) xs -- | Verify that the signal connects to an endpoint that exists and has the right type. witnessConnection :: forall (scene :: Symbol) (from :: Symbol) (signal :: Symbol) (to :: Symbol) (method :: Symbol) parent sigTy hTy. (SceneNode scene to, NodeSignal parent signal sigTy, -- TODO This the check unsound, but SceneNodeType isn't right for this constraint. What is? -- The warning produced because 'from' is not used is a reminder of this issue. -- parent :< SceneNodeType scene from, NodeMethod hTy method sigTy (IO ()), NodeInScene scene to hTy) => () witnessConnection = () -- | Sets up a class class NodeInit n where init :: BaseClass n -> IO n -- | You never implement this. It's a helper so that we can have a more -- polymorphic call to nodeMethod which will work when the method is implemneted -- for any parent of the current node. class NodeMethodSuper node (name :: Symbol) (args :: [*]) (ret :: *) | node name -> args, node name -> ret where nodeMethod' :: node -> ListToFun args ret -- | An instance that supports calling nodeMethod' on your parents This can lead -- to infinite loops in the type checker on error, so we isolate it in -- NodeMethodSuper instead of NodeMethod. instance {-# OVERLAPPABLE #-} (NodeMethod (BaseClass node) name arg ret, HasBaseClass node) => NodeMethodSuper node name arg ret where nodeMethod' = nodeMethod' @node @name @arg @ret mkProperty' :: forall node (name :: Symbol) ty. (NodeProperty node name ty 'False, KnownSymbol name) => ClassProperty node mkProperty' = ClassProperty (T.pack $ symbolVal (Proxy @name)) a s g where (_,_,Just (g,s,a)) = nodeProperty @node @name @ty @'False -- | You should use this as: -- setupNode ''Ty -- deriveBase ''Ty -- This will instantiate everything that your Object needs setupNode :: Name -> String -> String -> Q [Dec] setupNode ty scene sceneNode = do -- Collect information about all scenes tree <- map unTree . classInstances <$> reify ''(:<) sceneRoots <- M.fromList . map unSceneRootNode . familyInstances <$> reify ''SceneRootNode sceneNodes <- map unSceneNodeType . familyInstances <$> reify ''SceneNodeType haskellNodes <- map unNodeInScene . classInstances <$> reify ''NodeInScene allSignals <- map unNodeSignal . classInstances <$> reify ''NodeSignal -- Collect information about our node rdt <- reifyDatatype ty let base = case datatypeCons rdt of (c:_) -> case (constructorFields c, constructorVariant c) of (ConT baseTy:_, RecordConstructor (baseFn:_)) -> Just (baseTy, baseFn) _ -> Nothing _ -> Nothing -- methods <- filter (\i -> i^._1 == ty) . mapMaybe unNodeMethod . classInstances <$> reify ''NodeMethod properties <- filter (\i -> i^._1 == ty) . mapMaybe unNodeProperty . classInstances <$> reify ''NodeProperty let signals = filter (\i -> i^._1 == ty) allSignals connections <- filter (\i -> i^._1 == scene && i^._4 == sceneNode) . map unConnect . classInstances <$> reify ''SceneConnection -- Helpers let parentsOf cls = map snd $ filter (\(c,_) -> cls == c) tree let nodeToType :: String -> String -> Name nodeToType scene node = case (hty, ty ^. _4) of (Just t, _) -> t (_, Nothing) -> ty ^. _3 (_, Just scene') -> case M.lookup scene' sceneRoots of Nothing -> error $ "Looking up the root of a scene that is lacking one. This is a bug. " ++ show (scene', scene, node) Just node' -> nodeToType scene' node' where ty = fromJust $ find (\n -> n^._1 == scene && n^._2 == node) sceneNodes hty = (^._3) <$> find (\n -> n^._1 == scene && n^._2 == node) haskellNodes let resolveSignalActualClass scene from signal = case mapMaybe (\p -> (p,) <$> find (\s -> s^._2 == signal && s^._1 == p) allSignals) $ parentsOf (nodeToType scene from) of -- The root issue is that the signal might not yet exist. -- If witnessConnection was not unsound, this would not be needed as the error would happen later. [] -> error $ "Class " ++ show from ++ " used in scene " ++ show scene ++ " is lacking a signal named " ++ show signal ++ "\n" ++ show (nodeToType scene from) ++ "\n" ++ show (parentsOf (nodeToType scene from)) (h:_) -> h ^. _1 -- Debug when False $ runIO $ do putStrLn "Regenerating .." print rdt putStrLn "\nScene roots:" print sceneRoots putStrLn "\nScene nodes types:" mapM_ print sceneNodes putStrLn "\nMethods:" mapM_ print methods putStrLn "\nProperties:" mapM_ print properties putStrLn "\nSignals:" mapM_ print allSignals mapM_ print signals putStrLn "\nConnections:" mapM_ print connections putStrLn "\nHaskell nodes:" mapM_ print haskellNodes -- Generate code bi <- case base of Just (baseTy, baseFn) -> [d|instance HasBaseClass $(pure $ PromotedT ty) where type BaseClass $(pure $ PromotedT ty) = $(pure $ PromotedT baseTy) super = $(pure $ VarE baseFn)|] _ -> error "setupNode can only handle records whose first field is the Godot base class. You can still interface with Godot, but you will need to set things up manually." nis <- [d|instance NodeInScene $(pure $ LitT $ StrTyLit scene) $(pure $ LitT $ StrTyLit sceneNode) $(pure $ PromotedT ty)|] ns <- [d|instance NativeScript $(pure $ PromotedT ty) where classInit = Project.Support.init classMethods = $(ListE <$> mapM (\(t,n,argTy,_) -> let m = case nrArguments argTy of 0 -> [e|method0|] 1 -> [e|method1|] 2 -> [e|method2|] 3 -> [e|method3|] 4 -> [e|method4|] 5 -> [e|method5|] n -> error $ "More arguments than we currently impelement, look for 'method5' for more info " ++ show n in [e|$m $(pure $ LitE $ StringL n) (nodeMethod @ $(pure $ PromotedT t) @ $(pure $ LitT $ StrTyLit n))|]) methods) classProperties = $(ListE <$> mapM (\(name,prop,_,_) -> [e|mkProperty' @ $(pure $ PromotedT name) @ $(pure $ LitT $ StrTyLit prop) |]) properties) classSignals = $(ListE <$> mapM (\(ty,name,_) -> [e|signal' @ $(pure $ PromotedT ty) @ $(pure $ LitT $ StrTyLit name)|]) signals)|] let cn = mkName $ "witness_connections_" ++ nameBase ty ws <- (:) <$> (cn `sigD` [t| [()] |]) <*> [d|$(varP cn) = $(ListE <$> mapM (\(scene,from,signal,to,method) -> [e|witnessConnection @ $(pure $ LitT $ StrTyLit scene) @ $(pure $ LitT $ StrTyLit from) @ $(pure $ LitT $ StrTyLit signal) @ $(pure $ LitT $ StrTyLit to) @ $(pure $ LitT $ StrTyLit method) @ $(pure $ PromotedT $ resolveSignalActualClass scene from signal) |]) connections)|] pure $ bi <> nis <> ns <> ws where unTree (InstanceD Nothing [] (AppT (AppT _ parent) child) []) = (unName child, unName parent) unTree p = error $ "I don't understand this parent " ++ show p unName (ConT x) = x unName (AppT (ConT x) _) = x unName x = error $ "I don't know how to extract the name of this type: " ++ show x unSceneRootNode (TySynInstD (TySynEqn Nothing (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit node)))) = (scene,node) unSceneRootNode x = error $ "Don't know how unpack this SceneRootNode: " ++ show x unSceneNodeType (TySynInstD (TySynEqn Nothing (AppT (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit node))) ty)) = (scene,node,unName ty, unpackScene ty) unSceneNodeType x = error $ "Don't know how unpack this SceneNodeType: " ++ show x unpackScene (ConT _) = Nothing unpackScene (AppT (ConT _) (LitT (StrTyLit scene))) = Just scene unpackScene x = error $ "Don't know how unpack this Scene: " ++ show x unNodeMethod (InstanceD Nothing [] (AppT (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) ret) []) = Just (cls, name, arg, ret) unNodeMethod _ = Nothing unNodeProperty (InstanceD Nothing [] (AppT (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) ret) []) = Just (cls, name, arg, ret) unNodeProperty x = error $ show x unNodeInScene (InstanceD Nothing [] (AppT (AppT (AppT (ConT _) (LitT (StrTyLit scene))) (LitT (StrTyLit node))) (ConT hty)) []) = (scene, node, hty) unNodeInScene x = error $ show x unNodeSignal (InstanceD Nothing [] (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) []) = (cls, name, arg) unNodeSignal _ = error "Bad signal" unConnect (InstanceD Nothing [] (AppT (AppT (AppT (AppT (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit from))) (LitT (StrTyLit signal))) (LitT (StrTyLit to))) (LitT (StrTyLit method))) []) = (scene, from, signal, to, method) unConnect x = error $ "Bad signal" ++ show x nrArguments :: Type -> Int nrArguments (AppT _ r) = 1 + nrArguments r nrArguments (SigT PromotedNilT (AppT ListT StarT)) = 0 nrArguments _ = error "Can't compute # of arguments" classInstances :: Info -> [InstanceDec] classInstances (ClassI _ is) = is classInstances _ = error "Bad class" familyInstances :: Info -> [InstanceDec] familyInstances (FamilyI _ is) = is familyInstances _ = error "Bad class" ================================================ FILE: examples/top-down-ten-minutes/stack-shell.nix ================================================ { nixpkgs ? import ./pinned-nixpkgs.nix {} , ghc }: with nixpkgs; haskell.lib.buildStackProject { inherit ghc; name = "top-down-ten-minutes"; buildInputs = []; } ================================================ FILE: examples/top-down-ten-minutes/stack.yaml ================================================ resolver: nightly-2021-02-06 packages: - . extra-deps: - ../../ require-stack-version: ">=1.8" nix: enable: false pure: true packages: [] shell-file: stack-shell.nix nix-shell-options: [] path: [] add-gc-roots: false ================================================ FILE: examples/top-down-ten-minutes/top-down-ten-minutes.cabal ================================================ cabal-version: 1.12 -- This file has been generated from package.yaml by hpack version 0.33.0. -- -- see: https://github.com/sol/hpack -- -- hash: 10ec9e894d9fdb50a0b9d9dcb3b406e33d320e82e151cfe5d0ef335c059e3aad name: top-down-ten-minutes version: 0.0.0.0 description: Please see the README on Github at homepage: https://github.com/SimulaVR/godot-haskell#readme bug-reports: https://github.com/SimulaVR/godot-haskell/issues author: Andrei Barbu maintainer: andrei@0xab.com copyright: Andrei Barbu 2019, 2021 license: BSD3 license-file: LICENSE build-type: Simple extra-source-files: ChangeLog.md README.md foreign-library top-down-ten-minutes type: native-shared other-modules: FLib hs-source-dirs: ffi/flib c-sources: ffi/cbits/flib.c build-depends: base >= 4.12 && <5 , godot-haskell , top-down-ten-minutes , text default-language: Haskell2010 source-repository head type: git location: https://github.com/SimulaVR/godot-haskell library exposed-modules: Lib other-modules: Game.World Project.Requirements Project.Scenes Project.Scenes.Bullet Project.Scenes.Enemy Project.Scenes.Explosion Project.Scenes.World Project.Support Paths_top_down_ten_minutes hs-source-dirs: src game default-extensions: FlexibleContexts MultiParamTypeClasses OverloadedStrings TemplateHaskell TypeApplications TypeFamilies DataKinds FlexibleInstances ScopedTypeVariables AllowAmbiguousTypes TupleSections FunctionalDependencies LambdaCase TypeOperators ghc-options: -Wall -Wno-orphans -O0 -Wno-name-shadowing build-depends: base >=4.12 && <5 , containers , extra , godot-haskell , lens , linear , mono-traversable , random , strict-concurrency , template-haskell , text , th-abstraction , vector default-language: Haskell2010 ================================================ FILE: godot-haskell.cabal ================================================ cabal-version: 2.0 -- This file has been generated from package.yaml by hpack version 0.33.0. -- -- see: https://github.com/sol/hpack -- -- hash: 9eee1b834a7b311c2aaf343d7472f4478f3d5840413d415e779ebfd822966642 name: godot-haskell version: 3.1.0.0 synopsis: Haskell bindings for the Godot game engine API description: This package contains Haskell bindings for GDNative and the Godot API. For details and examples, see README.md category: Web homepage: https://github.com/KaneTW/godot-haskell#readme bug-reports: https://github.com/KaneTW/godot-haskell/issues author: David Kraeutmann maintainer: kane@kane.cx copyright: 2018 David Kraeutmann license: BSD3 license-file: LICENSE build-type: Simple extra-source-files: README.md cbits/util.h godot_headers/android/godot_android.h godot_headers/arvr/godot_arvr.h godot_headers/gdnative/aabb.h godot_headers/gdnative/array.h godot_headers/gdnative/basis.h godot_headers/gdnative/color.h godot_headers/gdnative/dictionary.h godot_headers/gdnative/gdnative.h godot_headers/gdnative/node_path.h godot_headers/gdnative/plane.h godot_headers/gdnative/pool_arrays.h godot_headers/gdnative/quat.h godot_headers/gdnative/rect2.h godot_headers/gdnative/rid.h godot_headers/gdnative/string.h godot_headers/gdnative/string_name.h godot_headers/gdnative/transform.h godot_headers/gdnative/transform2d.h godot_headers/gdnative/variant.h godot_headers/gdnative/vector2.h godot_headers/gdnative/vector3.h godot_headers/gdnative_api_struct.gen.h godot_headers/nativescript/godot_nativescript.h godot_headers/net/godot_net.h godot_headers/net/godot_webrtc.h godot_headers/pluginscript/godot_pluginscript.h godot_headers/videodecoder/godot_videodecoder.h godot_headers/api.json godot_headers/gdnative_api.json source-repository head type: git location: https://github.com/KaneTW/godot-haskell library exposed-modules: Godot Godot.Api Godot.Api.Types Godot.Core.AcceptDialog Godot.Core.AnimatedSprite Godot.Core.AnimatedSprite3D Godot.Core.AnimatedTexture Godot.Core.Animation Godot.Core.AnimationNode Godot.Core.AnimationNodeAdd2 Godot.Core.AnimationNodeAdd3 Godot.Core.AnimationNodeAnimation Godot.Core.AnimationNodeBlend2 Godot.Core.AnimationNodeBlend3 Godot.Core.AnimationNodeBlendSpace1D Godot.Core.AnimationNodeBlendSpace2D Godot.Core.AnimationNodeBlendTree Godot.Core.AnimationNodeOneShot Godot.Core.AnimationNodeOutput Godot.Core.AnimationNodeStateMachine Godot.Core.AnimationNodeStateMachinePlayback Godot.Core.AnimationNodeStateMachineTransition Godot.Core.AnimationNodeTimeScale Godot.Core.AnimationNodeTimeSeek Godot.Core.AnimationNodeTransition Godot.Core.AnimationPlayer Godot.Core.AnimationRootNode Godot.Core.AnimationTree Godot.Core.AnimationTreePlayer Godot.Core.Area Godot.Core.Area2D Godot.Core.ArrayMesh Godot.Core.ARVRAnchor Godot.Core.ARVRCamera Godot.Core.ARVRController Godot.Core.ARVRInterface Godot.Core.ARVRInterfaceGDNative Godot.Core.ARVROrigin Godot.Core.ARVRPositionalTracker Godot.Core.ARVRServer Godot.Core.AStar Godot.Core.AStar2D Godot.Core.AtlasTexture Godot.Core.AudioBusLayout Godot.Core.AudioEffect Godot.Core.AudioEffectAmplify Godot.Core.AudioEffectBandLimitFilter Godot.Core.AudioEffectBandPassFilter Godot.Core.AudioEffectChorus Godot.Core.AudioEffectCompressor Godot.Core.AudioEffectDelay Godot.Core.AudioEffectDistortion Godot.Core.AudioEffectEQ Godot.Core.AudioEffectEQ10 Godot.Core.AudioEffectEQ21 Godot.Core.AudioEffectEQ6 Godot.Core.AudioEffectFilter Godot.Core.AudioEffectHighPassFilter Godot.Core.AudioEffectHighShelfFilter Godot.Core.AudioEffectInstance Godot.Core.AudioEffectLimiter Godot.Core.AudioEffectLowPassFilter Godot.Core.AudioEffectLowShelfFilter Godot.Core.AudioEffectNotchFilter Godot.Core.AudioEffectPanner Godot.Core.AudioEffectPhaser Godot.Core.AudioEffectPitchShift Godot.Core.AudioEffectRecord Godot.Core.AudioEffectReverb Godot.Core.AudioEffectSpectrumAnalyzer Godot.Core.AudioEffectSpectrumAnalyzerInstance Godot.Core.AudioEffectStereoEnhance Godot.Core.AudioServer Godot.Core.AudioStream Godot.Core.AudioStreamGenerator Godot.Core.AudioStreamGeneratorPlayback Godot.Core.AudioStreamMicrophone Godot.Core.AudioStreamOGGVorbis Godot.Core.AudioStreamPlayback Godot.Core.AudioStreamPlaybackResampled Godot.Core.AudioStreamPlayer Godot.Core.AudioStreamPlayer2D Godot.Core.AudioStreamPlayer3D Godot.Core.AudioStreamRandomPitch Godot.Core.AudioStreamSample Godot.Core.BackBufferCopy Godot.Core.BakedLightmap Godot.Core.BakedLightmapData Godot.Core.BaseButton Godot.Core.BitMap Godot.Core.BitmapFont Godot.Core.Bone2D Godot.Core.BoneAttachment Godot.Core.BoxContainer Godot.Core.BoxShape Godot.Core.BulletPhysicsDirectBodyState Godot.Core.BulletPhysicsServer Godot.Core.Button Godot.Core.ButtonGroup Godot.Core.Camera Godot.Core.Camera2D Godot.Core.CameraFeed Godot.Core.CameraServer Godot.Core.CameraTexture Godot.Core.CanvasItem Godot.Core.CanvasItemMaterial Godot.Core.CanvasLayer Godot.Core.CanvasModulate Godot.Core.CapsuleMesh Godot.Core.CapsuleShape Godot.Core.CapsuleShape2D Godot.Core.CenterContainer Godot.Core.CharFXTransform Godot.Core.CheckBox Godot.Core.CheckButton Godot.Core.CircleShape2D Godot.Core.ClassDB Godot.Core.ClippedCamera Godot.Core.CollisionObject Godot.Core.CollisionObject2D Godot.Core.CollisionPolygon Godot.Core.CollisionPolygon2D Godot.Core.CollisionShape Godot.Core.CollisionShape2D Godot.Core.ColorPicker Godot.Core.ColorPickerButton Godot.Core.ColorRect Godot.Core.ConcavePolygonShape Godot.Core.ConcavePolygonShape2D Godot.Core.ConeTwistJoint Godot.Core.ConfigFile Godot.Core.ConfirmationDialog Godot.Core.Container Godot.Core.Control Godot.Core.ConvexPolygonShape Godot.Core.ConvexPolygonShape2D Godot.Core.CPUParticles Godot.Core.CPUParticles2D Godot.Core.Crypto Godot.Core.CryptoKey Godot.Core.CSGBox Godot.Core.CSGCombiner Godot.Core.CSGCylinder Godot.Core.CSGMesh Godot.Core.CSGPolygon Godot.Core.CSGPrimitive Godot.Core.CSGShape Godot.Core.CSGSphere Godot.Core.CSGTorus Godot.Core.CubeMap Godot.Core.CubeMesh Godot.Core.Curve Godot.Core.Curve2D Godot.Core.Curve3D Godot.Core.CurveTexture Godot.Core.CylinderMesh Godot.Core.CylinderShape Godot.Core.DampedSpringJoint2D Godot.Core.DirectionalLight Godot.Core.Directory Godot.Core.DynamicFont Godot.Core.DynamicFontData Godot.Core.EncodedObjectAsID Godot.Core.Engine Godot.Core.Environment Godot.Core.Expression Godot.Core.File Godot.Core.FileDialog Godot.Core.Font Godot.Core.FuncRef Godot.Core.GDNative Godot.Core.GDNativeLibrary Godot.Core.GDScript Godot.Core.GDScriptFunctionState Godot.Core.Generic6DOFJoint Godot.Core.Geometry Godot.Core.GeometryInstance Godot.Core.GIProbe Godot.Core.GIProbeData Godot.Core.GlobalConstants Godot.Core.Gradient Godot.Core.GradientTexture Godot.Core.GraphEdit Godot.Core.GraphNode Godot.Core.GridContainer Godot.Core.GridMap Godot.Core.GrooveJoint2D Godot.Core.HashingContext Godot.Core.HBoxContainer Godot.Core.HeightMapShape Godot.Core.HingeJoint Godot.Core.HScrollBar Godot.Core.HSeparator Godot.Core.HSlider Godot.Core.HSplitContainer Godot.Core.HTTPClient Godot.Core.HTTPRequest Godot.Core.Image Godot.Core.ImageTexture Godot.Core.ImmediateGeometry Godot.Core.Input Godot.Core.InputDefault Godot.Core.InputEvent Godot.Core.InputEventAction Godot.Core.InputEventGesture Godot.Core.InputEventJoypadButton Godot.Core.InputEventJoypadMotion Godot.Core.InputEventKey Godot.Core.InputEventMagnifyGesture Godot.Core.InputEventMIDI Godot.Core.InputEventMouse Godot.Core.InputEventMouseButton Godot.Core.InputEventMouseMotion Godot.Core.InputEventPanGesture Godot.Core.InputEventScreenDrag Godot.Core.InputEventScreenTouch Godot.Core.InputEventWithModifiers Godot.Core.InputMap Godot.Core.InstancePlaceholder Godot.Core.InterpolatedCamera Godot.Core.IP Godot.Core.IP_Unix Godot.Core.ItemList Godot.Core.JavaClass Godot.Core.JavaClassWrapper Godot.Core.JavaScript Godot.Core.Joint Godot.Core.Joint2D Godot.Core.JSON Godot.Core.JSONParseResult Godot.Core.JSONRPC Godot.Core.KinematicBody Godot.Core.KinematicBody2D Godot.Core.KinematicCollision Godot.Core.KinematicCollision2D Godot.Core.Label Godot.Core.LargeTexture Godot.Core.Light Godot.Core.Light2D Godot.Core.LightOccluder2D Godot.Core.Line2D Godot.Core.LineEdit Godot.Core.LineShape2D Godot.Core.LinkButton Godot.Core.Listener Godot.Core.MainLoop Godot.Core.MarginContainer Godot.Core.Marshalls Godot.Core.Material Godot.Core.MenuButton Godot.Core.Mesh Godot.Core.MeshDataTool Godot.Core.MeshInstance Godot.Core.MeshInstance2D Godot.Core.MeshLibrary Godot.Core.MeshTexture Godot.Core.MobileVRInterface Godot.Core.MultiMesh Godot.Core.MultiMeshInstance Godot.Core.MultiMeshInstance2D Godot.Core.MultiplayerAPI Godot.Core.MultiplayerPeerGDNative Godot.Core.Mutex Godot.Core.NativeScript Godot.Core.Navigation Godot.Core.Navigation2D Godot.Core.NavigationMesh Godot.Core.NavigationMeshInstance Godot.Core.NavigationPolygon Godot.Core.NavigationPolygonInstance Godot.Core.NetworkedMultiplayerENet Godot.Core.NetworkedMultiplayerPeer Godot.Core.NinePatchRect Godot.Core.Node Godot.Core.Node2D Godot.Core.NoiseTexture Godot.Core.Object Godot.Core.OccluderPolygon2D Godot.Core.OmniLight Godot.Core.OpenSimplexNoise Godot.Core.OptionButton Godot.Core.OS Godot.Core.PackedDataContainer Godot.Core.PackedDataContainerRef Godot.Core.PackedScene Godot.Core.PacketPeer Godot.Core.PacketPeerGDNative Godot.Core.PacketPeerStream Godot.Core.PacketPeerUDP Godot.Core.Panel Godot.Core.PanelContainer Godot.Core.PanoramaSky Godot.Core.ParallaxBackground Godot.Core.ParallaxLayer Godot.Core.Particles Godot.Core.Particles2D Godot.Core.ParticlesMaterial Godot.Core.Path Godot.Core.Path2D Godot.Core.PathFollow Godot.Core.PathFollow2D Godot.Core.PCKPacker Godot.Core.Performance Godot.Core.PHashTranslation Godot.Core.PhysicalBone Godot.Core.Physics2DDirectBodyState Godot.Core.Physics2DDirectBodyStateSW Godot.Core.Physics2DDirectSpaceState Godot.Core.Physics2DServer Godot.Core.Physics2DServerSW Godot.Core.Physics2DShapeQueryParameters Godot.Core.Physics2DShapeQueryResult Godot.Core.Physics2DTestMotionResult Godot.Core.PhysicsBody Godot.Core.PhysicsBody2D Godot.Core.PhysicsDirectBodyState Godot.Core.PhysicsDirectSpaceState Godot.Core.PhysicsMaterial Godot.Core.PhysicsServer Godot.Core.PhysicsShapeQueryParameters Godot.Core.PhysicsShapeQueryResult Godot.Core.PinJoint Godot.Core.PinJoint2D Godot.Core.PlaneMesh Godot.Core.PlaneShape Godot.Core.PluginScript Godot.Core.PointMesh Godot.Core.Polygon2D Godot.Core.PolygonPathFinder Godot.Core.Popup Godot.Core.PopupDialog Godot.Core.PopupMenu Godot.Core.PopupPanel Godot.Core.Position2D Godot.Core.Position3D Godot.Core.PrimitiveMesh Godot.Core.PrismMesh Godot.Core.ProceduralSky Godot.Core.ProgressBar Godot.Core.ProjectSettings Godot.Core.ProximityGroup Godot.Core.ProxyTexture Godot.Core.QuadMesh Godot.Core.RandomNumberGenerator Godot.Core.Range Godot.Core.RayCast Godot.Core.RayCast2D Godot.Core.RayShape Godot.Core.RayShape2D Godot.Core.RectangleShape2D Godot.Core.Reference Godot.Core.ReferenceRect Godot.Core.ReflectionProbe Godot.Core.RegEx Godot.Core.RegExMatch Godot.Core.RemoteTransform Godot.Core.RemoteTransform2D Godot.Core.Resource Godot.Core.ResourceFormatLoader Godot.Core.ResourceFormatLoaderCrypto Godot.Core.ResourceFormatSaver Godot.Core.ResourceFormatSaverCrypto Godot.Core.ResourceImporter Godot.Core.ResourceInteractiveLoader Godot.Core.ResourceLoader Godot.Core.ResourcePreloader Godot.Core.ResourceSaver Godot.Core.RichTextEffect Godot.Core.RichTextLabel Godot.Core.RigidBody Godot.Core.RigidBody2D Godot.Core.RootMotionView Godot.Core.SceneState Godot.Core.SceneTree Godot.Core.SceneTreeTimer Godot.Core.Script Godot.Core.ScrollBar Godot.Core.ScrollContainer Godot.Core.SegmentShape2D Godot.Core.Semaphore Godot.Core.Separator Godot.Core.Shader Godot.Core.ShaderMaterial Godot.Core.Shape Godot.Core.Shape2D Godot.Core.ShortCut Godot.Core.Skeleton Godot.Core.Skeleton2D Godot.Core.SkeletonIK Godot.Core.Skin Godot.Core.SkinReference Godot.Core.Sky Godot.Core.Slider Godot.Core.SliderJoint Godot.Core.SoftBody Godot.Core.Spatial Godot.Core.SpatialGizmo Godot.Core.SpatialMaterial Godot.Core.SpatialVelocityTracker Godot.Core.SphereMesh Godot.Core.SphereShape Godot.Core.SpinBox Godot.Core.SplitContainer Godot.Core.SpotLight Godot.Core.SpringArm Godot.Core.Sprite Godot.Core.Sprite3D Godot.Core.SpriteBase3D Godot.Core.SpriteFrames Godot.Core.StaticBody Godot.Core.StaticBody2D Godot.Core.StreamPeer Godot.Core.StreamPeerBuffer Godot.Core.StreamPeerGDNative Godot.Core.StreamPeerSSL Godot.Core.StreamPeerTCP Godot.Core.StreamTexture Godot.Core.StyleBox Godot.Core.StyleBoxEmpty Godot.Core.StyleBoxFlat Godot.Core.StyleBoxLine Godot.Core.StyleBoxTexture Godot.Core.SurfaceTool Godot.Core.TabContainer Godot.Core.Tabs Godot.Core.TCP_Server Godot.Core.TextEdit Godot.Core.TextFile Godot.Core.Texture Godot.Core.Texture3D Godot.Core.TextureArray Godot.Core.TextureButton Godot.Core.TextureLayered Godot.Core.TextureProgress Godot.Core.TextureRect Godot.Core.Theme Godot.Core.Thread Godot.Core.TileMap Godot.Core.TileSet Godot.Core.Timer Godot.Core.ToolButton Godot.Core.TouchScreenButton Godot.Core.Translation Godot.Core.TranslationServer Godot.Core.Tree Godot.Core.TreeItem Godot.Core.TriangleMesh Godot.Core.Tween Godot.Core.UndoRedo Godot.Core.UPNP Godot.Core.UPNPDevice Godot.Core.VBoxContainer Godot.Core.VehicleBody Godot.Core.VehicleWheel Godot.Core.VideoPlayer Godot.Core.VideoStream Godot.Core.VideoStreamGDNative Godot.Core.VideoStreamTheora Godot.Core.VideoStreamWebm Godot.Core.Viewport Godot.Core.ViewportContainer Godot.Core.ViewportTexture Godot.Core.VisibilityEnabler Godot.Core.VisibilityEnabler2D Godot.Core.VisibilityNotifier Godot.Core.VisibilityNotifier2D Godot.Core.VisualInstance Godot.Core.VisualScript Godot.Core.VisualScriptBasicTypeConstant Godot.Core.VisualScriptBuiltinFunc Godot.Core.VisualScriptClassConstant Godot.Core.VisualScriptComment Godot.Core.VisualScriptComposeArray Godot.Core.VisualScriptCondition Godot.Core.VisualScriptConstant Godot.Core.VisualScriptConstructor Godot.Core.VisualScriptCustomNode Godot.Core.VisualScriptDeconstruct Godot.Core.VisualScriptEmitSignal Godot.Core.VisualScriptEngineSingleton Godot.Core.VisualScriptExpression Godot.Core.VisualScriptFunction Godot.Core.VisualScriptFunctionCall Godot.Core.VisualScriptFunctionState Godot.Core.VisualScriptGlobalConstant Godot.Core.VisualScriptIndexGet Godot.Core.VisualScriptIndexSet Godot.Core.VisualScriptInputAction Godot.Core.VisualScriptIterator Godot.Core.VisualScriptLists Godot.Core.VisualScriptLocalVar Godot.Core.VisualScriptLocalVarSet Godot.Core.VisualScriptMathConstant Godot.Core.VisualScriptNode Godot.Core.VisualScriptOperator Godot.Core.VisualScriptPreload Godot.Core.VisualScriptPropertyGet Godot.Core.VisualScriptPropertySet Godot.Core.VisualScriptResourcePath Godot.Core.VisualScriptReturn Godot.Core.VisualScriptSceneNode Godot.Core.VisualScriptSceneTree Godot.Core.VisualScriptSelect Godot.Core.VisualScriptSelf Godot.Core.VisualScriptSequence Godot.Core.VisualScriptSubCall Godot.Core.VisualScriptSwitch Godot.Core.VisualScriptTypeCast Godot.Core.VisualScriptVariableGet Godot.Core.VisualScriptVariableSet Godot.Core.VisualScriptWhile Godot.Core.VisualScriptYield Godot.Core.VisualScriptYieldSignal Godot.Core.VisualServer Godot.Core.VisualShader Godot.Core.VisualShaderNode Godot.Core.VisualShaderNodeBooleanConstant Godot.Core.VisualShaderNodeBooleanUniform Godot.Core.VisualShaderNodeColorConstant Godot.Core.VisualShaderNodeColorFunc Godot.Core.VisualShaderNodeColorOp Godot.Core.VisualShaderNodeColorUniform Godot.Core.VisualShaderNodeCompare Godot.Core.VisualShaderNodeCubeMap Godot.Core.VisualShaderNodeCubeMapUniform Godot.Core.VisualShaderNodeCustom Godot.Core.VisualShaderNodeDeterminant Godot.Core.VisualShaderNodeDotProduct Godot.Core.VisualShaderNodeExpression Godot.Core.VisualShaderNodeFaceForward Godot.Core.VisualShaderNodeFresnel Godot.Core.VisualShaderNodeGlobalExpression Godot.Core.VisualShaderNodeGroupBase Godot.Core.VisualShaderNodeIf Godot.Core.VisualShaderNodeInput Godot.Core.VisualShaderNodeIs Godot.Core.VisualShaderNodeOuterProduct Godot.Core.VisualShaderNodeOutput Godot.Core.VisualShaderNodeScalarClamp Godot.Core.VisualShaderNodeScalarConstant Godot.Core.VisualShaderNodeScalarDerivativeFunc Godot.Core.VisualShaderNodeScalarFunc Godot.Core.VisualShaderNodeScalarInterp Godot.Core.VisualShaderNodeScalarOp Godot.Core.VisualShaderNodeScalarSmoothStep Godot.Core.VisualShaderNodeScalarSwitch Godot.Core.VisualShaderNodeScalarUniform Godot.Core.VisualShaderNodeSwitch Godot.Core.VisualShaderNodeTexture Godot.Core.VisualShaderNodeTextureUniform Godot.Core.VisualShaderNodeTextureUniformTriplanar Godot.Core.VisualShaderNodeTransformCompose Godot.Core.VisualShaderNodeTransformConstant Godot.Core.VisualShaderNodeTransformDecompose Godot.Core.VisualShaderNodeTransformFunc Godot.Core.VisualShaderNodeTransformMult Godot.Core.VisualShaderNodeTransformUniform Godot.Core.VisualShaderNodeTransformVecMult Godot.Core.VisualShaderNodeUniform Godot.Core.VisualShaderNodeVec3Constant Godot.Core.VisualShaderNodeVec3Uniform Godot.Core.VisualShaderNodeVectorClamp Godot.Core.VisualShaderNodeVectorCompose Godot.Core.VisualShaderNodeVectorDecompose Godot.Core.VisualShaderNodeVectorDerivativeFunc Godot.Core.VisualShaderNodeVectorDistance Godot.Core.VisualShaderNodeVectorFunc Godot.Core.VisualShaderNodeVectorInterp Godot.Core.VisualShaderNodeVectorLen Godot.Core.VisualShaderNodeVectorOp Godot.Core.VisualShaderNodeVectorRefract Godot.Core.VisualShaderNodeVectorScalarMix Godot.Core.VisualShaderNodeVectorScalarSmoothStep Godot.Core.VisualShaderNodeVectorScalarStep Godot.Core.VisualShaderNodeVectorSmoothStep Godot.Core.VScrollBar Godot.Core.VSeparator Godot.Core.VSlider Godot.Core.VSplitContainer Godot.Core.WeakRef Godot.Core.WebRTCDataChannel Godot.Core.WebRTCDataChannelGDNative Godot.Core.WebRTCMultiplayer Godot.Core.WebRTCPeerConnection Godot.Core.WebRTCPeerConnectionGDNative Godot.Core.WebSocketClient Godot.Core.WebSocketMultiplayerPeer Godot.Core.WebSocketPeer Godot.Core.WebSocketServer Godot.Core.WindowDialog Godot.Core.World Godot.Core.World2D Godot.Core.WorldEnvironment Godot.Core.X509Certificate Godot.Core.XMLParser Godot.Core.YSort Godot.Gdnative Godot.Gdnative.Internal Godot.Gdnative.Internal.Api Godot.Gdnative.Internal.Gdnative Godot.Gdnative.Internal.TH Godot.Gdnative.Internal.Types Godot.Internal.Dispatch Godot.Nativescript Godot.Tools.AnimationTrackEditPlugin Godot.Tools.EditorExportPlugin Godot.Tools.EditorFeatureProfile Godot.Tools.EditorFileDialog Godot.Tools.EditorFileSystem Godot.Tools.EditorFileSystemDirectory Godot.Tools.EditorImportPlugin Godot.Tools.EditorInspector Godot.Tools.EditorInspectorPlugin Godot.Tools.EditorInterface Godot.Tools.EditorNavigationMeshGenerator Godot.Tools.EditorPlugin Godot.Tools.EditorProperty Godot.Tools.EditorResourceConversionPlugin Godot.Tools.EditorResourcePreview Godot.Tools.EditorResourcePreviewGenerator Godot.Tools.EditorSceneImporter Godot.Tools.EditorSceneImporterAssimp Godot.Tools.EditorScenePostImport Godot.Tools.EditorScript Godot.Tools.EditorSelection Godot.Tools.EditorSettings Godot.Tools.EditorSpatialGizmo Godot.Tools.EditorSpatialGizmoPlugin Godot.Tools.EditorSpinSlider Godot.Tools.EditorVCSInterface Godot.Tools.ScriptCreateDialog Godot.Tools.ScriptEditor Godot.Tools.VisualScriptEditor other-modules: Paths_godot_haskell hs-source-dirs: src default-extensions: FlexibleContexts FlexibleInstances ScopedTypeVariables TypeApplications StandaloneDeriving DerivingStrategies DefaultSignatures MultiParamTypeClasses FunctionalDependencies TypeFamilies TemplateHaskell TypeOperators TypeInType QuasiQuotes OverloadedStrings PatternSynonyms GeneralizedNewtypeDeriving ghc-options: -O0 include-dirs: godot_headers cbits build-tools: c2hs build-depends: aeson , base , bytestring , casing , colour , containers , extra , generate , lens , linear , mtl , stm , template-haskell , text , th-abstraction , unordered-containers , vector default-language: Haskell2010 library generate exposed-modules: Generate Spec Types Types.Internal other-modules: Paths_godot_haskell hs-source-dirs: src-generate default-extensions: FlexibleContexts FlexibleInstances ScopedTypeVariables TypeApplications StandaloneDeriving DerivingStrategies DefaultSignatures MultiParamTypeClasses FunctionalDependencies TypeFamilies TemplateHaskell TypeOperators TypeInType QuasiQuotes OverloadedStrings PatternSynonyms GeneralizedNewtypeDeriving ghc-options: -O0 build-depends: aeson , ansi-wl-pprint , base , bytestring , casing , containers , extra , lens , mtl , parsec , parsers , stm , template-haskell , text , th-abstraction , unordered-containers , vector default-language: Haskell2010 executable godot-haskell-project-generator main-is: Main.hs other-modules: Paths_godot_haskell hs-source-dirs: project-generator default-extensions: FlexibleContexts FlexibleInstances ScopedTypeVariables TypeApplications StandaloneDeriving DerivingStrategies DefaultSignatures MultiParamTypeClasses FunctionalDependencies TypeFamilies TemplateHaskell TypeOperators TypeInType QuasiQuotes OverloadedStrings PatternSynonyms GeneralizedNewtypeDeriving ghc-options: -O0 build-depends: aeson , base , bytestring , casing , containers , directory , extra , filepath , fsnotify , interpolate , lens , mtl , stm , template-haskell , text , th-abstraction , unordered-containers , vector default-language: Haskell2010 ================================================ FILE: hie.yaml ================================================ cradle: stack: - path: "./src" component: "godot-haskell:lib" - path: "./src-generate" component: "godot-haskell:lib:generate" - path: "./project-generator/Main.hs" component: "godot-haskell:exe:godot-haskell-project-generator" ================================================ FILE: nix/pinned/all-hies.json ================================================ { "url": "https://github.com/Infinisil/all-hies.git", "rev": "d98bdbff3ebdab408a12a9b7890d4cf400180839", "date": "2020-02-17T18:53:14+01:00", "sha256": "1lr4dw10f37fp68b6ig065dgrl8h1v4xmigy5ncljdz74k0jvhg4", "fetchSubmodules": true, "deepClone": false, "leaveDotGit": false } ================================================ FILE: nix/pinned/default.nix ================================================ { fetchFromGitHub, lib }: let fetch = owner: repo: jsonFile: fetchFromGitHub { inherit owner repo; inherit (lib.importJSON jsonFile) rev sha256; }; in { nixpkgs = import (fetch "NixOS" "nix-channels" ./nixpkgs.json) {}; hie = { ghc, useSystem ? true, useLatest ? false, versions ? [] }: import ./hie.nix { inherit fetchFromGitHub lib ghc useSystem useLatest versions; }; } ================================================ FILE: nix/pinned/hie.nix ================================================ { fetchFromGitHub, lib, ghc, useSystem ? true, useLatest ? false, versions ? [] }: let fetch = owner: repo: jsonFile: fetchFromGitHub { inherit owner repo; inherit (lib.importJSON jsonFile) rev sha256; }; all-hies = import (fetch "Infinisil" "all-hies" ./all-hies.json) {}; ghcVersionList = builtins.splitVersion ghc.version; ghcVersionToString = builtins.foldl' (x: y: x + y) "" ghcVersionList; ghcVersionKey = "ghc${ghcVersionToString}"; versionList = versions ++ (if useSystem then [ ghcVersionKey ] else []) ++ (if useLatest then [ lib.last (lib.attrValues versions) ] else []); selector = p: builtins.foldl' (a: b: a // b) {} (map (v: { ${v} = p.${v}; }) versionList); in all-hies.selection { selector = selector; } ================================================ FILE: nix/pinned/nixpkgs.json ================================================ { "url": "https://github.com/nixos/nixpkgs-channels.git", "rev": "ce9f1aaa39ee2a5b76a9c9580c859a74de65ead5", "date": "2020-02-27T20:22:41+01:00", "sha256": "1s2b9rvpyamiagvpl5cggdb2nmx4f7lpylipd397wz8f0wngygpi", "fetchSubmodules": false, "deepClone": false, "leaveDotGit": false } ================================================ FILE: nix/spacemacs-hie.nix ================================================ { pkgs, hsPkgs }: let pinned = import ./pinned { inherit (pkgs) fetchFromGitHub lib; }; hie = pinned.hie { inherit (hsPkgs) ghc; }; emacsPkgs = (with pkgs; [ emacs emacs-all-the-icons-fonts dejavu_fonts material-design-icons # nerdfonts source-code-pro weather-icons ]); in emacsPkgs ++ [ hie ] ++ (with hsPkgs; [ apply-refact brittany cabal-install Cabal_3_0_0_0 # Cabal_2_4_1_0 hasktags hlint hoogle ]) ================================================ FILE: nixpkgs-version.json ================================================ { "url": "https://github.com/nixos/nixpkgs-channels.git", "rev": "c8db7a8a16ee9d54103cade6e766509e1d1c8d7b", "date": "2020-01-11T14:34:27-05:00", "sha256": "1b3h4mwpi10blzpvgsc0191k4shaw3nw0qd2p82hygbr8vv4g9dv", "fetchSubmodules": false } ================================================ FILE: package.yaml ================================================ name: godot-haskell synopsis: Haskell bindings for the Godot game engine API description: This package contains Haskell bindings for GDNative and the Godot API. For details and examples, see README.md version: '3.1.0.0' category: Web author: David Kraeutmann maintainer: kane@kane.cx copyright: 2018 David Kraeutmann license: BSD3 github: KaneTW/godot-haskell extra-source-files: - README.md - cbits/* - godot_headers/**/*.h - godot_headers/**/*.json dependencies: - base - aeson - bytestring - template-haskell - th-abstraction - lens - text - casing - vector - containers - unordered-containers - mtl - stm - extra default-extensions: - FlexibleContexts - FlexibleInstances - ScopedTypeVariables - TypeApplications - StandaloneDeriving - DerivingStrategies - DefaultSignatures - MultiParamTypeClasses - FunctionalDependencies - TypeFamilies - TemplateHaskell - TypeOperators - TypeInType - QuasiQuotes - OverloadedStrings - PatternSynonyms - GeneralizedNewtypeDeriving executables: godot-haskell-project-generator: main: Main.hs source-dirs: project-generator dependencies: - fsnotify - directory - filepath - interpolate - lens library: source-dirs: src build-tools: - c2hs include-dirs: - godot_headers - cbits dependencies: - generate - linear - colour internal-libraries: generate: source-dirs: src-generate dependencies: - parsec - parsers - mtl - ansi-wl-pprint ghc-options: - -O0 ================================================ FILE: pinned-nixpkgs.nix ================================================ {}: let hostPkgs = import {}; pinnedVersion = hostPkgs.lib.importJSON ./nixpkgs-version.json; pinnedPkgs = hostPkgs.fetchFromGitHub { owner = "NixOS"; repo = "nixpkgs-channels"; inherit (pinnedVersion) rev sha256; }; in import pinnedPkgs {} ================================================ FILE: project-generator/Main.hs ================================================ {-# LANGUAGE DerivingStrategies #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE MultiWayIf #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} module Main where import Control.Concurrent (threadDelay) import Control.Lens hiding (from, to) import Control.Lens.TH import Control.Monad import Data.Char import Data.List import qualified Data.Map as M import Data.Maybe import Data.String.Interpolate import qualified Data.Text as T import qualified Data.Text.IO as T import Debug.Trace import qualified Language.Haskell.TH.Syntax as TH import System.Directory import System.Environment import System.FSNotify import System.FilePath import Prelude hiding (id) newtype Id = Id {unId :: T.Text} deriving (Eq, Ord) deriving newtype (Show) newtype Name = Name {unName :: T.Text} deriving (Eq, Ord) deriving newtype (Show) newtype Method = Method {unMethod :: T.Text} deriving (Eq, Ord) deriving newtype (Show) newtype Signal = Signal {unSignal :: T.Text} deriving (Eq, Ord) deriving newtype (Show) newtype Ty = Ty {unTy :: T.Text} deriving (Eq, Ord) deriving newtype (Show) newtype NodePath = NodePath {unNodePath :: T.Text} deriving (Eq, Ord) deriving newtype (Show) data Resource = Resource { _resourceTy :: Ty, _resourcePath :: T.Text } deriving (Show) makeFields ''Resource data TscnNode = TscnNode { _tscnNodeTy :: Ty, _tscnNodeParent :: Maybe NodePath, _tscnNodeInstanceof :: Maybe Id, _tscnNodeScript :: Maybe Id } deriving (Show) makeFields ''TscnNode data TscnConnection = TscnConnection { _tscnConnectionSignal :: Signal, _tscnConnectionFrom :: NodePath, _tscnConnectionTo :: NodePath, _tscnConnectionMethod :: Method } deriving (Show) makeFields ''TscnConnection data Tscn = Tscn { _tscnSceneName :: Name, _tscnResources :: M.Map Id Resource, _tscnNodes :: M.Map Name TscnNode, _tscnConnections :: [TscnConnection], _tscnRootNode :: Maybe Name, _tscnFilepath :: FilePath } deriving (Show) makeFields ''Tscn data Gdns = Gdns { _gdnsExtResources :: M.Map Id Resource, _gdnsResources :: M.Map Name Id } deriving (Show) makeFields ''Gdns allByExtension :: String -> FilePath -> IO [String] allByExtension ext dir = do b <- doesDirectoryExist dir if b then do l <- map (dir ) <$> listDirectory dir tscns <- filterM (\f -> (&& isSuffixOf ext f) <$> doesFileExist f) l dirs <- filterM doesDirectoryExist l (tscns ++) . concat <$> mapM (allByExtension ext) dirs else pure [] mangle (h : t) = toUpper h : t createAndWriteFile :: FilePath -> T.Text -> IO () createAndWriteFile path content = do createDirectoryIfMissing True $ takeDirectory path T.writeFile path ("-- | This file is AUTOGENERATED by godot-haskell-project-generator. DO NOT EDIT\n\n" <> content) support = [i| {-# OPTIONS_GHC -Wno-name-shadowing #-} module Project.Support where import Control.Lens import Control.Monad import Data.Coerce import Data.List import qualified Data.Map as M import Data.Maybe import qualified Data.Text as T import Data.Typeable import GHC.TypeLits import Godot import Godot.Core.Object import Godot.Core.PackedScene import Godot.Core.ResourceLoader import Godot.Gdnative import Godot.Gdnative.Internal.Types import Godot.Internal.Dispatch as D import Language.Haskell.TH import Language.Haskell.TH.Datatype -- * Helper to keep Haskell types in sync with the Godot project. newtype PackedScene' (scene :: Symbol) = PackedScene' PackedScene deriving newtype AsVariant instance HasBaseClass (PackedScene' scene) where type BaseClass (PackedScene' scene) = PackedScene super = coerce deriveBase ''PackedScene' -- | Use this to register all of your classes, it makes sure that you don't -- forget a class that Godot needs. -- -- exports :: GdnativeHandle -> IO () -- exports desc = registerAll' @Nodes @'[HUD, Main, Mob, Player] desc registerAll' :: forall (res :: [*]) (ns :: [*]). ImplementedInHaskell res ns => GdnativeHandle -> IO () registerAll' = fill @res @ns -- | A safe version of getNode; gives you back the Godot object -- getNode' @"MobPath/MobSpawnLocation" self getNode' :: forall label b cls scene name. ( Object :< cls , Node :< cls , Node :< b , NodeInScene scene name cls , SceneNode scene label , SceneNodeType scene label ~ b , KnownSymbol label) => cls -> IO b getNode' o = getNode @(SceneNodeType scene label) o (T.pack $ symbolVal (Proxy @label)) -- | A safe version of getNodeNativeScript; gives you back the Haskell object -- getNodeNativeScript' @"HUD" self getNodeNativeScript' :: forall label b cls scene name scene' label'. ( NativeScript b , Node :< cls , Object :< cls , NodeInScene scene name cls , SceneNodeIsHaskell scene label ~ 'Just '(scene', label') , NodeInScene scene' label' b , KnownSymbol label) => cls -> IO b getNodeNativeScript' cls = getNodeNativeScript @b cls (T.pack $ symbolVal (Proxy @label)) -- | A safe version of emit_signal; will error at compile time if the signal doesn't exist -- emit_signal' @"hit" self [] -- TODO We don't check arguments yet! emit_signal' :: forall label args cls. (Object :< cls, Object :< cls, NodeSignal cls label args, KnownSymbol label) => cls -> [Variant 'GodotTy] -> IO () emit_signal' cls args = do name <- toLowLevel (T.pack $ symbolVal (Proxy @label)) emit_signal cls name args -- | A safe version of await; will error at compile time if the signal and nodes don't exist -- await' @"MessageTimer" @"timeout" self $ \\self' -> pure () await' :: forall (label :: Symbol) (signal :: Symbol) a b cls scene name. ( NodeInScene scene name cls , NativeScript cls , KnownSymbol label , KnownSymbol signal , SceneNode scene label , Node :< cls , AsVariant a , Node :< SceneNodeType scene label , NodeSignal b signal '[] , SceneNodeType scene label ~ b) => cls -> (cls -> IO a) -> IO () await' o f = do n <- getNode' @label o await o n (T.pack $ symbolVal (Proxy @signal)) f -- | Preload a scene so you can instantiate it later. -- Use this when the scene is known ahead of time. Store scenes in as @PackedScene' "SceneName"@ preloadScene :: forall scene. (KnownSymbol scene, SceneResourcePath scene) => IO (PackedScene' scene) preloadScene = do Just r <- getSingleton @ResourceLoader path <- toLowLevel $ sceneResourcePath @scene PackedScene' <$> (tryCast' =<< load r path Nothing Nothing) -- | Create an instance of a scene from a @PackedScene' "SceneName"@ -- Makes sure that you are getting the type of the scene root. sceneInstance :: forall scene o. (Node :< o, Typeable o, AsVariant o, SceneNodeType scene (SceneRootNode scene) ~ o) => PackedScene' scene -> IO o sceneInstance e = tryCast' =<< instance' e Nothing -- | Combines nodeMethod with getNode' to call functions in a type-safe way -- Provides no additional safety compared to using the two separately, but does clean up code a bit. -- For example: fn @"MyNode" @"hide" self fn :: forall (node :: Symbol) (func :: Symbol) scene name cls args ret b. ( Object :< cls , Node :< cls , Node :< SceneNodeType scene node , NodeInScene scene name cls , SceneNode scene node , NodeMethodSuper (SceneNodeType scene node) func args ret , ListToFun args ret ~ IO b , KnownSymbol node) => cls -> IO b fn self = nodeMethod' @_ @func =<< getNode' @node self -- | Get the file path to the scene class SceneResourcePath (scene :: Symbol) where sceneResourcePath :: forall scene. T.Text -- * Internal helpers: You won't use these -- | The root node of a scene class SceneRoot (scene :: Symbol) where type SceneRootNode scene :: Symbol -- | A node in the scene, we know its type and its name, @s@ is the path relate -- to the scene class ( Typeable (SceneNodeType scene s) , AsVariant (SceneNodeType scene s) , Object :< SceneNodeType scene s) => SceneNode (scene :: Symbol) (s :: Symbol) where type SceneNodeType scene s :: * type SceneNodeName scene s :: Symbol type SceneNodeIsHaskell scene s :: Maybe (Symbol, Symbol) -- | You declare this for your types. You offer up a haskell type, @n@, for the -- node. This class verifies that your base class is correct. class (HasBaseClass n, BaseClass n ~ SceneNodeType scene s) => NodeInScene (scene :: Symbol) (s :: Symbol) n | scene s -> n, n -> scene s -- | A connection between nodes in a scene. @from@ and @to@ are paths. -- It connects @signal@ in @from@ to @method@ in @to@. class SceneConnection (scene :: Symbol) (from :: Symbol) (signal :: Symbol) (to :: Symbol) (method :: Symbol) -- | Internal, just for convenience data OneResourceNode (resource :: Symbol) (name :: Symbol) -- | Internal. Don't touch this and don't make instances of it. It's the -- workhorse for making sure that you are implementing all of the classes that -- Godot needs, nothing more and nothing less. class ImplementedInHaskell (a :: [*]) (b :: [*]) where fill :: GdnativeHandle -> IO () instance ImplementedInHaskell '[] '[] where fill _ = pure () registerOne :: forall ty. (NativeScript ty, AsVariant (BaseClass ty)) => GdnativeHandle -> IO () registerOne desc = registerClass $ RegClass desc $ classInit @ty instance ( NodeInScene scene name n , NativeScript n , AsVariant (BaseClass n) , ImplementedInHaskell t t' , SceneNodeIsHaskell scene name ~ 'Just '(resource, name)) => ImplementedInHaskell (OneResourceNode resource name ': t) (n ': t') where fill handle = do registerOne @n handle fill @t @t' handle -- | Create a signal -- TODO args ~ '[] is temproary, we need signeltons to reflect this into a runtime value signal' :: forall cls label args. (NodeSignal cls label args, KnownSymbol label, args ~ '[]) => (Text, [SignalArgument]) signal' = signal (T.pack $ symbolVal (Proxy @label)) [] createMVarProperty' :: (Typeable ty, AsVariant ty) => Text -> (node -> MVar ty) -- ^ We typically can't do IO (for initialisation) when calling this, in -- which case we need to annotate the type without providing a value. -> Either VariantType ty -> ( node -> IO ty , node -> ty -> IO () , Maybe ( Object -> node -> IO GodotVariant , Object -> node -> GodotVariant -> IO () , PropertyAttributes)) createMVarProperty' name fieldName tyOrVal = (readMVar . fieldName, \\c t -> propertySetter p undefined c =<< toGodotVariant t, Just (propertyGetter p, propertySetter p, propertyAttrs p)) where p = createMVarProperty name fieldName tyOrVal appsT :: Type -> [Type] -> Type appsT t [] = t appsT t (x:xs) = appsT (AppT t x) xs -- | Verify that the signal connects to an endpoint that exists and has the right type. witnessConnection :: forall (scene :: Symbol) (from :: Symbol) (signal :: Symbol) (to :: Symbol) (method :: Symbol) parent sigTy hTy. ( SceneNode scene to , NodeSignal parent signal sigTy -- TODO This the check unsound, but SceneNodeType isn't right for this constraint. What is? -- The warning produced because 'from' is not used is a reminder of this issue. -- parent :< SceneNodeType scene from, , NodeMethod hTy method sigTy (IO ()) , NodeInScene scene to hTy) => () witnessConnection = () -- | Sets up a class class NodeInit n where init :: BaseClass n -> IO n -- | You never implement this. It's a helper so that we can have a more -- polymorphic call to nodeMethod which will work when the method is implemneted -- for any parent of the current node. class NodeMethodSuper node (name :: Symbol) (args :: [*]) (ret :: *) | node name -> args, node name -> ret where nodeMethod' :: node -> ListToFun args ret -- | An instance that supports calling nodeMethod' on your parents This can lead -- to infinite loops in the type checker on error, so we isolate it in -- NodeMethodSuper instead of NodeMethod. instance {-# OVERLAPPABLE #-}(NodeMethod (BaseClass node) name arg ret, HasBaseClass node) => NodeMethodSuper node name arg ret where nodeMethod' = nodeMethod' @node @name @arg @ret mkProperty' :: forall node (name :: Symbol) ty. (NodeProperty node name ty 'False, KnownSymbol name) => ClassProperty node mkProperty' = ClassProperty (T.pack $ symbolVal (Proxy @name)) a s g where (_,_,Just (g,s,a)) = nodeProperty @node @name @ty @'False deriveHasBase :: Name -> Q [Dec] deriveHasBase ty = do rdt <- reifyDatatype ty let base = case datatypeCons rdt of (c:_) -> case (constructorFields c, constructorVariant c) of (ConT baseTy:_, RecordConstructor (baseFn:_)) -> Just (baseTy, baseFn) _ -> Nothing _ -> Nothing case base of Just (baseTy, baseFn) -> [d|instance HasBaseClass $(pure $ PromotedT ty) where type BaseClass $(pure $ PromotedT ty) = $(pure $ PromotedT baseTy) super = $(pure $ VarE baseFn)#{end} _ -> error "setupNode can only handle records whose first field is the Godot base class. You can still interface with Godot, but you will need to set things up manually." -- | You should use this as: -- deriveHasBase ''Ty -- setupNode ''Ty "sceneName" "nodePath" -- This will instantiate everything that your Object needs setupNode :: Name -> String -> String -> Q [Dec] setupNode ty scene sceneNode = do -- Collect information about all scenes tree <- map unTree . classInstances <$> reify ''(:<) sceneRoots <- M.fromList . map unSceneRootNode . familyInstances <$> reify ''SceneRootNode sceneNodes <- map unSceneNodeType . familyInstances <$> reify ''SceneNodeType haskellNodes <- map unNodeInScene . classInstances <$> reify ''NodeInScene allSignals <- map unNodeSignal . classInstances <$> reify ''NodeSignal -- Collect information about our node rdt <- reifyDatatype ty -- methods <- filter (\\i -> i ^. _1 == ty) . mapMaybe unNodeMethod . classInstances <$> reify ''NodeMethod properties <- filter (\\i -> i ^. _1 == ty) . mapMaybe unNodeProperty . classInstances <$> reify ''NodeProperty let signals = filter (\\i -> i ^. _1 == ty) allSignals connections <- filter (\\i -> i ^. _1 == scene && i ^. _4 == sceneNode) . map unConnect . classInstances <$> reify ''SceneConnection -- Helpers let parentsOf cls = map snd $ filter (\\(c, _) -> cls == c) tree let nodeToType :: String -> String -> Name nodeToType scene node = case (hty, ty ^. _4) of (Just t, _) -> t (_, Nothing) -> ty ^. _3 (_, Just scene') -> case M.lookup scene' sceneRoots of Nothing -> error $ "Looking up the root of a scene that is lacking one. This is a bug. " ++ show (scene', scene, node) Just node' -> nodeToType scene' node' where ty = fromJust $ find (\\n -> n ^. _1 == scene && n ^. _2 == node) sceneNodes hty = (^. _3) <$> find (\\n -> n ^. _1 == scene && n ^. _2 == node) haskellNodes let resolveSignalActualClass scene from signal = case mapMaybe (\\p -> (p, ) <$> find (\\s -> s ^. _2 == signal && s ^. _1 == p) allSignals) $ parentsOf (nodeToType scene from) of -- The root issue is that the signal might not yet exist. -- If witnessConnection was not unsound, this would not be needed as the error would happen later. [] -> error $ "Class " ++ show from ++ " used in scene " ++ show scene ++ " is lacking a signal named " ++ show signal ++ "\\n" ++ show (nodeToType scene from) ++ "\\n" ++ show (parentsOf (nodeToType scene from)) (h:_) -> h ^. _1 -- Debug when False $ runIO $ do putStrLn "Regenerating .." print rdt putStrLn "\\nScene roots:" print sceneRoots putStrLn "\\nScene nodes types:" mapM_ print sceneNodes putStrLn "\\nMethods:" mapM_ print methods putStrLn "\\nProperties:" mapM_ print properties putStrLn "\\nSignals:" mapM_ print allSignals mapM_ print signals putStrLn "\\nConnections:" mapM_ print connections putStrLn "\\nHaskell nodes:" mapM_ print haskellNodes -- Generate code inh <- deriveBase ty nis <- [d|instance NodeInScene $(pure $ LitT $ StrTyLit scene) $(pure $ LitT $ StrTyLit sceneNode) $(pure $ PromotedT ty)#{end} ns <- [d|instance NativeScript $(pure $ PromotedT ty) where classInit = Project.Support.init classMethods = $(ListE <$> mapM (\\(t, n, argTy, _) -> let m = case nrArguments argTy of 0 -> [e|method0#{end} 1 -> [e|method1#{end} 2 -> [e|method2#{end} 3 -> [e|method3#{end} 4 -> [e|method4#{end} 5 -> [e|method5#{end} n -> error $ "More arguments than we currently impelement, look for 'method5' for more info " ++ show n in [e|$m $(pure $ LitE $ StringL n) (nodeMethod @($(pure $ PromotedT t)) @($(pure $ LitT $ StrTyLit n)))#{end}) methods) classProperties = $(ListE <$> mapM (\\(name, prop, _, _) -> [e|mkProperty' @($(pure $ PromotedT name)) @($(pure $ LitT $ StrTyLit prop))#{end}) properties) classSignals = $(ListE <$> mapM (\\(ty, name, _) -> [e|signal' @($(pure $ PromotedT ty)) @($(pure $ LitT $ StrTyLit name))#{end}) signals)#{end} let cn = mkName $ "witness_connections_" ++ nameBase ty ws <- (:) <$> (cn `sigD` [t| [()] #{end}) <*> [d|$(varP cn) = $(ListE <$> mapM (\\(scene,from,signal,to,method) -> [e|witnessConnection @($(pure $ LitT $ StrTyLit scene)) @($(pure $ LitT $ StrTyLit from)) @($(pure $ LitT $ StrTyLit signal)) @($(pure $ LitT $ StrTyLit to)) @($(pure $ LitT $ StrTyLit method)) @($(pure $ PromotedT $ resolveSignalActualClass scene from signal)) #{end}) connections)#{end} pure $ inh <> nis <> ns <> ws where unTree (InstanceD Nothing [] (AppT (AppT _ parent) child) []) = (unName child, unName parent) unTree p = error $ "I don't understand this parent " ++ show p unName (ConT x) = x unName (AppT (ConT x) _) = x unName x = error $ "I don't know how to extract the name of this type: " ++ show x unSceneRootNode (TySynInstD (TySynEqn Nothing (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit node)))) = (scene, node) unSceneRootNode x = error $ "Don't know how unpack this SceneRootNode: " ++ show x unSceneNodeType (TySynInstD (TySynEqn Nothing (AppT (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit node))) ty)) = (scene, node, unName ty, unpackScene ty) unSceneNodeType x = error $ "Don't know how unpack this SceneNodeType: " ++ show x unpackScene (ConT _) = Nothing unpackScene (AppT (ConT _) (LitT (StrTyLit scene))) = Just scene unpackScene x = error $ "Don't know how unpack this Scene: " ++ show x unNodeMethod (InstanceD Nothing [] (AppT (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) ret) []) = Just (cls, name, arg, ret) unNodeMethod _ = Nothing unNodeProperty (InstanceD Nothing [] (AppT (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) ret) []) = Just (cls, name, arg, ret) unNodeProperty x = error $ show x unNodeInScene (InstanceD Nothing [] (AppT (AppT (AppT (ConT _) (LitT (StrTyLit scene))) (LitT (StrTyLit node))) (ConT hty)) []) = (scene, node, hty) unNodeInScene x = error $ show x unNodeSignal (InstanceD Nothing [] (AppT (AppT (AppT (ConT _) (ConT cls)) (LitT (StrTyLit name))) arg) []) = (cls, name, arg) unNodeSignal _ = error "Bad signal" unConnect (InstanceD Nothing [] (AppT (AppT (AppT (AppT (AppT _ (LitT (StrTyLit scene))) (LitT (StrTyLit from))) (LitT (StrTyLit signal))) (LitT (StrTyLit to))) (LitT (StrTyLit method))) []) = (scene, from, signal, to, method) unConnect x = error $ "Bad signal" ++ show x nrArguments :: Type -> Int nrArguments (AppT _ r) = 1 + nrArguments r nrArguments (SigT PromotedNilT (AppT ListT StarT)) = 0 nrArguments _ = error "Can't compute # of arguments" classInstances :: Info -> [InstanceDec] classInstances (ClassI _ is) = is classInstances _ = error "Bad class" familyInstances :: Info -> [InstanceDec] familyInstances (FamilyI _ is) = is familyInstances _ = error "Bad class" |] where end = "|]" language = [i|{-# LANGUAGE FlexibleContexts, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances, OverloadedStrings, TemplateHaskell, TypeApplications, TypeFamilies, TupleSections, DataKinds, TypeOperators, FlexibleInstances, RankNTypes, AllowAmbiguousTypes, ScopedTypeVariables, DerivingStrategies, GeneralizedNewtypeDeriving, LambdaCase, ImplicitPrelude #-} |] mkModule qualifiedName = T.pack [i|module Project.Scenes.#{qualifiedName} where import Prelude import Project.Support import Godot import GHC.TypeLits |] mkSceneRoot scene (Just name) = T.pack [i| instance SceneRoot "#{mangle $ T.unpack $ unName scene}" where type SceneRootNode "#{mangle $ T.unpack $ unName scene}" = "#{unName name}" |] mkScenePath scene filepath = T.pack [i| instance SceneResourcePath "#{mangle $ T.unpack $ unName scene}" where sceneResourcePath = "res://#{filepath}" |] mkSceneNode scene name path ty ty' isHaskell = ( T.pack [i|import Godot.Core.#{ty}()|], T.pack [i| instance SceneNode "#{scene}" "#{path}" where type SceneNodeType "#{scene}" "#{path}" = #{ty'} type SceneNodeName "#{scene}" "#{path}" = "#{name'}" type SceneNodeIsHaskell "#{scene}" "#{path}" = #{hsNode} |] ) where name' = T.pack name hsNode = case isHaskell of Nothing -> "'Nothing" Just (Name s, Name n) -> "'Just '(\"" <> s <> "\", \"" <> n <> "\")" mkSceneConnection scene from signal to method = T.pack [i| instance SceneConnection "#{scene}" "#{from}" "#{signal}" "#{to}" "#{method}" |] after x = T.drop (T.length x) . snd . T.breakOn x rowType = Ty . T.takeWhile (/= '\"') . after "type=\"" rowPath = T.takeWhile (/= '\"') . after "path=\"res://" rowName = Name . T.takeWhile (/= '\"') . after "name=\"" rowParent t = NodePath <$> if T.isInfixOf " parent=\"" t then Just $ T.takeWhile (/= '\"') $ after "parent=\"" t else Nothing rowId = Id . T.takeWhile isNumber . after "id=" rowInstance t = Id <$> if T.isInfixOf " instance=ExtResource( " t then Just $ T.takeWhile isNumber $ after " instance=ExtResource( " t else Nothing resClassName = Name . T.takeWhile (/= '\"') . after "class_name = \"" resScript = Id . T.takeWhile isNumber . after "script = ExtResource( " resLibrary = Id . T.takeWhile isNumber . after "library = ExtResource( " rowSignal = Signal . T.takeWhile (/= '\"') . after "signal=\"" rowMethod = Method . T.takeWhile (/= '\"') . after "method=\"" rowFrom current = resolve current . NodePath . T.takeWhile (/= '\"') . after "from=\"" rowTo current = resolve current . NodePath . T.takeWhile (/= '\"') . after "to=\"" resolve :: Maybe Name -> NodePath -> NodePath resolve (Just (Name n)) (NodePath ".") = NodePath n resolve _ (NodePath ".") = error "Relative node path without a current node" resolve _ p = p readTscn fn relFile = do b <- doesFileExist fn let tscnName = Name $ T.pack $ takeBaseName fn if b then do f <- T.lines <$> T.readFile fn case f of [] -> error $ "Empty .tscn file: " ++ fn (h : l) -> do if T.isPrefixOf "[gd_scene " h then pure $ fillRoot $ foldl' ( \(s, current, root) t -> if | T.isPrefixOf "[ext_resource " t -> ( s & resources . at (rowId t) ?~ Resource (rowType t) (rowPath t), current, root ) | T.isPrefixOf "[node " t -> ( s & nodes . at (rowName t) ?~ TscnNode (rowType t) (rowParent t) (rowInstance t) Nothing, Just $ rowName t, case rowParent t of Nothing -> Just $ rowName t _ -> root ) | T.isPrefixOf "[connection " t -> ( s & connections %~ (TscnConnection (rowSignal t) (rowFrom root t) (rowTo root t) (rowMethod t) :), current, root ) | T.isPrefixOf "script = ExtResource( " t -> case current of Just name -> (s & nodes . ix name . script ?~ resScript t, current, root) | otherwise -> (s, current, root) ) (Tscn tscnName M.empty M.empty [] Nothing relFile, Nothing, Nothing) l else pure $ Tscn tscnName M.empty M.empty [] Nothing relFile else pure $ Tscn tscnName M.empty M.empty [] Nothing relFile where fillRoot (tscn, _, root) = tscn & rootNode .~ root readGdns fn = do b <- doesFileExist fn if b then do f <- T.lines <$> T.readFile fn case f of [] -> error $ "Empty .gdns file: " ++ fn (h : l) -> do if T.isPrefixOf "[gd_resource type=\"NativeScript\" " h then pure $ fst $ foldl' ( \(s, current) t -> if | T.isPrefixOf "[ext_resource " t -> (s & extResources . at (rowId t) ?~ Resource (rowType t) (rowPath t), current) | T.isPrefixOf "[" t -> (s, Nothing) -- Reset on any new heading | T.isPrefixOf "class_name =" t -> (s, Just $ resClassName t) | T.isPrefixOf "library = " t -> ( s & resources . at (fromJust current) ?~ resLibrary t, current ) | otherwise -> (s, current) ) (Gdns M.empty M.empty, Nothing) l else pure $ Gdns M.empty M.empty else pure $ Gdns M.empty M.empty main :: IO () main = do args <- getArgs case args of [inDir, outDir] -> do let regenerate = do putStrLn "Regenerating ..." gdnsFiles <- allByExtension ".gdns" inDir tscnFiles <- allByExtension ".tscn" inDir mapM_ putStrLn gdnsFiles mapM_ putStrLn tscnFiles b <- doesDirectoryExist (outDir "Project") when b $ removeDirectoryRecursive (outDir "Project") createDirectoryIfMissing True (outDir "Project" "Scenes") outputSupport outDir --- tscns <- fmap M.fromList $ forM tscnFiles $ \f -> let relFile = makeRelative inDir f in (T.pack relFile,) <$> readTscn f relFile gdnss <- fmap M.fromList $ forM gdnsFiles $ \f -> (T.pack $ makeRelative inDir f,) <$> readGdns f --- forM_ (M.toList tscns) $ \(fn, t) -> outputTscn (segmentsName inDir fn) (moduleName inDir fn) outDir t tscns gdnss outputCombined inDir outDir tscns outputGdnss inDir outDir gdnss putStrLn "Generated!" putStrLn "Watching ... ctrl+c to stop" regenerate withManager $ \mgr -> do watchDir mgr inDir ( \e -> let ext = takeExtension (eventPath e) in ext == ".gdns" || ext == ".tscn" ) ( \a -> do regenerate print a ) forever $ threadDelay 1000000 _ -> error "Usage: godot-haskell-project-generator " segmentsName :: FilePath -> T.Text -> [[Char]] segmentsName inDir tscnFilepath = map mangle $ filter (/= ".") $ splitPath $ takeDirectory $ T.unpack tscnFilepath moduleName :: FilePath -> T.Text -> [Char] moduleName inDir tscnFilepath = mangle $ takeBaseName $ T.unpack tscnFilepath outputTscn :: [FilePath] -> FilePath -> FilePath -> Tscn -> M.Map T.Text Tscn -> M.Map T.Text Gdns -> IO () outputTscn segmentsTscnName sceneName outDir tscn tscns gdnss = do createAndWriteFile (normalise $ outDir "Project" "Scenes" joinPath segmentsTscnName sceneName <> ".hs") $ T.unlines ( [T.pack language, mkModule (toNamespace $ segmentsTscnName <> [sceneName])] ++ nub (map fst sceneNodes) ++ [ mkScenePath (_tscnSceneName tscn) (tscn ^. filepath), mkSceneRoot (_tscnSceneName tscn) (tscn ^. rootNode) ] ++ map snd sceneNodes ++ map ( \conn -> mkSceneConnection sceneName (conn ^. from) (conn ^. signal) (conn ^. to) (conn ^. method) ) (tscn ^. connections) ) where sceneNodes = flip mapMaybe (M.toList $ tscn ^. nodes) $ \(name, node) -> do ty <- case (node ^. ty, node ^. instanceof) of (Ty "", Just i) -> case M.lookup i (tscn ^. resources) of Just r -> Just $ r ^. ty Nothing -> error $ "Can't look up type of " ++ show (name, node) -- This happens for nodes from editable scenes (Ty "", Nothing) -> Nothing (t, _) -> Just t return $ mkSceneNode sceneName (T.unpack $ unName name) ( case node ^. parent of Nothing -> unName name Just (NodePath ".") -> unName name Just (NodePath p') -> p' <> "/" <> unName name ) ty (annotatePackedScene node ty) (isHaskellNode name node tscn tscns gdnss) annotatePackedScene node (Ty "PackedScene") = Ty $ "PackedScene' \"" <> unName ( fromJust $ do i <- node ^. instanceof r <- M.lookup i (tscn ^. resources) t <- M.lookup (r ^. path) tscns t ^. rootNode ) <> "\"" annotatePackedScene node ty = ty isHaskellNode :: Name -> TscnNode -> Tscn -> M.Map T.Text Tscn -> M.Map T.Text Gdns -> Maybe (Name, Name) isHaskellNode name node tscn tscns gdnss = case ((\f -> tscn ^? resources . at f . _Just . path) =<< (node ^. script), node ^. instanceof) of (Just p, _) -> case gdnss ^. at p of Just g -> if isHaskellGdns name g then Just (Name $ T.pack $ dropExtension $ T.unpack p, name) else Nothing Nothing -> Nothing (_, Just i) -> let t = tscns ^. at (tscn ^. resources . at i . _Just . path) in case (t, rootNodeTscn (fromJust t)) of (Just t', Just (n, r)) -> isHaskellNode n r t' tscns gdnss _ -> Nothing _ -> Nothing isHaskellGdns :: Name -> Gdns -> Bool isHaskellGdns n gdns = maybe False (\f -> maybe False isHaskellResource (gdns ^. extResources . at f)) (gdns ^. resources . at n) isHaskellResource :: Resource -> Bool isHaskellResource r = T.isSuffixOf ".gdnlib" $ r ^. path rootNodeTscn :: Tscn -> Maybe (Name, TscnNode) rootNodeTscn tscn = find (\(name, node) -> isNothing (node ^. parent)) $ M.toList $ tscn ^. nodes outputCombined inDir outDir tscns = createAndWriteFile (outDir "Project" "Scenes.hs") $ T.pack [i|module Project.Scenes #{exports} where #{imports} |] where imports = unlines $ map ( \(fn, t) -> let f = toNamespace $ segmentsName inDir fn <> [moduleName inDir fn] in [i|import qualified Project.Scenes.#{f} as M|] ) $ M.toList tscns exports = if null imports then "" else "(module M)" outputSupport dir = createAndWriteFile (dir "Project" "Support.hs") (T.pack $ language ++ support) mkRequirementsModule inDir gdnss = T.pack [i|{-# LANGUAGE DataKinds #-} module Project.Requirements where import Project.Support type Nodes = '[#{reqs}] |] where reqs = intercalate ", " $ map one $ sort $ concatMap (mkRequirement inDir) gdnss one (resource, name) = [i|OneResourceNode "#{resource}" "#{name}"|] outputGdnss :: FilePath -> FilePath -> M.Map T.Text Gdns -> IO () outputGdnss inDir dir gdnss = createAndWriteFile (dir "Project" "Requirements.hs") $ mkRequirementsModule inDir $ M.toList gdnss mkRequirement :: FilePath -> (T.Text, Gdns) -> [(String, T.Text)] mkRequirement inDir (fn, gdns) = mapMaybe ( \(n, i) -> case M.lookup i (gdns ^. extResources) of Just r -> if T.isInfixOf ".gdnlib" (r ^. path) && unTy (r ^. ty) == "GDNativeLibrary" then Just (moduleName inDir fn, unName n) else Nothing _ -> Nothing ) $ M.toList $ gdns ^. resources toNamespace :: [FilePath] -> String toNamespace = intercalate "." . fmap dropTrailingPathSeparator ================================================ FILE: release.nix ================================================ let pkgs = import { }; in pkgs.haskellPackages.callPackage ./default.nix { api-json = null; } ================================================ FILE: shell-spacemacs-hie.nix ================================================ let pinned = import ./nix/pinned { inherit (import {}) fetchFromGitHub lib; }; hsPkgs = pinned.nixpkgs.haskell.packages."ghc864"; in hsPkgs.developPackage { root = ./.; modifier = drv: pinned.nixpkgs.haskell.lib.addBuildTools drv (import ./nix/spacemacs-hie.nix { pkgs = pinned.nixpkgs; inherit hsPkgs; }); } ================================================ FILE: shell.nix ================================================ { nixpkgs ? import ./pinned-nixpkgs.nix {} , compiler ? "default" , doBenchmark ? false }: let inherit (nixpkgs) pkgs; haskellPackages = if compiler == "default" then pkgs.haskellPackages else pkgs.haskell.packages.${compiler}; variant = if doBenchmark then pkgs.haskell.lib.doBenchmark else pkgs.lib.id; drv = variant (haskellPackages.callPackage ./. {}); in if pkgs.lib.inNixShell then drv.env else drv ================================================ FILE: src/Godot/Api/Types.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TemplateHaskell #-} module Godot.Api.Types (HasBaseClass(..), GlobalConstants(..), ARVRAnchor(..), ARVRCamera(..), ARVRController(..), ARVRInterface(..), ARVRInterfaceGDNative(..), ARVROrigin(..), ARVRPositionalTracker(..), ARVRServer(..), AStar(..), AStar2D(..), AcceptDialog(..), AnimatedSprite(..), AnimatedSprite3D(..), AnimatedTexture(..), Animation(..), AnimationNode(..), AnimationNodeAdd2(..), AnimationNodeAdd3(..), AnimationNodeAnimation(..), AnimationNodeBlend2(..), AnimationNodeBlend3(..), AnimationNodeBlendSpace1D(..), AnimationNodeBlendSpace2D(..), AnimationNodeBlendTree(..), AnimationNodeOneShot(..), AnimationNodeOutput(..), AnimationNodeStateMachine(..), AnimationNodeStateMachinePlayback(..), AnimationNodeStateMachineTransition(..), AnimationNodeTimeScale(..), AnimationNodeTimeSeek(..), AnimationNodeTransition(..), AnimationPlayer(..), AnimationRootNode(..), AnimationTrackEditPlugin(..), AnimationTree(..), AnimationTreePlayer(..), Area(..), Area2D(..), ArrayMesh(..), AtlasTexture(..), AudioBusLayout(..), AudioEffect(..), AudioEffectAmplify(..), AudioEffectBandLimitFilter(..), AudioEffectBandPassFilter(..), AudioEffectChorus(..), AudioEffectCompressor(..), AudioEffectDelay(..), AudioEffectDistortion(..), AudioEffectEQ(..), AudioEffectEQ10(..), AudioEffectEQ21(..), AudioEffectEQ6(..), AudioEffectFilter(..), AudioEffectHighPassFilter(..), AudioEffectHighShelfFilter(..), AudioEffectInstance(..), AudioEffectLimiter(..), AudioEffectLowPassFilter(..), AudioEffectLowShelfFilter(..), AudioEffectNotchFilter(..), AudioEffectPanner(..), AudioEffectPhaser(..), AudioEffectPitchShift(..), AudioEffectRecord(..), AudioEffectReverb(..), AudioEffectSpectrumAnalyzer(..), AudioEffectSpectrumAnalyzerInstance(..), AudioEffectStereoEnhance(..), AudioServer(..), AudioStream(..), AudioStreamGenerator(..), AudioStreamGeneratorPlayback(..), AudioStreamMicrophone(..), AudioStreamOGGVorbis(..), AudioStreamPlayback(..), AudioStreamPlaybackResampled(..), AudioStreamPlayer(..), AudioStreamPlayer2D(..), AudioStreamPlayer3D(..), AudioStreamRandomPitch(..), AudioStreamSample(..), BackBufferCopy(..), BakedLightmap(..), BakedLightmapData(..), BaseButton(..), BitMap(..), BitmapFont(..), Bone2D(..), BoneAttachment(..), BoxContainer(..), BoxShape(..), BulletPhysicsDirectBodyState(..), BulletPhysicsServer(..), Button(..), ButtonGroup(..), CPUParticles(..), CPUParticles2D(..), CSGBox(..), CSGCombiner(..), CSGCylinder(..), CSGMesh(..), CSGPolygon(..), CSGPrimitive(..), CSGShape(..), CSGSphere(..), CSGTorus(..), Camera(..), Camera2D(..), CameraFeed(..), CameraServer(..), CameraTexture(..), CanvasItem(..), CanvasItemMaterial(..), CanvasLayer(..), CanvasModulate(..), CapsuleMesh(..), CapsuleShape(..), CapsuleShape2D(..), CenterContainer(..), CharFXTransform(..), CheckBox(..), CheckButton(..), CircleShape2D(..), ClippedCamera(..), CollisionObject(..), CollisionObject2D(..), CollisionPolygon(..), CollisionPolygon2D(..), CollisionShape(..), CollisionShape2D(..), ColorPicker(..), ColorPickerButton(..), ColorRect(..), ConcavePolygonShape(..), ConcavePolygonShape2D(..), ConeTwistJoint(..), ConfigFile(..), ConfirmationDialog(..), Container(..), Control(..), ConvexPolygonShape(..), ConvexPolygonShape2D(..), Crypto(..), CryptoKey(..), CubeMap(..), CubeMesh(..), Curve(..), Curve2D(..), Curve3D(..), CurveTexture(..), CylinderMesh(..), CylinderShape(..), DampedSpringJoint2D(..), DirectionalLight(..), DynamicFont(..), DynamicFontData(..), EditorExportPlugin(..), EditorFeatureProfile(..), EditorFileDialog(..), EditorFileSystem(..), EditorFileSystemDirectory(..), EditorImportPlugin(..), EditorInspector(..), EditorInspectorPlugin(..), EditorInterface(..), EditorNavigationMeshGenerator(..), EditorPlugin(..), EditorProperty(..), EditorResourceConversionPlugin(..), EditorResourcePreview(..), EditorResourcePreviewGenerator(..), EditorSceneImporter(..), EditorSceneImporterAssimp(..), EditorScenePostImport(..), EditorScript(..), EditorSelection(..), EditorSettings(..), EditorSpatialGizmo(..), EditorSpatialGizmoPlugin(..), EditorSpinSlider(..), EditorVCSInterface(..), EncodedObjectAsID(..), Environment(..), Expression(..), FileDialog(..), Font(..), FuncRef(..), GDNative(..), GDNativeLibrary(..), GDScript(..), GDScriptFunctionState(..), GIProbe(..), GIProbeData(..), Generic6DOFJoint(..), GeometryInstance(..), Gradient(..), GradientTexture(..), GraphEdit(..), GraphNode(..), GridContainer(..), GridMap(..), GrooveJoint2D(..), HBoxContainer(..), HScrollBar(..), HSeparator(..), HSlider(..), HSplitContainer(..), HTTPClient(..), HTTPRequest(..), HashingContext(..), HeightMapShape(..), HingeJoint(..), IP(..), IP_Unix(..), Image(..), ImageTexture(..), ImmediateGeometry(..), Input(..), InputDefault(..), InputEvent(..), InputEventAction(..), InputEventGesture(..), InputEventJoypadButton(..), InputEventJoypadMotion(..), InputEventKey(..), InputEventMIDI(..), InputEventMagnifyGesture(..), InputEventMouse(..), InputEventMouseButton(..), InputEventMouseMotion(..), InputEventPanGesture(..), InputEventScreenDrag(..), InputEventScreenTouch(..), InputEventWithModifiers(..), InputMap(..), InstancePlaceholder(..), InterpolatedCamera(..), ItemList(..), JSONParseResult(..), JSONRPC(..), JavaClass(..), JavaClassWrapper(..), JavaScript(..), Joint(..), Joint2D(..), KinematicBody(..), KinematicBody2D(..), KinematicCollision(..), KinematicCollision2D(..), Label(..), LargeTexture(..), Light(..), Light2D(..), LightOccluder2D(..), Line2D(..), LineEdit(..), LineShape2D(..), LinkButton(..), Listener(..), MainLoop(..), MarginContainer(..), Material(..), MenuButton(..), Mesh(..), MeshDataTool(..), MeshInstance(..), MeshInstance2D(..), MeshLibrary(..), MeshTexture(..), MobileVRInterface(..), MultiMesh(..), MultiMeshInstance(..), MultiMeshInstance2D(..), MultiplayerAPI(..), MultiplayerPeerGDNative(..), NativeScript(..), Navigation(..), Navigation2D(..), NavigationMesh(..), NavigationMeshInstance(..), NavigationPolygon(..), NavigationPolygonInstance(..), NetworkedMultiplayerENet(..), NetworkedMultiplayerPeer(..), NinePatchRect(..), Node(..), Node2D(..), NoiseTexture(..), OccluderPolygon2D(..), OmniLight(..), OpenSimplexNoise(..), OptionButton(..), PCKPacker(..), PHashTranslation(..), PackedDataContainer(..), PackedDataContainerRef(..), PackedScene(..), PacketPeer(..), PacketPeerGDNative(..), PacketPeerStream(..), PacketPeerUDP(..), Panel(..), PanelContainer(..), PanoramaSky(..), ParallaxBackground(..), ParallaxLayer(..), Particles(..), Particles2D(..), ParticlesMaterial(..), Path(..), Path2D(..), PathFollow(..), PathFollow2D(..), Performance(..), PhysicalBone(..), Physics2DDirectBodyState(..), Physics2DDirectBodyStateSW(..), Physics2DDirectSpaceState(..), Physics2DServer(..), Physics2DServerSW(..), Physics2DShapeQueryParameters(..), Physics2DShapeQueryResult(..), Physics2DTestMotionResult(..), PhysicsBody(..), PhysicsBody2D(..), PhysicsDirectBodyState(..), PhysicsDirectSpaceState(..), PhysicsMaterial(..), PhysicsServer(..), PhysicsShapeQueryParameters(..), PhysicsShapeQueryResult(..), PinJoint(..), PinJoint2D(..), PlaneMesh(..), PlaneShape(..), PluginScript(..), PointMesh(..), Polygon2D(..), PolygonPathFinder(..), Popup(..), PopupDialog(..), PopupMenu(..), PopupPanel(..), Position2D(..), Position3D(..), PrimitiveMesh(..), PrismMesh(..), ProceduralSky(..), ProgressBar(..), ProjectSettings(..), ProximityGroup(..), ProxyTexture(..), QuadMesh(..), RandomNumberGenerator(..), Range(..), RayCast(..), RayCast2D(..), RayShape(..), RayShape2D(..), RectangleShape2D(..), Reference(..), ReferenceRect(..), ReflectionProbe(..), RegEx(..), RegExMatch(..), RemoteTransform(..), RemoteTransform2D(..), Resource(..), ResourceFormatLoader(..), ResourceFormatLoaderCrypto(..), ResourceFormatSaver(..), ResourceFormatSaverCrypto(..), ResourceImporter(..), ResourceInteractiveLoader(..), ResourcePreloader(..), RichTextEffect(..), RichTextLabel(..), RigidBody(..), RigidBody2D(..), RootMotionView(..), SceneState(..), SceneTree(..), SceneTreeTimer(..), Script(..), ScriptCreateDialog(..), ScriptEditor(..), ScrollBar(..), ScrollContainer(..), SegmentShape2D(..), Separator(..), Shader(..), ShaderMaterial(..), Shape(..), Shape2D(..), ShortCut(..), Skeleton(..), Skeleton2D(..), SkeletonIK(..), Skin(..), SkinReference(..), Sky(..), Slider(..), SliderJoint(..), SoftBody(..), Spatial(..), SpatialGizmo(..), SpatialMaterial(..), SpatialVelocityTracker(..), SphereMesh(..), SphereShape(..), SpinBox(..), SplitContainer(..), SpotLight(..), SpringArm(..), Sprite(..), Sprite3D(..), SpriteBase3D(..), SpriteFrames(..), StaticBody(..), StaticBody2D(..), StreamPeer(..), StreamPeerBuffer(..), StreamPeerGDNative(..), StreamPeerSSL(..), StreamPeerTCP(..), StreamTexture(..), StyleBox(..), StyleBoxEmpty(..), StyleBoxFlat(..), StyleBoxLine(..), StyleBoxTexture(..), SurfaceTool(..), TCP_Server(..), TabContainer(..), Tabs(..), TextEdit(..), TextFile(..), Texture(..), Texture3D(..), TextureArray(..), TextureButton(..), TextureLayered(..), TextureProgress(..), TextureRect(..), Theme(..), TileMap(..), TileSet(..), Timer(..), ToolButton(..), TouchScreenButton(..), Translation(..), TranslationServer(..), Tree(..), TreeItem(..), TriangleMesh(..), Tween(..), UPNP(..), UPNPDevice(..), UndoRedo(..), VBoxContainer(..), VScrollBar(..), VSeparator(..), VSlider(..), VSplitContainer(..), VehicleBody(..), VehicleWheel(..), VideoPlayer(..), VideoStream(..), VideoStreamGDNative(..), VideoStreamTheora(..), VideoStreamWebm(..), Viewport(..), ViewportContainer(..), ViewportTexture(..), VisibilityEnabler(..), VisibilityEnabler2D(..), VisibilityNotifier(..), VisibilityNotifier2D(..), VisualInstance(..), VisualScript(..), VisualScriptBasicTypeConstant(..), VisualScriptBuiltinFunc(..), VisualScriptClassConstant(..), VisualScriptComment(..), VisualScriptComposeArray(..), VisualScriptCondition(..), VisualScriptConstant(..), VisualScriptConstructor(..), VisualScriptCustomNode(..), VisualScriptDeconstruct(..), VisualScriptEmitSignal(..), VisualScriptEngineSingleton(..), VisualScriptExpression(..), VisualScriptFunction(..), VisualScriptFunctionCall(..), VisualScriptFunctionState(..), VisualScriptGlobalConstant(..), VisualScriptIndexGet(..), VisualScriptIndexSet(..), VisualScriptInputAction(..), VisualScriptIterator(..), VisualScriptLists(..), VisualScriptLocalVar(..), VisualScriptLocalVarSet(..), VisualScriptMathConstant(..), VisualScriptNode(..), VisualScriptOperator(..), VisualScriptPreload(..), VisualScriptPropertyGet(..), VisualScriptPropertySet(..), VisualScriptResourcePath(..), VisualScriptReturn(..), VisualScriptSceneNode(..), VisualScriptSceneTree(..), VisualScriptSelect(..), VisualScriptSelf(..), VisualScriptSequence(..), VisualScriptSubCall(..), VisualScriptSwitch(..), VisualScriptTypeCast(..), VisualScriptVariableGet(..), VisualScriptVariableSet(..), VisualScriptWhile(..), VisualScriptYield(..), VisualScriptYieldSignal(..), VisualServer(..), VisualShader(..), VisualShaderNode(..), VisualShaderNodeBooleanConstant(..), VisualShaderNodeBooleanUniform(..), VisualShaderNodeColorConstant(..), VisualShaderNodeColorFunc(..), VisualShaderNodeColorOp(..), VisualShaderNodeColorUniform(..), VisualShaderNodeCompare(..), VisualShaderNodeCubeMap(..), VisualShaderNodeCubeMapUniform(..), VisualShaderNodeCustom(..), VisualShaderNodeDeterminant(..), VisualShaderNodeDotProduct(..), VisualShaderNodeExpression(..), VisualShaderNodeFaceForward(..), VisualShaderNodeFresnel(..), VisualShaderNodeGlobalExpression(..), VisualShaderNodeGroupBase(..), VisualShaderNodeIf(..), VisualShaderNodeInput(..), VisualShaderNodeIs(..), VisualShaderNodeOuterProduct(..), VisualShaderNodeOutput(..), VisualShaderNodeScalarClamp(..), VisualShaderNodeScalarConstant(..), VisualShaderNodeScalarDerivativeFunc(..), VisualShaderNodeScalarFunc(..), VisualShaderNodeScalarInterp(..), VisualShaderNodeScalarOp(..), VisualShaderNodeScalarSmoothStep(..), VisualShaderNodeScalarSwitch(..), VisualShaderNodeScalarUniform(..), VisualShaderNodeSwitch(..), VisualShaderNodeTexture(..), VisualShaderNodeTextureUniform(..), VisualShaderNodeTextureUniformTriplanar(..), VisualShaderNodeTransformCompose(..), VisualShaderNodeTransformConstant(..), VisualShaderNodeTransformDecompose(..), VisualShaderNodeTransformFunc(..), VisualShaderNodeTransformMult(..), VisualShaderNodeTransformUniform(..), VisualShaderNodeTransformVecMult(..), VisualShaderNodeUniform(..), VisualShaderNodeVec3Constant(..), VisualShaderNodeVec3Uniform(..), VisualShaderNodeVectorClamp(..), VisualShaderNodeVectorCompose(..), VisualShaderNodeVectorDecompose(..), VisualShaderNodeVectorDerivativeFunc(..), VisualShaderNodeVectorDistance(..), VisualShaderNodeVectorFunc(..), VisualShaderNodeVectorInterp(..), VisualShaderNodeVectorLen(..), VisualShaderNodeVectorOp(..), VisualShaderNodeVectorRefract(..), VisualShaderNodeVectorScalarMix(..), VisualShaderNodeVectorScalarSmoothStep(..), VisualShaderNodeVectorScalarStep(..), VisualShaderNodeVectorSmoothStep(..), WeakRef(..), WebRTCDataChannel(..), WebRTCDataChannelGDNative(..), WebRTCMultiplayer(..), WebRTCPeerConnection(..), WebRTCPeerConnectionGDNative(..), WebSocketClient(..), WebSocketMultiplayerPeer(..), WebSocketPeer(..), WebSocketServer(..), WindowDialog(..), World(..), World2D(..), WorldEnvironment(..), X509Certificate(..), XMLParser(..), YSort(..), ClassDB(..), Directory(..), Engine(..), File(..), Geometry(..), JSON(..), Marshalls(..), Mutex(..), OS(..), ResourceLoader(..), ResourceSaver(..), Semaphore(..), Thread(..), VisualScriptEditor(..)) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import Godot.Gdnative.Internal newtype GlobalConstants = GlobalConstants Object deriving newtype AsVariant -- | An anchor point in AR space. -- The @ARVRAnchor@ point is a spatial node that maps a real world location identified by the AR platform to a position within the game world. For example, as long as plane detection in ARKit is on, ARKit will identify and update the position of planes (tables, floors, etc) and create anchors for them. -- This node is mapped to one of the anchors through its unique ID. When you receive a signal that a new anchor is available, you should add this node to your scene for that anchor. You can predefine nodes and set the ID; the nodes will simply remain on 0,0,0 until a plane is recognized. -- Keep in mind that, as long as plane detection is enabled, the size, placing and orientation of an anchor will be updated as the detection logic learns more about the real world out there especially if only part of the surface is in view. newtype ARVRAnchor = ARVRAnchor Object deriving newtype AsVariant instance HasBaseClass ARVRAnchor where type BaseClass ARVRAnchor = Spatial super = coerce -- | A camera node with a few overrules for AR/VR applied, such as location tracking. -- This is a helper spatial node for our camera; note that, if stereoscopic rendering is applicable (VR-HMD), most of the camera properties are ignored, as the HMD information overrides them. The only properties that can be trusted are the near and far planes. -- The position and orientation of this node is automatically updated by the ARVR Server to represent the location of the HMD if such tracking is available and can thus be used by game logic. Note that, in contrast to the ARVR Controller, the render thread has access to the most up-to-date tracking data of the HMD and the location of the ARVRCamera can lag a few milliseconds behind what is used for rendering as a result. newtype ARVRCamera = ARVRCamera Object deriving newtype AsVariant instance HasBaseClass ARVRCamera where type BaseClass ARVRCamera = Camera super = coerce -- | A spatial node representing a spatially-tracked controller. -- This is a helper spatial node that is linked to the tracking of controllers. It also offers several handy passthroughs to the state of buttons and such on the controllers. -- Controllers are linked by their ID. You can create controller nodes before the controllers are available. If your game always uses two controllers (one for each hand), you can predefine the controllers with ID 1 and 2; they will become active as soon as the controllers are identified. If you expect additional controllers to be used, you should react to the signals and add ARVRController nodes to your scene. -- The position of the controller node is automatically updated by the @ARVRServer@. This makes this node ideal to add child nodes to visualize the controller. newtype ARVRController = ARVRController Object deriving newtype AsVariant instance HasBaseClass ARVRController where type BaseClass ARVRController = Spatial super = coerce -- | Base class for an AR/VR interface implementation. -- This class needs to be implemented to make an AR or VR platform available to Godot and these should be implemented as C++ modules or GDNative modules (note that for GDNative the subclass ARVRScriptInterface should be used). Part of the interface is exposed to GDScript so you can detect, enable and configure an AR or VR platform. -- Interfaces should be written in such a way that simply enabling them will give us a working setup. You can query the available interfaces through @ARVRServer@. newtype ARVRInterface = ARVRInterface Object deriving newtype AsVariant instance HasBaseClass ARVRInterface where type BaseClass ARVRInterface = Reference super = coerce newtype ARVRInterfaceGDNative = ARVRInterfaceGDNative Object deriving newtype AsVariant instance HasBaseClass ARVRInterfaceGDNative where type BaseClass ARVRInterfaceGDNative = ARVRInterface super = coerce -- | The origin point in AR/VR. -- This is a special node within the AR/VR system that maps the physical location of the center of our tracking space to the virtual location within our game world. -- There should be only one of these nodes in your scene and you must have one. All the ARVRCamera, ARVRController and ARVRAnchor nodes should be direct children of this node for spatial tracking to work correctly. -- It is the position of this node that you update when your character needs to move through your game world while we're not moving in the real world. Movement in the real world is always in relation to this origin point. -- For example, if your character is driving a car, the ARVROrigin node should be a child node of this car. Or, if you're implementing a teleport system to move your character, you should change the position of this node. newtype ARVROrigin = ARVROrigin Object deriving newtype AsVariant instance HasBaseClass ARVROrigin where type BaseClass ARVROrigin = Spatial super = coerce -- | A tracked object. -- An instance of this object represents a device that is tracked, such as a controller or anchor point. HMDs aren't represented here as they are handled internally. -- As controllers are turned on and the AR/VR interface detects them, instances of this object are automatically added to this list of active tracking objects accessible through the @ARVRServer@. -- The @ARVRController@ and @ARVRAnchor@ both consume objects of this type and should be used in your project. The positional trackers are just under-the-hood objects that make this all work. These are mostly exposed so that GDNative-based interfaces can interact with them. newtype ARVRPositionalTracker = ARVRPositionalTracker Object deriving newtype AsVariant instance HasBaseClass ARVRPositionalTracker where type BaseClass ARVRPositionalTracker = Object super = coerce -- | Server for AR and VR features. -- The AR/VR server is the heart of our Advanced and Virtual Reality solution and handles all the processing. newtype ARVRServer = ARVRServer Object deriving newtype AsVariant instance HasBaseClass ARVRServer where type BaseClass ARVRServer = Object super = coerce -- | An implementation of A* to find shortest paths among connected points in space. -- A* (A star) is a computer algorithm that is widely used in pathfinding and graph traversal, the process of plotting short paths among vertices (points), passing through a given set of edges (segments). It enjoys widespread use due to its performance and accuracy. Godot's A* implementation uses points in three-dimensional space and Euclidean distances by default. -- You must add points manually with @method add_point@ and create segments manually with @method connect_points@. Then you can test if there is a path between two points with the @method are_points_connected@ function, get a path containing indices by @method get_id_path@, or one containing actual coordinates with @method get_point_path@. -- It is also possible to use non-Euclidean distances. To do so, create a class that extends @AStar@ and override methods @method _compute_cost@ and @method _estimate_cost@. Both take two indices and return a length, as is shown in the following example. -- -- @ -- -- class MyAStar: -- extends AStar -- -- func _compute_cost(u, v): -- return abs(u - v) -- -- func _estimate_cost(u, v): -- return min(0, abs(u - v) - 1) -- -- @ -- -- @method _estimate_cost@ should return a lower bound of the distance, i.e. @_estimate_cost(u, v) <= _compute_cost(u, v)@. This serves as a hint to the algorithm because the custom @_compute_cost@ might be computation-heavy. If this is not the case, make @method _estimate_cost@ return the same value as @method _compute_cost@ to provide the algorithm with the most accurate information. newtype AStar = AStar Object deriving newtype AsVariant instance HasBaseClass AStar where type BaseClass AStar = Reference super = coerce -- | AStar class representation that uses 2D vectors as edges. -- This is a wrapper for the @AStar@ class which uses 2D vectors instead of 3D vectors. newtype AStar2D = AStar2D Object deriving newtype AsVariant instance HasBaseClass AStar2D where type BaseClass AStar2D = Reference super = coerce -- | Base dialog for user notification. -- This dialog is useful for small notifications to the user about an event. It can only be accepted or closed, with the same result. newtype AcceptDialog = AcceptDialog Object deriving newtype AsVariant instance HasBaseClass AcceptDialog where type BaseClass AcceptDialog = WindowDialog super = coerce -- | Sprite node that can use multiple textures for animation. -- Animations are created using a @SpriteFrames@ resource, which can be configured in the editor via the SpriteFrames panel. -- __Note:__ You can associate a set of normal maps by creating additional @SpriteFrames@ resources with a @_normal@ suffix. For example, having 2 @SpriteFrames@ resources @run@ and @run_normal@ will make it so the @run@ animation uses the normal map. newtype AnimatedSprite = AnimatedSprite Object deriving newtype AsVariant instance HasBaseClass AnimatedSprite where type BaseClass AnimatedSprite = Node2D super = coerce -- | 2D sprite node in 3D world, that can use multiple 2D textures for animation. -- Animations are created using a @SpriteFrames@ resource, which can be configured in the editor via the SpriteFrames panel. newtype AnimatedSprite3D = AnimatedSprite3D Object deriving newtype AsVariant instance HasBaseClass AnimatedSprite3D where type BaseClass AnimatedSprite3D = SpriteBase3D super = coerce -- | Proxy texture for simple frame-based animations. -- @AnimatedTexture@ is a resource format for frame-based animations, where multiple textures can be chained automatically with a predefined delay for each frame. Unlike @AnimationPlayer@ or @AnimatedSprite@, it isn't a @Node@, but has the advantage of being usable anywhere a @Texture@ resource can be used, e.g. in a @TileSet@. -- The playback of the animation is controlled by the @fps@ property as well as each frame's optional delay (see @method set_frame_delay@). The animation loops, i.e. it will restart at frame 0 automatically after playing the last frame. -- @AnimatedTexture@ currently requires all frame textures to have the same size, otherwise the bigger ones will be cropped to match the smallest one. -- __Note:__ AnimatedTexture doesn't support using @AtlasTexture@s. Each frame needs to be a separate @Texture@. newtype AnimatedTexture = AnimatedTexture Object deriving newtype AsVariant instance HasBaseClass AnimatedTexture where type BaseClass AnimatedTexture = Texture super = coerce -- | Contains data used to animate everything in the engine. -- An Animation resource contains data used to animate everything in the engine. Animations are divided into tracks, and each track must be linked to a node. The state of that node can be changed through time, by adding timed keys (events) to the track. -- -- @ -- -- # This creates an animation that makes the node "Enemy" move to the right by -- # 100 pixels in 0.5 seconds. -- var animation = Animation.new() -- var track_index = animation.add_track(Animation.TYPE_VALUE) -- animation.track_set_path(track_index, "Enemy:position:x") -- animation.track_insert_key(track_index, 0.0, 0) -- animation.track_insert_key(track_index, 0.5, 100) -- -- @ -- -- Animations are just data containers, and must be added to nodes such as an @AnimationPlayer@ or @AnimationTreePlayer@ to be played back. Animation tracks have different types, each with its own set of dedicated methods. Check @enum TrackType@ to see available types. newtype Animation = Animation Object deriving newtype AsVariant instance HasBaseClass Animation where type BaseClass Animation = Resource super = coerce -- | Base resource for @AnimationTree@ nodes. -- In general, it's not used directly, but you can create custom ones with custom blending formulas. -- Inherit this when creating nodes mainly for use in @AnimationNodeBlendTree@, otherwise @AnimationRootNode@ should be used instead. newtype AnimationNode = AnimationNode Object deriving newtype AsVariant instance HasBaseClass AnimationNode where type BaseClass AnimationNode = Resource super = coerce -- | Blends two animations additively inside of an @AnimationNodeBlendTree@. -- A resource to add to an @AnimationNodeBlendTree@. Blends two animations additively based on an amount value in the @@0.0, 1.0@@ range. newtype AnimationNodeAdd2 = AnimationNodeAdd2 Object deriving newtype AsVariant instance HasBaseClass AnimationNodeAdd2 where type BaseClass AnimationNodeAdd2 = AnimationNode super = coerce -- | Blends two of three animations additively inside of an @AnimationNodeBlendTree@. -- A resource to add to an @AnimationNodeBlendTree@. Blends two animations together additively out of three based on a value in the @@-1.0, 1.0@@ range. -- This node has three inputs: -- - The base animation to add to -- - A -add animation to blend with when the blend amount is in the @@-1.0, 0.0@@ range. -- - A +add animation to blend with when the blend amount is in the @@0.0, 1.0@@ range newtype AnimationNodeAdd3 = AnimationNodeAdd3 Object deriving newtype AsVariant instance HasBaseClass AnimationNodeAdd3 where type BaseClass AnimationNodeAdd3 = AnimationNode super = coerce -- | Input animation to use in an @AnimationNodeBlendTree@. -- A resource to add to an @AnimationNodeBlendTree@. Only features one output set using the @animation@ property. Use it as an input for @AnimationNode@ that blend animations together. newtype AnimationNodeAnimation = AnimationNodeAnimation Object deriving newtype AsVariant instance HasBaseClass AnimationNodeAnimation where type BaseClass AnimationNodeAnimation = AnimationRootNode super = coerce -- | Blends two animations linearly inside of an @AnimationNodeBlendTree@. -- A resource to add to an @AnimationNodeBlendTree@. Blends two animations linearly based on an amount value in the @@0.0, 1.0@@ range. newtype AnimationNodeBlend2 = AnimationNodeBlend2 Object deriving newtype AsVariant instance HasBaseClass AnimationNodeBlend2 where type BaseClass AnimationNodeBlend2 = AnimationNode super = coerce -- | Blends two of three animations linearly inside of an @AnimationNodeBlendTree@. -- A resource to add to an @AnimationNodeBlendTree@. Blends two animations together linearly out of three based on a value in the @@-1.0, 1.0@@ range. -- This node has three inputs: -- - The base animation -- - A -blend animation to blend with when the blend amount is in the @@-1.0, 0.0@@ range. -- - A +blend animation to blend with when the blend amount is in the @@0.0, 1.0@@ range newtype AnimationNodeBlend3 = AnimationNodeBlend3 Object deriving newtype AsVariant instance HasBaseClass AnimationNodeBlend3 where type BaseClass AnimationNodeBlend3 = AnimationNode super = coerce -- | Blends linearly between two of any number of @AnimationNode@ of any type placed on a virtual axis. -- A resource to add to an @AnimationNodeBlendTree@. -- This is a virtual axis on which you can add any type of @AnimationNode@ using @method add_blend_point@. -- Outputs the linear blend of the two @AnimationNode@s closest to the node's current value. -- You can set the extents of the axis using the @min_space@ and @max_space@. newtype AnimationNodeBlendSpace1D = AnimationNodeBlendSpace1D Object deriving newtype AsVariant instance HasBaseClass AnimationNodeBlendSpace1D where type BaseClass AnimationNodeBlendSpace1D = AnimationRootNode super = coerce -- | Blends linearly between three @AnimationNode@ of any type placed in a 2D space. -- A resource to add to an @AnimationNodeBlendTree@. -- This node allows you to blend linearly between three animations using a @Vector2@ weight. -- You can add vertices to the blend space with @method add_blend_point@ and automatically triangulate it by setting @auto_triangles@ to @true@. Otherwise, use @method add_triangle@ and @method remove_triangle@ to create up the blend space by hand. newtype AnimationNodeBlendSpace2D = AnimationNodeBlendSpace2D Object deriving newtype AsVariant instance HasBaseClass AnimationNodeBlendSpace2D where type BaseClass AnimationNodeBlendSpace2D = AnimationRootNode super = coerce -- | @AnimationTree@ node resource that contains many blend type nodes. -- This node may contain a sub-tree of any other blend type nodes, such as mix, blend2, blend3, one shot, etc. This is one of the most commonly used roots. newtype AnimationNodeBlendTree = AnimationNodeBlendTree Object deriving newtype AsVariant instance HasBaseClass AnimationNodeBlendTree where type BaseClass AnimationNodeBlendTree = AnimationRootNode super = coerce -- | Plays an animation once in @AnimationNodeBlendTree@. -- A resource to add to an @AnimationNodeBlendTree@. This node will execute a sub-animation and return once it finishes. Blend times for fading in and out can be customized, as well as filters. newtype AnimationNodeOneShot = AnimationNodeOneShot Object deriving newtype AsVariant instance HasBaseClass AnimationNodeOneShot where type BaseClass AnimationNodeOneShot = AnimationNode super = coerce -- | Generic output node to be added to @AnimationNodeBlendTree@. newtype AnimationNodeOutput = AnimationNodeOutput Object deriving newtype AsVariant instance HasBaseClass AnimationNodeOutput where type BaseClass AnimationNodeOutput = AnimationNode super = coerce -- | State machine for control of animations. -- Contains multiple nodes representing animation states, connected in a graph. Node transitions can be configured to happen automatically or via code, using a shortest-path algorithm. Retrieve the @AnimationNodeStateMachinePlayback@ object from the @AnimationTree@ node to control it programmatically. -- __Example:__ -- -- @ -- -- var state_machine = $AnimationTree.get("parameters/playback") -- state_machine.travel("some_state") -- -- @ newtype AnimationNodeStateMachine = AnimationNodeStateMachine Object deriving newtype AsVariant instance HasBaseClass AnimationNodeStateMachine where type BaseClass AnimationNodeStateMachine = AnimationRootNode super = coerce -- | Playback control for @AnimationNodeStateMachine@. -- Allows control of @AnimationTree@ state machines created with @AnimationNodeStateMachine@. Retrieve with @$AnimationTree.get("parameters/playback")@. -- __Example:__ -- -- @ -- -- var state_machine = $AnimationTree.get("parameters/playback") -- state_machine.travel("some_state") -- -- @ newtype AnimationNodeStateMachinePlayback = AnimationNodeStateMachinePlayback Object deriving newtype AsVariant instance HasBaseClass AnimationNodeStateMachinePlayback where type BaseClass AnimationNodeStateMachinePlayback = Resource super = coerce newtype AnimationNodeStateMachineTransition = AnimationNodeStateMachineTransition Object deriving newtype AsVariant instance HasBaseClass AnimationNodeStateMachineTransition where type BaseClass AnimationNodeStateMachineTransition = Resource super = coerce -- | A time-scaling animation node to be used with @AnimationTree@. -- Allows scaling the speed of the animation (or reversing it) in any children nodes. Setting it to 0 will pause the animation. newtype AnimationNodeTimeScale = AnimationNodeTimeScale Object deriving newtype AsVariant instance HasBaseClass AnimationNodeTimeScale where type BaseClass AnimationNodeTimeScale = AnimationNode super = coerce -- | A time-seeking animation node to be used with @AnimationTree@. -- This node can be used to cause a seek command to happen to any sub-children of the graph. After setting the time, this value returns to -1. newtype AnimationNodeTimeSeek = AnimationNodeTimeSeek Object deriving newtype AsVariant instance HasBaseClass AnimationNodeTimeSeek where type BaseClass AnimationNodeTimeSeek = AnimationNode super = coerce -- | A generic animation transition node for @AnimationTree@. -- Simple state machine for cases which don't require a more advanced @AnimationNodeStateMachine@. Animations can be connected to the inputs and transition times can be specified. newtype AnimationNodeTransition = AnimationNodeTransition Object deriving newtype AsVariant instance HasBaseClass AnimationNodeTransition where type BaseClass AnimationNodeTransition = AnimationNode super = coerce -- | Container and player of @Animation@ resources. -- An animation player is used for general-purpose playback of @Animation@ resources. It contains a dictionary of animations (referenced by name) and custom blend times between their transitions. Additionally, animations can be played and blended in different channels. -- @AnimationPlayer@ is more suited than @Tween@ for animations where you know the final values in advance. For example, fading a screen in and out is more easily done with an @AnimationPlayer@ node thanks to the animation tools provided by the editor. That particular example can also be implemented with a @Tween@ node, but it requires doing everything by code. -- Updating the target properties of animations occurs at process time. newtype AnimationPlayer = AnimationPlayer Object deriving newtype AsVariant instance HasBaseClass AnimationPlayer where type BaseClass AnimationPlayer = Node super = coerce newtype AnimationRootNode = AnimationRootNode Object deriving newtype AsVariant instance HasBaseClass AnimationRootNode where type BaseClass AnimationRootNode = AnimationNode super = coerce newtype AnimationTrackEditPlugin = AnimationTrackEditPlugin Object deriving newtype AsVariant instance HasBaseClass AnimationTrackEditPlugin where type BaseClass AnimationTrackEditPlugin = Reference super = coerce -- | A node to be used for advanced animation transitions in an @AnimationPlayer@. -- Note: When linked with an @AnimationPlayer@, several properties and methods of the corresponding @AnimationPlayer@ will not function as expected. Playback and transitions should be handled using only the @AnimationTree@ and its constituent @AnimationNode@(s). The @AnimationPlayer@ node should be used solely for adding, deleting, and editing animations. newtype AnimationTree = AnimationTree Object deriving newtype AsVariant instance HasBaseClass AnimationTree where type BaseClass AnimationTree = Node super = coerce -- | @i@Deprecated.@/i@ Animation player that uses a node graph for blending animations. Superseded by @AnimationTree@. -- @i@Deprecated.@/i@ A node graph tool for blending multiple animations bound to an @AnimationPlayer@. Especially useful for animating characters or other skeleton-based rigs. It can combine several animations to form a desired pose. -- It takes @Animation@s from an @AnimationPlayer@ node and mixes them depending on the graph. -- See @AnimationTree@ for a more full-featured replacement of this node. newtype AnimationTreePlayer = AnimationTreePlayer Object deriving newtype AsVariant instance HasBaseClass AnimationTreePlayer where type BaseClass AnimationTreePlayer = Node super = coerce -- | General-purpose area node for detection and 3D physics influence. -- 3D area that detects @CollisionObject@ nodes overlapping, entering, or exiting. Can also alter or override local physics parameters (gravity, damping). newtype Area = Area Object deriving newtype AsVariant instance HasBaseClass Area where type BaseClass Area = CollisionObject super = coerce -- | 2D area for detection and 2D physics influence. -- 2D area that detects @CollisionObject2D@ nodes overlapping, entering, or exiting. Can also alter or override local physics parameters (gravity, damping). newtype Area2D = Area2D Object deriving newtype AsVariant instance HasBaseClass Area2D where type BaseClass Area2D = CollisionObject2D super = coerce -- | @Mesh@ type that provides utility for constructing a surface from arrays. -- The @ArrayMesh@ is used to construct a @Mesh@ by specifying the attributes as arrays. -- The most basic example is the creation of a single triangle: -- -- @ -- -- var vertices = PoolVector3Array() -- vertices.push_back(Vector3(0, 1, 0)) -- vertices.push_back(Vector3(1, 0, 0)) -- vertices.push_back(Vector3(0, 0, 1)) -- # Initialize the ArrayMesh. -- var arr_mesh = ArrayMesh.new() -- var arrays = @@ -- arrays.resize(ArrayMesh.ARRAY_MAX) -- arrays@ArrayMesh.ARRAY_VERTEX@ = vertices -- # Create the Mesh. -- arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays) -- var m = MeshInstance.new() -- m.mesh = arr_mesh -- -- @ -- -- The @MeshInstance@ is ready to be added to the @SceneTree@ to be shown. -- See also @ImmediateGeometry@, @MeshDataTool@ and @SurfaceTool@ for procedural geometry generation. -- __Note:__ Godot uses clockwise @url=https://learnopengl.com/Advanced-OpenGL/Face-culling@winding order@/url@ for front faces of triangle primitive modes. newtype ArrayMesh = ArrayMesh Object deriving newtype AsVariant instance HasBaseClass ArrayMesh where type BaseClass ArrayMesh = Mesh super = coerce -- | Packs multiple small textures in a single, bigger one. Helps to optimize video memory costs and render calls. -- @Texture@ resource aimed at managing big textures files that pack multiple smaller textures. Consists of a @Texture@, a margin that defines the border width, and a region that defines the actual area of the AtlasTexture. newtype AtlasTexture = AtlasTexture Object deriving newtype AsVariant instance HasBaseClass AtlasTexture where type BaseClass AtlasTexture = Texture super = coerce -- | Stores information about the audio buses. -- Stores position, muting, solo, bypass, effects, effect position, volume, and the connections between buses. See @AudioServer@ for usage. newtype AudioBusLayout = AudioBusLayout Object deriving newtype AsVariant instance HasBaseClass AudioBusLayout where type BaseClass AudioBusLayout = Resource super = coerce -- | Audio effect for audio. -- Base resource for audio bus. Applies an audio effect on the bus that the resource is applied on. newtype AudioEffect = AudioEffect Object deriving newtype AsVariant instance HasBaseClass AudioEffect where type BaseClass AudioEffect = Resource super = coerce -- | Adds an amplifying audio effect to an audio bus. -- Increases or decreases the volume of the selected audio bus. -- Increases or decreases the volume being routed through the audio bus. newtype AudioEffectAmplify = AudioEffectAmplify Object deriving newtype AsVariant instance HasBaseClass AudioEffectAmplify where type BaseClass AudioEffectAmplify = AudioEffect super = coerce -- | Adds a band limit filter to the audio bus. -- Limits the frequencies in a range around the @AudioEffectFilter.cutoff_hz@ and allows frequencies outside of this range to pass. newtype AudioEffectBandLimitFilter = AudioEffectBandLimitFilter Object deriving newtype AsVariant instance HasBaseClass AudioEffectBandLimitFilter where type BaseClass AudioEffectBandLimitFilter = AudioEffectFilter super = coerce -- | Adds a band pass filter to the audio bus. -- Attenuates the frequencies inside of a range around the @AudioEffectFilter.cutoff_hz@ and cuts frequencies outside of this band. newtype AudioEffectBandPassFilter = AudioEffectBandPassFilter Object deriving newtype AsVariant instance HasBaseClass AudioEffectBandPassFilter where type BaseClass AudioEffectBandPassFilter = AudioEffectFilter super = coerce -- | Adds a chorus audio effect. -- The effect applies a filter with voices to duplicate the audio source and manipulate it through the filter. newtype AudioEffectChorus = AudioEffectChorus Object deriving newtype AsVariant instance HasBaseClass AudioEffectChorus where type BaseClass AudioEffectChorus = AudioEffect super = coerce -- | Adds a compressor audio effect to an audio bus. -- Reduces sounds that exceed a certain threshold level, smooths out the dynamics and increases the overall volume. -- Dynamic range compressor reduces the level of the sound when the amplitude goes over a certain threshold in Decibels. One of the main uses of a compressor is to increase the dynamic range by clipping as little as possible (when sound goes over 0dB). -- Compressor has many uses in the mix: -- - In the Master bus to compress the whole output (although an @AudioEffectLimiter@ is probably better). -- - In voice channels to ensure they sound as balanced as possible. -- - Sidechained. This can reduce the sound level sidechained with another audio bus for threshold detection. This technique is common in video game mixing to the level of music and SFX while voices are being heard. -- - Accentuates transients by using a wider attack, making effects sound more punchy. newtype AudioEffectCompressor = AudioEffectCompressor Object deriving newtype AsVariant instance HasBaseClass AudioEffectCompressor where type BaseClass AudioEffectCompressor = AudioEffect super = coerce -- | Adds a delay audio effect to an audio bus. Plays input signal back after a period of time. -- Two tap delay and feedback options. -- Plays input signal back after a period of time. The delayed signal may be played back multiple times to create the sound of a repeating, decaying echo. Delay effects range from a subtle echo effect to a pronounced blending of previous sounds with new sounds. newtype AudioEffectDelay = AudioEffectDelay Object deriving newtype AsVariant instance HasBaseClass AudioEffectDelay where type BaseClass AudioEffectDelay = AudioEffect super = coerce -- | Adds a distortion audio effect to an Audio bus. -- Modify the sound to make it distorted. -- Different types are available: clip, tan, lo-fi (bit crushing), overdrive, or waveshape. -- By distorting the waveform the frequency content change, which will often make the sound "crunchy" or "abrasive". For games, it can simulate sound coming from some saturated device or speaker very efficiently. newtype AudioEffectDistortion = AudioEffectDistortion Object deriving newtype AsVariant instance HasBaseClass AudioEffectDistortion where type BaseClass AudioEffectDistortion = AudioEffect super = coerce -- | Base class for audio equalizers. Gives you control over frequencies. -- Use it to create a custom equalizer if @AudioEffectEQ6@, @AudioEffectEQ10@ or @AudioEffectEQ21@ don't fit your needs. -- AudioEffectEQ gives you control over frequencies. Use it to compensate for existing deficiencies in audio. AudioEffectEQs are useful on the Master bus to completely master a mix and give it more character. They are also useful when a game is run on a mobile device, to adjust the mix to that kind of speakers (it can be added but disabled when headphones are plugged). newtype AudioEffectEQ = AudioEffectEQ Object deriving newtype AsVariant instance HasBaseClass AudioEffectEQ where type BaseClass AudioEffectEQ = AudioEffect super = coerce -- | Adds a 10-band equalizer audio effect to an Audio bus. Gives you control over frequencies from 31 Hz to 16000 Hz. -- Each frequency can be modulated between -60/+24 dB. -- Frequency bands: -- Band 1: 31 Hz -- Band 2: 62 Hz -- Band 3: 125 Hz -- Band 4: 250 Hz -- Band 5: 500 Hz -- Band 6: 1000 Hz -- Band 7: 2000 Hz -- Band 8: 4000 Hz -- Band 9: 8000 Hz -- Band 10: 16000 Hz -- See also @AudioEffectEQ@, @AudioEffectEQ6@, @AudioEffectEQ21@. newtype AudioEffectEQ10 = AudioEffectEQ10 Object deriving newtype AsVariant instance HasBaseClass AudioEffectEQ10 where type BaseClass AudioEffectEQ10 = AudioEffectEQ super = coerce -- | Adds a 21-band equalizer audio effect to an Audio bus. Gives you control over frequencies from 22 Hz to 22000 Hz. -- Each frequency can be modulated between -60/+24 dB. -- Frequency bands: -- Band 1: 22 Hz -- Band 2: 32 Hz -- Band 3: 44 Hz -- Band 4: 63 Hz -- Band 5: 90 Hz -- Band 6: 125 Hz -- Band 7: 175 Hz -- Band 8: 250 Hz -- Band 9: 350 Hz -- Band 10: 500 Hz -- Band 11: 700 Hz -- Band 12: 1000 Hz -- Band 13: 1400 Hz -- Band 14: 2000 Hz -- Band 15: 2800 Hz -- Band 16: 4000 Hz -- Band 17: 5600 Hz -- Band 18: 8000 Hz -- Band 19: 11000 Hz -- Band 20: 16000 Hz -- Band 21: 22000 Hz -- See also @AudioEffectEQ@, @AudioEffectEQ6@, @AudioEffectEQ10@. newtype AudioEffectEQ21 = AudioEffectEQ21 Object deriving newtype AsVariant instance HasBaseClass AudioEffectEQ21 where type BaseClass AudioEffectEQ21 = AudioEffectEQ super = coerce -- | Adds a 6-band equalizer audio effect to an Audio bus. Gives you control over frequencies from 32 Hz to 10000 Hz. -- Each frequency can be modulated between -60/+24 dB. -- Frequency bands: -- Band 1: 32 Hz -- Band 2: 100 Hz -- Band 3: 320 Hz -- Band 4: 1000 Hz -- Band 5: 3200 Hz -- Band 6: 10000 Hz -- See also @AudioEffectEQ@, @AudioEffectEQ10@, @AudioEffectEQ21@. newtype AudioEffectEQ6 = AudioEffectEQ6 Object deriving newtype AsVariant instance HasBaseClass AudioEffectEQ6 where type BaseClass AudioEffectEQ6 = AudioEffectEQ super = coerce -- | Adds a filter to the audio bus. -- Allows frequencies other than the @cutoff_hz@ to pass. newtype AudioEffectFilter = AudioEffectFilter Object deriving newtype AsVariant instance HasBaseClass AudioEffectFilter where type BaseClass AudioEffectFilter = AudioEffect super = coerce -- | Adds a high-pass filter to the Audio Bus. -- Cuts frequencies lower than the @AudioEffectFilter.cutoff_hz@ and allows higher frequencies to pass. newtype AudioEffectHighPassFilter = AudioEffectHighPassFilter Object deriving newtype AsVariant instance HasBaseClass AudioEffectHighPassFilter where type BaseClass AudioEffectHighPassFilter = AudioEffectFilter super = coerce newtype AudioEffectHighShelfFilter = AudioEffectHighShelfFilter Object deriving newtype AsVariant instance HasBaseClass AudioEffectHighShelfFilter where type BaseClass AudioEffectHighShelfFilter = AudioEffectFilter super = coerce newtype AudioEffectInstance = AudioEffectInstance Object deriving newtype AsVariant instance HasBaseClass AudioEffectInstance where type BaseClass AudioEffectInstance = Reference super = coerce -- | Adds a soft-clip limiter audio effect to an Audio bus. -- A limiter is similar to a compressor, but it's less flexible and designed to disallow sound going over a given dB threshold. Adding one in the Master bus is always recommended to reduce the effects of clipping. -- Soft clipping starts to reduce the peaks a little below the threshold level and progressively increases its effect as the input level increases such that the threshold is never exceeded. newtype AudioEffectLimiter = AudioEffectLimiter Object deriving newtype AsVariant instance HasBaseClass AudioEffectLimiter where type BaseClass AudioEffectLimiter = AudioEffect super = coerce -- | Adds a low-pass filter to the Audio bus. -- Cuts frequencies higher than the @AudioEffectFilter.cutoff_hz@ and allows lower frequencies to pass. newtype AudioEffectLowPassFilter = AudioEffectLowPassFilter Object deriving newtype AsVariant instance HasBaseClass AudioEffectLowPassFilter where type BaseClass AudioEffectLowPassFilter = AudioEffectFilter super = coerce newtype AudioEffectLowShelfFilter = AudioEffectLowShelfFilter Object deriving newtype AsVariant instance HasBaseClass AudioEffectLowShelfFilter where type BaseClass AudioEffectLowShelfFilter = AudioEffectFilter super = coerce -- | Adds a notch filter to the Audio bus. -- Attenuates frequencies in a narrow band around the @AudioEffectFilter.cutoff_hz@ and cuts frequencies outside of this range. newtype AudioEffectNotchFilter = AudioEffectNotchFilter Object deriving newtype AsVariant instance HasBaseClass AudioEffectNotchFilter where type BaseClass AudioEffectNotchFilter = AudioEffectFilter super = coerce -- | Adds a panner audio effect to an Audio bus. Pans sound left or right. -- Determines how much of an audio signal is sent to the left and right buses. newtype AudioEffectPanner = AudioEffectPanner Object deriving newtype AsVariant instance HasBaseClass AudioEffectPanner where type BaseClass AudioEffectPanner = AudioEffect super = coerce -- | Adds a phaser audio effect to an Audio bus. -- Combines the original signal with a copy that is slightly out of phase with the original. -- Combines phase-shifted signals with the original signal. The movement of the phase-shifted signals is controlled using a low-frequency oscillator. newtype AudioEffectPhaser = AudioEffectPhaser Object deriving newtype AsVariant instance HasBaseClass AudioEffectPhaser where type BaseClass AudioEffectPhaser = AudioEffect super = coerce -- | Adds a pitch-shifting audio effect to an Audio bus. -- Raises or lowers the pitch of original sound. -- Allows modulation of pitch independently of tempo. All frequencies can be increased/decreased with minimal effect on transients. newtype AudioEffectPitchShift = AudioEffectPitchShift Object deriving newtype AsVariant instance HasBaseClass AudioEffectPitchShift where type BaseClass AudioEffectPitchShift = AudioEffect super = coerce -- | Audio effect used for recording sound from a microphone. -- Allows the user to record sound from a microphone. It sets and gets the format in which the audio file will be recorded (8-bit, 16-bit, or compressed). It checks whether or not the recording is active, and if it is, records the sound. It then returns the recorded sample. newtype AudioEffectRecord = AudioEffectRecord Object deriving newtype AsVariant instance HasBaseClass AudioEffectRecord where type BaseClass AudioEffectRecord = AudioEffect super = coerce -- | Adds a reverberation audio effect to an Audio bus. -- Simulates the sound of acoustic environments such as rooms, concert halls, caverns, or an open spaces. -- Simulates rooms of different sizes. Its parameters can be adjusted to simulate the sound of a specific room. newtype AudioEffectReverb = AudioEffectReverb Object deriving newtype AsVariant instance HasBaseClass AudioEffectReverb where type BaseClass AudioEffectReverb = AudioEffect super = coerce newtype AudioEffectSpectrumAnalyzer = AudioEffectSpectrumAnalyzer Object deriving newtype AsVariant instance HasBaseClass AudioEffectSpectrumAnalyzer where type BaseClass AudioEffectSpectrumAnalyzer = AudioEffect super = coerce newtype AudioEffectSpectrumAnalyzerInstance = AudioEffectSpectrumAnalyzerInstance Object deriving newtype AsVariant instance HasBaseClass AudioEffectSpectrumAnalyzerInstance where type BaseClass AudioEffectSpectrumAnalyzerInstance = AudioEffectInstance super = coerce newtype AudioEffectStereoEnhance = AudioEffectStereoEnhance Object deriving newtype AsVariant instance HasBaseClass AudioEffectStereoEnhance where type BaseClass AudioEffectStereoEnhance = AudioEffect super = coerce -- | Server interface for low-level audio access. -- @AudioServer@ is a low-level server interface for audio access. It is in charge of creating sample data (playable audio) as well as its playback via a voice interface. newtype AudioServer = AudioServer Object deriving newtype AsVariant instance HasBaseClass AudioServer where type BaseClass AudioServer = Object super = coerce -- | Base class for audio streams. -- Audio streams are used for sound effects and music playback, and support WAV (via @AudioStreamSample@) and OGG (via @AudioStreamOGGVorbis@) file formats. newtype AudioStream = AudioStream Object deriving newtype AsVariant instance HasBaseClass AudioStream where type BaseClass AudioStream = Resource super = coerce newtype AudioStreamGenerator = AudioStreamGenerator Object deriving newtype AsVariant instance HasBaseClass AudioStreamGenerator where type BaseClass AudioStreamGenerator = AudioStream super = coerce newtype AudioStreamGeneratorPlayback = AudioStreamGeneratorPlayback Object deriving newtype AsVariant instance HasBaseClass AudioStreamGeneratorPlayback where type BaseClass AudioStreamGeneratorPlayback = AudioStreamPlaybackResampled super = coerce newtype AudioStreamMicrophone = AudioStreamMicrophone Object deriving newtype AsVariant instance HasBaseClass AudioStreamMicrophone where type BaseClass AudioStreamMicrophone = AudioStream super = coerce newtype AudioStreamOGGVorbis = AudioStreamOGGVorbis Object deriving newtype AsVariant instance HasBaseClass AudioStreamOGGVorbis where type BaseClass AudioStreamOGGVorbis = AudioStream super = coerce -- | Meta class for playing back audio. -- Can play, loop, pause a scroll through audio. See @AudioStream@ and @AudioStreamOGGVorbis@ for usage. newtype AudioStreamPlayback = AudioStreamPlayback Object deriving newtype AsVariant instance HasBaseClass AudioStreamPlayback where type BaseClass AudioStreamPlayback = Reference super = coerce newtype AudioStreamPlaybackResampled = AudioStreamPlaybackResampled Object deriving newtype AsVariant instance HasBaseClass AudioStreamPlaybackResampled where type BaseClass AudioStreamPlaybackResampled = AudioStreamPlayback super = coerce -- | Plays back audio non-positionally. -- Plays an audio stream non-positionally. newtype AudioStreamPlayer = AudioStreamPlayer Object deriving newtype AsVariant instance HasBaseClass AudioStreamPlayer where type BaseClass AudioStreamPlayer = Node super = coerce -- | Plays audio in 2D. -- Plays audio that dampens with distance from screen center. newtype AudioStreamPlayer2D = AudioStreamPlayer2D Object deriving newtype AsVariant instance HasBaseClass AudioStreamPlayer2D where type BaseClass AudioStreamPlayer2D = Node2D super = coerce -- | Plays 3D sound in 3D space. -- Plays a sound effect with directed sound effects, dampens with distance if needed, generates effect of hearable position in space. -- By default, audio is heard from the camera position. This can be changed by adding a @Listener@ node to the scene and enabling it by calling @method Listener.make_current@ on it. newtype AudioStreamPlayer3D = AudioStreamPlayer3D Object deriving newtype AsVariant instance HasBaseClass AudioStreamPlayer3D where type BaseClass AudioStreamPlayer3D = Spatial super = coerce -- | Plays audio with random pitch shifting. -- Randomly varies pitch on each start. newtype AudioStreamRandomPitch = AudioStreamRandomPitch Object deriving newtype AsVariant instance HasBaseClass AudioStreamRandomPitch where type BaseClass AudioStreamRandomPitch = AudioStream super = coerce -- | Stores audio data loaded from WAV files. -- AudioStreamSample stores sound samples loaded from WAV files. To play the stored sound, use an @AudioStreamPlayer@ (for non-positional audio) or @AudioStreamPlayer2D@/@AudioStreamPlayer3D@ (for positional audio). The sound can be looped. -- This class can also be used to store dynamically-generated PCM audio data. newtype AudioStreamSample = AudioStreamSample Object deriving newtype AsVariant instance HasBaseClass AudioStreamSample where type BaseClass AudioStreamSample = AudioStream super = coerce -- | Copies a region of the screen (or the whole screen) to a buffer so it can be accessed in your shader scripts through the @texture(SCREEN_TEXTURE, ...)@ function. -- Node for back-buffering the currently-displayed screen. The region defined in the BackBufferCopy node is bufferized with the content of the screen it covers, or the entire screen according to the copy mode set. Use the @texture(SCREEN_TEXTURE, ...)@ function in your shader scripts to access the buffer. -- __Note:__ Since this node inherits from @Node2D@ (and not @Control@), anchors and margins won't apply to child @Control@-derived nodes. This can be problematic when resizing the window. To avoid this, add @Control@-derived nodes as @i@siblings@/i@ to the BackBufferCopy node instead of adding them as children. newtype BackBufferCopy = BackBufferCopy Object deriving newtype AsVariant instance HasBaseClass BackBufferCopy where type BaseClass BackBufferCopy = Node2D super = coerce -- | Prerendered indirect light map for a scene. -- Baked lightmaps are an alternative workflow for adding indirect (or baked) lighting to a scene. Unlike the @GIProbe@ approach, baked lightmaps work fine on low-end PCs and mobile devices as they consume almost no resources in run-time. -- __Note:__ This node has many known bugs and will be @url=https://godotengine.org/article/godot-40-will-get-new-modernized-lightmapper@rewritten for Godot 4.0@/url@. See @url=https://github.com/godotengine/godot/issues/30929@GitHub issue #30929@/url@. newtype BakedLightmap = BakedLightmap Object deriving newtype AsVariant instance HasBaseClass BakedLightmap where type BaseClass BakedLightmap = VisualInstance super = coerce newtype BakedLightmapData = BakedLightmapData Object deriving newtype AsVariant instance HasBaseClass BakedLightmapData where type BaseClass BakedLightmapData = Resource super = coerce -- | Base class for different kinds of buttons. -- BaseButton is the abstract base class for buttons, so it shouldn't be used directly (it doesn't display anything). Other types of buttons inherit from it. newtype BaseButton = BaseButton Object deriving newtype AsVariant instance HasBaseClass BaseButton where type BaseClass BaseButton = Control super = coerce -- | Boolean matrix. -- A two-dimensional array of boolean values, can be used to efficiently store a binary matrix (every matrix element takes only one bit) and query the values using natural cartesian coordinates. newtype BitMap = BitMap Object deriving newtype AsVariant instance HasBaseClass BitMap where type BaseClass BitMap = Resource super = coerce -- | Renders text using fonts under the @url=https://www.angelcode.com/products/bmfont/@BMFont@/url@ format. -- Handles files with the @.fnt@ extension. -- Renders text using @*.fnt@ fonts containing texture atlases. Supports distance fields. For using vector font files like TTF directly, see @DynamicFont@. newtype BitmapFont = BitmapFont Object deriving newtype AsVariant instance HasBaseClass BitmapFont where type BaseClass BitmapFont = Font super = coerce -- | Joint used with @Skeleton2D@ to control and animate other nodes. -- Use a hierarchy of @Bone2D@ bound to a @Skeleton2D@ to control, and animate other @Node2D@ nodes. -- You can use @Bone2D@ and @Skeleton2D@ nodes to animate 2D meshes created with the Polygon 2D UV editor. -- Each bone has a @rest@ transform that you can reset to with @method apply_rest@. These rest poses are relative to the bone's parent. -- If in the editor, you can set the rest pose of an entire skeleton using a menu option, from the code, you need to iterate over the bones to set their individual rest poses. newtype Bone2D = Bone2D Object deriving newtype AsVariant instance HasBaseClass Bone2D where type BaseClass Bone2D = Node2D super = coerce -- | A node that will attach to a bone. -- This node must be the child of a @Skeleton@ node. You can then select a bone for this node to attach to. The BoneAttachment node will copy the transform of the selected bone. newtype BoneAttachment = BoneAttachment Object deriving newtype AsVariant instance HasBaseClass BoneAttachment where type BaseClass BoneAttachment = Spatial super = coerce -- | Base class for box containers. -- Arranges child controls vertically or horizontally, and rearranges the controls automatically when their minimum size changes. newtype BoxContainer = BoxContainer Object deriving newtype AsVariant instance HasBaseClass BoxContainer where type BaseClass BoxContainer = Container super = coerce -- | Box shape resource. -- 3D box shape that can be a child of a @PhysicsBody@ or @Area@. newtype BoxShape = BoxShape Object deriving newtype AsVariant instance HasBaseClass BoxShape where type BaseClass BoxShape = Shape super = coerce newtype BulletPhysicsDirectBodyState = BulletPhysicsDirectBodyState Object deriving newtype AsVariant instance HasBaseClass BulletPhysicsDirectBodyState where type BaseClass BulletPhysicsDirectBodyState = PhysicsDirectBodyState super = coerce newtype BulletPhysicsServer = BulletPhysicsServer Object deriving newtype AsVariant instance HasBaseClass BulletPhysicsServer where type BaseClass BulletPhysicsServer = PhysicsServer super = coerce -- | Standard themed Button. -- Button is the standard themed button. It can contain text and an icon, and will display them according to the current @Theme@. -- __Example of creating a button and assigning an action when pressed by code:__ -- -- @ -- -- func _ready(): -- var button = Button.new() -- button.text = "Click me" -- button.connect("pressed", self, "_button_pressed") -- add_child(button) -- -- func _button_pressed(): -- print("Hello world!") -- -- @ -- -- Buttons (like all Control nodes) can also be created in the editor, but some situations may require creating them from code. newtype Button = Button Object deriving newtype AsVariant instance HasBaseClass Button where type BaseClass Button = BaseButton super = coerce -- | Group of Buttons. -- Group of @Button@. All direct and indirect children buttons become radios. Only one allows being pressed. -- @BaseButton.toggle_mode@ should be @true@. newtype ButtonGroup = ButtonGroup Object deriving newtype AsVariant instance HasBaseClass ButtonGroup where type BaseClass ButtonGroup = Resource super = coerce -- | CPU-based 3D particle emitter. -- CPU-based 3D particle node used to create a variety of particle systems and effects. -- See also @Particles@, which provides the same functionality with hardware acceleration, but may not run on older devices. newtype CPUParticles = CPUParticles Object deriving newtype AsVariant instance HasBaseClass CPUParticles where type BaseClass CPUParticles = GeometryInstance super = coerce -- | CPU-based 2D particle emitter. -- CPU-based 2D particle node used to create a variety of particle systems and effects. -- See also @Particles2D@, which provides the same functionality with hardware acceleration, but may not run on older devices. newtype CPUParticles2D = CPUParticles2D Object deriving newtype AsVariant instance HasBaseClass CPUParticles2D where type BaseClass CPUParticles2D = Node2D super = coerce newtype CSGBox = CSGBox Object deriving newtype AsVariant instance HasBaseClass CSGBox where type BaseClass CSGBox = CSGPrimitive super = coerce newtype CSGCombiner = CSGCombiner Object deriving newtype AsVariant instance HasBaseClass CSGCombiner where type BaseClass CSGCombiner = CSGShape super = coerce newtype CSGCylinder = CSGCylinder Object deriving newtype AsVariant instance HasBaseClass CSGCylinder where type BaseClass CSGCylinder = CSGPrimitive super = coerce newtype CSGMesh = CSGMesh Object deriving newtype AsVariant instance HasBaseClass CSGMesh where type BaseClass CSGMesh = CSGPrimitive super = coerce newtype CSGPolygon = CSGPolygon Object deriving newtype AsVariant instance HasBaseClass CSGPolygon where type BaseClass CSGPolygon = CSGPrimitive super = coerce newtype CSGPrimitive = CSGPrimitive Object deriving newtype AsVariant instance HasBaseClass CSGPrimitive where type BaseClass CSGPrimitive = CSGShape super = coerce newtype CSGShape = CSGShape Object deriving newtype AsVariant instance HasBaseClass CSGShape where type BaseClass CSGShape = GeometryInstance super = coerce newtype CSGSphere = CSGSphere Object deriving newtype AsVariant instance HasBaseClass CSGSphere where type BaseClass CSGSphere = CSGPrimitive super = coerce newtype CSGTorus = CSGTorus Object deriving newtype AsVariant instance HasBaseClass CSGTorus where type BaseClass CSGTorus = CSGPrimitive super = coerce -- | Camera node, displays from a point of view. -- Camera is a special node that displays what is visible from its current location. Cameras register themselves in the nearest @Viewport@ node (when ascending the tree). Only one camera can be active per viewport. If no viewport is available ascending the tree, the camera will register in the global viewport. In other words, a camera just provides 3D display capabilities to a @Viewport@, and, without one, a scene registered in that @Viewport@ (or higher viewports) can't be displayed. newtype Camera = Camera Object deriving newtype AsVariant instance HasBaseClass Camera where type BaseClass Camera = Spatial super = coerce -- | Camera node for 2D scenes. -- It forces the screen (current layer) to scroll following this node. This makes it easier (and faster) to program scrollable scenes than manually changing the position of @CanvasItem@-based nodes. -- This node is intended to be a simple helper to get things going quickly and it may happen that more functionality is desired to change how the camera works. To make your own custom camera node, inherit from @Node2D@ and change the transform of the canvas by setting @Viewport.canvas_transform@ in @Viewport@ (you can obtain the current @Viewport@ by using @method Node.get_viewport@). -- Note that the @Camera2D@ node's @position@ doesn't represent the actual position of the screen, which may differ due to applied smoothing or limits. You can use @method get_camera_screen_center@ to get the real position. newtype Camera2D = Camera2D Object deriving newtype AsVariant instance HasBaseClass Camera2D where type BaseClass Camera2D = Node2D super = coerce -- | A camera feed gives you access to a single physical camera attached to your device. -- When enabled, Godot will start capturing frames from the camera which can then be used. -- __Note:__ Many cameras will return YCbCr images which are split into two textures and need to be combined in a shader. Godot does this automatically for you if you set the environment to show the camera image in the background. newtype CameraFeed = CameraFeed Object deriving newtype AsVariant instance HasBaseClass CameraFeed where type BaseClass CameraFeed = Reference super = coerce -- | Server keeping track of different cameras accessible in Godot. -- The @CameraServer@ keeps track of different cameras accessible in Godot. These are external cameras such as webcams or the cameras on your phone. -- It is notably used to provide AR modules with a video feed from the camera. newtype CameraServer = CameraServer Object deriving newtype AsVariant instance HasBaseClass CameraServer where type BaseClass CameraServer = Object super = coerce -- | Texture provided by a @CameraFeed@. -- This texture gives access to the camera texture provided by a @CameraFeed@. -- __Note:__ Many cameras supply YCbCr images which need to be converted in a shader. newtype CameraTexture = CameraTexture Object deriving newtype AsVariant instance HasBaseClass CameraTexture where type BaseClass CameraTexture = Texture super = coerce -- | Base class of anything 2D. -- Canvas items are laid out in a tree; children inherit and extend their parent's transform. @CanvasItem@ is extended by @Control@ for anything GUI-related, and by @Node2D@ for anything related to the 2D engine. -- Any @CanvasItem@ can draw. For this, @method update@ must be called, then @NOTIFICATION_DRAW@ will be received on idle time to request redraw. Because of this, canvas items don't need to be redrawn on every frame, improving the performance significantly. Several functions for drawing on the @CanvasItem@ are provided (see @draw_*@ functions). However, they can only be used inside the @method Object._notification@, signal or @method _draw@ virtual functions. -- Canvas items are drawn in tree order. By default, children are on top of their parents so a root @CanvasItem@ will be drawn behind everything. This behavior can be changed on a per-item basis. -- A @CanvasItem@ can also be hidden, which will also hide its children. It provides many ways to change parameters such as modulation (for itself and its children) and self modulation (only for itself), as well as its blend mode. -- Ultimately, a transform notification can be requested, which will notify the node that its global position changed in case the parent tree changed. -- __Note:__ Unless otherwise specified, all methods that have angle parameters must have angles specified as @i@radians@/i@. To convert degrees to radians, use @method @GDScript.deg2rad@. newtype CanvasItem = CanvasItem Object deriving newtype AsVariant instance HasBaseClass CanvasItem where type BaseClass CanvasItem = Node super = coerce -- | A material for @CanvasItem@s. -- @CanvasItemMaterial@s provide a means of modifying the textures associated with a CanvasItem. They specialize in describing blend and lighting behaviors for textures. Use a @ShaderMaterial@ to more fully customize a material's interactions with a @CanvasItem@. newtype CanvasItemMaterial = CanvasItemMaterial Object deriving newtype AsVariant instance HasBaseClass CanvasItemMaterial where type BaseClass CanvasItemMaterial = Material super = coerce -- | Canvas drawing layer. -- @CanvasItem@ nodes that are direct or indirect children of a @CanvasLayer@ will be drawn in that layer. The layer is a numeric index that defines the draw order. The default 2D scene renders with index 0, so a @CanvasLayer@ with index -1 will be drawn below, and one with index 1 will be drawn above. This is very useful for HUDs (in layer 1+ or above), or backgrounds (in layer -1 or below). newtype CanvasLayer = CanvasLayer Object deriving newtype AsVariant instance HasBaseClass CanvasLayer where type BaseClass CanvasLayer = Node super = coerce -- | Tint the entire canvas. -- @CanvasModulate@ tints the canvas elements using its assigned @color@. newtype CanvasModulate = CanvasModulate Object deriving newtype AsVariant instance HasBaseClass CanvasModulate where type BaseClass CanvasModulate = Node2D super = coerce -- | Class representing a capsule-shaped @PrimitiveMesh@. newtype CapsuleMesh = CapsuleMesh Object deriving newtype AsVariant instance HasBaseClass CapsuleMesh where type BaseClass CapsuleMesh = PrimitiveMesh super = coerce -- | Capsule shape for collisions. newtype CapsuleShape = CapsuleShape Object deriving newtype AsVariant instance HasBaseClass CapsuleShape where type BaseClass CapsuleShape = Shape super = coerce -- | Capsule shape for 2D collisions. newtype CapsuleShape2D = CapsuleShape2D Object deriving newtype AsVariant instance HasBaseClass CapsuleShape2D where type BaseClass CapsuleShape2D = Shape2D super = coerce -- | Keeps children controls centered. -- CenterContainer keeps children controls centered. This container keeps all children to their minimum size, in the center. newtype CenterContainer = CenterContainer Object deriving newtype AsVariant instance HasBaseClass CenterContainer where type BaseClass CenterContainer = Container super = coerce -- | Controls how an individual character will be displayed in a @RichTextEffect@. -- By setting various properties on this object, you can control how individual characters will be displayed in a @RichTextEffect@. newtype CharFXTransform = CharFXTransform Object deriving newtype AsVariant instance HasBaseClass CharFXTransform where type BaseClass CharFXTransform = Reference super = coerce -- | Binary choice user interface widget. See also @CheckButton@. -- A checkbox allows the user to make a binary choice (choosing only one of two possible options). It's similar to @CheckButton@ in functionality, but it has a different apperance. To follow established UX patterns, it's recommended to use CheckBox when toggling it has __no__ immediate effect on something. For instance, it should be used when toggling it will only do something once a confirmation button is pressed. newtype CheckBox = CheckBox Object deriving newtype AsVariant instance HasBaseClass CheckBox where type BaseClass CheckBox = Button super = coerce -- | Checkable button. See also @CheckBox@. -- CheckButton is a toggle button displayed as a check field. It's similar to @CheckBox@ in functionality, but it has a different apperance. To follow established UX patterns, it's recommended to use CheckButton when toggling it has an __immediate__ effect on something. For instance, it should be used if toggling it enables/disables a setting without requiring the user to press a confirmation button. newtype CheckButton = CheckButton Object deriving newtype AsVariant instance HasBaseClass CheckButton where type BaseClass CheckButton = Button super = coerce -- | Circular shape for 2D collisions. -- This shape is useful for modeling balls or small characters and its collision detection with everything else is very fast. newtype CircleShape2D = CircleShape2D Object deriving newtype AsVariant instance HasBaseClass CircleShape2D where type BaseClass CircleShape2D = Shape2D super = coerce -- | A @Camera@ that includes collision. -- This node extends @Camera@ to add collisions with @Area@ and/or @PhysicsBody@ nodes. The camera cannot move through colliding objects. newtype ClippedCamera = ClippedCamera Object deriving newtype AsVariant instance HasBaseClass ClippedCamera where type BaseClass ClippedCamera = Camera super = coerce -- | Base node for collision objects. -- CollisionObject is the base class for physics objects. It can hold any number of collision @Shape@s. Each shape must be assigned to a @i@shape owner@/i@. The CollisionObject can have any number of shape owners. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the @shape_owner_*@ methods. newtype CollisionObject = CollisionObject Object deriving newtype AsVariant instance HasBaseClass CollisionObject where type BaseClass CollisionObject = Spatial super = coerce -- | Base node for 2D collision objects. -- CollisionObject2D is the base class for 2D physics objects. It can hold any number of 2D collision @Shape2D@s. Each shape must be assigned to a @i@shape owner@/i@. The CollisionObject2D can have any number of shape owners. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the @shape_owner_*@ methods. newtype CollisionObject2D = CollisionObject2D Object deriving newtype AsVariant instance HasBaseClass CollisionObject2D where type BaseClass CollisionObject2D = Node2D super = coerce -- | Editor-only class for defining a collision polygon in 3D space. -- Allows editing a collision polygon's vertices on a selected plane. Can also set a depth perpendicular to that plane. This class is only available in the editor. It will not appear in the scene tree at run-time. Creates a @Shape@ for gameplay. Properties modified during gameplay will have no effect. newtype CollisionPolygon = CollisionPolygon Object deriving newtype AsVariant instance HasBaseClass CollisionPolygon where type BaseClass CollisionPolygon = Spatial super = coerce -- | Defines a 2D collision polygon. -- Provides a 2D collision polygon to a @CollisionObject2D@ parent. Polygons can be drawn in the editor or specified by a list of vertices. newtype CollisionPolygon2D = CollisionPolygon2D Object deriving newtype AsVariant instance HasBaseClass CollisionPolygon2D where type BaseClass CollisionPolygon2D = Node2D super = coerce -- | Node that represents collision shape data in 3D space. -- Editor facility for creating and editing collision shapes in 3D space. You can use this node to represent all sorts of collision shapes, for example, add this to an @Area@ to give it a detection shape, or add it to a @PhysicsBody@ to create a solid object. __IMPORTANT__: this is an Editor-only helper to create shapes, use @method CollisionObject.shape_owner_get_shape@ to get the actual shape. newtype CollisionShape = CollisionShape Object deriving newtype AsVariant instance HasBaseClass CollisionShape where type BaseClass CollisionShape = Spatial super = coerce -- | Node that represents collision shape data in 2D space. -- Editor facility for creating and editing collision shapes in 2D space. You can use this node to represent all sorts of collision shapes, for example, add this to an @Area2D@ to give it a detection shape, or add it to a @PhysicsBody2D@ to create a solid object. __IMPORTANT__: this is an Editor-only helper to create shapes, use @method CollisionObject2D.shape_owner_get_shape@ to get the actual shape. newtype CollisionShape2D = CollisionShape2D Object deriving newtype AsVariant instance HasBaseClass CollisionShape2D where type BaseClass CollisionShape2D = Node2D super = coerce -- | Color picker control. -- @Control@ node displaying a color picker widget. It's useful for selecting a color from an RGB/RGBA colorspace. newtype ColorPicker = ColorPicker Object deriving newtype AsVariant instance HasBaseClass ColorPicker where type BaseClass ColorPicker = BoxContainer super = coerce -- | Button that pops out a @ColorPicker@. -- Encapsulates a @ColorPicker@ making it accessible by pressing a button. Pressing the button will toggle the @ColorPicker@ visibility. newtype ColorPickerButton = ColorPickerButton Object deriving newtype AsVariant instance HasBaseClass ColorPickerButton where type BaseClass ColorPickerButton = Button super = coerce -- | Colored rectangle. -- Displays a colored rectangle. newtype ColorRect = ColorRect Object deriving newtype AsVariant instance HasBaseClass ColorRect where type BaseClass ColorRect = Control super = coerce -- | Concave polygon shape. -- Concave polygon shape resource, which can be set into a @PhysicsBody@ or area. This shape is created by feeding a list of triangles. -- Note: when used for collision, @ConcavePolygonShape@ is intended to work with static @PhysicsBody@ nodes like @StaticBody@ and will not work with @KinematicBody@ or @RigidBody@ with a mode other than Static. newtype ConcavePolygonShape = ConcavePolygonShape Object deriving newtype AsVariant instance HasBaseClass ConcavePolygonShape where type BaseClass ConcavePolygonShape = Shape super = coerce -- | Concave polygon 2D shape resource for physics. -- It is made out of segments and is optimal for complex polygonal concave collisions. However, it is not advised to use for @RigidBody2D@ nodes. A CollisionPolygon2D in convex decomposition mode (solids) or several convex objects are advised for that instead. Otherwise, a concave polygon 2D shape is better for static collisions. -- The main difference between a @ConvexPolygonShape2D@ and a @ConcavePolygonShape2D@ is that a concave polygon assumes it is concave and uses a more complex method of collision detection, and a convex one forces itself to be convex in order to speed up collision detection. newtype ConcavePolygonShape2D = ConcavePolygonShape2D Object deriving newtype AsVariant instance HasBaseClass ConcavePolygonShape2D where type BaseClass ConcavePolygonShape2D = Shape2D super = coerce -- | A twist joint between two 3D bodies. -- The joint can rotate the bodies across an axis defined by the local x-axes of the @Joint@. -- The twist axis is initiated as the X axis of the @Joint@. -- Once the Bodies swing, the twist axis is calculated as the middle of the x-axes of the Joint in the local space of the two Bodies. newtype ConeTwistJoint = ConeTwistJoint Object deriving newtype AsVariant instance HasBaseClass ConeTwistJoint where type BaseClass ConeTwistJoint = Joint super = coerce -- | Helper class to handle INI-style files. -- This helper class can be used to store @Variant@ values on the filesystem using INI-style formatting. The stored values are identified by a section and a key: -- -- @ -- -- @section@ -- some_key=42 -- string_example="Hello World!" -- a_vector=Vector3( 1, 0, 2 ) -- -- @ -- -- The stored data can be saved to or parsed from a file, though ConfigFile objects can also be used directly without accessing the filesystem. -- The following example shows how to parse an INI-style file from the system, read its contents and store new values in it: -- -- @ -- -- var config = ConfigFile.new() -- var err = config.load("user://settings.cfg") -- if err == OK: # If not, something went wrong with the file loading -- # Look for the display/width pair, and default to 1024 if missing -- var screen_width = config.get_value("display", "width", 1024) -- # Store a variable if and only if it hasn't been defined yet -- if not config.has_section_key("audio", "mute"): -- config.set_value("audio", "mute", false) -- # Save the changes by overwriting the previous file -- config.save("user://settings.cfg") -- -- @ -- -- Keep in mind that section and property names can't contain spaces. Anything after a space will be ignored on save and on load. -- ConfigFiles can also contain manually written comment lines starting with a semicolon (@;@). Those lines will be ignored when parsing the file. Note that comments will be lost when saving the ConfigFile. This can still be useful for dedicated server configuration files, which are typically never overwritten without explicit user action. newtype ConfigFile = ConfigFile Object deriving newtype AsVariant instance HasBaseClass ConfigFile where type BaseClass ConfigFile = Reference super = coerce -- | Dialog for confirmation of actions. -- This dialog inherits from @AcceptDialog@, but has by default an OK and Cancel button (in host OS order). -- To get cancel action, you can use: -- -- @ -- -- get_cancel().connect("pressed", self, "cancelled") -- -- @ -- . newtype ConfirmationDialog = ConfirmationDialog Object deriving newtype AsVariant instance HasBaseClass ConfirmationDialog where type BaseClass ConfirmationDialog = AcceptDialog super = coerce -- | Base node for containers. -- A @Container@ contains other controls and automatically arranges them in a certain way. -- A Control can inherit this to create custom container classes. newtype Container = Container Object deriving newtype AsVariant instance HasBaseClass Container where type BaseClass Container = Control super = coerce -- | All user interface nodes inherit from Control. A control's anchors and margins adapt its position and size relative to its parent. -- Base class for all UI-related nodes. @Control@ features a bounding rectangle that defines its extents, an anchor position relative to its parent control or the current viewport, and margins that represent an offset to the anchor. The margins update automatically when the node, any of its parents, or the screen size change. -- For more information on Godot's UI system, anchors, margins, and containers, see the related tutorials in the manual. To build flexible UIs, you'll need a mix of UI elements that inherit from @Control@ and @Container@ nodes. -- __User Interface nodes and input__ -- Godot sends input events to the scene's root node first, by calling @method Node._input@. @method Node._input@ forwards the event down the node tree to the nodes under the mouse cursor, or on keyboard focus. To do so, it calls @method MainLoop._input_event@. Call @method accept_event@ so no other node receives the event. Once you accepted an input, it becomes handled so @method Node._unhandled_input@ will not process it. -- Only one @Control@ node can be in keyboard focus. Only the node in focus will receive keyboard events. To get the focus, call @method grab_focus@. @Control@ nodes lose focus when another node grabs it, or if you hide the node in focus. -- Sets @mouse_filter@ to @MOUSE_FILTER_IGNORE@ to tell a @Control@ node to ignore mouse or touch events. You'll need it if you place an icon on top of a button. -- @Theme@ resources change the Control's appearance. If you change the @Theme@ on a @Control@ node, it affects all of its children. To override some of the theme's parameters, call one of the @add_*_override@ methods, like @method add_font_override@. You can override the theme with the inspector. -- __Note:__ Theme items are @i@not@/i@ @Object@ properties. This means you can't access their values using @method Object.get@ and @method Object.set@. Instead, use @method get_color@, @method get_constant@, @method get_font@, @method get_icon@, @method get_stylebox@, and the @add_*_override@ methods provided by this class. newtype Control = Control Object deriving newtype AsVariant instance HasBaseClass Control where type BaseClass Control = CanvasItem super = coerce -- | Convex polygon shape for 3D physics. -- Convex polygon shape resource, which can be added to a @PhysicsBody@ or area. newtype ConvexPolygonShape = ConvexPolygonShape Object deriving newtype AsVariant instance HasBaseClass ConvexPolygonShape where type BaseClass ConvexPolygonShape = Shape super = coerce -- | Convex polygon shape for 2D physics. -- A convex polygon, whatever its shape, is internally decomposed into as many convex polygons as needed to ensure all collision checks against it are always done on convex polygons (which are faster to check). -- The main difference between a @ConvexPolygonShape2D@ and a @ConcavePolygonShape2D@ is that a concave polygon assumes it is concave and uses a more complex method of collision detection, and a convex one forces itself to be convex in order to speed up collision detection. newtype ConvexPolygonShape2D = ConvexPolygonShape2D Object deriving newtype AsVariant instance HasBaseClass ConvexPolygonShape2D where type BaseClass ConvexPolygonShape2D = Shape2D super = coerce -- | Access to advanced cryptographic functionalities. -- The Crypto class allows you to access some more advanced cryptographic functionalities in Godot. -- For now, this includes generating cryptographically secure random bytes, and RSA keys and self-signed X509 certificates generation. More functionalities are planned for future releases. -- -- @ -- -- extends Node -- -- var crypto = Crypto.new() -- var key = CryptoKey.new() -- var cert = X509Certificate.new() -- -- func _ready(): -- # Generate new RSA key. -- key = crypto.generate_rsa(4096) -- # Generate new self-signed certificate with the given key. -- cert = crypto.generate_self_signed_certificate(key, "CN=mydomain.com,O=My Game Company,C=IT") -- # Save key and certificate in the user folder. -- key.save("user://generated.key") -- cert.save("user://generated.crt") -- -- @ -- -- __Note:__ Not available in HTML5 exports. newtype Crypto = Crypto Object deriving newtype AsVariant instance HasBaseClass Crypto where type BaseClass Crypto = Reference super = coerce -- | A cryptographic key (RSA). -- The CryptoKey class represents a cryptographic key. Keys can be loaded and saved like any other @Resource@. -- They can be used to generate a self-signed @X509Certificate@ via @method Crypto.generate_self_signed_certificate@ and as private key in @method StreamPeerSSL.accept_stream@ along with the appropriate certificate. -- __Note:__ Not available in HTML5 exports. newtype CryptoKey = CryptoKey Object deriving newtype AsVariant instance HasBaseClass CryptoKey where type BaseClass CryptoKey = Resource super = coerce -- | A CubeMap is a 6-sided 3D texture. -- A 6-sided 3D texture typically used for faking reflections. It can be used to make an object look as if it's reflecting its surroundings. This usually delivers much better performance than other reflection methods. newtype CubeMap = CubeMap Object deriving newtype AsVariant instance HasBaseClass CubeMap where type BaseClass CubeMap = Resource super = coerce -- | Generate an axis-aligned cuboid @PrimitiveMesh@. -- -- The cube's UV layout is arranged in a 3×2 layout that allows texturing each face individually. To apply the same texture on all faces, change the material's UV property to @Vector3(3, 2, 1)@. newtype CubeMesh = CubeMesh Object deriving newtype AsVariant instance HasBaseClass CubeMesh where type BaseClass CubeMesh = PrimitiveMesh super = coerce -- | A mathematic curve. -- A curve that can be saved and re-used for other objects. By default, it ranges between @0@ and @1@ on the Y axis and positions points relative to the @0.5@ Y position. newtype Curve = Curve Object deriving newtype AsVariant instance HasBaseClass Curve where type BaseClass Curve = Resource super = coerce -- | Describes a Bézier curve in 2D space. -- This class describes a Bézier curve in 2D space. It is mainly used to give a shape to a @Path2D@, but can be manually sampled for other purposes. -- It keeps a cache of precalculated points along the curve, to speed up further calculations. newtype Curve2D = Curve2D Object deriving newtype AsVariant instance HasBaseClass Curve2D where type BaseClass Curve2D = Resource super = coerce -- | Describes a Bézier curve in 3D space. -- This class describes a Bézier curve in 3D space. It is mainly used to give a shape to a @Path@, but can be manually sampled for other purposes. -- It keeps a cache of precalculated points along the curve, to speed up further calculations. newtype Curve3D = Curve3D Object deriving newtype AsVariant instance HasBaseClass Curve3D where type BaseClass Curve3D = Resource super = coerce -- | A texture that shows a curve. -- Renders a given @Curve@ provided to it. Simplifies the task of drawing curves and/or saving them as image files. newtype CurveTexture = CurveTexture Object deriving newtype AsVariant instance HasBaseClass CurveTexture where type BaseClass CurveTexture = Texture super = coerce -- | Class representing a cylindrical @PrimitiveMesh@. -- This class can be used to create cones by setting either the @top_radius@ or @bottom_radius@ properties to 0.0. newtype CylinderMesh = CylinderMesh Object deriving newtype AsVariant instance HasBaseClass CylinderMesh where type BaseClass CylinderMesh = PrimitiveMesh super = coerce -- | Cylinder shape for collisions. newtype CylinderShape = CylinderShape Object deriving newtype AsVariant instance HasBaseClass CylinderShape where type BaseClass CylinderShape = Shape super = coerce -- | Damped spring constraint for 2D physics. -- This resembles a spring joint that always wants to go back to a given length. newtype DampedSpringJoint2D = DampedSpringJoint2D Object deriving newtype AsVariant instance HasBaseClass DampedSpringJoint2D where type BaseClass DampedSpringJoint2D = Joint2D super = coerce -- | Directional light from a distance, as from the Sun. -- A directional light is a type of @Light@ node that models an infinite number of parallel rays covering the entire scene. It is used for lights with strong intensity that are located far away from the scene to model sunlight or moonlight. The worldspace location of the DirectionalLight transform (origin) is ignored. Only the basis is used to determine light direction. newtype DirectionalLight = DirectionalLight Object deriving newtype AsVariant instance HasBaseClass DirectionalLight where type BaseClass DirectionalLight = Light super = coerce -- | DynamicFont renders vector font files at runtime. -- DynamicFont renders vector font files (such as TTF or OTF) dynamically at runtime instead of using a prerendered texture atlas like @BitmapFont@. This trades the faster loading time of @BitmapFont@s for the ability to change font parameters like size and spacing during runtime. @DynamicFontData@ is used for referencing the font file paths. DynamicFont also supports defining one or more fallback fonts, which will be used when displaying a character not supported by the main font. -- DynamicFont uses the @url=https://www.freetype.org/@FreeType@/url@ library for rasterization. -- -- @ -- -- var dynamic_font = DynamicFont.new() -- dynamic_font.font_data = load("res://BarlowCondensed-Bold.ttf") -- dynamic_font.size = 64 -- $"Label".set("custom_fonts/font", dynamic_font) -- -- @ -- -- __Note:__ DynamicFont doesn't support features such as kerning, right-to-left typesetting, ligatures, text shaping, variable fonts and optional font features yet. If you wish to "bake" an optional font feature into a TTF font file, you can use @url=https://fontforge.org/@FontForge@/url@ to do so. In FontForge, use __File > Generate Fonts__, click __Options__, choose the desired features then generate the font. newtype DynamicFont = DynamicFont Object deriving newtype AsVariant instance HasBaseClass DynamicFont where type BaseClass DynamicFont = Font super = coerce -- | Used with @DynamicFont@ to describe the location of a font file. -- Used with @DynamicFont@ to describe the location of a vector font file for dynamic rendering at runtime. newtype DynamicFontData = DynamicFontData Object deriving newtype AsVariant instance HasBaseClass DynamicFontData where type BaseClass DynamicFontData = Resource super = coerce -- | A script that is executed when exporting projects. newtype EditorExportPlugin = EditorExportPlugin Object deriving newtype AsVariant instance HasBaseClass EditorExportPlugin where type BaseClass EditorExportPlugin = Reference super = coerce -- | An editor feature profile which can be used to disable specific features. -- An editor feature profile can be used to disable specific features of the Godot editor. When disabled, the features won't appear in the editor, which makes the editor less cluttered. This is useful in education settings to reduce confusion or when working in a team. For example, artists and level designers could use a feature profile that disables the script editor to avoid accidentally making changes to files they aren't supposed to edit. -- To manage editor feature profiles visually, use __Editor > Manage Feature Profiles...__ at the top of the editor window. newtype EditorFeatureProfile = EditorFeatureProfile Object deriving newtype AsVariant instance HasBaseClass EditorFeatureProfile where type BaseClass EditorFeatureProfile = Reference super = coerce -- | A modified version of @FileDialog@ used by the editor. newtype EditorFileDialog = EditorFileDialog Object deriving newtype AsVariant instance HasBaseClass EditorFileDialog where type BaseClass EditorFileDialog = ConfirmationDialog super = coerce -- | Resource filesystem, as the editor sees it. -- This object holds information of all resources in the filesystem, their types, etc. -- __Note:__ This class shouldn't be instantiated directly. Instead, access the singleton using @method EditorInterface.get_resource_filesystem@. newtype EditorFileSystem = EditorFileSystem Object deriving newtype AsVariant instance HasBaseClass EditorFileSystem where type BaseClass EditorFileSystem = Node super = coerce -- | A directory for the resource filesystem. -- A more generalized, low-level variation of the directory concept. newtype EditorFileSystemDirectory = EditorFileSystemDirectory Object deriving newtype AsVariant instance HasBaseClass EditorFileSystemDirectory where type BaseClass EditorFileSystemDirectory = Object super = coerce -- | Registers a custom resource importer in the editor. Use the class to parse any file and import it as a new resource type. -- EditorImportPlugins provide a way to extend the editor's resource import functionality. Use them to import resources from custom files or to provide alternatives to the editor's existing importers. Register your @EditorPlugin@ with @method EditorPlugin.add_import_plugin@. -- EditorImportPlugins work by associating with specific file extensions and a resource type. See @method get_recognized_extensions@ and @method get_resource_type@. They may optionally specify some import presets that affect the import process. EditorImportPlugins are responsible for creating the resources and saving them in the @.import@ directory. -- Below is an example EditorImportPlugin that imports a @Mesh@ from a file with the extension ".special" or ".spec": -- -- @ -- -- tool -- extends EditorImportPlugin -- -- func get_importer_name(): -- return "my.special.plugin" -- -- func get_visible_name(): -- return "Special Mesh Importer" -- -- func get_recognized_extensions(): -- return @"special", "spec"@ -- -- func get_save_extension(): -- return "mesh" -- -- func get_resource_type(): -- return "Mesh" -- -- func get_preset_count(): -- return 1 -- -- func get_preset_name(i): -- return "Default" -- -- func get_import_options(i): -- return @{"name": "my_option", "default_value": false}@ -- -- func import(source_file, save_path, options, platform_variants, gen_files): -- var file = File.new() -- if file.open(source_file, File.READ) != OK: -- return FAILED -- -- var mesh = Mesh.new() -- # Fill the Mesh with data read in "file", left as an exercise to the reader -- -- var filename = save_path + "." + get_save_extension() -- ResourceSaver.save(filename, mesh) -- return OK -- -- @ newtype EditorImportPlugin = EditorImportPlugin Object deriving newtype AsVariant instance HasBaseClass EditorImportPlugin where type BaseClass EditorImportPlugin = ResourceImporter super = coerce -- | A tab used to edit properties of the selected node. -- The editor inspector is by default located on the right-hand side of the editor. It's used to edit the properties of the selected node. For example, you can select a node such as @Sprite@ then edit its transform through the inspector tool. The editor inspector is an essential tool in the game development workflow. -- __Note:__ This class shouldn't be instantiated directly. Instead, access the singleton using @method EditorInterface.get_inspector@. newtype EditorInspector = EditorInspector Object deriving newtype AsVariant instance HasBaseClass EditorInspector where type BaseClass EditorInspector = ScrollContainer super = coerce -- | Plugin for adding custom property editors on inspector. -- This plugins allows adding custom property editors to @EditorInspector@. -- Plugins are registered via @method EditorPlugin.add_inspector_plugin@. -- When an object is edited, the @method can_handle@ function is called and must return @true@ if the object type is supported. -- If supported, the function @method parse_begin@ will be called, allowing to place custom controls at the beginning of the class. -- Subsequently, the @method parse_category@ and @method parse_property@ are called for every category and property. They offer the ability to add custom controls to the inspector too. -- Finally @method parse_end@ will be called. -- On each of these calls, the "add" functions can be called. newtype EditorInspectorPlugin = EditorInspectorPlugin Object deriving newtype AsVariant instance HasBaseClass EditorInspectorPlugin where type BaseClass EditorInspectorPlugin = Reference super = coerce -- | Godot editor's interface. -- EditorInterface gives you control over Godot editor's window. It allows customizing the window, saving and (re-)loading scenes, rendering mesh previews, inspecting and editing resources and objects, and provides access to @EditorSettings@, @EditorFileSystem@, @EditorResourcePreview@, @ScriptEditor@, the editor viewport, and information about scenes. -- __Note:__ This class shouldn't be instantiated directly. Instead, access the singleton using @method EditorPlugin.get_editor_interface@. newtype EditorInterface = EditorInterface Object deriving newtype AsVariant instance HasBaseClass EditorInterface where type BaseClass EditorInterface = Node super = coerce newtype EditorNavigationMeshGenerator = EditorNavigationMeshGenerator Object deriving newtype AsVariant instance HasBaseClass EditorNavigationMeshGenerator where type BaseClass EditorNavigationMeshGenerator = Object super = coerce -- | Used by the editor to extend its functionality. -- Plugins are used by the editor to extend functionality. The most common types of plugins are those which edit a given node or resource type, import plugins and export plugins. See also @EditorScript@ to add functions to the editor. newtype EditorPlugin = EditorPlugin Object deriving newtype AsVariant instance HasBaseClass EditorPlugin where type BaseClass EditorPlugin = Node super = coerce -- | Custom control to edit properties for adding into the inspector. -- This control allows property editing for one or multiple properties into @EditorInspector@. It is added via @EditorInspectorPlugin@. newtype EditorProperty = EditorProperty Object deriving newtype AsVariant instance HasBaseClass EditorProperty where type BaseClass EditorProperty = Container super = coerce newtype EditorResourceConversionPlugin = EditorResourceConversionPlugin Object deriving newtype AsVariant instance HasBaseClass EditorResourceConversionPlugin where type BaseClass EditorResourceConversionPlugin = Reference super = coerce -- | Helper to generate previews of resources or files. -- This object is used to generate previews for resources of files. -- __Note:__ This class shouldn't be instantiated directly. Instead, access the singleton using @method EditorInterface.get_resource_previewer@. newtype EditorResourcePreview = EditorResourcePreview Object deriving newtype AsVariant instance HasBaseClass EditorResourcePreview where type BaseClass EditorResourcePreview = Node super = coerce -- | Custom generator of previews. -- Custom code to generate previews. Please check @file_dialog/thumbnail_size@ in @EditorSettings@ to find out the right size to do previews at. newtype EditorResourcePreviewGenerator = EditorResourcePreviewGenerator Object deriving newtype AsVariant instance HasBaseClass EditorResourcePreviewGenerator where type BaseClass EditorResourcePreviewGenerator = Reference super = coerce -- | Imports scenes from third-parties' 3D files. newtype EditorSceneImporter = EditorSceneImporter Object deriving newtype AsVariant instance HasBaseClass EditorSceneImporter where type BaseClass EditorSceneImporter = Reference super = coerce -- | FBX 3D asset importer based on @url=http://assimp.org/@Assimp@/url@. -- This is an FBX 3D asset importer based on @url=http://assimp.org/@Assimp@/url@. It currently has many known limitations and works best with static meshes. Most animated meshes won't import correctly. -- If exporting a FBX scene from Autodesk Maya, use these FBX export settings: -- -- @ -- -- - Smoothing Groups -- - Smooth Mesh -- - Triangluate (for meshes with blend shapes) -- - Bake Animation -- - Resample All -- - Deformed Models -- - Skins -- - Blend Shapes -- - Curve Filters -- - Constant Key Reducer -- - Auto Tangents Only -- - *Do not check* Constraints (as it will break the file) -- - Can check Embed Media (embeds textures into the exported FBX file) -- - Note that when importing embedded media, the texture and mesh will be a single immutable file. -- - You will have to re-export then re-import the FBX if the texture has changed. -- - Units: Centimeters -- - Up Axis: Y -- - Binary format in FBX 2017 -- -- @ newtype EditorSceneImporterAssimp = EditorSceneImporterAssimp Object deriving newtype AsVariant instance HasBaseClass EditorSceneImporterAssimp where type BaseClass EditorSceneImporterAssimp = EditorSceneImporter super = coerce -- | Post-processes scenes after import. -- Imported scenes can be automatically modified right after import by setting their __Custom Script__ Import property to a @tool@ script that inherits from this class. -- The @method post_import@ callback receives the imported scene's root node and returns the modified version of the scene. Usage example: -- -- @ -- -- tool # Needed so it runs in editor -- extends EditorScenePostImport -- -- # This sample changes all node names -- -- # Called right after the scene is imported and gets the root node -- func post_import(scene): -- # Change all node names to "modified_@oldnodename@" -- iterate(scene) -- return scene # Remember to return the imported scene -- -- func iterate(node): -- if node != null: -- node.name = "modified_" + node.name -- for child in node.get_children(): -- iterate(child) -- -- @ newtype EditorScenePostImport = EditorScenePostImport Object deriving newtype AsVariant instance HasBaseClass EditorScenePostImport where type BaseClass EditorScenePostImport = Reference super = coerce -- | Base script that can be used to add extension functions to the editor. -- Scripts extending this class and implementing its @method _run@ method can be executed from the Script Editor's __File > Run__ menu option (or by pressing @Ctrl+Shift+X@) while the editor is running. This is useful for adding custom in-editor functionality to Godot. For more complex additions, consider using @EditorPlugin@s instead. -- __Note:__ Extending scripts need to have @tool@ mode enabled. -- __Example script:__ -- -- @ -- -- tool -- extends EditorScript -- -- func _run(): -- print("Hello from the Godot Editor!") -- -- @ -- -- __Note:__ The script is run in the Editor context, which means the output is visible in the console window started with the Editor (stdout) instead of the usual Godot __Output__ dock. newtype EditorScript = EditorScript Object deriving newtype AsVariant instance HasBaseClass EditorScript where type BaseClass EditorScript = Reference super = coerce -- | Manages the SceneTree selection in the editor. -- This object manages the SceneTree selection in the editor. -- __Note:__ This class shouldn't be instantiated directly. Instead, access the singleton using @method EditorInterface.get_selection@. newtype EditorSelection = EditorSelection Object deriving newtype AsVariant instance HasBaseClass EditorSelection where type BaseClass EditorSelection = Object super = coerce -- | Object that holds the project-independent editor settings. -- These settings are generally visible in the __Editor > Editor Settings__ menu. -- Property names use slash delimiters to distinguish sections. Setting values can be of any @Variant@ type. It's recommended to use @snake_case@ for editor settings to be consistent with the Godot editor itself. -- Accessing the settings can be done using the following methods, such as: -- -- @ -- -- # `settings.set("some/property", value)` also works as this class overrides `_set()` internally. -- settings.set_setting("some/property",value) -- -- # `settings.get("some/property", value)` also works as this class overrides `_get()` internally. -- settings.get_setting("some/property") -- -- var list_of_settings = settings.get_property_list() -- -- @ -- -- __Note:__ This class shouldn't be instantiated directly. Instead, access the singleton using @method EditorInterface.get_editor_settings@. newtype EditorSettings = EditorSettings Object deriving newtype AsVariant instance HasBaseClass EditorSettings where type BaseClass EditorSettings = Resource super = coerce -- | Custom gizmo for editing Spatial objects. -- Custom gizmo that is used for providing custom visualization and editing (handles) for 3D Spatial objects. See @EditorSpatialGizmoPlugin@ for more information. newtype EditorSpatialGizmo = EditorSpatialGizmo Object deriving newtype AsVariant instance HasBaseClass EditorSpatialGizmo where type BaseClass EditorSpatialGizmo = SpatialGizmo super = coerce -- | Used by the editor to define Spatial gizmo types. -- EditorSpatialGizmoPlugin allows you to define a new type of Gizmo. There are two main ways to do so: extending @EditorSpatialGizmoPlugin@ for the simpler gizmos, or creating a new @EditorSpatialGizmo@ type. See the tutorial in the documentation for more info. newtype EditorSpatialGizmoPlugin = EditorSpatialGizmoPlugin Object deriving newtype AsVariant instance HasBaseClass EditorSpatialGizmoPlugin where type BaseClass EditorSpatialGizmoPlugin = Resource super = coerce newtype EditorSpinSlider = EditorSpinSlider Object deriving newtype AsVariant instance HasBaseClass EditorSpinSlider where type BaseClass EditorSpinSlider = Range super = coerce -- | Version Control System (VCS) interface which reads and writes to the local VCS in use. -- Used by the editor to display VCS extracted information in the editor. The implementation of this API is included in VCS addons, which are essentially GDNative plugins that need to be put into the project folder. These VCS addons are scripts which are attached (on demand) to the object instance of @EditorVCSInterface@. All the functions listed below, instead of performing the task themselves, they call the internally defined functions in the VCS addons to provide a plug-n-play experience. newtype EditorVCSInterface = EditorVCSInterface Object deriving newtype AsVariant instance HasBaseClass EditorVCSInterface where type BaseClass EditorVCSInterface = Object super = coerce -- | Holds a reference to an @Object@'s instance ID. -- Utility class which holds a reference to the internal identifier of an @Object@ instance, as given by @method Object.get_instance_id@. This ID can then be used to retrieve the object instance with @method @GDScript.instance_from_id@. -- This class is used internally by the editor inspector and script debugger, but can also be used in plugins to pass and display objects as their IDs. newtype EncodedObjectAsID = EncodedObjectAsID Object deriving newtype AsVariant instance HasBaseClass EncodedObjectAsID where type BaseClass EncodedObjectAsID = Reference super = coerce -- | Resource for environment nodes (like @WorldEnvironment@) that define multiple rendering options. -- Resource for environment nodes (like @WorldEnvironment@) that define multiple environment operations (such as background @Sky@ or @Color@, ambient light, fog, depth-of-field...). These parameters affect the final render of the scene. The order of these operations is: -- - Depth of Field Blur -- - Glow -- - Tonemap (Auto Exposure) -- - Adjustments -- These effects will only apply when the @Viewport@'s intended usage is "3D" or "3D Without Effects". This can be configured for the root Viewport with @ProjectSettings.rendering/quality/intended_usage/framebuffer_allocation@, or for specific Viewports via the @Viewport.usage@ property. newtype Environment = Environment Object deriving newtype AsVariant instance HasBaseClass Environment where type BaseClass Environment = Resource super = coerce -- | A class that stores an expression you can execute. -- An expression can be made of any arithmetic operation, built-in math function call, method call of a passed instance, or built-in type construction call. -- An example expression text using the built-in math functions could be @sqrt(pow(3,2) + pow(4,2))@. -- In the following example we use a @LineEdit@ node to write our expression and show the result. -- -- @ -- -- onready var expression = Expression.new() -- -- func _ready(): -- $LineEdit.connect("text_entered", self, "_on_text_entered") -- -- func _on_text_entered(command): -- var error = expression.parse(command, @@) -- if error != OK: -- print(expression.get_error_text()) -- return -- var result = expression.execute(@@, null, true) -- if not expression.has_execute_failed(): -- $LineEdit.text = str(result) -- -- @ newtype Expression = Expression Object deriving newtype AsVariant instance HasBaseClass Expression where type BaseClass Expression = Reference super = coerce -- | Dialog for selecting files or directories in the filesystem. -- FileDialog is a preset dialog used to choose files and directories in the filesystem. It supports filter masks. The FileDialog automatically sets its window title according to the @mode@. If you want to use a custom title, disable this by setting @mode_overrides_title@ to @false@. newtype FileDialog = FileDialog Object deriving newtype AsVariant instance HasBaseClass FileDialog where type BaseClass FileDialog = ConfirmationDialog super = coerce -- | Internationalized font and text drawing support. -- Font contains a Unicode-compatible character set, as well as the ability to draw it with variable width, ascent, descent and kerning. For creating fonts from TTF files (or other font formats), see the editor support for fonts. -- __Note:__ If a DynamicFont doesn't contain a character used in a string, the character in question will be replaced with codepoint @0xfffd@ if it's available in the DynamicFont. If this replacement character isn't available in the DynamicFont, the character will be hidden without displaying any replacement character in the string. -- __Note:__ If a BitmapFont doesn't contain a character used in a string, the character in question will be hidden without displaying any replacement character in the string. newtype Font = Font Object deriving newtype AsVariant instance HasBaseClass Font where type BaseClass Font = Resource super = coerce -- | Reference to a function in an object. -- In GDScript, functions are not @i@first-class objects@/i@. This means it is impossible to store them directly as variables, return them from another function, or pass them as arguments. -- However, by creating a @FuncRef@ using the @method @GDScript.funcref@ function, a reference to a function in a given object can be created, passed around and called. newtype FuncRef = FuncRef Object deriving newtype AsVariant instance HasBaseClass FuncRef where type BaseClass FuncRef = Reference super = coerce newtype GDNative = GDNative Object deriving newtype AsVariant instance HasBaseClass GDNative where type BaseClass GDNative = Reference super = coerce newtype GDNativeLibrary = GDNativeLibrary Object deriving newtype AsVariant instance HasBaseClass GDNativeLibrary where type BaseClass GDNativeLibrary = Resource super = coerce newtype GDScript = GDScript Object deriving newtype AsVariant instance HasBaseClass GDScript where type BaseClass GDScript = Script super = coerce newtype GDScriptFunctionState = GDScriptFunctionState Object deriving newtype AsVariant instance HasBaseClass GDScriptFunctionState where type BaseClass GDScriptFunctionState = Reference super = coerce -- | Real-time global illumination (GI) probe. -- @GIProbe@s are used to provide high-quality real-time indirect light to scenes. They precompute the effect of objects that emit light and the effect of static geometry to simulate the behavior of complex light in real-time. @GIProbe@s need to be baked before using, however, once baked, dynamic objects will receive light from them. Further, lights can be fully dynamic or baked. -- Having @GIProbe@s in a scene can be expensive, the quality of the probe can be turned down in exchange for better performance in the @ProjectSettings@ using @ProjectSettings.rendering/quality/voxel_cone_tracing/high_quality@. newtype GIProbe = GIProbe Object deriving newtype AsVariant instance HasBaseClass GIProbe where type BaseClass GIProbe = VisualInstance super = coerce newtype GIProbeData = GIProbeData Object deriving newtype AsVariant instance HasBaseClass GIProbeData where type BaseClass GIProbeData = Resource super = coerce -- | The generic 6-degrees-of-freedom joint can implement a variety of joint types by locking certain axes' rotation or translation. -- The first 3 DOF axes are linear axes, which represent translation of Bodies, and the latter 3 DOF axes represent the angular motion. Each axis can be either locked, or limited. newtype Generic6DOFJoint = Generic6DOFJoint Object deriving newtype AsVariant instance HasBaseClass Generic6DOFJoint where type BaseClass Generic6DOFJoint = Joint super = coerce -- | Base node for geometry-based visual instances. -- Shares some common functionality like visibility and custom materials. newtype GeometryInstance = GeometryInstance Object deriving newtype AsVariant instance HasBaseClass GeometryInstance where type BaseClass GeometryInstance = VisualInstance super = coerce -- | A color interpolator resource which can be used to generate colors between user-defined color points. -- Given a set of colors, this resource will interpolate them in order. This means that if you have color 1, color 2 and color 3, the ramp will interpolate from color 1 to color 2 and from color 2 to color 3. The ramp will initially have 2 colors (black and white), one (black) at ramp lower offset 0 and the other (white) at the ramp higher offset 1. newtype Gradient = Gradient Object deriving newtype AsVariant instance HasBaseClass Gradient where type BaseClass Gradient = Resource super = coerce -- | Gradient-filled texture. -- GradientTexture uses a @Gradient@ to fill the texture data. The gradient will be filled from left to right using colors obtained from the gradient. This means the texture does not necessarily represent an exact copy of the gradient, but instead an interpolation of samples obtained from the gradient at fixed steps (see @width@). newtype GradientTexture = GradientTexture Object deriving newtype AsVariant instance HasBaseClass GradientTexture where type BaseClass GradientTexture = Texture super = coerce -- | GraphEdit is an area capable of showing various GraphNodes. It manages connection events between them. -- GraphEdit manages the showing of GraphNodes it contains, as well as connections and disconnections between them. Signals are sent for each of these two events. Disconnection between GraphNode slots is disabled by default. -- It is greatly advised to enable low-processor usage mode (see @OS.low_processor_usage_mode@) when using GraphEdits. newtype GraphEdit = GraphEdit Object deriving newtype AsVariant instance HasBaseClass GraphEdit where type BaseClass GraphEdit = Control super = coerce -- | A GraphNode is a container with potentially several input and output slots allowing connections between GraphNodes. Slots can have different, incompatible types. -- A GraphNode is a container. Each GraphNode can have several input and output slots, sometimes referred to as ports, allowing connections between GraphNodes. To add a slot to GraphNode, add any @Control@-derived child node to it. -- After adding at least one child to GraphNode new sections will be automatically created in the Inspector called 'Slot'. When 'Slot' is expanded you will see list with index number for each slot. You can click on each of them to expand further. -- In the Inspector you can enable (show) or disable (hide) slots. By default all slots are disabled so you may not see any slots on your GraphNode initially. You can assign a type to each slot. Only slots of the same type will be able to connect to each other. You can also assign colors to slots. A tuple of input and output slots is defined for each GUI element included in the GraphNode. Input connections are on the left and output connections are on the right side of GraphNode. Only enabled slots are counted as connections. newtype GraphNode = GraphNode Object deriving newtype AsVariant instance HasBaseClass GraphNode where type BaseClass GraphNode = Container super = coerce -- | Grid container used to arrange Control-derived children in a grid like layout. -- GridContainer will arrange its Control-derived children in a grid like structure, the grid columns are specified using the @columns@ property and the number of rows will be equal to the number of children in the container divided by the number of columns. For example, if the container has 5 children, and 2 columns, there will be 3 rows in the container. -- Notice that grid layout will preserve the columns and rows for every size of the container, and that empty columns will be expanded automatically. -- __Note:__ GridContainer only works with child nodes inheriting from Control. It won't rearrange child nodes inheriting from Node2D. newtype GridContainer = GridContainer Object deriving newtype AsVariant instance HasBaseClass GridContainer where type BaseClass GridContainer = Container super = coerce newtype GridMap = GridMap Object deriving newtype AsVariant instance HasBaseClass GridMap where type BaseClass GridMap = Spatial super = coerce -- | Groove constraint for 2D physics. -- This is useful for making a body "slide" through a segment placed in another. newtype GrooveJoint2D = GrooveJoint2D Object deriving newtype AsVariant instance HasBaseClass GrooveJoint2D where type BaseClass GrooveJoint2D = Joint2D super = coerce -- | Horizontal box container. -- See @BoxContainer@. newtype HBoxContainer = HBoxContainer Object deriving newtype AsVariant instance HasBaseClass HBoxContainer where type BaseClass HBoxContainer = BoxContainer super = coerce -- | Horizontal scroll bar. -- Horizontal version of @ScrollBar@, which goes from left (min) to right (max). newtype HScrollBar = HScrollBar Object deriving newtype AsVariant instance HasBaseClass HScrollBar where type BaseClass HScrollBar = ScrollBar super = coerce -- | Horizontal separator. -- See @Separator@. Even though it looks horizontal, it is used to separate objects vertically. newtype HSeparator = HSeparator Object deriving newtype AsVariant instance HasBaseClass HSeparator where type BaseClass HSeparator = Separator super = coerce -- | Horizontal slider. -- See @Slider@. This one goes from left (min) to right (max). -- __Note:__ The @signal Range.changed@ and @signal Range.value_changed@ signals are part of the @Range@ class which this class inherits from. newtype HSlider = HSlider Object deriving newtype AsVariant instance HasBaseClass HSlider where type BaseClass HSlider = Slider super = coerce -- | Horizontal split container. -- See @SplitContainer@. This goes from left to right. newtype HSplitContainer = HSplitContainer Object deriving newtype AsVariant instance HasBaseClass HSplitContainer where type BaseClass HSplitContainer = SplitContainer super = coerce -- | Low-level hyper-text transfer protocol client. -- Hyper-text transfer protocol client (sometimes called "User Agent"). Used to make HTTP requests to download web content, upload files and other data or to communicate with various services, among other use cases. __See the @HTTPRequest@ node for an higher-level alternative.__ -- __Note:__ This client only needs to connect to a host once (see @method connect_to_host@) to send multiple requests. Because of this, methods that take URLs usually take just the part after the host instead of the full URL, as the client is already connected to a host. See @method request@ for a full example and to get started. -- A @HTTPClient@ should be reused between multiple requests or to connect to different hosts instead of creating one client per request. Supports SSL and SSL server certificate verification. HTTP status codes in the 2xx range indicate success, 3xx redirection (i.e. "try again, but over here"), 4xx something was wrong with the request, and 5xx something went wrong on the server's side. -- For more information on HTTP, see https://developer.mozilla.org/en-US/docs/Web/HTTP (or read RFC 2616 to get it straight from the source: https://tools.ietf.org/html/rfc2616). -- __Note:__ When performing HTTP requests from a project exported to HTML5, keep in mind the remote server may not allow requests from foreign origins due to @url=https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS@CORS@/url@. If you host the server in question, you should modify its backend to allow requests from foreign origins by adding the @Access-Control-Allow-Origin: *@ HTTP header. newtype HTTPClient = HTTPClient Object deriving newtype AsVariant instance HasBaseClass HTTPClient where type BaseClass HTTPClient = Reference super = coerce -- | A node with the ability to send HTTP(S) requests. -- A node with the ability to send HTTP requests. Uses @HTTPClient@ internally. -- Can be used to make HTTP requests, i.e. download or upload files or web content via HTTP. -- __Example of contacting a REST API and printing one of its returned fields:__ -- -- @ -- -- func _ready(): -- # Create an HTTP request node and connect its completion signal. -- var http_request = HTTPRequest.new() -- add_child(http_request) -- http_request.connect("request_completed", self, "_http_request_completed") -- -- # Perform a GET request. The URL below returns JSON as of writing. -- var error = http_request.request("https://httpbin.org/get") -- if error != OK: -- push_error("An error occurred in the HTTP request.") -- -- # Perform a POST request. The URL below returns JSON as of writing. -- # Note: Don't make simultaneous requests using a single HTTPRequest node. -- # The snippet below is provided for reference only. -- var body = {"name": "Godette"} -- var error = http_request.request("https://httpbin.org/post", @@, true, HTTPClient.METHOD_POST, body) -- if error != OK: -- push_error("An error occurred in the HTTP request.") -- -- -- # Called when the HTTP request is completed. -- func _http_request_completed(result, response_code, headers, body): -- var response = parse_json(body.get_string_from_utf8()) -- -- # Will print the user agent string used by the HTTPRequest node (as recognized by httpbin.org). -- print(response.headers@"User-Agent"@) -- -- @ -- -- __Example of loading and displaying an image using HTTPRequest:__ -- -- @ -- -- func _ready(): -- # Create an HTTP request node and connect its completion signal. -- var http_request = HTTPRequest.new() -- add_child(http_request) -- http_request.connect("request_completed", self, "_http_request_completed") -- -- # Perform the HTTP request. The URL below returns a PNG image as of writing. -- var error = http_request.request("https://via.placeholder.com/512") -- if error != OK: -- push_error("An error occurred in the HTTP request.") -- -- -- # Called when the HTTP request is completed. -- func _http_request_completed(result, response_code, headers, body): -- var image = Image.new() -- var error = image.load_png_from_buffer(body) -- if error != OK: -- push_error("Couldn't load the image.") -- -- var texture = ImageTexture.new() -- texture.create_from_image(image) -- -- # Display the image in a TextureRect node. -- var texture_rect = TextureRect.new() -- add_child(texture_rect) -- texture_rect.texture = texture -- -- @ -- -- __Note:__ When performing HTTP requests from a project exported to HTML5, keep in mind the remote server may not allow requests from foreign origins due to @url=https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS@CORS@/url@. If you host the server in question, you should modify its backend to allow requests from foreign origins by adding the @Access-Control-Allow-Origin: *@ HTTP header. newtype HTTPRequest = HTTPRequest Object deriving newtype AsVariant instance HasBaseClass HTTPRequest where type BaseClass HTTPRequest = Node super = coerce -- | Context to compute cryptographic hashes over multiple iterations. -- The HashingContext class provides an interface for computing cryptographic hashes over multiple iterations. This is useful for example when computing hashes of big files (so you don't have to load them all in memory), network streams, and data streams in general (so you don't have to hold buffers). -- The @enum HashType@ enum shows the supported hashing algorithms. -- -- @ -- -- const CHUNK_SIZE = 1024 -- -- func hash_file(path): -- var ctx = HashingContext.new() -- var file = File.new() -- # Start a SHA-256 context. -- ctx.start(HashingContext.HASH_SHA256) -- # Check that file exists. -- if not file.file_exists(path): -- return -- # Open the file to hash. -- file.open(path, File.READ) -- # Update the context after reading each chunk. -- while not file.eof_reached(): -- ctx.update(file.get_buffer(CHUNK_SIZE)) -- # Get the computed hash. -- var res = ctx.finish() -- # Print the result as hex string and array. -- printt(res.hex_encode(), Array(res)) -- -- @ -- -- __Note:__ Not available in HTML5 exports. newtype HashingContext = HashingContext Object deriving newtype AsVariant instance HasBaseClass HashingContext where type BaseClass HashingContext = Reference super = coerce -- | Height map shape for 3D physics (Bullet only). -- Height map shape resource, which can be added to a @PhysicsBody@ or @Area@. newtype HeightMapShape = HeightMapShape Object deriving newtype AsVariant instance HasBaseClass HeightMapShape where type BaseClass HeightMapShape = Shape super = coerce -- | A hinge between two 3D bodies. -- A HingeJoint normally uses the Z axis of body A as the hinge axis, another axis can be specified when adding it manually though. newtype HingeJoint = HingeJoint Object deriving newtype AsVariant instance HasBaseClass HingeJoint where type BaseClass HingeJoint = Joint super = coerce -- | Internet protocol (IP) support functions such as DNS resolution. -- IP contains support functions for the Internet Protocol (IP). TCP/IP support is in different classes (see @StreamPeerTCP@ and @TCP_Server@). IP provides DNS hostname resolution support, both blocking and threaded. newtype IP = IP Object deriving newtype AsVariant instance HasBaseClass IP where type BaseClass IP = Object super = coerce newtype IP_Unix = IP_Unix Object deriving newtype AsVariant instance HasBaseClass IP_Unix where type BaseClass IP_Unix = IP super = coerce -- | Image datatype. -- Native image datatype. Contains image data, which can be converted to a @Texture@, and several functions to interact with it. The maximum width and height for an @Image@ are @MAX_WIDTH@ and @MAX_HEIGHT@. -- __Note:__ The maximum image size is 16384×16384 pixels due to graphics hardware limitations. Larger images will fail to import. newtype Image = Image Object deriving newtype AsVariant instance HasBaseClass Image where type BaseClass Image = Resource super = coerce -- | A @Texture@ based on an @Image@. -- Can be created from an @Image@ with @method create_from_image@. -- __Note:__ The maximum image size is 16384×16384 pixels due to graphics hardware limitations. Larger images will fail to import. newtype ImageTexture = ImageTexture Object deriving newtype AsVariant instance HasBaseClass ImageTexture where type BaseClass ImageTexture = Texture super = coerce -- | Draws simple geometry from code. -- Uses a drawing mode similar to OpenGL 1.x. -- See also @ArrayMesh@, @MeshDataTool@ and @SurfaceTool@ for procedural geometry generation. -- __Note:__ ImmediateGeometry3D is best suited to small amounts of mesh data that change every frame. It will be slow when handling large amounts of mesh data. If mesh data doesn't change often, use @ArrayMesh@, @MeshDataTool@ or @SurfaceTool@ instead. -- __Note:__ Godot uses clockwise @url=https://learnopengl.com/Advanced-OpenGL/Face-culling@winding order@/url@ for front faces of triangle primitive modes. newtype ImmediateGeometry = ImmediateGeometry Object deriving newtype AsVariant instance HasBaseClass ImmediateGeometry where type BaseClass ImmediateGeometry = GeometryInstance super = coerce -- | A singleton that deals with inputs. -- This includes key presses, mouse buttons and movement, joypads, and input actions. Actions and their events can be set in the __Input Map__ tab in the __Project > Project Settings__, or with the @InputMap@ class. newtype Input = Input Object deriving newtype AsVariant instance HasBaseClass Input where type BaseClass Input = Object super = coerce newtype InputDefault = InputDefault Object deriving newtype AsVariant instance HasBaseClass InputDefault where type BaseClass InputDefault = Input super = coerce -- | Generic input event. -- Base class of all sort of input event. See @method Node._input@. newtype InputEvent = InputEvent Object deriving newtype AsVariant instance HasBaseClass InputEvent where type BaseClass InputEvent = Resource super = coerce -- | Input event type for actions. -- Contains a generic action which can be targeted from several types of inputs. Actions can be created from the __Input Map__ tab in the __Project > Project Settings__ menu. See @method Node._input@. newtype InputEventAction = InputEventAction Object deriving newtype AsVariant instance HasBaseClass InputEventAction where type BaseClass InputEventAction = InputEvent super = coerce -- | Base class for touch control gestures. newtype InputEventGesture = InputEventGesture Object deriving newtype AsVariant instance HasBaseClass InputEventGesture where type BaseClass InputEventGesture = InputEventWithModifiers super = coerce -- | Input event for gamepad buttons. -- Input event type for gamepad buttons. For gamepad analog sticks and joysticks, see @InputEventJoypadMotion@. newtype InputEventJoypadButton = InputEventJoypadButton Object deriving newtype AsVariant instance HasBaseClass InputEventJoypadButton where type BaseClass InputEventJoypadButton = InputEvent super = coerce -- | Input event type for gamepad joysticks and other motions. For buttons, see @InputEventJoypadButton@. -- Stores information about joystick motions. One @InputEventJoypadMotion@ represents one axis at a time. newtype InputEventJoypadMotion = InputEventJoypadMotion Object deriving newtype AsVariant instance HasBaseClass InputEventJoypadMotion where type BaseClass InputEventJoypadMotion = InputEvent super = coerce -- | Input event type for keyboard events. -- Stores key presses on the keyboard. Supports key presses, key releases and @echo@ events. newtype InputEventKey = InputEventKey Object deriving newtype AsVariant instance HasBaseClass InputEventKey where type BaseClass InputEventKey = InputEventWithModifiers super = coerce newtype InputEventMIDI = InputEventMIDI Object deriving newtype AsVariant instance HasBaseClass InputEventMIDI where type BaseClass InputEventMIDI = InputEvent super = coerce newtype InputEventMagnifyGesture = InputEventMagnifyGesture Object deriving newtype AsVariant instance HasBaseClass InputEventMagnifyGesture where type BaseClass InputEventMagnifyGesture = InputEventGesture super = coerce -- | Base input event type for mouse events. -- Stores general mouse events information. newtype InputEventMouse = InputEventMouse Object deriving newtype AsVariant instance HasBaseClass InputEventMouse where type BaseClass InputEventMouse = InputEventWithModifiers super = coerce -- | Input event type for mouse button events. -- Contains mouse click information. See @method Node._input@. newtype InputEventMouseButton = InputEventMouseButton Object deriving newtype AsVariant instance HasBaseClass InputEventMouseButton where type BaseClass InputEventMouseButton = InputEventMouse super = coerce -- | Input event type for mouse motion events. -- Contains mouse and pen motion information. Supports relative, absolute positions and speed. See @method Node._input@. -- __Note:__ By default, this event is only emitted once per frame rendered at most. If you need more precise input reporting, call @method Input.set_use_accumulated_input@ with @false@ to make events emitted as often as possible. If you use InputEventMouseMotion to draw lines, consider implementing @url=https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm@Bresenham's line algorithm@/url@ as well to avoid visible gaps in lines if the user is moving the mouse quickly. newtype InputEventMouseMotion = InputEventMouseMotion Object deriving newtype AsVariant instance HasBaseClass InputEventMouseMotion where type BaseClass InputEventMouseMotion = InputEventMouse super = coerce newtype InputEventPanGesture = InputEventPanGesture Object deriving newtype AsVariant instance HasBaseClass InputEventPanGesture where type BaseClass InputEventPanGesture = InputEventGesture super = coerce -- | Input event type for screen drag events. Only available on mobile devices. -- Contains screen drag information. See @method Node._input@. newtype InputEventScreenDrag = InputEventScreenDrag Object deriving newtype AsVariant instance HasBaseClass InputEventScreenDrag where type BaseClass InputEventScreenDrag = InputEvent super = coerce -- | Input event type for screen touch events. -- (only available on mobile devices) -- Stores multi-touch press/release information. Supports touch press, touch release and @index@ for multi-touch count and order. newtype InputEventScreenTouch = InputEventScreenTouch Object deriving newtype AsVariant instance HasBaseClass InputEventScreenTouch where type BaseClass InputEventScreenTouch = InputEvent super = coerce -- | Base class for keys events with modifiers. -- Contains keys events information with modifiers support like @Shift@ or @Alt@. See @method Node._input@. newtype InputEventWithModifiers = InputEventWithModifiers Object deriving newtype AsVariant instance HasBaseClass InputEventWithModifiers where type BaseClass InputEventWithModifiers = InputEvent super = coerce -- | Singleton that manages @InputEventAction@. -- Manages all @InputEventAction@ which can be created/modified from the project settings menu __Project > Project Settings > Input Map__ or in code with @method add_action@ and @method action_add_event@. See @method Node._input@. newtype InputMap = InputMap Object deriving newtype AsVariant instance HasBaseClass InputMap where type BaseClass InputMap = Object super = coerce -- | Placeholder for the root @Node@ of a @PackedScene@. -- Turning on the option __Load As Placeholder__ for an instanced scene in the editor causes it to be replaced by an InstancePlaceholder when running the game. This makes it possible to delay actually loading the scene until calling @method replace_by_instance@. This is useful to avoid loading large scenes all at once by loading parts of it selectively. -- The InstancePlaceholder does not have a transform. This causes any child nodes to be positioned relatively to the Viewport from point (0,0), rather than their parent as displayed in the editor. Replacing the placeholder with a scene with a transform will transform children relatively to their parent again. newtype InstancePlaceholder = InstancePlaceholder Object deriving newtype AsVariant instance HasBaseClass InstancePlaceholder where type BaseClass InstancePlaceholder = Node super = coerce -- | @i@Deprecated.@/i@ Camera which moves toward another node. -- @i@Deprecated (will be removed in Godot 4.0).@/i@ InterpolatedCamera is a @Camera@ which smoothly moves to match a target node's position and rotation. -- If it is not @enabled@ or does not have a valid target set, InterpolatedCamera acts like a normal Camera. newtype InterpolatedCamera = InterpolatedCamera Object deriving newtype AsVariant instance HasBaseClass InterpolatedCamera where type BaseClass InterpolatedCamera = Camera super = coerce -- | Control that provides a list of selectable items (and/or icons) in a single column, or optionally in multiple columns. -- This control provides a selectable list of items that may be in a single (or multiple columns) with option of text, icons, or both text and icon. Tooltips are supported and may be different for every item in the list. -- Selectable items in the list may be selected or deselected and multiple selection may be enabled. Selection with right mouse button may also be enabled to allow use of popup context menus. Items may also be "activated" by double-clicking them or by pressing Enter. -- Item text only supports single-line strings, newline characters (e.g. @\n@) in the string won't produce a newline. Text wrapping is enabled in @ICON_MODE_TOP@ mode, but column's width is adjusted to fully fit its content by default. You need to set @fixed_column_width@ greater than zero to wrap the text. newtype ItemList = ItemList Object deriving newtype AsVariant instance HasBaseClass ItemList where type BaseClass ItemList = Control super = coerce -- | Data class wrapper for decoded JSON. -- Returned by @method JSON.parse@, @JSONParseResult@ contains the decoded JSON or error information if the JSON source wasn't successfully parsed. You can check if the JSON source was successfully parsed with @if json_result.error == OK@. newtype JSONParseResult = JSONParseResult Object deriving newtype AsVariant instance HasBaseClass JSONParseResult where type BaseClass JSONParseResult = Reference super = coerce newtype JSONRPC = JSONRPC Object deriving newtype AsVariant instance HasBaseClass JSONRPC where type BaseClass JSONRPC = Object super = coerce newtype JavaClass = JavaClass Object deriving newtype AsVariant instance HasBaseClass JavaClass where type BaseClass JavaClass = Reference super = coerce newtype JavaClassWrapper = JavaClassWrapper Object deriving newtype AsVariant instance HasBaseClass JavaClassWrapper where type BaseClass JavaClassWrapper = Object super = coerce -- | Singleton that connects the engine with the browser's JavaScript context in HTML5 export. -- The JavaScript singleton is implemented only in the HTML5 export. It's used to access the browser's JavaScript context. This allows interaction with embedding pages or calling third-party JavaScript APIs. newtype JavaScript = JavaScript Object deriving newtype AsVariant instance HasBaseClass JavaScript where type BaseClass JavaScript = Object super = coerce -- | Base class for all 3D joints. -- Joints are used to bind together two physics bodies. They have a solver priority and can define if the bodies of the two attached nodes should be able to collide with each other. newtype Joint = Joint Object deriving newtype AsVariant instance HasBaseClass Joint where type BaseClass Joint = Spatial super = coerce -- | Base node for all joint constraints in 2D physics. -- Joints take 2 bodies and apply a custom constraint. newtype Joint2D = Joint2D Object deriving newtype AsVariant instance HasBaseClass Joint2D where type BaseClass Joint2D = Node2D super = coerce -- | Kinematic body 3D node. -- Kinematic bodies are special types of bodies that are meant to be user-controlled. They are not affected by physics at all; to other types of bodies, such as a character or a rigid body, these are the same as a static body. However, they have two main uses: -- __Simulated motion:__ When these bodies are moved manually, either from code or from an @AnimationPlayer@ (with @AnimationPlayer.playback_process_mode@ set to "physics"), the physics will automatically compute an estimate of their linear and angular velocity. This makes them very useful for moving platforms or other AnimationPlayer-controlled objects (like a door, a bridge that opens, etc). -- __Kinematic characters:__ KinematicBody also has an API for moving objects (the @method move_and_collide@ and @method move_and_slide@ methods) while performing collision tests. This makes them really useful to implement characters that collide against a world, but that don't require advanced physics. newtype KinematicBody = KinematicBody Object deriving newtype AsVariant instance HasBaseClass KinematicBody where type BaseClass KinematicBody = PhysicsBody super = coerce -- | Kinematic body 2D node. -- Kinematic bodies are special types of bodies that are meant to be user-controlled. They are not affected by physics at all; to other types of bodies, such as a character or a rigid body, these are the same as a static body. However, they have two main uses: -- __Simulated motion:__ When these bodies are moved manually, either from code or from an @AnimationPlayer@ (with @AnimationPlayer.playback_process_mode@ set to "physics"), the physics will automatically compute an estimate of their linear and angular velocity. This makes them very useful for moving platforms or other AnimationPlayer-controlled objects (like a door, a bridge that opens, etc). -- __Kinematic characters:__ KinematicBody2D also has an API for moving objects (the @method move_and_collide@ and @method move_and_slide@ methods) while performing collision tests. This makes them really useful to implement characters that collide against a world, but that don't require advanced physics. newtype KinematicBody2D = KinematicBody2D Object deriving newtype AsVariant instance HasBaseClass KinematicBody2D where type BaseClass KinematicBody2D = PhysicsBody2D super = coerce -- | Collision data for @KinematicBody@ collisions. -- Contains collision data for @KinematicBody@ collisions. When a @KinematicBody@ is moved using @method KinematicBody.move_and_collide@, it stops if it detects a collision with another body. If a collision is detected, a KinematicCollision object is returned. -- This object contains information about the collision, including the colliding object, the remaining motion, and the collision position. This information can be used to calculate a collision response. newtype KinematicCollision = KinematicCollision Object deriving newtype AsVariant instance HasBaseClass KinematicCollision where type BaseClass KinematicCollision = Reference super = coerce -- | Collision data for @KinematicBody2D@ collisions. -- Contains collision data for @KinematicBody2D@ collisions. When a @KinematicBody2D@ is moved using @method KinematicBody2D.move_and_collide@, it stops if it detects a collision with another body. If a collision is detected, a KinematicCollision2D object is returned. -- This object contains information about the collision, including the colliding object, the remaining motion, and the collision position. This information can be used to calculate a collision response. newtype KinematicCollision2D = KinematicCollision2D Object deriving newtype AsVariant instance HasBaseClass KinematicCollision2D where type BaseClass KinematicCollision2D = Reference super = coerce -- | Displays plain text in a line or wrapped inside a rectangle. For formatted text, use @RichTextLabel@. -- Label displays plain text on the screen. It gives you control over the horizontal and vertical alignment, and can wrap the text inside the node's bounding rectangle. It doesn't support bold, italics or other formatting. For that, use @RichTextLabel@ instead. -- __Note:__ Contrarily to most other @Control@s, Label's @Control.mouse_filter@ defaults to @Control.MOUSE_FILTER_IGNORE@ (i.e. it doesn't react to mouse input events). This implies that a label won't display any configured @Control.hint_tooltip@, unless you change its mouse filter. newtype Label = Label Object deriving newtype AsVariant instance HasBaseClass Label where type BaseClass Label = Control super = coerce -- | A @Texture@ capable of storing many smaller textures with offsets. -- -- You can dynamically add pieces (@Texture@s) to this @LargeTexture@ using different offsets. newtype LargeTexture = LargeTexture Object deriving newtype AsVariant instance HasBaseClass LargeTexture where type BaseClass LargeTexture = Texture super = coerce -- | Provides a base class for different kinds of light nodes. -- Light is the @i@abstract@/i@ base class for light nodes. As it can't be instanced, it shouldn't be used directly. Other types of light nodes inherit from it. Light contains the common variables and parameters used for lighting. newtype Light = Light Object deriving newtype AsVariant instance HasBaseClass Light where type BaseClass Light = VisualInstance super = coerce -- | Casts light in a 2D environment. -- Light is defined by a (usually grayscale) texture, a color, an energy value, a mode (see constants), and various other parameters (range and shadows-related). -- __Note:__ Light2D can also be used as a mask. newtype Light2D = Light2D Object deriving newtype AsVariant instance HasBaseClass Light2D where type BaseClass Light2D = Node2D super = coerce -- | Occludes light cast by a Light2D, casting shadows. -- The LightOccluder2D must be provided with an @OccluderPolygon2D@ in order for the shadow to be computed. newtype LightOccluder2D = LightOccluder2D Object deriving newtype AsVariant instance HasBaseClass LightOccluder2D where type BaseClass LightOccluder2D = Node2D super = coerce -- | A 2D line. -- A line through several points in 2D space. -- __Note:__ By default, Godot can only draw up to 4,096 polygon points at a time. To increase this limit, open the Project Settings and increase @ProjectSettings.rendering/limits/buffers/canvas_polygon_buffer_size_kb@ and @ProjectSettings.rendering/limits/buffers/canvas_polygon_index_buffer_size_kb@. newtype Line2D = Line2D Object deriving newtype AsVariant instance HasBaseClass Line2D where type BaseClass Line2D = Node2D super = coerce -- | Control that provides single-line string editing. -- LineEdit provides a single-line string editor, used for text fields. -- It features many built-in shortcuts which will always be available (@Ctrl@ here maps to @Command@ on macOS): -- - Ctrl + C: Copy -- - Ctrl + X: Cut -- - Ctrl + V or Ctrl + Y: Paste/"yank" -- - Ctrl + Z: Undo -- - Ctrl + Shift + Z: Redo -- - Ctrl + U: Delete text from the cursor position to the beginning of the line -- - Ctrl + K: Delete text from the cursor position to the end of the line -- - Ctrl + A: Select all text -- - Up/Down arrow: Move the cursor to the beginning/end of the line -- On macOS, some extra keyboard shortcuts are available: -- - Ctrl + F: Like the right arrow key, move the cursor one character right -- - Ctrl + B: Like the left arrow key, move the cursor one character left -- - Ctrl + P: Like the up arrow key, move the cursor to the previous line -- - Ctrl + N: Like the down arrow key, move the cursor to the next line -- - Ctrl + D: Like the Delete key, delete the character on the right side of cursor -- - Ctrl + H: Like the Backspace key, delete the character on the left side of the cursor -- - Command + Left arrow: Like the Home key, move the cursor to the beginning of the line -- - Command + Right arrow: Like the End key, move the cursor to the end of the line newtype LineEdit = LineEdit Object deriving newtype AsVariant instance HasBaseClass LineEdit where type BaseClass LineEdit = Control super = coerce -- | Line shape for 2D collisions. -- It works like a 2D plane and will not allow any physics body to go to the negative side. Not recommended for rigid bodies, and usually not recommended for static bodies either because it forces checks against it on every frame. newtype LineShape2D = LineShape2D Object deriving newtype AsVariant instance HasBaseClass LineShape2D where type BaseClass LineShape2D = Shape2D super = coerce -- | Simple button used to represent a link to some resource. -- This kind of button is primarily used when the interaction with the button causes a context change (like linking to a web page). newtype LinkButton = LinkButton Object deriving newtype AsVariant instance HasBaseClass LinkButton where type BaseClass LinkButton = BaseButton super = coerce -- | Overrides the location sounds are heard from. -- Once added to the scene tree and enabled using @method make_current@, this node will override the location sounds are heard from. This can be used to listen from a location different from the @Camera@. -- __Note:__ There is no 2D equivalent for this node yet. newtype Listener = Listener Object deriving newtype AsVariant instance HasBaseClass Listener where type BaseClass Listener = Spatial super = coerce -- | Abstract base class for the game's main loop. -- @MainLoop@ is the abstract base class for a Godot project's game loop. It is inherited by @SceneTree@, which is the default game loop implementation used in Godot projects, though it is also possible to write and use one's own @MainLoop@ subclass instead of the scene tree. -- Upon the application start, a @MainLoop@ implementation must be provided to the OS; otherwise, the application will exit. This happens automatically (and a @SceneTree@ is created) unless a main @Script@ is provided from the command line (with e.g. @godot -s my_loop.gd@, which should then be a @MainLoop@ implementation. -- Here is an example script implementing a simple @MainLoop@: -- -- @ -- -- extends MainLoop -- -- var time_elapsed = 0 -- var keys_typed = @@ -- var quit = false -- -- func _initialize(): -- print("Initialized:") -- print(" Starting time: %s" % str(time_elapsed)) -- -- func _idle(delta): -- time_elapsed += delta -- # Return true to end the main loop. -- return quit -- -- func _input_event(event): -- # Record keys. -- if event is InputEventKey and event.pressed and !event.echo: -- keys_typed.append(OS.get_scancode_string(event.scancode)) -- # Quit on Escape press. -- if event.scancode == KEY_ESCAPE: -- quit = true -- # Quit on any mouse click. -- if event is InputEventMouseButton: -- quit = true -- -- func _finalize(): -- print("Finalized:") -- print(" End time: %s" % str(time_elapsed)) -- print(" Keys typed: %s" % var2str(keys_typed)) -- -- @ newtype MainLoop = MainLoop Object deriving newtype AsVariant instance HasBaseClass MainLoop where type BaseClass MainLoop = Object super = coerce -- | Simple margin container. -- Adds a top, left, bottom, and right margin to all @Control@ nodes that are direct children of the container. To control the @MarginContainer@'s margin, use the @margin_*@ theme properties listed below. -- __Note:__ Be careful, @Control@ margin values are different than the constant margin values. If you want to change the custom margin values of the @MarginContainer@ by code, you should use the following examples: -- -- @ -- -- var margin_value = 100 -- set("custom_constants/margin_top", margin_value) -- set("custom_constants/margin_left", margin_value) -- set("custom_constants/margin_bottom", margin_value) -- set("custom_constants/margin_right", margin_value) -- -- @ newtype MarginContainer = MarginContainer Object deriving newtype AsVariant instance HasBaseClass MarginContainer where type BaseClass MarginContainer = Container super = coerce -- | Abstract base @Resource@ for coloring and shading geometry. -- Material is a base @Resource@ used for coloring and shading geometry. All materials inherit from it and almost all @VisualInstance@ derived nodes carry a Material. A few flags and parameters are shared between all material types and are configured here. newtype Material = Material Object deriving newtype AsVariant instance HasBaseClass Material where type BaseClass Material = Resource super = coerce -- | Special button that brings up a @PopupMenu@ when clicked. -- -- New items can be created inside this @PopupMenu@ using @get_popup().add_item("My Item Name")@. You can also create them directly from the editor. To do so, select the @MenuButton@ node, then in the toolbar at the top of the 2D editor, click __Items__ then click __Add__ in the popup. You will be able to give each items new properties. newtype MenuButton = MenuButton Object deriving newtype AsVariant instance HasBaseClass MenuButton where type BaseClass MenuButton = Button super = coerce -- | A @Resource@ that contains vertex array-based geometry. -- Mesh is a type of @Resource@ that contains vertex array-based geometry, divided in @i@surfaces@/i@. Each surface contains a completely separate array and a material used to draw it. Design wise, a mesh with multiple surfaces is preferred to a single surface, because objects created in 3D editing software commonly contain multiple materials. newtype Mesh = Mesh Object deriving newtype AsVariant instance HasBaseClass Mesh where type BaseClass Mesh = Resource super = coerce -- | Helper tool to access and edit @Mesh@ data. -- MeshDataTool provides access to individual vertices in a @Mesh@. It allows users to read and edit vertex data of meshes. It also creates an array of faces and edges. -- To use MeshDataTool, load a mesh with @method create_from_surface@. When you are finished editing the data commit the data to a mesh with @method commit_to_surface@. -- Below is an example of how MeshDataTool may be used. -- -- @ -- -- var mdt = MeshDataTool.new() -- mdt.create_from_surface(mesh, 0) -- for i in range(mdt.get_vertex_count()): -- var vertex = mdt.get_vertex(i) -- ... -- mdt.set_vertex(i, vertex) -- mesh.surface_remove(0) -- mdt.commit_to_surface(mesh) -- -- @ -- -- See also @ArrayMesh@, @ImmediateGeometry@ and @SurfaceTool@ for procedural geometry generation. -- __Note:__ Godot uses clockwise @url=https://learnopengl.com/Advanced-OpenGL/Face-culling@winding order@/url@ for front faces of triangle primitive modes. newtype MeshDataTool = MeshDataTool Object deriving newtype AsVariant instance HasBaseClass MeshDataTool where type BaseClass MeshDataTool = Reference super = coerce -- | Node that instances meshes into a scenario. -- MeshInstance is a node that takes a @Mesh@ resource and adds it to the current scenario by creating an instance of it. This is the class most often used to get 3D geometry rendered and can be used to instance a single @Mesh@ in many places. This allows to reuse geometry and save on resources. When a @Mesh@ has to be instanced more than thousands of times at close proximity, consider using a @MultiMesh@ in a @MultiMeshInstance@ instead. newtype MeshInstance = MeshInstance Object deriving newtype AsVariant instance HasBaseClass MeshInstance where type BaseClass MeshInstance = GeometryInstance super = coerce -- | Node used for displaying a @Mesh@ in 2D. -- Can be constructed from an existing @Sprite@ via a tool in the editor toolbar. Select "Sprite" then "Convert to Mesh2D", select settings in popup and press "Create Mesh2D". newtype MeshInstance2D = MeshInstance2D Object deriving newtype AsVariant instance HasBaseClass MeshInstance2D where type BaseClass MeshInstance2D = Node2D super = coerce -- | Library of meshes. -- A library of meshes. Contains a list of @Mesh@ resources, each with a name and ID. Each item can also include collision and navigation shapes. This resource is used in @GridMap@. newtype MeshLibrary = MeshLibrary Object deriving newtype AsVariant instance HasBaseClass MeshLibrary where type BaseClass MeshLibrary = Resource super = coerce -- | Simple texture that uses a mesh to draw itself. -- It's limited because flags can't be changed and region drawing is not supported. newtype MeshTexture = MeshTexture Object deriving newtype AsVariant instance HasBaseClass MeshTexture where type BaseClass MeshTexture = Texture super = coerce newtype MobileVRInterface = MobileVRInterface Object deriving newtype AsVariant instance HasBaseClass MobileVRInterface where type BaseClass MobileVRInterface = ARVRInterface super = coerce -- | Provides high-performance mesh instancing. -- MultiMesh provides low-level mesh instancing. Drawing thousands of @MeshInstance@ nodes can be slow, since each object is submitted to the GPU then drawn individually. -- MultiMesh is much faster as it can draw thousands of instances with a single draw call, resulting in less API overhead. -- As a drawback, if the instances are too far away of each other, performance may be reduced as every single instance will always rendered (they are spatially indexed as one, for the whole object). -- Since instances may have any behavior, the AABB used for visibility must be provided by the user. newtype MultiMesh = MultiMesh Object deriving newtype AsVariant instance HasBaseClass MultiMesh where type BaseClass MultiMesh = Resource super = coerce -- | Node that instances a @MultiMesh@. -- @MultiMeshInstance@ is a specialized node to instance @GeometryInstance@s based on a @MultiMesh@ resource. -- This is useful to optimize the rendering of a high amount of instances of a given mesh (for example trees in a forest or grass strands). newtype MultiMeshInstance = MultiMeshInstance Object deriving newtype AsVariant instance HasBaseClass MultiMeshInstance where type BaseClass MultiMeshInstance = GeometryInstance super = coerce -- | Node that instances a @MultiMesh@ in 2D. -- @MultiMeshInstance2D@ is a specialized node to instance a @MultiMesh@ resource in 2D. -- Usage is the same as @MultiMeshInstance@. newtype MultiMeshInstance2D = MultiMeshInstance2D Object deriving newtype AsVariant instance HasBaseClass MultiMeshInstance2D where type BaseClass MultiMeshInstance2D = Node2D super = coerce -- | High-level multiplayer API. -- This class implements most of the logic behind the high-level multiplayer API. -- By default, @SceneTree@ has a reference to this class that is used to provide multiplayer capabilities (i.e. RPC/RSET) across the whole scene. -- It is possible to override the MultiplayerAPI instance used by specific Nodes by setting the @Node.custom_multiplayer@ property, effectively allowing to run both client and server in the same scene. newtype MultiplayerAPI = MultiplayerAPI Object deriving newtype AsVariant instance HasBaseClass MultiplayerAPI where type BaseClass MultiplayerAPI = Reference super = coerce newtype MultiplayerPeerGDNative = MultiplayerPeerGDNative Object deriving newtype AsVariant instance HasBaseClass MultiplayerPeerGDNative where type BaseClass MultiplayerPeerGDNative = NetworkedMultiplayerPeer super = coerce newtype NativeScript = NativeScript Object deriving newtype AsVariant instance HasBaseClass NativeScript where type BaseClass NativeScript = Script super = coerce -- | Mesh-based navigation and pathfinding node. -- Provides navigation and pathfinding within a collection of @NavigationMesh@es. By default, these will be automatically collected from child @NavigationMeshInstance@ nodes, but they can also be added on the fly with @method navmesh_add@. In addition to basic pathfinding, this class also assists with aligning navigation agents with the meshes they are navigating on. newtype Navigation = Navigation Object deriving newtype AsVariant instance HasBaseClass Navigation where type BaseClass Navigation = Spatial super = coerce -- | 2D navigation and pathfinding node. -- Navigation2D provides navigation and pathfinding within a 2D area, specified as a collection of @NavigationPolygon@ resources. By default, these are automatically collected from child @NavigationPolygonInstance@ nodes, but they can also be added on the fly with @method navpoly_add@. newtype Navigation2D = Navigation2D Object deriving newtype AsVariant instance HasBaseClass Navigation2D where type BaseClass Navigation2D = Node2D super = coerce newtype NavigationMesh = NavigationMesh Object deriving newtype AsVariant instance HasBaseClass NavigationMesh where type BaseClass NavigationMesh = Resource super = coerce newtype NavigationMeshInstance = NavigationMeshInstance Object deriving newtype AsVariant instance HasBaseClass NavigationMeshInstance where type BaseClass NavigationMeshInstance = Spatial super = coerce -- | A node that has methods to draw outlines or use indices of vertices to create navigation polygons. -- There are two ways to create polygons. Either by using the @method add_outline@ method, or using the @method add_polygon@ method. -- Using @method add_outline@: -- -- @ -- -- var polygon = NavigationPolygon.new() -- var outline = PoolVector2Array(@Vector2(0, 0), Vector2(0, 50), Vector2(50, 50), Vector2(50, 0)@) -- polygon.add_outline(outline) -- polygon.make_polygons_from_outlines() -- $NavigationPolygonInstance.navpoly = polygon -- -- @ -- -- Using @method add_polygon@ and indices of the vertices array. -- -- @ -- -- var polygon = NavigationPolygon.new() -- var vertices = PoolVector2Array(@Vector2(0, 0), Vector2(0, 50), Vector2(50, 50), Vector2(50, 0)@) -- polygon.set_vertices(vertices) -- var indices = PoolIntArray(0, 3, 1) -- polygon.add_polygon(indices) -- $NavigationPolygonInstance.navpoly = polygon -- -- @ newtype NavigationPolygon = NavigationPolygon Object deriving newtype AsVariant instance HasBaseClass NavigationPolygon where type BaseClass NavigationPolygon = Resource super = coerce newtype NavigationPolygonInstance = NavigationPolygonInstance Object deriving newtype AsVariant instance HasBaseClass NavigationPolygonInstance where type BaseClass NavigationPolygonInstance = Node2D super = coerce newtype NetworkedMultiplayerENet = NetworkedMultiplayerENet Object deriving newtype AsVariant instance HasBaseClass NetworkedMultiplayerENet where type BaseClass NetworkedMultiplayerENet = NetworkedMultiplayerPeer super = coerce -- | A high-level network interface to simplify multiplayer interactions. -- Manages the connection to network peers. Assigns unique IDs to each client connected to the server. newtype NetworkedMultiplayerPeer = NetworkedMultiplayerPeer Object deriving newtype AsVariant instance HasBaseClass NetworkedMultiplayerPeer where type BaseClass NetworkedMultiplayerPeer = PacketPeer super = coerce -- | Scalable texture-based frame that tiles the texture's centers and sides, but keeps the corners' original size. Perfect for panels and dialog boxes. -- Also known as 9-slice panels, NinePatchRect produces clean panels of any size, based on a small texture. To do so, it splits the texture in a 3×3 grid. When you scale the node, it tiles the texture's sides horizontally or vertically, the center on both axes but it doesn't scale or tile the corners. newtype NinePatchRect = NinePatchRect Object deriving newtype AsVariant instance HasBaseClass NinePatchRect where type BaseClass NinePatchRect = Control super = coerce -- | Base class for all @i@scene@/i@ objects. -- Nodes are Godot's building blocks. They can be assigned as the child of another node, resulting in a tree arrangement. A given node can contain any number of nodes as children with the requirement that all siblings (direct children of a node) should have unique names. -- A tree of nodes is called a @i@scene@/i@. Scenes can be saved to the disk and then instanced into other scenes. This allows for very high flexibility in the architecture and data model of Godot projects. -- __Scene tree:__ The @SceneTree@ contains the active tree of nodes. When a node is added to the scene tree, it receives the @NOTIFICATION_ENTER_TREE@ notification and its @method _enter_tree@ callback is triggered. Child nodes are always added @i@after@/i@ their parent node, i.e. the @method _enter_tree@ callback of a parent node will be triggered before its child's. -- Once all nodes have been added in the scene tree, they receive the @NOTIFICATION_READY@ notification and their respective @method _ready@ callbacks are triggered. For groups of nodes, the @method _ready@ callback is called in reverse order, starting with the children and moving up to the parent nodes. -- This means that when adding a node to the scene tree, the following order will be used for the callbacks: @method _enter_tree@ of the parent, @method _enter_tree@ of the children, @method _ready@ of the children and finally @method _ready@ of the parent (recursively for the entire scene tree). -- __Processing:__ Nodes can override the "process" state, so that they receive a callback on each frame requesting them to process (do something). Normal processing (callback @method _process@, toggled with @method set_process@) happens as fast as possible and is dependent on the frame rate, so the processing time @i@delta@/i@ is passed as an argument. Physics processing (callback @method _physics_process@, toggled with @method set_physics_process@) happens a fixed number of times per second (60 by default) and is useful for code related to the physics engine. -- Nodes can also process input events. When present, the @method _input@ function will be called for each input that the program receives. In many cases, this can be overkill (unless used for simple projects), and the @method _unhandled_input@ function might be preferred; it is called when the input event was not handled by anyone else (typically, GUI @Control@ nodes), ensuring that the node only receives the events that were meant for it. -- To keep track of the scene hierarchy (especially when instancing scenes into other scenes), an "owner" can be set for the node with the @owner@ property. This keeps track of who instanced what. This is mostly useful when writing editors and tools, though. -- Finally, when a node is freed with @method Object.free@ or @method queue_free@, it will also free all its children. -- __Groups:__ Nodes can be added to as many groups as you want to be easy to manage, you could create groups like "enemies" or "collectables" for example, depending on your game. See @method add_to_group@, @method is_in_group@ and @method remove_from_group@. You can then retrieve all nodes in these groups, iterate them and even call methods on groups via the methods on @SceneTree@. -- __Networking with nodes:__ After connecting to a server (or making one, see @NetworkedMultiplayerENet@), it is possible to use the built-in RPC (remote procedure call) system to communicate over the network. By calling @method rpc@ with a method name, it will be called locally and in all connected peers (peers = clients and the server that accepts connections). To identify which node receives the RPC call, Godot will use its @NodePath@ (make sure node names are the same on all peers). Also, take a look at the high-level networking tutorial and corresponding demos. newtype Node = Node Object deriving newtype AsVariant instance HasBaseClass Node where type BaseClass Node = Object super = coerce -- | A 2D game object, inherited by all 2D-related nodes. Has a position, rotation, scale, and Z index. -- A 2D game object, with a transform (position, rotation, and scale). All 2D nodes, including physics objects and sprites, inherit from Node2D. Use Node2D as a parent node to move, scale and rotate children in a 2D project. Also gives control of the node's render order. newtype Node2D = Node2D Object deriving newtype AsVariant instance HasBaseClass Node2D where type BaseClass Node2D = CanvasItem super = coerce newtype NoiseTexture = NoiseTexture Object deriving newtype AsVariant instance HasBaseClass NoiseTexture where type BaseClass NoiseTexture = Texture super = coerce -- | Defines a 2D polygon for LightOccluder2D. -- Editor facility that helps you draw a 2D polygon used as resource for @LightOccluder2D@. newtype OccluderPolygon2D = OccluderPolygon2D Object deriving newtype AsVariant instance HasBaseClass OccluderPolygon2D where type BaseClass OccluderPolygon2D = Resource super = coerce -- | Omnidirectional light, such as a light bulb or a candle. -- An Omnidirectional light is a type of @Light@ that emits light in all directions. The light is attenuated by distance and this attenuation can be configured by changing its energy, radius, and attenuation parameters. newtype OmniLight = OmniLight Object deriving newtype AsVariant instance HasBaseClass OmniLight where type BaseClass OmniLight = Light super = coerce newtype OpenSimplexNoise = OpenSimplexNoise Object deriving newtype AsVariant instance HasBaseClass OpenSimplexNoise where type BaseClass OpenSimplexNoise = Resource super = coerce -- | Button control that provides selectable options when pressed. -- OptionButton is a type button that provides a selectable list of items when pressed. The item selected becomes the "current" item and is displayed as the button text. newtype OptionButton = OptionButton Object deriving newtype AsVariant instance HasBaseClass OptionButton where type BaseClass OptionButton = Button super = coerce -- | Creates packages that can be loaded into a running project. -- The @PCKPacker@ is used to create packages that can be loaded into a running project using @method ProjectSettings.load_resource_pack@. -- -- @ -- -- var packer = PCKPacker.new() -- packer.pck_start("test.pck") -- packer.add_file("res://text.txt", "text.txt") -- packer.flush() -- -- @ -- -- The above @PCKPacker@ creates package @test.pck@, then adds a file named @text.txt@ at the root of the package. newtype PCKPacker = PCKPacker Object deriving newtype AsVariant instance HasBaseClass PCKPacker where type BaseClass PCKPacker = Reference super = coerce -- | Optimized translation. -- Uses real-time compressed translations, which results in very small dictionaries. newtype PHashTranslation = PHashTranslation Object deriving newtype AsVariant instance HasBaseClass PHashTranslation where type BaseClass PHashTranslation = Translation super = coerce newtype PackedDataContainer = PackedDataContainer Object deriving newtype AsVariant instance HasBaseClass PackedDataContainer where type BaseClass PackedDataContainer = Resource super = coerce -- | Reference version of @PackedDataContainer@. newtype PackedDataContainerRef = PackedDataContainerRef Object deriving newtype AsVariant instance HasBaseClass PackedDataContainerRef where type BaseClass PackedDataContainerRef = Reference super = coerce -- | An abstraction of a serialized scene. -- A simplified interface to a scene file. Provides access to operations and checks that can be performed on the scene resource itself. -- Can be used to save a node to a file. When saving, the node as well as all the node it owns get saved (see @owner@ property on @Node@). -- __Note:__ The node doesn't need to own itself. -- __Example of loading a saved scene:__ -- -- @ -- -- # Use `load()` instead of `preload()` if the path isn't known at compile-time. -- var scene = preload("res://scene.tscn").instance() -- # Add the node as a child of the node the script is attached to. -- add_child(scene) -- -- @ -- -- __Example of saving a node with different owners:__ The following example creates 3 objects: @Node2D@ (@node@), @RigidBody2D@ (@rigid@) and @CollisionObject2D@ (@collision@). @collision@ is a child of @rigid@ which is a child of @node@. Only @rigid@ is owned by @node@ and @pack@ will therefore only save those two nodes, but not @collision@. -- -- @ -- -- # Create the objects. -- var node = Node2D.new() -- var rigid = RigidBody2D.new() -- var collision = CollisionShape2D.new() -- -- # Create the object hierarchy. -- rigid.add_child(collision) -- node.add_child(rigid) -- -- # Change owner of `rigid`, but not of `collision`. -- rigid.owner = node -- -- var scene = PackedScene.new() -- # Only `node` and `rigid` are now packed. -- var result = scene.pack(node) -- if result == OK: -- var error = ResourceSaver.save("res://path/name.scn", scene) # Or "user://..." -- if error != OK: -- push_error("An error occurred while saving the scene to disk.") -- -- @ newtype PackedScene = PackedScene Object deriving newtype AsVariant instance HasBaseClass PackedScene where type BaseClass PackedScene = Resource super = coerce -- | Abstraction and base class for packet-based protocols. -- PacketPeer is an abstraction and base class for packet-based protocols (such as UDP). It provides an API for sending and receiving packets both as raw data or variables. This makes it easy to transfer data over a protocol, without having to encode data as low-level bytes or having to worry about network ordering. newtype PacketPeer = PacketPeer Object deriving newtype AsVariant instance HasBaseClass PacketPeer where type BaseClass PacketPeer = Reference super = coerce newtype PacketPeerGDNative = PacketPeerGDNative Object deriving newtype AsVariant instance HasBaseClass PacketPeerGDNative where type BaseClass PacketPeerGDNative = PacketPeer super = coerce -- | Wrapper to use a PacketPeer over a StreamPeer. -- PacketStreamPeer provides a wrapper for working using packets over a stream. This allows for using packet based code with StreamPeers. PacketPeerStream implements a custom protocol over the StreamPeer, so the user should not read or write to the wrapped StreamPeer directly. newtype PacketPeerStream = PacketPeerStream Object deriving newtype AsVariant instance HasBaseClass PacketPeerStream where type BaseClass PacketPeerStream = PacketPeer super = coerce -- | UDP packet peer. -- Can be used to send raw UDP packets as well as @Variant@s. newtype PacketPeerUDP = PacketPeerUDP Object deriving newtype AsVariant instance HasBaseClass PacketPeerUDP where type BaseClass PacketPeerUDP = PacketPeer super = coerce -- | Provides an opaque background for @Control@ children. -- Panel is a @Control@ that displays an opaque background. It's commonly used as a parent and container for other types of @Control@ nodes. newtype Panel = Panel Object deriving newtype AsVariant instance HasBaseClass Panel where type BaseClass Panel = Control super = coerce -- | Panel container type. -- This container fits controls inside of the delimited area of a stylebox. It's useful for giving controls an outline. newtype PanelContainer = PanelContainer Object deriving newtype AsVariant instance HasBaseClass PanelContainer where type BaseClass PanelContainer = Container super = coerce -- | A type of @Sky@ used to draw a background texture. -- A resource referenced in an @Environment@ that is used to draw a background. The Panorama sky functions similar to skyboxes in other engines, except it uses an equirectangular sky map instead of a cube map. -- Using an HDR panorama is strongly recommended for accurate, high-quality reflections. Godot supports the Radiance HDR (@.hdr@) and OpenEXR (@.exr@) image formats for this purpose. -- You can use @url=https://danilw.github.io/GLSL-howto/cubemap_to_panorama_js/cubemap_to_panorama.html@this tool@/url@ to convert a cube map to an equirectangular sky map. newtype PanoramaSky = PanoramaSky Object deriving newtype AsVariant instance HasBaseClass PanoramaSky where type BaseClass PanoramaSky = Sky super = coerce -- | A node used to create a parallax scrolling background. -- A ParallaxBackground uses one or more @ParallaxLayer@ child nodes to create a parallax effect. Each @ParallaxLayer@ can move at a different speed using @ParallaxLayer.motion_offset@. This creates an illusion of depth in a 2D game. If not used with a @Camera2D@, you must manually calculate the @scroll_offset@. newtype ParallaxBackground = ParallaxBackground Object deriving newtype AsVariant instance HasBaseClass ParallaxBackground where type BaseClass ParallaxBackground = CanvasLayer super = coerce -- | A parallax scrolling layer to be used with @ParallaxBackground@. -- A ParallaxLayer must be the child of a @ParallaxBackground@ node. Each ParallaxLayer can be set to move at different speeds relative to the camera movement or the @ParallaxBackground.scroll_offset@ value. -- This node's children will be affected by its scroll offset. -- __Note:__ Any changes to this node's position and scale made after it enters the scene will be ignored. newtype ParallaxLayer = ParallaxLayer Object deriving newtype AsVariant instance HasBaseClass ParallaxLayer where type BaseClass ParallaxLayer = Node2D super = coerce -- | 3D particle emitter. -- 3D particle node used to create a variety of particle systems and effects. @Particles@ features an emitter that generates some number of particles at a given rate. -- Use the @process_material@ property to add a @ParticlesMaterial@ to configure particle appearance and behavior. Alternatively, you can add a @ShaderMaterial@ which will be applied to all particles. newtype Particles = Particles Object deriving newtype AsVariant instance HasBaseClass Particles where type BaseClass Particles = GeometryInstance super = coerce -- | 2D particle emitter. -- 2D particle node used to create a variety of particle systems and effects. @Particles2D@ features an emitter that generates some number of particles at a given rate. -- Use the @process_material@ property to add a @ParticlesMaterial@ to configure particle appearance and behavior. Alternatively, you can add a @ShaderMaterial@ which will be applied to all particles. newtype Particles2D = Particles2D Object deriving newtype AsVariant instance HasBaseClass Particles2D where type BaseClass Particles2D = Node2D super = coerce -- | Particle properties for @Particles@ and @Particles2D@ nodes. -- ParticlesMaterial defines particle properties and behavior. It is used in the @process_material@ of @Particles@ and @Particles2D@ emitter nodes. -- Some of this material's properties are applied to each particle when emitted, while others can have a @CurveTexture@ applied to vary values over the lifetime of the particle. -- When a randomness ratio is applied to a property it is used to scale that property by a random amount. The random ratio is used to interpolate between @1.0@ and a random number less than one, the result is multiplied by the property to obtain the randomized property. For example a random ratio of @0.4@ would scale the original property between @0.4-1.0@ of its original value. newtype ParticlesMaterial = ParticlesMaterial Object deriving newtype AsVariant instance HasBaseClass ParticlesMaterial where type BaseClass ParticlesMaterial = Material super = coerce -- | Contains a @Curve3D@ path for @PathFollow@ nodes to follow. -- Can have @PathFollow@ child nodes moving along the @Curve3D@. See @PathFollow@ for more information on the usage. -- Note that the path is considered as relative to the moved nodes (children of @PathFollow@). As such, the curve should usually start with a zero vector @(0, 0, 0)@. newtype Path = Path Object deriving newtype AsVariant instance HasBaseClass Path where type BaseClass Path = Spatial super = coerce -- | Contains a @Curve2D@ path for @PathFollow2D@ nodes to follow. -- Can have @PathFollow2D@ child nodes moving along the @Curve2D@. See @PathFollow2D@ for more information on usage. -- __Note:__ The path is considered as relative to the moved nodes (children of @PathFollow2D@). As such, the curve should usually start with a zero vector (@(0, 0)@). newtype Path2D = Path2D Object deriving newtype AsVariant instance HasBaseClass Path2D where type BaseClass Path2D = Node2D super = coerce -- | Point sampler for a @Path@. -- This node takes its parent @Path@, and returns the coordinates of a point within it, given a distance from the first vertex. -- It is useful for making other nodes follow a path, without coding the movement pattern. For that, the nodes must be children of this node. The descendant nodes will then move accordingly when setting an offset in this node. newtype PathFollow = PathFollow Object deriving newtype AsVariant instance HasBaseClass PathFollow where type BaseClass PathFollow = Spatial super = coerce -- | Point sampler for a @Path2D@. -- This node takes its parent @Path2D@, and returns the coordinates of a point within it, given a distance from the first vertex. -- It is useful for making other nodes follow a path, without coding the movement pattern. For that, the nodes must be children of this node. The descendant nodes will then move accordingly when setting an offset in this node. newtype PathFollow2D = PathFollow2D Object deriving newtype AsVariant instance HasBaseClass PathFollow2D where type BaseClass PathFollow2D = Node2D super = coerce -- | Exposes performance-related data. -- This class provides access to a number of different monitors related to performance, such as memory usage, draw calls, and FPS. These are the same as the values displayed in the __Monitor__ tab in the editor's __Debugger__ panel. By using the @method get_monitor@ method of this class, you can access this data from your code. -- __Note:__ A few of these monitors are only available in debug mode and will always return 0 when used in a release build. -- __Note:__ Many of these monitors are not updated in real-time, so there may be a short delay between changes. newtype Performance = Performance Object deriving newtype AsVariant instance HasBaseClass Performance where type BaseClass Performance = Object super = coerce newtype PhysicalBone = PhysicalBone Object deriving newtype AsVariant instance HasBaseClass PhysicalBone where type BaseClass PhysicalBone = PhysicsBody super = coerce -- | Direct access object to a physics body in the @Physics2DServer@. -- Provides direct access to a physics body in the @Physics2DServer@, allowing safe changes to physics properties. This object is passed via the direct state callback of rigid/character bodies, and is intended for changing the direct state of that body. See @method RigidBody2D._integrate_forces@. newtype Physics2DDirectBodyState = Physics2DDirectBodyState Object deriving newtype AsVariant instance HasBaseClass Physics2DDirectBodyState where type BaseClass Physics2DDirectBodyState = Object super = coerce newtype Physics2DDirectBodyStateSW = Physics2DDirectBodyStateSW Object deriving newtype AsVariant instance HasBaseClass Physics2DDirectBodyStateSW where type BaseClass Physics2DDirectBodyStateSW = Physics2DDirectBodyState super = coerce -- | Direct access object to a space in the @Physics2DServer@. -- It's used mainly to do queries against objects and areas residing in a given space. newtype Physics2DDirectSpaceState = Physics2DDirectSpaceState Object deriving newtype AsVariant instance HasBaseClass Physics2DDirectSpaceState where type BaseClass Physics2DDirectSpaceState = Object super = coerce -- | Server interface for low-level 2D physics access. -- Physics2DServer is the server responsible for all 2D physics. It can create many kinds of physics objects, but does not insert them on the node tree. newtype Physics2DServer = Physics2DServer Object deriving newtype AsVariant instance HasBaseClass Physics2DServer where type BaseClass Physics2DServer = Object super = coerce newtype Physics2DServerSW = Physics2DServerSW Object deriving newtype AsVariant instance HasBaseClass Physics2DServerSW where type BaseClass Physics2DServerSW = Physics2DServer super = coerce -- | Parameters to be sent to a 2D shape physics query. -- This class contains the shape and other parameters for 2D intersection/collision queries. See also @Physics2DShapeQueryResult@. newtype Physics2DShapeQueryParameters = Physics2DShapeQueryParameters Object deriving newtype AsVariant instance HasBaseClass Physics2DShapeQueryParameters where type BaseClass Physics2DShapeQueryParameters = Reference super = coerce -- | Result of a 2D shape query in @Physics2DServer@. -- The result of a 2D shape query in @Physics2DServer@. See also @Physics2DShapeQueryParameters@. newtype Physics2DShapeQueryResult = Physics2DShapeQueryResult Object deriving newtype AsVariant instance HasBaseClass Physics2DShapeQueryResult where type BaseClass Physics2DShapeQueryResult = Reference super = coerce newtype Physics2DTestMotionResult = Physics2DTestMotionResult Object deriving newtype AsVariant instance HasBaseClass Physics2DTestMotionResult where type BaseClass Physics2DTestMotionResult = Reference super = coerce -- | Base class for all objects affected by physics in 3D space. -- PhysicsBody is an abstract base class for implementing a physics body. All *Body types inherit from it. newtype PhysicsBody = PhysicsBody Object deriving newtype AsVariant instance HasBaseClass PhysicsBody where type BaseClass PhysicsBody = CollisionObject super = coerce -- | Base class for all objects affected by physics in 2D space. -- PhysicsBody2D is an abstract base class for implementing a physics body. All *Body2D types inherit from it. newtype PhysicsBody2D = PhysicsBody2D Object deriving newtype AsVariant instance HasBaseClass PhysicsBody2D where type BaseClass PhysicsBody2D = CollisionObject2D super = coerce -- | Direct access object to a physics body in the @PhysicsServer@. -- Provides direct access to a physics body in the @PhysicsServer@, allowing safe changes to physics properties. This object is passed via the direct state callback of rigid/character bodies, and is intended for changing the direct state of that body. See @method RigidBody._integrate_forces@. newtype PhysicsDirectBodyState = PhysicsDirectBodyState Object deriving newtype AsVariant instance HasBaseClass PhysicsDirectBodyState where type BaseClass PhysicsDirectBodyState = Object super = coerce -- | Direct access object to a space in the @PhysicsServer@. -- It's used mainly to do queries against objects and areas residing in a given space. newtype PhysicsDirectSpaceState = PhysicsDirectSpaceState Object deriving newtype AsVariant instance HasBaseClass PhysicsDirectSpaceState where type BaseClass PhysicsDirectSpaceState = Object super = coerce -- | A material for physics properties. -- Provides a means of modifying the collision properties of a @PhysicsBody@. newtype PhysicsMaterial = PhysicsMaterial Object deriving newtype AsVariant instance HasBaseClass PhysicsMaterial where type BaseClass PhysicsMaterial = Resource super = coerce -- | Server interface for low-level physics access. -- PhysicsServer is the server responsible for all 3D physics. It can create many kinds of physics objects, but does not insert them on the node tree. newtype PhysicsServer = PhysicsServer Object deriving newtype AsVariant instance HasBaseClass PhysicsServer where type BaseClass PhysicsServer = Object super = coerce -- | Parameters to be sent to a 3D shape physics query. -- This class contains the shape and other parameters for 3D intersection/collision queries. See also @PhysicsShapeQueryResult@. newtype PhysicsShapeQueryParameters = PhysicsShapeQueryParameters Object deriving newtype AsVariant instance HasBaseClass PhysicsShapeQueryParameters where type BaseClass PhysicsShapeQueryParameters = Reference super = coerce -- | Result of a 3D shape query in @PhysicsServer@. -- The result of a 3D shape query in @PhysicsServer@. See also @PhysicsShapeQueryParameters@. newtype PhysicsShapeQueryResult = PhysicsShapeQueryResult Object deriving newtype AsVariant instance HasBaseClass PhysicsShapeQueryResult where type BaseClass PhysicsShapeQueryResult = Reference super = coerce -- | Pin joint for 3D shapes. -- Pin joint for 3D rigid bodies. It pins 2 bodies (rigid or static) together. newtype PinJoint = PinJoint Object deriving newtype AsVariant instance HasBaseClass PinJoint where type BaseClass PinJoint = Joint super = coerce -- | Pin Joint for 2D shapes. -- Pin Joint for 2D rigid bodies. It pins two bodies (rigid or static) together. newtype PinJoint2D = PinJoint2D Object deriving newtype AsVariant instance HasBaseClass PinJoint2D where type BaseClass PinJoint2D = Joint2D super = coerce -- | Class representing a planar @PrimitiveMesh@. -- This flat mesh does not have a thickness. By default, this mesh is aligned on the X and Z axes; this default rotation isn't suited for use with billboarded materials. For billboarded materials, use @QuadMesh@ instead. newtype PlaneMesh = PlaneMesh Object deriving newtype AsVariant instance HasBaseClass PlaneMesh where type BaseClass PlaneMesh = PrimitiveMesh super = coerce -- | Infinite plane shape for 3D collisions. -- An infinite plane shape for 3D collisions. Note that the @Plane@'s normal matters; anything "below" the plane will collide with it. If the @PlaneShape@ is used in a @PhysicsBody@, it will cause colliding objects placed "below" it to teleport "above" the plane. newtype PlaneShape = PlaneShape Object deriving newtype AsVariant instance HasBaseClass PlaneShape where type BaseClass PlaneShape = Shape super = coerce newtype PluginScript = PluginScript Object deriving newtype AsVariant instance HasBaseClass PluginScript where type BaseClass PluginScript = Script super = coerce -- | Mesh with a single Point primitive. -- The PointMesh is made from a single point. Instead of relying on triangles, points are rendered as a single rectangle on the screen with a constant size. They are intended to be used with Particle systems, but can be used as a cheap way to render constant size billboarded sprites (for example in a point cloud). -- PointMeshes, must be used with a material that has a point size. Point size can be accessed in a shader with @POINT_SIZE@, or in a @SpatialMaterial@ by setting @SpatialMaterial.flags_use_point_size@ and the variable @SpatialMaterial.params_point_size@. -- When using PointMeshes, properties that normally alter vertices will be ignored, including billboard mode, grow, and cull face. newtype PointMesh = PointMesh Object deriving newtype AsVariant instance HasBaseClass PointMesh where type BaseClass PointMesh = PrimitiveMesh super = coerce -- | A 2D polygon. -- A Polygon2D is defined by a set of points. Each point is connected to the next, with the final point being connected to the first, resulting in a closed polygon. Polygon2Ds can be filled with color (solid or gradient) or filled with a given texture. -- __Note:__ By default, Godot can only draw up to 4,096 polygon points at a time. To increase this limit, open the Project Settings and increase @ProjectSettings.rendering/limits/buffers/canvas_polygon_buffer_size_kb@ and @ProjectSettings.rendering/limits/buffers/canvas_polygon_index_buffer_size_kb@. newtype Polygon2D = Polygon2D Object deriving newtype AsVariant instance HasBaseClass Polygon2D where type BaseClass Polygon2D = Node2D super = coerce newtype PolygonPathFinder = PolygonPathFinder Object deriving newtype AsVariant instance HasBaseClass PolygonPathFinder where type BaseClass PolygonPathFinder = Resource super = coerce -- | Base container control for popups and dialogs. -- Popup is a base @Control@ used to show dialogs and popups. It's a subwindow and modal by default (see @Control@) and has helpers for custom popup behavior. All popup methods ensure correct placement within the viewport. newtype Popup = Popup Object deriving newtype AsVariant instance HasBaseClass Popup where type BaseClass Popup = Control super = coerce -- | Base class for popup dialogs. -- PopupDialog is a base class for popup dialogs, along with @WindowDialog@. newtype PopupDialog = PopupDialog Object deriving newtype AsVariant instance HasBaseClass PopupDialog where type BaseClass PopupDialog = Popup super = coerce -- | PopupMenu displays a list of options. -- @PopupMenu@ is a @Control@ that displays a list of options. They are popular in toolbars or context menus. newtype PopupMenu = PopupMenu Object deriving newtype AsVariant instance HasBaseClass PopupMenu where type BaseClass PopupMenu = Popup super = coerce -- | Class for displaying popups with a panel background. -- In some cases it might be simpler to use than @Popup@, since it provides a configurable background. If you are making windows, better check @WindowDialog@. newtype PopupPanel = PopupPanel Object deriving newtype AsVariant instance HasBaseClass PopupPanel where type BaseClass PopupPanel = Popup super = coerce -- | Generic 2D position hint for editing. -- It's just like a plain @Node2D@, but it displays as a cross in the 2D editor at all times. You can set cross' visual size by using the gizmo in the 2D editor while the node is selected. newtype Position2D = Position2D Object deriving newtype AsVariant instance HasBaseClass Position2D where type BaseClass Position2D = Node2D super = coerce -- | Generic 3D position hint for editing. -- It's just like a plain @Spatial@, but it displays as a cross in the 3D editor at all times. newtype Position3D = Position3D Object deriving newtype AsVariant instance HasBaseClass Position3D where type BaseClass Position3D = Spatial super = coerce -- | Base class for all primitive meshes. Handles applying a @Material@ to a primitive mesh. -- Examples include @CapsuleMesh@, @CubeMesh@, @CylinderMesh@, @PlaneMesh@, @PrismMesh@, @QuadMesh@, and @SphereMesh@. newtype PrimitiveMesh = PrimitiveMesh Object deriving newtype AsVariant instance HasBaseClass PrimitiveMesh where type BaseClass PrimitiveMesh = Mesh super = coerce -- | Class representing a prism-shaped @PrimitiveMesh@. newtype PrismMesh = PrismMesh Object deriving newtype AsVariant instance HasBaseClass PrismMesh where type BaseClass PrismMesh = PrimitiveMesh super = coerce -- | Type of @Sky@ that is generated procedurally based on user input parameters. -- ProceduralSky provides a way to create an effective background quickly by defining procedural parameters for the sun, the sky and the ground. The sky and ground are very similar, they are defined by a color at the horizon, another color, and finally an easing curve to interpolate between these two colors. Similarly, the sun is described by a position in the sky, a color, and an easing curve. However, the sun also defines a minimum and maximum angle, these two values define at what distance the easing curve begins and ends from the sun, and thus end up defining the size of the sun in the sky. -- The ProceduralSky is updated on the CPU after the parameters change. It is stored in a texture and then displayed as a background in the scene. This makes it relatively unsuitable for real-time updates during gameplay. However, with a small enough texture size, it can still be updated relatively frequently, as it is updated on a background thread when multi-threading is available. newtype ProceduralSky = ProceduralSky Object deriving newtype AsVariant instance HasBaseClass ProceduralSky where type BaseClass ProceduralSky = Sky super = coerce -- | General-purpose progress bar. -- Shows fill percentage from right to left. newtype ProgressBar = ProgressBar Object deriving newtype AsVariant instance HasBaseClass ProgressBar where type BaseClass ProgressBar = Range super = coerce -- | Contains global variables accessible from everywhere. -- Use @method get_setting@, @method set_setting@ or @method has_setting@ to access them. Variables stored in @project.godot@ are also loaded into ProjectSettings, making this object very useful for reading custom game configuration options. -- When naming a Project Settings property, use the full path to the setting including the category. For example, @"application/config/name"@ for the project name. Category and property names can be viewed in the Project Settings dialog. -- __Overriding:__ Any project setting can be overridden by creating a file named @override.cfg@ in the project's root directory. This can also be used in exported projects by placing this file in the same directory as the project binary. newtype ProjectSettings = ProjectSettings Object deriving newtype AsVariant instance HasBaseClass ProjectSettings where type BaseClass ProjectSettings = Object super = coerce -- | General-purpose proximity detection node. newtype ProximityGroup = ProximityGroup Object deriving newtype AsVariant instance HasBaseClass ProximityGroup where type BaseClass ProximityGroup = Spatial super = coerce newtype ProxyTexture = ProxyTexture Object deriving newtype AsVariant instance HasBaseClass ProxyTexture where type BaseClass ProxyTexture = Texture super = coerce -- | Class representing a square mesh. -- Class representing a square @PrimitiveMesh@. This flat mesh does not have a thickness. By default, this mesh is aligned on the X and Y axes; this default rotation is more suited for use with billboarded materials. Unlike @PlaneMesh@, this mesh doesn't provide subdivision options. newtype QuadMesh = QuadMesh Object deriving newtype AsVariant instance HasBaseClass QuadMesh where type BaseClass QuadMesh = PrimitiveMesh super = coerce -- | A class for generating pseudo-random numbers. -- RandomNumberGenerator is a class for generating pseudo-random numbers. It currently uses @url=http://www.pcg-random.org/@PCG32@/url@. -- __Note:__ The underlying algorithm is an implementation detail. As a result, it should not be depended upon for reproducible random streams across Godot versions. -- To generate a random float number (within a given range) based on a time-dependant seed: -- -- @ -- -- var rng = RandomNumberGenerator.new() -- func _ready(): -- rng.randomize() -- var my_random_number = rng.randf_range(-10.0, 10.0) -- -- @ newtype RandomNumberGenerator = RandomNumberGenerator Object deriving newtype AsVariant instance HasBaseClass RandomNumberGenerator where type BaseClass RandomNumberGenerator = Reference super = coerce -- | Abstract base class for range-based controls. -- Range is a base class for @Control@ nodes that change a floating-point @i@value@/i@ between a @i@minimum@/i@ and a @i@maximum@/i@, using @i@step@/i@ and @i@page@/i@, for example a @ScrollBar@. newtype Range = Range Object deriving newtype AsVariant instance HasBaseClass Range where type BaseClass Range = Control super = coerce -- | Query the closest object intersecting a ray. -- A RayCast represents a line from its origin to its destination position, @cast_to@. It is used to query the 3D space in order to find the closest object along the path of the ray. -- RayCast can ignore some objects by adding them to the exception list via @add_exception@ or by setting proper filtering with collision layers and masks. -- RayCast can be configured to report collisions with @Area@s (@collide_with_areas@) and/or @PhysicsBody@s (@collide_with_bodies@). -- Only enabled raycasts will be able to query the space and report collisions. -- RayCast calculates intersection every physics frame (see @Node@), and the result is cached so it can be used later until the next frame. If multiple queries are required between physics frames (or during the same frame), use @method force_raycast_update@ after adjusting the raycast. newtype RayCast = RayCast Object deriving newtype AsVariant instance HasBaseClass RayCast where type BaseClass RayCast = Spatial super = coerce -- | Query the closest object intersecting a ray. -- A RayCast represents a line from its origin to its destination position, @cast_to@. It is used to query the 2D space in order to find the closest object along the path of the ray. -- RayCast2D can ignore some objects by adding them to the exception list via @add_exception@, by setting proper filtering with collision layers, or by filtering object types with type masks. -- RayCast2D can be configured to report collisions with @Area2D@s (@collide_with_areas@) and/or @PhysicsBody2D@s (@collide_with_bodies@). -- Only enabled raycasts will be able to query the space and report collisions. -- RayCast2D calculates intersection every physics frame (see @Node@), and the result is cached so it can be used later until the next frame. If multiple queries are required between physics frames (or during the same frame) use @method force_raycast_update@ after adjusting the raycast. newtype RayCast2D = RayCast2D Object deriving newtype AsVariant instance HasBaseClass RayCast2D where type BaseClass RayCast2D = Node2D super = coerce -- | Ray shape for 3D collisions. -- Ray shape for 3D collisions, which can be set into a @PhysicsBody@ or @Area@. A ray is not really a collision body; instead, it tries to separate itself from whatever is touching its far endpoint. It's often useful for characters. newtype RayShape = RayShape Object deriving newtype AsVariant instance HasBaseClass RayShape where type BaseClass RayShape = Shape super = coerce -- | Ray shape for 2D collisions. -- A ray is not really a collision body; instead, it tries to separate itself from whatever is touching its far endpoint. It's often useful for characters. newtype RayShape2D = RayShape2D Object deriving newtype AsVariant instance HasBaseClass RayShape2D where type BaseClass RayShape2D = Shape2D super = coerce -- | Rectangle shape for 2D collisions. -- This shape is useful for modeling box-like 2D objects. newtype RectangleShape2D = RectangleShape2D Object deriving newtype AsVariant instance HasBaseClass RectangleShape2D where type BaseClass RectangleShape2D = Shape2D super = coerce -- | Base class for reference-counted objects. -- Base class for any object that keeps a reference count. @Resource@ and many other helper objects inherit this class. -- Unlike @Object@s, References keep an internal reference counter so that they are automatically released when no longer in use, and only then. References therefore do not need to be freed manually with @method Object.free@. -- In the vast majority of use cases, instantiating and using @Reference@-derived types is all you need to do. The methods provided in this class are only for advanced users, and can cause issues if misused. newtype Reference = Reference Object deriving newtype AsVariant instance HasBaseClass Reference where type BaseClass Reference = Object super = coerce -- | Reference frame for GUI. -- A rectangle box that displays only a @border_color@ border color around its rectangle. @ReferenceRect@ has no fill @Color@. newtype ReferenceRect = ReferenceRect Object deriving newtype AsVariant instance HasBaseClass ReferenceRect where type BaseClass ReferenceRect = Control super = coerce -- | Captures its surroundings to create reflections. -- Capture its surroundings as a dual paraboloid image, and stores versions of it with increasing levels of blur to simulate different material roughnesses. -- The @ReflectionProbe@ is used to create high-quality reflections at the cost of performance. It can be combined with @GIProbe@s and Screen Space Reflections to achieve high quality reflections. @ReflectionProbe@s render all objects within their @cull_mask@, so updating them can be quite expensive. It is best to update them once with the important static objects and then leave them. -- Note: By default Godot will only render 16 reflection probes. If you need more, increase the number of atlas subdivisions. This setting can be found in @ProjectSettings.rendering/quality/reflections/atlas_subdiv@. newtype ReflectionProbe = ReflectionProbe Object deriving newtype AsVariant instance HasBaseClass ReflectionProbe where type BaseClass ReflectionProbe = VisualInstance super = coerce newtype RegEx = RegEx Object deriving newtype AsVariant instance HasBaseClass RegEx where type BaseClass RegEx = Reference super = coerce newtype RegExMatch = RegExMatch Object deriving newtype AsVariant instance HasBaseClass RegExMatch where type BaseClass RegExMatch = Reference super = coerce -- | RemoteTransform pushes its own @Transform@ to another @Spatial@ derived Node in the scene. -- RemoteTransform pushes its own @Transform@ to another @Spatial@ derived Node (called the remote node) in the scene. -- It can be set to update another Node's position, rotation and/or scale. It can use either global or local coordinates. newtype RemoteTransform = RemoteTransform Object deriving newtype AsVariant instance HasBaseClass RemoteTransform where type BaseClass RemoteTransform = Spatial super = coerce -- | RemoteTransform2D pushes its own @Transform2D@ to another @CanvasItem@ derived Node in the scene. -- RemoteTransform2D pushes its own @Transform2D@ to another @CanvasItem@ derived Node (called the remote node) in the scene. -- It can be set to update another Node's position, rotation and/or scale. It can use either global or local coordinates. newtype RemoteTransform2D = RemoteTransform2D Object deriving newtype AsVariant instance HasBaseClass RemoteTransform2D where type BaseClass RemoteTransform2D = Node2D super = coerce -- | Base class for all resources. -- Resource is the base class for all Godot-specific resource types, serving primarily as data containers. Unlike @Object@s, they are reference-counted and freed when no longer in use. They are also cached once loaded from disk, so that any further attempts to load a resource from a given path will return the same reference (all this in contrast to a @Node@, which is not reference-counted and can be instanced from disk as many times as desired). Resources can be saved externally on disk or bundled into another object, such as a @Node@ or another resource. newtype Resource = Resource Object deriving newtype AsVariant instance HasBaseClass Resource where type BaseClass Resource = Reference super = coerce -- | Loads a specific resource type from a file. -- Godot loads resources in the editor or in exported games using ResourceFormatLoaders. They are queried automatically via the @ResourceLoader@ singleton, or when a resource with internal dependencies is loaded. Each file type may load as a different resource type, so multiple ResourceFormatLoaders are registered in the engine. -- Extending this class allows you to define your own loader. Be sure to respect the documented return types and values. You should give it a global class name with @class_name@ for it to be registered. Like built-in ResourceFormatLoaders, it will be called automatically when loading resources of its handled type(s). You may also implement a @ResourceFormatSaver@. -- __Note:__ You can also extend @EditorImportPlugin@ if the resource type you need exists but Godot is unable to load its format. Choosing one way over another depends if the format is suitable or not for the final exported game. For example, it's better to import @.png@ textures as @.stex@ (@StreamTexture@) first, so they can be loaded with better efficiency on the graphics card. newtype ResourceFormatLoader = ResourceFormatLoader Object deriving newtype AsVariant instance HasBaseClass ResourceFormatLoader where type BaseClass ResourceFormatLoader = Reference super = coerce newtype ResourceFormatLoaderCrypto = ResourceFormatLoaderCrypto Object deriving newtype AsVariant instance HasBaseClass ResourceFormatLoaderCrypto where type BaseClass ResourceFormatLoaderCrypto = ResourceFormatLoader super = coerce -- | Saves a specific resource type to a file. -- The engine can save resources when you do it from the editor, or when you use the @ResourceSaver@ singleton. This is accomplished thanks to multiple @ResourceFormatSaver@s, each handling its own format and called automatically by the engine. -- By default, Godot saves resources as @.tres@ (text-based), @.res@ (binary) or another built-in format, but you can choose to create your own format by extending this class. Be sure to respect the documented return types and values. You should give it a global class name with @class_name@ for it to be registered. Like built-in ResourceFormatSavers, it will be called automatically when saving resources of its recognized type(s). You may also implement a @ResourceFormatLoader@. newtype ResourceFormatSaver = ResourceFormatSaver Object deriving newtype AsVariant instance HasBaseClass ResourceFormatSaver where type BaseClass ResourceFormatSaver = Reference super = coerce newtype ResourceFormatSaverCrypto = ResourceFormatSaverCrypto Object deriving newtype AsVariant instance HasBaseClass ResourceFormatSaverCrypto where type BaseClass ResourceFormatSaverCrypto = ResourceFormatSaver super = coerce newtype ResourceImporter = ResourceImporter Object deriving newtype AsVariant instance HasBaseClass ResourceImporter where type BaseClass ResourceImporter = Reference super = coerce -- | Interactive @Resource@ loader. -- This object is returned by @ResourceLoader@ when performing an interactive load. It allows loading resources with high granularity, which makes it mainly useful for displaying loading bars or percentages. newtype ResourceInteractiveLoader = ResourceInteractiveLoader Object deriving newtype AsVariant instance HasBaseClass ResourceInteractiveLoader where type BaseClass ResourceInteractiveLoader = Reference super = coerce -- | Resource Preloader Node. -- This node is used to preload sub-resources inside a scene, so when the scene is loaded, all the resources are ready to use and can be retrieved from the preloader. -- GDScript has a simplified @method @GDScript.preload@ built-in method which can be used in most situations, leaving the use of @ResourcePreloader@ for more advanced scenarios. newtype ResourcePreloader = ResourcePreloader Object deriving newtype AsVariant instance HasBaseClass ResourcePreloader where type BaseClass ResourcePreloader = Node super = coerce -- | A custom effect for use with @RichTextLabel@. -- -- __Note:__ For a @RichTextEffect@ to be usable, a BBCode tag must be defined as a member variable called @bbcode@ in the script. -- -- @ -- -- # The RichTextEffect will be usable like this: `@example@Some text@/example@` -- var bbcode = "example" -- -- @ -- -- __Note:__ As soon as a @RichTextLabel@ contains at least one @RichTextEffect@, it will continuously process the effect unless the project is paused. This may impact battery life negatively. newtype RichTextEffect = RichTextEffect Object deriving newtype AsVariant instance HasBaseClass RichTextEffect where type BaseClass RichTextEffect = Resource super = coerce -- | Label that displays rich text. -- Rich text can contain custom text, fonts, images and some basic formatting. The label manages these as an internal tag stack. It also adapts itself to given width/heights. -- __Note:__ Assignments to @bbcode_text@ clear the tag stack and reconstruct it from the property's contents. Any edits made to @bbcode_text@ will erase previous edits made from other manual sources such as @method append_bbcode@ and the @push_*@ / @method pop@ methods. -- __Note:__ Unlike @Label@, RichTextLabel doesn't have a @i@property@/i@ to horizontally align text to the center. Instead, enable @bbcode_enabled@ and surround the text in a @@center@@ tag as follows: @@center@Example@/center@@. There is currently no built-in way to vertically align text either, but this can be emulated by relying on anchors/containers and the @fit_content_height@ property. newtype RichTextLabel = RichTextLabel Object deriving newtype AsVariant instance HasBaseClass RichTextLabel where type BaseClass RichTextLabel = Control super = coerce -- | Physics Body whose position is determined through physics simulation in 3D space. -- This is the node that implements full 3D physics. This means that you do not control a RigidBody directly. Instead, you can apply forces to it (gravity, impulses, etc.), and the physics simulation will calculate the resulting movement, collision, bouncing, rotating, etc. -- A RigidBody has 4 behavior @mode@s: Rigid, Static, Character, and Kinematic. -- __Note:__ Don't change a RigidBody's position every frame or very often. Sporadic changes work fine, but physics runs at a different granularity (fixed Hz) than usual rendering (process callback) and maybe even in a separate thread, so changing this from a process loop may result in strange behavior. If you need to directly affect the body's state, use @method _integrate_forces@, which allows you to directly access the physics state. -- If you need to override the default physics behavior, you can write a custom force integration function. See @custom_integrator@. -- With Bullet physics (the default), the center of mass is the RigidBody3D center. With GodotPhysics, the center of mass is the average of the @CollisionShape@ centers. newtype RigidBody = RigidBody Object deriving newtype AsVariant instance HasBaseClass RigidBody where type BaseClass RigidBody = PhysicsBody super = coerce -- | A body that is controlled by the 2D physics engine. -- This node implements simulated 2D physics. You do not control a RigidBody2D directly. Instead you apply forces to it (gravity, impulses, etc.) and the physics simulation calculates the resulting movement based on its mass, friction, and other physical properties. -- A RigidBody2D has 4 behavior @mode@s: Rigid, Static, Character, and Kinematic. -- __Note:__ You should not change a RigidBody2D's @position@ or @linear_velocity@ every frame or even very often. If you need to directly affect the body's state, use @method _integrate_forces@, which allows you to directly access the physics state. -- Please also keep in mind that physics bodies manage their own transform which overwrites the ones you set. So any direct or indirect transformation (including scaling of the node or its parent) will be visible in the editor only, and immediately reset at runtime. -- If you need to override the default physics behavior or add a transformation at runtime, you can write a custom force integration. See @custom_integrator@. -- The center of mass is always located at the node's origin without taking into account the @CollisionShape2D@ centroid offsets. newtype RigidBody2D = RigidBody2D Object deriving newtype AsVariant instance HasBaseClass RigidBody2D where type BaseClass RigidBody2D = PhysicsBody2D super = coerce newtype RootMotionView = RootMotionView Object deriving newtype AsVariant instance HasBaseClass RootMotionView where type BaseClass RootMotionView = VisualInstance super = coerce -- | A script interface to a scene file's data. -- Maintains a list of resources, nodes, exported, and overridden properties, and built-in scripts associated with a scene. -- This class cannot be instantiated directly, it is retrieved for a given scene as the result of @method PackedScene.get_state@. newtype SceneState = SceneState Object deriving newtype AsVariant instance HasBaseClass SceneState where type BaseClass SceneState = Reference super = coerce -- | Manages the game loop via a hierarchy of nodes. -- As one of the most important classes, the @SceneTree@ manages the hierarchy of nodes in a scene as well as scenes themselves. Nodes can be added, retrieved and removed. The whole scene tree (and thus the current scene) can be paused. Scenes can be loaded, switched and reloaded. -- You can also use the @SceneTree@ to organize your nodes into groups: every node can be assigned as many groups as you want to create, e.g. a "enemy" group. You can then iterate these groups or even call methods and set properties on all the group's members at once. -- @SceneTree@ is the default @MainLoop@ implementation used by scenes, and is thus in charge of the game loop. newtype SceneTree = SceneTree Object deriving newtype AsVariant instance HasBaseClass SceneTree where type BaseClass SceneTree = MainLoop super = coerce -- | One-shot timer. -- A one-shot timer managed by the scene tree, which emits @signal timeout@ on completion. See also @method SceneTree.create_timer@. -- As opposed to @Timer@, it does not require the instantiation of a node. Commonly used to create a one-shot delay timer as in the following example: -- -- @ -- -- func some_function(): -- print("Timer started.") -- yield(get_tree().create_timer(1.0), "timeout") -- print("Timer ended.") -- -- @ newtype SceneTreeTimer = SceneTreeTimer Object deriving newtype AsVariant instance HasBaseClass SceneTreeTimer where type BaseClass SceneTreeTimer = Reference super = coerce -- | A class stored as a resource. -- A script extends the functionality of all objects that instance it. -- The @new@ method of a script subclass creates a new instance. @method Object.set_script@ extends an existing object, if that object's class matches one of the script's base classes. newtype Script = Script Object deriving newtype AsVariant instance HasBaseClass Script where type BaseClass Script = Resource super = coerce -- | The Editor's popup dialog for creating new @Script@ files. -- The @ScriptCreateDialog@ creates script files according to a given template for a given scripting language. The standard use is to configure its fields prior to calling one of the @method Popup.popup@ methods. -- -- @ -- -- func _ready(): -- dialog.config("Node", "res://new_node.gd") # For in-engine types -- dialog.config("\"res://base_node.gd\"", "res://derived_node.gd") # For script types -- dialog.popup_centered() -- -- @ newtype ScriptCreateDialog = ScriptCreateDialog Object deriving newtype AsVariant instance HasBaseClass ScriptCreateDialog where type BaseClass ScriptCreateDialog = ConfirmationDialog super = coerce -- | Godot editor's script editor. -- __Note:__ This class shouldn't be instantiated directly. Instead, access the singleton using @method EditorInterface.get_script_editor@. newtype ScriptEditor = ScriptEditor Object deriving newtype AsVariant instance HasBaseClass ScriptEditor where type BaseClass ScriptEditor = PanelContainer super = coerce -- | Base class for scroll bars. -- Scrollbars are a @Range@-based @Control@, that display a draggable area (the size of the page). Horizontal (@HScrollBar@) and Vertical (@VScrollBar@) versions are available. newtype ScrollBar = ScrollBar Object deriving newtype AsVariant instance HasBaseClass ScrollBar where type BaseClass ScrollBar = Range super = coerce -- | A helper node for displaying scrollable elements such as lists. -- A ScrollContainer node meant to contain a @Control@ child. ScrollContainers will automatically create a scrollbar child (@HScrollBar@, @VScrollBar@, or both) when needed and will only draw the Control within the ScrollContainer area. Scrollbars will automatically be drawn at the right (for vertical) or bottom (for horizontal) and will enable dragging to move the viewable Control (and its children) within the ScrollContainer. Scrollbars will also automatically resize the grabber based on the @Control.rect_min_size@ of the Control relative to the ScrollContainer. Works great with a @Panel@ control. You can set @EXPAND@ on the children's size flags, so they will upscale to the ScrollContainer's size if it's larger (scroll is invisible for the chosen dimension). newtype ScrollContainer = ScrollContainer Object deriving newtype AsVariant instance HasBaseClass ScrollContainer where type BaseClass ScrollContainer = Container super = coerce -- | Segment shape for 2D collisions. -- Consists of two points, @a@ and @b@. newtype SegmentShape2D = SegmentShape2D Object deriving newtype AsVariant instance HasBaseClass SegmentShape2D where type BaseClass SegmentShape2D = Shape2D super = coerce -- | Base class for separators. -- Separator is a @Control@ used for separating other controls. It's purely a visual decoration. Horizontal (@HSeparator@) and Vertical (@VSeparator@) versions are available. newtype Separator = Separator Object deriving newtype AsVariant instance HasBaseClass Separator where type BaseClass Separator = Control super = coerce -- | A custom shader program. -- This class allows you to define a custom shader program that can be used by a @ShaderMaterial@. Shaders allow you to write your own custom behavior for rendering objects or updating particle information. For a detailed explanation and usage, please see the tutorials linked below. newtype Shader = Shader Object deriving newtype AsVariant instance HasBaseClass Shader where type BaseClass Shader = Resource super = coerce -- | A material that uses a custom @Shader@ program. -- A material that uses a custom @Shader@ program to render either items to screen or process particles. You can create multiple materials for the same shader but configure different values for the uniforms defined in the shader. newtype ShaderMaterial = ShaderMaterial Object deriving newtype AsVariant instance HasBaseClass ShaderMaterial where type BaseClass ShaderMaterial = Material super = coerce -- | Base class for all 3D shape resources. -- Nodes that inherit from this can be used as shapes for a @PhysicsBody@ or @Area@ objects. newtype Shape = Shape Object deriving newtype AsVariant instance HasBaseClass Shape where type BaseClass Shape = Resource super = coerce -- | Base class for all 2D shapes. -- All 2D shape types inherit from this. newtype Shape2D = Shape2D Object deriving newtype AsVariant instance HasBaseClass Shape2D where type BaseClass Shape2D = Resource super = coerce -- | A shortcut for binding input. -- -- Shortcuts are commonly used for interacting with a @Control@ element from a @InputEvent@. newtype ShortCut = ShortCut Object deriving newtype AsVariant instance HasBaseClass ShortCut where type BaseClass ShortCut = Resource super = coerce -- | Skeleton for characters and animated objects. -- Skeleton provides a hierarchical interface for managing bones, including pose, rest and animation (see @Animation@). It can also use ragdoll physics. -- The overall transform of a bone with respect to the skeleton is determined by the following hierarchical order: rest pose, custom pose and pose. -- Note that "global pose" below refers to the overall transform of the bone with respect to skeleton, so it not the actual global/world transform of the bone. newtype Skeleton = Skeleton Object deriving newtype AsVariant instance HasBaseClass Skeleton where type BaseClass Skeleton = Spatial super = coerce -- | Skeleton for 2D characters and animated objects. -- Skeleton2D parents a hierarchy of @Bone2D@ objects. It is a requirement of @Bone2D@. Skeleton2D holds a reference to the rest pose of its children and acts as a single point of access to its bones. newtype Skeleton2D = Skeleton2D Object deriving newtype AsVariant instance HasBaseClass Skeleton2D where type BaseClass Skeleton2D = Node2D super = coerce newtype SkeletonIK = SkeletonIK Object deriving newtype AsVariant instance HasBaseClass SkeletonIK where type BaseClass SkeletonIK = Node super = coerce newtype Skin = Skin Object deriving newtype AsVariant instance HasBaseClass Skin where type BaseClass Skin = Resource super = coerce newtype SkinReference = SkinReference Object deriving newtype AsVariant instance HasBaseClass SkinReference where type BaseClass SkinReference = Reference super = coerce -- | The base class for @PanoramaSky@ and @ProceduralSky@. newtype Sky = Sky Object deriving newtype AsVariant instance HasBaseClass Sky where type BaseClass Sky = Resource super = coerce -- | Base class for GUI sliders. -- -- __Note:__ The @signal Range.changed@ and @signal Range.value_changed@ signals are part of the @Range@ class which this class inherits from. newtype Slider = Slider Object deriving newtype AsVariant instance HasBaseClass Slider where type BaseClass Slider = Range super = coerce -- | Piston kind of slider between two bodies in 3D. -- Slides across the X axis of the pivot object. newtype SliderJoint = SliderJoint Object deriving newtype AsVariant instance HasBaseClass SliderJoint where type BaseClass SliderJoint = Joint super = coerce -- | A soft mesh physics body. -- A deformable physics body. Used to create elastic or deformable objects such as cloth, rubber, or other flexible materials. newtype SoftBody = SoftBody Object deriving newtype AsVariant instance HasBaseClass SoftBody where type BaseClass SoftBody = MeshInstance super = coerce -- | Most basic 3D game object, parent of all 3D-related nodes. -- Most basic 3D game object, with a 3D @Transform@ and visibility settings. All other 3D game objects inherit from Spatial. Use @Spatial@ as a parent node to move, scale, rotate and show/hide children in a 3D project. -- Affine operations (rotate, scale, translate) happen in parent's local coordinate system, unless the @Spatial@ object is set as top-level. Affine operations in this coordinate system correspond to direct affine operations on the @Spatial@'s transform. The word local below refers to this coordinate system. The coordinate system that is attached to the @Spatial@ object itself is referred to as object-local coordinate system. -- __Note:__ Unless otherwise specified, all methods that have angle parameters must have angles specified as @i@radians@/i@. To convert degrees to radians, use @method @GDScript.deg2rad@. newtype Spatial = Spatial Object deriving newtype AsVariant instance HasBaseClass Spatial where type BaseClass Spatial = Node super = coerce newtype SpatialGizmo = SpatialGizmo Object deriving newtype AsVariant instance HasBaseClass SpatialGizmo where type BaseClass SpatialGizmo = Reference super = coerce -- | Default 3D rendering material. -- This provides a default material with a wide variety of rendering features and properties without the need to write shader code. See the tutorial below for details. newtype SpatialMaterial = SpatialMaterial Object deriving newtype AsVariant instance HasBaseClass SpatialMaterial where type BaseClass SpatialMaterial = Material super = coerce newtype SpatialVelocityTracker = SpatialVelocityTracker Object deriving newtype AsVariant instance HasBaseClass SpatialVelocityTracker where type BaseClass SpatialVelocityTracker = Reference super = coerce -- | Class representing a spherical @PrimitiveMesh@. newtype SphereMesh = SphereMesh Object deriving newtype AsVariant instance HasBaseClass SphereMesh where type BaseClass SphereMesh = PrimitiveMesh super = coerce -- | Sphere shape for 3D collisions. -- Sphere shape for 3D collisions, which can be set into a @PhysicsBody@ or @Area@. This shape is useful for modeling sphere-like 3D objects. newtype SphereShape = SphereShape Object deriving newtype AsVariant instance HasBaseClass SphereShape where type BaseClass SphereShape = Shape super = coerce -- | Numerical input text field. -- SpinBox is a numerical input text field. It allows entering integers and floats. -- __Example:__ -- -- @ -- -- var spin_box = SpinBox.new() -- add_child(spin_box) -- var line_edit = spin_box.get_line_edit() -- line_edit.context_menu_enabled = false -- spin_box.align = LineEdit.ALIGN_RIGHT -- -- @ -- -- The above code will create a @SpinBox@, disable context menu on it and set the text alignment to right. -- See @Range@ class for more options over the @SpinBox@. newtype SpinBox = SpinBox Object deriving newtype AsVariant instance HasBaseClass SpinBox where type BaseClass SpinBox = Range super = coerce -- | Container for splitting and adjusting. -- Container for splitting two @Control@s vertically or horizontally, with a grabber that allows adjusting the split offset or ratio. newtype SplitContainer = SplitContainer Object deriving newtype AsVariant instance HasBaseClass SplitContainer where type BaseClass SplitContainer = Container super = coerce -- | A spotlight, such as a reflector spotlight or a lantern. -- A Spotlight is a type of @Light@ node that emits lights in a specific direction, in the shape of a cone. The light is attenuated through the distance. This attenuation can be configured by changing the energy, radius and attenuation parameters of @Light@. newtype SpotLight = SpotLight Object deriving newtype AsVariant instance HasBaseClass SpotLight where type BaseClass SpotLight = Light super = coerce -- | A helper node, mostly used in 3rd person cameras. -- The SpringArm node is a node that casts a ray (or collision shape) along its z axis and moves all its direct children to the collision point, minus a margin. -- The most common use case for this is to make a 3rd person camera that reacts to collisions in the environment. -- The SpringArm will either cast a ray, or if a shape is given, it will cast the shape in the direction of its z axis. -- If you use the SpringArm as a camera controller for your player, you might need to exclude the player's collider from the SpringArm's collision check. newtype SpringArm = SpringArm Object deriving newtype AsVariant instance HasBaseClass SpringArm where type BaseClass SpringArm = Spatial super = coerce -- | General-purpose sprite node. -- A node that displays a 2D texture. The texture displayed can be a region from a larger atlas texture, or a frame from a sprite sheet animation. newtype Sprite = Sprite Object deriving newtype AsVariant instance HasBaseClass Sprite where type BaseClass Sprite = Node2D super = coerce -- | 2D sprite node in a 3D world. -- A node that displays a 2D texture in a 3D environment. The texture displayed can be a region from a larger atlas texture, or a frame from a sprite sheet animation. newtype Sprite3D = Sprite3D Object deriving newtype AsVariant instance HasBaseClass Sprite3D where type BaseClass Sprite3D = SpriteBase3D super = coerce -- | 2D sprite node in 3D environment. -- A node that displays 2D texture information in a 3D environment. newtype SpriteBase3D = SpriteBase3D Object deriving newtype AsVariant instance HasBaseClass SpriteBase3D where type BaseClass SpriteBase3D = GeometryInstance super = coerce -- | Sprite frame library for AnimatedSprite. -- Sprite frame library for @AnimatedSprite@. Contains frames and animation data for playback. -- __Note:__ You can associate a set of normal maps by creating additional @SpriteFrames@ resources with a @_normal@ suffix. For example, having 2 @SpriteFrames@ resources @run@ and @run_normal@ will make it so the @run@ animation uses the normal map. newtype SpriteFrames = SpriteFrames Object deriving newtype AsVariant instance HasBaseClass SpriteFrames where type BaseClass SpriteFrames = Resource super = coerce -- | Static body for 3D physics. -- A static body is a simple body that is not intended to move. In contrast to @RigidBody@, they don't consume any CPU resources as long as they don't move. -- Additionally, a constant linear or angular velocity can be set for the static body, so even if it doesn't move, it affects other bodies as if it was moving (this is useful for simulating conveyor belts or conveyor wheels). newtype StaticBody = StaticBody Object deriving newtype AsVariant instance HasBaseClass StaticBody where type BaseClass StaticBody = PhysicsBody super = coerce -- | Static body for 2D physics. -- A StaticBody2D is a body that is not intended to move. It is ideal for implementing objects in the environment, such as walls or platforms. -- Additionally, a constant linear or angular velocity can be set for the static body, which will affect colliding bodies as if it were moving (for example, a conveyor belt). newtype StaticBody2D = StaticBody2D Object deriving newtype AsVariant instance HasBaseClass StaticBody2D where type BaseClass StaticBody2D = PhysicsBody2D super = coerce -- | Abstraction and base class for stream-based protocols. -- StreamPeer is an abstraction and base class for stream-based protocols (such as TCP or UNIX sockets). It provides an API for sending and receiving data through streams as raw data or strings. newtype StreamPeer = StreamPeer Object deriving newtype AsVariant instance HasBaseClass StreamPeer where type BaseClass StreamPeer = Reference super = coerce newtype StreamPeerBuffer = StreamPeerBuffer Object deriving newtype AsVariant instance HasBaseClass StreamPeerBuffer where type BaseClass StreamPeerBuffer = StreamPeer super = coerce newtype StreamPeerGDNative = StreamPeerGDNative Object deriving newtype AsVariant instance HasBaseClass StreamPeerGDNative where type BaseClass StreamPeerGDNative = StreamPeer super = coerce -- | SSL stream peer. -- This object can be used to connect to an SSL server or accept a single SSL client connection. newtype StreamPeerSSL = StreamPeerSSL Object deriving newtype AsVariant instance HasBaseClass StreamPeerSSL where type BaseClass StreamPeerSSL = StreamPeer super = coerce -- | TCP stream peer. -- This object can be used to connect to TCP servers, or also is returned by a TCP server. newtype StreamPeerTCP = StreamPeerTCP Object deriving newtype AsVariant instance HasBaseClass StreamPeerTCP where type BaseClass StreamPeerTCP = StreamPeer super = coerce -- | A @.stex@ texture. -- A texture that is loaded from a @.stex@ file. newtype StreamTexture = StreamTexture Object deriving newtype AsVariant instance HasBaseClass StreamTexture where type BaseClass StreamTexture = Texture super = coerce -- | Base class for drawing stylized boxes for the UI. -- StyleBox is @Resource@ that provides an abstract base class for drawing stylized boxes for the UI. StyleBoxes are used for drawing the styles of buttons, line edit backgrounds, tree backgrounds, etc. and also for testing a transparency mask for pointer signals. If mask test fails on a StyleBox assigned as mask to a control, clicks and motion signals will go through it to the one below. newtype StyleBox = StyleBox Object deriving newtype AsVariant instance HasBaseClass StyleBox where type BaseClass StyleBox = Resource super = coerce -- | Empty stylebox (does not display anything). -- Empty stylebox (really does not display anything). newtype StyleBoxEmpty = StyleBoxEmpty Object deriving newtype AsVariant instance HasBaseClass StyleBoxEmpty where type BaseClass StyleBoxEmpty = StyleBox super = coerce -- | Customizable @StyleBox@ with a given set of parameters (no texture required). -- This @StyleBox@ can be used to achieve all kinds of looks without the need of a texture. Those properties are customizable: -- - Color -- - Border width (individual width for each border) -- - Rounded corners (individual radius for each corner) -- - Shadow (with blur and offset) -- Setting corner radius to high values is allowed. As soon as corners would overlap, the stylebox will switch to a relative system. Example: -- -- @ -- -- height = 30 -- corner_radius_top_left = 50 -- corner_radius_bottom_left = 100 -- -- @ -- -- The relative system now would take the 1:2 ratio of the two left corners to calculate the actual corner width. Both corners added will __never__ be more than the height. Result: -- -- @ -- -- corner_radius_top_left: 10 -- corner_radius_bottom_left: 20 -- -- @ newtype StyleBoxFlat = StyleBoxFlat Object deriving newtype AsVariant instance HasBaseClass StyleBoxFlat where type BaseClass StyleBoxFlat = StyleBox super = coerce -- | @StyleBox@ that displays a single line. -- @StyleBox@ that displays a single line of a given color and thickness. It can be used to draw things like separators. newtype StyleBoxLine = StyleBoxLine Object deriving newtype AsVariant instance HasBaseClass StyleBoxLine where type BaseClass StyleBoxLine = StyleBox super = coerce -- | Texture-based nine-patch @StyleBox@. -- Texture-based nine-patch @StyleBox@, in a way similar to @NinePatchRect@. This stylebox performs a 3×3 scaling of a texture, where only the center cell is fully stretched. This makes it possible to design bordered styles regardless of the stylebox's size. newtype StyleBoxTexture = StyleBoxTexture Object deriving newtype AsVariant instance HasBaseClass StyleBoxTexture where type BaseClass StyleBoxTexture = StyleBox super = coerce -- | Helper tool to create geometry. -- The @SurfaceTool@ is used to construct a @Mesh@ by specifying vertex attributes individually. It can be used to construct a @Mesh@ from a script. All properties except indices need to be added before calling @method add_vertex@. For example, to add vertex colors and UVs: -- -- @ -- -- var st = SurfaceTool.new() -- st.begin(Mesh.PRIMITIVE_TRIANGLES) -- st.add_color(Color(1, 0, 0)) -- st.add_uv(Vector2(0, 0)) -- st.add_vertex(Vector3(0, 0, 0)) -- -- @ -- -- The above @SurfaceTool@ now contains one vertex of a triangle which has a UV coordinate and a specified @Color@. If another vertex were added without calling @method add_uv@ or @method add_color@, then the last values would be used. -- Vertex attributes must be passed __before__ calling @method add_vertex@. Failure to do so will result in an error when committing the vertex information to a mesh. -- Additionally, the attributes used before the first vertex is added determine the format of the mesh. For example, if you only add UVs to the first vertex, you cannot add color to any of the subsequent vertices. -- See also @ArrayMesh@, @ImmediateGeometry@ and @MeshDataTool@ for procedural geometry generation. -- __Note:__ Godot uses clockwise @url=https://learnopengl.com/Advanced-OpenGL/Face-culling@winding order@/url@ for front faces of triangle primitive modes. newtype SurfaceTool = SurfaceTool Object deriving newtype AsVariant instance HasBaseClass SurfaceTool where type BaseClass SurfaceTool = Reference super = coerce -- | A TCP server. -- Listens to connections on a port and returns a @StreamPeerTCP@ when it gets an incoming connection. newtype TCP_Server = TCP_Server Object deriving newtype AsVariant instance HasBaseClass TCP_Server where type BaseClass TCP_Server = Reference super = coerce -- | Tabbed container. -- Sets the active tab's @visible@ property to the value @true@. Sets all other children's to @false@. -- Ignores non-@Control@ children. -- Individual tabs are always visible unless you use @method set_tab_disabled@ and @method set_tab_title@ to hide it. -- To hide only a tab's content, nest the content inside a child @Control@, so it receives the @TabContainer@'s visibility setting instead. newtype TabContainer = TabContainer Object deriving newtype AsVariant instance HasBaseClass TabContainer where type BaseClass TabContainer = Container super = coerce -- | Tabs control. -- Simple tabs control, similar to @TabContainer@ but is only in charge of drawing tabs, not interact with children. newtype Tabs = Tabs Object deriving newtype AsVariant instance HasBaseClass Tabs where type BaseClass Tabs = Control super = coerce -- | Multiline text editing control. -- TextEdit is meant for editing large, multiline text. It also has facilities for editing code, such as syntax highlighting support and multiple levels of undo/redo. newtype TextEdit = TextEdit Object deriving newtype AsVariant instance HasBaseClass TextEdit where type BaseClass TextEdit = Control super = coerce newtype TextFile = TextFile Object deriving newtype AsVariant instance HasBaseClass TextFile where type BaseClass TextFile = Resource super = coerce -- | Texture for 2D and 3D. -- A texture works by registering an image in the video hardware, which then can be used in 3D models or 2D @Sprite@ or GUI @Control@. -- Textures are often created by loading them from a file. See @method @GDScript.load@. -- @Texture@ is a base for other resources. It cannot be used directly. newtype Texture = Texture Object deriving newtype AsVariant instance HasBaseClass Texture where type BaseClass Texture = Resource super = coerce -- | Texture with 3 dimensions. -- Texture3D is a 3-dimensional texture that has a width, height, and depth. newtype Texture3D = Texture3D Object deriving newtype AsVariant instance HasBaseClass Texture3D where type BaseClass Texture3D = TextureLayered super = coerce -- | Array of textures stored in a single primitive. -- @TextureArray@s store an array of images in a single @Texture@ primitive. Each layer of the texture array has its own mipmap chain. This makes it is a good alternative to texture atlases. newtype TextureArray = TextureArray Object deriving newtype AsVariant instance HasBaseClass TextureArray where type BaseClass TextureArray = TextureLayered super = coerce -- | Texture-based button. Supports Pressed, Hover, Disabled and Focused states. -- @TextureButton@ has the same functionality as @Button@, except it uses sprites instead of Godot's @Theme@ resource. It is faster to create, but it doesn't support localization like more complex @Control@s. -- The "normal" state must contain a texture (@texture_normal@); other textures are optional. newtype TextureButton = TextureButton Object deriving newtype AsVariant instance HasBaseClass TextureButton where type BaseClass TextureButton = BaseButton super = coerce -- | Base class for 3D texture types. -- Base class for @Texture3D@ and @TextureArray@. Cannot be used directly, but contains all the functions necessary for accessing and using @Texture3D@ and @TextureArray@. Data is set on a per-layer basis. For @Texture3D@s, the layer sepcifies the depth or Z-index, they can be treated as a bunch of 2D slices. Similarly, for @TextureArray@s, the layer specifies the array layer. newtype TextureLayered = TextureLayered Object deriving newtype AsVariant instance HasBaseClass TextureLayered where type BaseClass TextureLayered = Resource super = coerce -- | Texture-based progress bar. Useful for loading screens and life or stamina bars. -- TextureProgress works like @ProgressBar@, but uses up to 3 textures instead of Godot's @Theme@ resource. It can be used to create horizontal, vertical and radial progress bars. newtype TextureProgress = TextureProgress Object deriving newtype AsVariant instance HasBaseClass TextureProgress where type BaseClass TextureProgress = Range super = coerce -- | Control for drawing textures. -- Used to draw icons and sprites in a user interface. The texture's placement can be controlled with the @stretch_mode@ property. It can scale, tile, or stay centered inside its bounding rectangle. -- __Note:__ You should enable @flip_v@ when using a TextureRect to display a @ViewportTexture@. Alternatively, you can enable @Viewport.render_target_v_flip@ on the Viewport. Otherwise, the image will appear upside down. newtype TextureRect = TextureRect Object deriving newtype AsVariant instance HasBaseClass TextureRect where type BaseClass TextureRect = Control super = coerce -- | Theme for controls. -- A theme for skinning controls. Controls can be skinned individually, but for complex applications, it's more practical to just create a global theme that defines everything. This theme can be applied to any @Control@; the Control and its children will automatically use it. -- Theme resources can alternatively be loaded by writing them in a @.theme@ file, see the documentation for more information. newtype Theme = Theme Object deriving newtype AsVariant instance HasBaseClass Theme where type BaseClass Theme = Resource super = coerce -- | Node for 2D tile-based maps. -- Tilemaps use a @TileSet@ which contain a list of tiles (textures plus optional collision, navigation, and/or occluder shapes) which are used to create grid-based maps. newtype TileMap = TileMap Object deriving newtype AsVariant instance HasBaseClass TileMap where type BaseClass TileMap = Node2D super = coerce -- | Tile library for tilemaps. -- A TileSet is a library of tiles for a @TileMap@. It contains a list of tiles, each consisting of a sprite and optional collision shapes. -- Tiles are referenced by a unique integer ID. newtype TileSet = TileSet Object deriving newtype AsVariant instance HasBaseClass TileSet where type BaseClass TileSet = Resource super = coerce -- | A countdown timer. -- Counts down a specified interval and emits a signal on reaching 0. Can be set to repeat or "one-shot" mode. -- __Note:__ To create an one-shot timer without instantiating a node, use @method SceneTree.create_timer@. newtype Timer = Timer Object deriving newtype AsVariant instance HasBaseClass Timer where type BaseClass Timer = Node super = coerce -- | Flat button helper class. -- This is a helper class to generate a flat @Button@ (see @Button.flat@), creating a @ToolButton@ is equivalent to: -- -- @ -- -- var btn = Button.new() -- btn.flat = true -- -- @ newtype ToolButton = ToolButton Object deriving newtype AsVariant instance HasBaseClass ToolButton where type BaseClass ToolButton = Button super = coerce -- | Button for touch screen devices for gameplay use. -- TouchScreenButton allows you to create on-screen buttons for touch devices. It's intended for gameplay use, such as a unit you have to touch to move. -- This node inherits from @Node2D@. Unlike with @Control@ nodes, you cannot set anchors on it. If you want to create menus or user interfaces, you may want to use @Button@ nodes instead. To make button nodes react to touch events, you can enable the Emulate Mouse option in the Project Settings. -- You can configure TouchScreenButton to be visible only on touch devices, helping you develop your game both for desktop and mobile devices. newtype TouchScreenButton = TouchScreenButton Object deriving newtype AsVariant instance HasBaseClass TouchScreenButton where type BaseClass TouchScreenButton = Node2D super = coerce -- | Language Translation. -- Translations are resources that can be loaded and unloaded on demand. They map a string to another string. newtype Translation = Translation Object deriving newtype AsVariant instance HasBaseClass Translation where type BaseClass Translation = Resource super = coerce -- | Server that manages all translations. -- Translations can be set to it and removed from it. newtype TranslationServer = TranslationServer Object deriving newtype AsVariant instance HasBaseClass TranslationServer where type BaseClass TranslationServer = Object super = coerce -- | Control to show a tree of items. -- This shows a tree of items that can be selected, expanded and collapsed. The tree can have multiple columns with custom controls like text editing, buttons and popups. It can be useful for structured displays and interactions. -- Trees are built via code, using @TreeItem@ objects to create the structure. They have a single root but multiple roots can be simulated if a dummy hidden root is added. -- -- @ -- -- func _ready(): -- var tree = Tree.new() -- var root = tree.create_item() -- tree.set_hide_root(true) -- var child1 = tree.create_item(root) -- var child2 = tree.create_item(root) -- var subchild1 = tree.create_item(child1) -- subchild1.set_text(0, "Subchild1") -- -- @ -- -- To iterate over all the @TreeItem@ objects in a @Tree@ object, use @method TreeItem.get_next@ and @method TreeItem.get_children@ after getting the root through @method get_root@. You can use @method Object.free@ on a @TreeItem@ to remove it from the @Tree@. newtype Tree = Tree Object deriving newtype AsVariant instance HasBaseClass Tree where type BaseClass Tree = Control super = coerce -- | Control for a single item inside a @Tree@. -- May have child @TreeItem@s and be styled as well as contain buttons. -- You can remove a @TreeItem@ by using @method Object.free@. newtype TreeItem = TreeItem Object deriving newtype AsVariant instance HasBaseClass TreeItem where type BaseClass TreeItem = Object super = coerce -- | Internal mesh type. -- Mesh type used internally for collision calculations. newtype TriangleMesh = TriangleMesh Object deriving newtype AsVariant instance HasBaseClass TriangleMesh where type BaseClass TriangleMesh = Reference super = coerce -- | Smoothly animates a node's properties over time. -- Tweens are useful for animations requiring a numerical property to be interpolated over a range of values. The name @i@tween@/i@ comes from @i@in-betweening@/i@, an animation technique where you specify @i@keyframes@/i@ and the computer interpolates the frames that appear between them. -- @Tween@ is more suited than @AnimationPlayer@ for animations where you don't know the final values in advance. For example, interpolating a dynamically-chosen camera zoom value is best done with a @Tween@ node; it would be difficult to do the same thing with an @AnimationPlayer@ node. -- Here is a brief usage example that makes a 2D node move smoothly between two positions: -- -- @ -- -- var tween = get_node("Tween") -- tween.interpolate_property($Node2D, "position", -- Vector2(0, 0), Vector2(100, 100), 1, -- Tween.TRANS_LINEAR, Tween.EASE_IN_OUT) -- tween.start() -- -- @ -- -- Many methods require a property name, such as @"position"@ above. You can find the correct property name by hovering over the property in the Inspector. You can also provide the components of a property directly by using @"property:component"@ (eg. @position:x@), where it would only apply to that particular component. -- Many of the methods accept @trans_type@ and @ease_type@. The first accepts an @enum TransitionType@ constant, and refers to the way the timing of the animation is handled (see @url=https://easings.net/@easings.net@/url@ for some examples). The second accepts an @enum EaseType@ constant, and controls where the @trans_type@ is applied to the interpolation (in the beginning, the end, or both). If you don't know which transition and easing to pick, you can try different @enum TransitionType@ constants with @EASE_IN_OUT@, and use the one that looks best. -- @url=https://raw.githubusercontent.com/godotengine/godot-docs/master/img/tween_cheatsheet.png@Tween easing and transition types cheatsheet@/url@ newtype Tween = Tween Object deriving newtype AsVariant instance HasBaseClass Tween where type BaseClass Tween = Node super = coerce newtype UPNP = UPNP Object deriving newtype AsVariant instance HasBaseClass UPNP where type BaseClass UPNP = Reference super = coerce newtype UPNPDevice = UPNPDevice Object deriving newtype AsVariant instance HasBaseClass UPNPDevice where type BaseClass UPNPDevice = Reference super = coerce -- | Helper to manage undo/redo operations in the editor or custom tools. -- It works by registering methods and property changes inside "actions". -- Common behavior is to create an action, then add do/undo calls to functions or property changes, then committing the action. -- Here's an example on how to add an action to the Godot editor's own @UndoRedo@, from a plugin: -- -- @ -- -- var undo_redo = get_undo_redo() # Method of EditorPlugin. -- -- func do_something(): -- pass # Put your code here. -- -- func undo_something(): -- pass # Put here the code that reverts what's done by "do_something()". -- -- func _on_MyButton_pressed(): -- var node = get_node("MyNode2D") -- undo_redo.create_action("Move the node") -- undo_redo.add_do_method(self, "do_something") -- undo_redo.add_undo_method(self, "undo_something") -- undo_redo.add_do_property(node, "position", Vector2(100,100)) -- undo_redo.add_undo_property(node, "position", node.position) -- undo_redo.commit_action() -- -- @ -- -- @method create_action@, @method add_do_method@, @method add_undo_method@, @method add_do_property@, @method add_undo_property@, and @method commit_action@ should be called one after the other, like in the example. Not doing so could lead to crashes. -- If you don't need to register a method, you can leave @method add_do_method@ and @method add_undo_method@ out; the same goes for properties. You can also register more than one method/property. newtype UndoRedo = UndoRedo Object deriving newtype AsVariant instance HasBaseClass UndoRedo where type BaseClass UndoRedo = Object super = coerce -- | Vertical box container. -- See @BoxContainer@. newtype VBoxContainer = VBoxContainer Object deriving newtype AsVariant instance HasBaseClass VBoxContainer where type BaseClass VBoxContainer = BoxContainer super = coerce -- | Vertical scroll bar. -- Vertical version of @ScrollBar@, which goes from top (min) to bottom (max). newtype VScrollBar = VScrollBar Object deriving newtype AsVariant instance HasBaseClass VScrollBar where type BaseClass VScrollBar = ScrollBar super = coerce -- | Vertical version of @Separator@. -- Even though it looks vertical, it is used to separate objects horizontally. newtype VSeparator = VSeparator Object deriving newtype AsVariant instance HasBaseClass VSeparator where type BaseClass VSeparator = Separator super = coerce -- | Vertical slider. -- See @Slider@. This one goes from bottom (min) to top (max). -- __Note:__ The @signal Range.changed@ and @signal Range.value_changed@ signals are part of the @Range@ class which this class inherits from. newtype VSlider = VSlider Object deriving newtype AsVariant instance HasBaseClass VSlider where type BaseClass VSlider = Slider super = coerce -- | Vertical split container. -- See @SplitContainer@. This goes from top to bottom. newtype VSplitContainer = VSplitContainer Object deriving newtype AsVariant instance HasBaseClass VSplitContainer where type BaseClass VSplitContainer = SplitContainer super = coerce -- | Physics body that simulates the behavior of a car. -- This node implements all the physics logic needed to simulate a car. It is based on the raycast vehicle system commonly found in physics engines. You will need to add a @CollisionShape@ for the main body of your vehicle and add @VehicleWheel@ nodes for the wheels. You should also add a @MeshInstance@ to this node for the 3D model of your car but this model should not include meshes for the wheels. You should control the vehicle by using the @brake@, @engine_force@, and @steering@ properties and not change the position or orientation of this node directly. -- __Note:__ The origin point of your VehicleBody will determine the center of gravity of your vehicle so it is better to keep this low and move the @CollisionShape@ and @MeshInstance@ upwards. -- __Note:__ This class has known issues and isn't designed to provide realistic 3D vehicle physics. If you want advanced vehicle physics, you will probably have to write your own physics integration using another @PhysicsBody@ class. newtype VehicleBody = VehicleBody Object deriving newtype AsVariant instance HasBaseClass VehicleBody where type BaseClass VehicleBody = RigidBody super = coerce -- | Physics object that simulates the behavior of a wheel. -- This node needs to be used as a child node of @VehicleBody@ and simulates the behavior of one of its wheels. This node also acts as a collider to detect if the wheel is touching a surface. -- __Note:__ This class has known issues and isn't designed to provide realistic 3D vehicle physics. If you want advanced vehicle physics, you will probably have to write your own physics integration using another @PhysicsBody@ class. newtype VehicleWheel = VehicleWheel Object deriving newtype AsVariant instance HasBaseClass VehicleWheel where type BaseClass VehicleWheel = Spatial super = coerce -- | Control for playing video streams. -- Control node for playing video streams using @VideoStream@ resources. -- Supported video formats are @url=https://www.webmproject.org/@WebM@/url@ (@VideoStreamWebm@), @url=https://www.theora.org/@Ogg Theora@/url@ (@VideoStreamTheora@), and any format exposed via a GDNative plugin using @VideoStreamGDNative@. newtype VideoPlayer = VideoPlayer Object deriving newtype AsVariant instance HasBaseClass VideoPlayer where type BaseClass VideoPlayer = Control super = coerce -- | Base resource for video streams. -- Base resource type for all video streams. Classes that derive from @VideoStream@ can all be used as resource types to play back videos in @VideoPlayer@. newtype VideoStream = VideoStream Object deriving newtype AsVariant instance HasBaseClass VideoStream where type BaseClass VideoStream = Resource super = coerce newtype VideoStreamGDNative = VideoStreamGDNative Object deriving newtype AsVariant instance HasBaseClass VideoStreamGDNative where type BaseClass VideoStreamGDNative = VideoStream super = coerce newtype VideoStreamTheora = VideoStreamTheora Object deriving newtype AsVariant instance HasBaseClass VideoStreamTheora where type BaseClass VideoStreamTheora = VideoStream super = coerce newtype VideoStreamWebm = VideoStreamWebm Object deriving newtype AsVariant instance HasBaseClass VideoStreamWebm where type BaseClass VideoStreamWebm = VideoStream super = coerce -- | Creates a sub-view into the screen. -- A Viewport creates a different view into the screen, or a sub-view inside another viewport. Children 2D Nodes will display on it, and children Camera 3D nodes will render on it too. -- Optionally, a viewport can have its own 2D or 3D world, so they don't share what they draw with other viewports. -- If a viewport is a child of a @ViewportContainer@, it will automatically take up its size, otherwise it must be set manually. -- Viewports can also choose to be audio listeners, so they generate positional audio depending on a 2D or 3D camera child of it. -- Also, viewports can be assigned to different screens in case the devices have multiple screens. -- Finally, viewports can also behave as render targets, in which case they will not be visible unless the associated texture is used to draw. newtype Viewport = Viewport Object deriving newtype AsVariant instance HasBaseClass Viewport where type BaseClass Viewport = Node super = coerce -- | Control for holding @Viewport@s. -- A @Container@ node that holds a @Viewport@, automatically setting its size. -- __Note:__ Changing a ViewportContainer's @Control.rect_scale@ will cause its contents to appear distorted. To change its visual size without causing distortion, adjust the node's margins instead (if it's not already in a container). newtype ViewportContainer = ViewportContainer Object deriving newtype AsVariant instance HasBaseClass ViewportContainer where type BaseClass ViewportContainer = Container super = coerce -- | Texture which displays the content of a @Viewport@. -- Displays the content of a @Viewport@ node as a dynamic @Texture@. This can be used to mix controls, 2D, and 3D elements in the same scene. -- To create a ViewportTexture in code, use the @method Viewport.get_texture@ method on the target viewport. newtype ViewportTexture = ViewportTexture Object deriving newtype AsVariant instance HasBaseClass ViewportTexture where type BaseClass ViewportTexture = Texture super = coerce -- | Enables certain nodes only when approximately visible. -- The VisibilityEnabler will disable @RigidBody@ and @AnimationPlayer@ nodes when they are not visible. It will only affect other nodes within the same scene as the VisibilityEnabler itself. -- If you just want to receive notifications, use @VisibilityNotifier@ instead. -- __Note:__ VisibilityEnabler uses an approximate heuristic for performance reasons. It doesn't take walls and other occlusion into account. The heuristic is an implementation detail and may change in future versions. If you need precise visibility checking, use another method such as adding an @Area@ node as a child of a @Camera@ node and/or @method Vector3.dot@. -- __Note:__ VisibilityEnabler will not affect nodes added after scene initialization. newtype VisibilityEnabler = VisibilityEnabler Object deriving newtype AsVariant instance HasBaseClass VisibilityEnabler where type BaseClass VisibilityEnabler = VisibilityNotifier super = coerce -- | Enables certain nodes only when approximately visible. -- The VisibilityEnabler2D will disable @RigidBody2D@, @AnimationPlayer@, and other nodes when they are not visible. It will only affect nodes with the same root node as the VisibilityEnabler2D, and the root node itself. -- If you just want to receive notifications, use @VisibilityNotifier2D@ instead. -- __Note:__ For performance reasons, VisibilityEnabler2D uses an approximate heuristic with precision determined by @ProjectSettings.world/2d/cell_size@. If you need precise visibility checking, use another method such as adding an @Area2D@ node as a child of a @Camera2D@ node. -- __Note:__ VisibilityEnabler2D will not affect nodes added after scene initialization. newtype VisibilityEnabler2D = VisibilityEnabler2D Object deriving newtype AsVariant instance HasBaseClass VisibilityEnabler2D where type BaseClass VisibilityEnabler2D = VisibilityNotifier2D super = coerce -- | Detects approximately when the node is visible on screen. -- The VisibilityNotifier detects when it is visible on the screen. It also notifies when its bounding rectangle enters or exits the screen or a @Camera@'s view. -- If you want nodes to be disabled automatically when they exit the screen, use @VisibilityEnabler@ instead. -- __Note:__ VisibilityNotifier uses an approximate heuristic for performance reasons. It does't take walls and other occlusion into account. The heuristic is an implementation detail and may change in future versions. If you need precise visibility checking, use another method such as adding an @Area@ node as a child of a @Camera@ node and/or @method Vector3.dot@. newtype VisibilityNotifier = VisibilityNotifier Object deriving newtype AsVariant instance HasBaseClass VisibilityNotifier where type BaseClass VisibilityNotifier = Spatial super = coerce -- | Detects approximately when the node is visible on screen. -- The VisibilityNotifier2D detects when it is visible on the screen. It also notifies when its bounding rectangle enters or exits the screen or a viewport. -- If you want nodes to be disabled automatically when they exit the screen, use @VisibilityEnabler2D@ instead. -- __Note:__ For performance reasons, VisibilityNotifier2D uses an approximate heuristic with precision determined by @ProjectSettings.world/2d/cell_size@. If you need precise visibility checking, use another method such as adding an @Area2D@ node as a child of a @Camera2D@ node. newtype VisibilityNotifier2D = VisibilityNotifier2D Object deriving newtype AsVariant instance HasBaseClass VisibilityNotifier2D where type BaseClass VisibilityNotifier2D = Node2D super = coerce -- | Parent of all visual 3D nodes. -- The @VisualInstance@ is used to connect a resource to a visual representation. All visual 3D nodes inherit from the @VisualInstance@. In general, you should not access the @VisualInstance@ properties directly as they are accessed and managed by the nodes that inherit from @VisualInstance@. @VisualInstance@ is the node representation of the @VisualServer@ instance. newtype VisualInstance = VisualInstance Object deriving newtype AsVariant instance HasBaseClass VisualInstance where type BaseClass VisualInstance = Spatial super = coerce newtype VisualScript = VisualScript Object deriving newtype AsVariant instance HasBaseClass VisualScript where type BaseClass VisualScript = Script super = coerce newtype VisualScriptBasicTypeConstant = VisualScriptBasicTypeConstant Object deriving newtype AsVariant instance HasBaseClass VisualScriptBasicTypeConstant where type BaseClass VisualScriptBasicTypeConstant = VisualScriptNode super = coerce newtype VisualScriptBuiltinFunc = VisualScriptBuiltinFunc Object deriving newtype AsVariant instance HasBaseClass VisualScriptBuiltinFunc where type BaseClass VisualScriptBuiltinFunc = VisualScriptNode super = coerce newtype VisualScriptClassConstant = VisualScriptClassConstant Object deriving newtype AsVariant instance HasBaseClass VisualScriptClassConstant where type BaseClass VisualScriptClassConstant = VisualScriptNode super = coerce newtype VisualScriptComment = VisualScriptComment Object deriving newtype AsVariant instance HasBaseClass VisualScriptComment where type BaseClass VisualScriptComment = VisualScriptNode super = coerce newtype VisualScriptComposeArray = VisualScriptComposeArray Object deriving newtype AsVariant instance HasBaseClass VisualScriptComposeArray where type BaseClass VisualScriptComposeArray = VisualScriptLists super = coerce newtype VisualScriptCondition = VisualScriptCondition Object deriving newtype AsVariant instance HasBaseClass VisualScriptCondition where type BaseClass VisualScriptCondition = VisualScriptNode super = coerce newtype VisualScriptConstant = VisualScriptConstant Object deriving newtype AsVariant instance HasBaseClass VisualScriptConstant where type BaseClass VisualScriptConstant = VisualScriptNode super = coerce newtype VisualScriptConstructor = VisualScriptConstructor Object deriving newtype AsVariant instance HasBaseClass VisualScriptConstructor where type BaseClass VisualScriptConstructor = VisualScriptNode super = coerce newtype VisualScriptCustomNode = VisualScriptCustomNode Object deriving newtype AsVariant instance HasBaseClass VisualScriptCustomNode where type BaseClass VisualScriptCustomNode = VisualScriptNode super = coerce newtype VisualScriptDeconstruct = VisualScriptDeconstruct Object deriving newtype AsVariant instance HasBaseClass VisualScriptDeconstruct where type BaseClass VisualScriptDeconstruct = VisualScriptNode super = coerce newtype VisualScriptEmitSignal = VisualScriptEmitSignal Object deriving newtype AsVariant instance HasBaseClass VisualScriptEmitSignal where type BaseClass VisualScriptEmitSignal = VisualScriptNode super = coerce newtype VisualScriptEngineSingleton = VisualScriptEngineSingleton Object deriving newtype AsVariant instance HasBaseClass VisualScriptEngineSingleton where type BaseClass VisualScriptEngineSingleton = VisualScriptNode super = coerce newtype VisualScriptExpression = VisualScriptExpression Object deriving newtype AsVariant instance HasBaseClass VisualScriptExpression where type BaseClass VisualScriptExpression = VisualScriptNode super = coerce newtype VisualScriptFunction = VisualScriptFunction Object deriving newtype AsVariant instance HasBaseClass VisualScriptFunction where type BaseClass VisualScriptFunction = VisualScriptNode super = coerce newtype VisualScriptFunctionCall = VisualScriptFunctionCall Object deriving newtype AsVariant instance HasBaseClass VisualScriptFunctionCall where type BaseClass VisualScriptFunctionCall = VisualScriptNode super = coerce newtype VisualScriptFunctionState = VisualScriptFunctionState Object deriving newtype AsVariant instance HasBaseClass VisualScriptFunctionState where type BaseClass VisualScriptFunctionState = Reference super = coerce newtype VisualScriptGlobalConstant = VisualScriptGlobalConstant Object deriving newtype AsVariant instance HasBaseClass VisualScriptGlobalConstant where type BaseClass VisualScriptGlobalConstant = VisualScriptNode super = coerce newtype VisualScriptIndexGet = VisualScriptIndexGet Object deriving newtype AsVariant instance HasBaseClass VisualScriptIndexGet where type BaseClass VisualScriptIndexGet = VisualScriptNode super = coerce newtype VisualScriptIndexSet = VisualScriptIndexSet Object deriving newtype AsVariant instance HasBaseClass VisualScriptIndexSet where type BaseClass VisualScriptIndexSet = VisualScriptNode super = coerce newtype VisualScriptInputAction = VisualScriptInputAction Object deriving newtype AsVariant instance HasBaseClass VisualScriptInputAction where type BaseClass VisualScriptInputAction = VisualScriptNode super = coerce newtype VisualScriptIterator = VisualScriptIterator Object deriving newtype AsVariant instance HasBaseClass VisualScriptIterator where type BaseClass VisualScriptIterator = VisualScriptNode super = coerce newtype VisualScriptLists = VisualScriptLists Object deriving newtype AsVariant instance HasBaseClass VisualScriptLists where type BaseClass VisualScriptLists = VisualScriptNode super = coerce newtype VisualScriptLocalVar = VisualScriptLocalVar Object deriving newtype AsVariant instance HasBaseClass VisualScriptLocalVar where type BaseClass VisualScriptLocalVar = VisualScriptNode super = coerce newtype VisualScriptLocalVarSet = VisualScriptLocalVarSet Object deriving newtype AsVariant instance HasBaseClass VisualScriptLocalVarSet where type BaseClass VisualScriptLocalVarSet = VisualScriptNode super = coerce newtype VisualScriptMathConstant = VisualScriptMathConstant Object deriving newtype AsVariant instance HasBaseClass VisualScriptMathConstant where type BaseClass VisualScriptMathConstant = VisualScriptNode super = coerce newtype VisualScriptNode = VisualScriptNode Object deriving newtype AsVariant instance HasBaseClass VisualScriptNode where type BaseClass VisualScriptNode = Resource super = coerce newtype VisualScriptOperator = VisualScriptOperator Object deriving newtype AsVariant instance HasBaseClass VisualScriptOperator where type BaseClass VisualScriptOperator = VisualScriptNode super = coerce newtype VisualScriptPreload = VisualScriptPreload Object deriving newtype AsVariant instance HasBaseClass VisualScriptPreload where type BaseClass VisualScriptPreload = VisualScriptNode super = coerce newtype VisualScriptPropertyGet = VisualScriptPropertyGet Object deriving newtype AsVariant instance HasBaseClass VisualScriptPropertyGet where type BaseClass VisualScriptPropertyGet = VisualScriptNode super = coerce newtype VisualScriptPropertySet = VisualScriptPropertySet Object deriving newtype AsVariant instance HasBaseClass VisualScriptPropertySet where type BaseClass VisualScriptPropertySet = VisualScriptNode super = coerce newtype VisualScriptResourcePath = VisualScriptResourcePath Object deriving newtype AsVariant instance HasBaseClass VisualScriptResourcePath where type BaseClass VisualScriptResourcePath = VisualScriptNode super = coerce newtype VisualScriptReturn = VisualScriptReturn Object deriving newtype AsVariant instance HasBaseClass VisualScriptReturn where type BaseClass VisualScriptReturn = VisualScriptNode super = coerce newtype VisualScriptSceneNode = VisualScriptSceneNode Object deriving newtype AsVariant instance HasBaseClass VisualScriptSceneNode where type BaseClass VisualScriptSceneNode = VisualScriptNode super = coerce newtype VisualScriptSceneTree = VisualScriptSceneTree Object deriving newtype AsVariant instance HasBaseClass VisualScriptSceneTree where type BaseClass VisualScriptSceneTree = VisualScriptNode super = coerce newtype VisualScriptSelect = VisualScriptSelect Object deriving newtype AsVariant instance HasBaseClass VisualScriptSelect where type BaseClass VisualScriptSelect = VisualScriptNode super = coerce newtype VisualScriptSelf = VisualScriptSelf Object deriving newtype AsVariant instance HasBaseClass VisualScriptSelf where type BaseClass VisualScriptSelf = VisualScriptNode super = coerce newtype VisualScriptSequence = VisualScriptSequence Object deriving newtype AsVariant instance HasBaseClass VisualScriptSequence where type BaseClass VisualScriptSequence = VisualScriptNode super = coerce newtype VisualScriptSubCall = VisualScriptSubCall Object deriving newtype AsVariant instance HasBaseClass VisualScriptSubCall where type BaseClass VisualScriptSubCall = VisualScriptNode super = coerce newtype VisualScriptSwitch = VisualScriptSwitch Object deriving newtype AsVariant instance HasBaseClass VisualScriptSwitch where type BaseClass VisualScriptSwitch = VisualScriptNode super = coerce newtype VisualScriptTypeCast = VisualScriptTypeCast Object deriving newtype AsVariant instance HasBaseClass VisualScriptTypeCast where type BaseClass VisualScriptTypeCast = VisualScriptNode super = coerce newtype VisualScriptVariableGet = VisualScriptVariableGet Object deriving newtype AsVariant instance HasBaseClass VisualScriptVariableGet where type BaseClass VisualScriptVariableGet = VisualScriptNode super = coerce newtype VisualScriptVariableSet = VisualScriptVariableSet Object deriving newtype AsVariant instance HasBaseClass VisualScriptVariableSet where type BaseClass VisualScriptVariableSet = VisualScriptNode super = coerce newtype VisualScriptWhile = VisualScriptWhile Object deriving newtype AsVariant instance HasBaseClass VisualScriptWhile where type BaseClass VisualScriptWhile = VisualScriptNode super = coerce newtype VisualScriptYield = VisualScriptYield Object deriving newtype AsVariant instance HasBaseClass VisualScriptYield where type BaseClass VisualScriptYield = VisualScriptNode super = coerce newtype VisualScriptYieldSignal = VisualScriptYieldSignal Object deriving newtype AsVariant instance HasBaseClass VisualScriptYieldSignal where type BaseClass VisualScriptYieldSignal = VisualScriptNode super = coerce -- | Server for anything visible. -- The visual server is the API backend for everything visible. The whole scene system mounts on it to display. -- The visual server is completely opaque, the internals are entirely implementation specific and cannot be accessed. -- The visual server can be used to bypass the scene system entirely. -- Resources are created using the @*_create@ functions. -- All objects are drawn to a viewport. You can use the @Viewport@ attached to the @SceneTree@ or you can create one yourself with @method viewport_create@. When using a custom scenario or canvas, the scenario or canvas needs to be attached to the viewport using @method viewport_set_scenario@ or @method viewport_attach_canvas@. -- In 3D, all visual objects must be associated with a scenario. The scenario is a visual representation of the world. If accessing the visual server from a running game, the scenario can be accessed from the scene tree from any @Spatial@ node with @method Spatial.get_world@. Otherwise, a scenario can be created with @method scenario_create@. -- Similarly in 2D, a canvas is needed to draw all canvas items. -- In 3D, all visible objects are comprised of a resource and an instance. A resource can be a mesh, a particle system, a light, or any other 3D object. In order to be visible resources must be attached to an instance using @method instance_set_base@. The instance must also be attached to the scenario using @method instance_set_scenario@ in order to be visible. -- In 2D, all visible objects are some form of canvas item. In order to be visible, a canvas item needs to be the child of a canvas attached to a viewport, or it needs to be the child of another canvas item that is eventually attached to the canvas. newtype VisualServer = VisualServer Object deriving newtype AsVariant instance HasBaseClass VisualServer where type BaseClass VisualServer = Object super = coerce -- | A custom shader program with a visual editor. -- This class allows you to define a custom shader program that can be used for various materials to render objects. -- The visual shader editor creates the shader. newtype VisualShader = VisualShader Object deriving newtype AsVariant instance HasBaseClass VisualShader where type BaseClass VisualShader = Shader super = coerce -- | Base class for nodes in a visual shader graph. newtype VisualShaderNode = VisualShaderNode Object deriving newtype AsVariant instance HasBaseClass VisualShaderNode where type BaseClass VisualShaderNode = Resource super = coerce -- | A boolean constant to be used within the visual shader graph. -- Has only one output port and no inputs. -- Translated to @bool@ in the shader language. newtype VisualShaderNodeBooleanConstant = VisualShaderNodeBooleanConstant Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeBooleanConstant where type BaseClass VisualShaderNodeBooleanConstant = VisualShaderNode super = coerce -- | A boolean uniform to be used within the visual shader graph. -- Translated to @uniform bool@ in the shader language. newtype VisualShaderNodeBooleanUniform = VisualShaderNodeBooleanUniform Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeBooleanUniform where type BaseClass VisualShaderNodeBooleanUniform = VisualShaderNodeUniform super = coerce -- | A @Color@ constant to be used within the visual shader graph. -- Has two output ports representing RGB and alpha channels of @Color@. -- Translated to @vec3 rgb@ and @float alpha@ in the shader language. newtype VisualShaderNodeColorConstant = VisualShaderNodeColorConstant Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeColorConstant where type BaseClass VisualShaderNodeColorConstant = VisualShaderNode super = coerce -- | A @Color@ function to be used within the visual shader graph. -- Accept a @Color@ to the input port and transform it according to @function@. newtype VisualShaderNodeColorFunc = VisualShaderNodeColorFunc Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeColorFunc where type BaseClass VisualShaderNodeColorFunc = VisualShaderNode super = coerce -- | A @Color@ operator to be used within the visual shader graph. -- Applies @operator@ to two color inputs. newtype VisualShaderNodeColorOp = VisualShaderNodeColorOp Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeColorOp where type BaseClass VisualShaderNodeColorOp = VisualShaderNode super = coerce -- | A @Color@ uniform to be used within the visual shader graph. -- Translated to @uniform vec4@ in the shader language. newtype VisualShaderNodeColorUniform = VisualShaderNodeColorUniform Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeColorUniform where type BaseClass VisualShaderNodeColorUniform = VisualShaderNodeUniform super = coerce -- | A comparison function for common types within the visual shader graph. -- Compares @a@ and @b@ of @type@ by @function@. Returns a boolean scalar. Translates to @if@ instruction in shader code. newtype VisualShaderNodeCompare = VisualShaderNodeCompare Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeCompare where type BaseClass VisualShaderNodeCompare = VisualShaderNode super = coerce -- | A @CubeMap@ sampling node to be used within the visual shader graph. -- Translated to @texture(cubemap, vec3)@ in the shader language. Returns a color vector and alpha channel as scalar. newtype VisualShaderNodeCubeMap = VisualShaderNodeCubeMap Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeCubeMap where type BaseClass VisualShaderNodeCubeMap = VisualShaderNode super = coerce -- | A @CubeMap@ uniform node to be used within the visual shader graph. -- Translated to @uniform samplerCube@ in the shader language. The output value can be used as port for @VisualShaderNodeCubeMap@. newtype VisualShaderNodeCubeMapUniform = VisualShaderNodeCubeMapUniform Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeCubeMapUniform where type BaseClass VisualShaderNodeCubeMapUniform = VisualShaderNodeTextureUniform super = coerce -- | Virtual class to define custom @VisualShaderNode@s for use in the Visual Shader Editor. -- By inheriting this class you can create a custom @VisualShader@ script addon which will be automatically added to the Visual Shader Editor. The @VisualShaderNode@'s behavior is defined by overriding the provided virtual methods. -- In order for the node to be registered as an editor addon, you must use the @tool@ keyword and provide a @class_name@ for your custom script. For example: -- -- @ -- -- tool -- extends VisualShaderNodeCustom -- class_name VisualShaderNodeNoise -- -- @ newtype VisualShaderNodeCustom = VisualShaderNodeCustom Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeCustom where type BaseClass VisualShaderNodeCustom = VisualShaderNode super = coerce -- | Calculates the determinant of a @Transform@ within the visual shader graph. -- Translates to @deteminant(x)@ in the shader language. newtype VisualShaderNodeDeterminant = VisualShaderNodeDeterminant Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeDeterminant where type BaseClass VisualShaderNodeDeterminant = VisualShaderNode super = coerce -- | Calculates a dot product of two vectors within the visual shader graph. -- Translates to @dot(a, b)@ in the shader language. newtype VisualShaderNodeDotProduct = VisualShaderNodeDotProduct Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeDotProduct where type BaseClass VisualShaderNodeDotProduct = VisualShaderNode super = coerce -- | A custom visual shader graph expression written in Godot Shading Language. -- Custom Godot Shading Language expression, with a custom amount of input and output ports. -- The provided code is directly injected into the graph's matching shader function (@vertex@, @fragment@, or @light@), so it cannot be used to to declare functions, varyings, uniforms, or global constants. See @VisualShaderNodeGlobalExpression@ for such global definitions. newtype VisualShaderNodeExpression = VisualShaderNodeExpression Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeExpression where type BaseClass VisualShaderNodeExpression = VisualShaderNodeGroupBase super = coerce -- | Returns the vector that points in the same direction as a reference vector within the visual shader graph. -- Translates to @faceforward(N, I, Nref)@ in the shader language. The function has three vector parameters: @N@, the vector to orient, @I@, the incident vector, and @Nref@, the reference vector. If the dot product of @I@ and @Nref@ is smaller than zero the return value is @N@. Otherwise @-N@ is returned. newtype VisualShaderNodeFaceForward = VisualShaderNodeFaceForward Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeFaceForward where type BaseClass VisualShaderNodeFaceForward = VisualShaderNode super = coerce -- | A Fresnel effect to be used within the visual shader graph. -- Returns falloff based on the dot product of surface normal and view direction of camera (pass associated inputs to it). newtype VisualShaderNodeFresnel = VisualShaderNodeFresnel Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeFresnel where type BaseClass VisualShaderNodeFresnel = VisualShaderNode super = coerce -- | A custom global visual shader graph expression written in Godot Shading Language. -- Custom Godot Shader Language expression, which is placed on top of the generated shader. You can place various function definitions inside to call later in @VisualShaderNodeExpression@s (which are injected in the main shader functions). You can also declare varyings, uniforms and global constants. newtype VisualShaderNodeGlobalExpression = VisualShaderNodeGlobalExpression Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeGlobalExpression where type BaseClass VisualShaderNodeGlobalExpression = VisualShaderNodeExpression super = coerce -- | Base class for a family of nodes with variable amount of input and output ports within the visual shader graph. -- Currently, has no direct usage, use the derived classes instead. newtype VisualShaderNodeGroupBase = VisualShaderNodeGroupBase Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeGroupBase where type BaseClass VisualShaderNodeGroupBase = VisualShaderNode super = coerce newtype VisualShaderNodeIf = VisualShaderNodeIf Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeIf where type BaseClass VisualShaderNodeIf = VisualShaderNode super = coerce newtype VisualShaderNodeInput = VisualShaderNodeInput Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeInput where type BaseClass VisualShaderNodeInput = VisualShaderNode super = coerce -- | A boolean comparison operator to be used within the visual shader graph. -- Returns the boolean result of the comparison between @INF@ or @NaN@ and a scalar parameter. newtype VisualShaderNodeIs = VisualShaderNodeIs Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeIs where type BaseClass VisualShaderNodeIs = VisualShaderNode super = coerce -- | Calculates an outer product of two vectors within the visual shader graph. -- @OuterProduct@ treats the first parameter @c@ as a column vector (matrix with one column) and the second parameter @r@ as a row vector (matrix with one row) and does a linear algebraic matrix multiply @c * r@, yielding a matrix whose number of rows is the number of components in @c@ and whose number of columns is the number of components in @r@. newtype VisualShaderNodeOuterProduct = VisualShaderNodeOuterProduct Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeOuterProduct where type BaseClass VisualShaderNodeOuterProduct = VisualShaderNode super = coerce -- | Represents the output shader parameters within the visual shader graph. -- This visual shader node is present in all shader graphs in form of "Output" block with mutliple output value ports. newtype VisualShaderNodeOutput = VisualShaderNodeOutput Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeOutput where type BaseClass VisualShaderNodeOutput = VisualShaderNode super = coerce -- | Clamps a scalar value within the visual shader graph. -- Constrains a value to lie between @min@ and @max@ values. newtype VisualShaderNodeScalarClamp = VisualShaderNodeScalarClamp Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarClamp where type BaseClass VisualShaderNodeScalarClamp = VisualShaderNode super = coerce newtype VisualShaderNodeScalarConstant = VisualShaderNodeScalarConstant Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarConstant where type BaseClass VisualShaderNodeScalarConstant = VisualShaderNode super = coerce -- | Calculates a scalar derivative within the visual shader graph. -- This node is only available in @Fragment@ and @Light@ visual shaders. newtype VisualShaderNodeScalarDerivativeFunc = VisualShaderNodeScalarDerivativeFunc Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarDerivativeFunc where type BaseClass VisualShaderNodeScalarDerivativeFunc = VisualShaderNode super = coerce newtype VisualShaderNodeScalarFunc = VisualShaderNodeScalarFunc Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarFunc where type BaseClass VisualShaderNodeScalarFunc = VisualShaderNode super = coerce -- | Linearly interpolates between two scalars within the visual shader graph. -- Translates to @mix(a, b, weight)@ in the shader language. newtype VisualShaderNodeScalarInterp = VisualShaderNodeScalarInterp Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarInterp where type BaseClass VisualShaderNodeScalarInterp = VisualShaderNode super = coerce newtype VisualShaderNodeScalarOp = VisualShaderNodeScalarOp Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarOp where type BaseClass VisualShaderNodeScalarOp = VisualShaderNode super = coerce -- | Calculates a scalar SmoothStep function within the visual shader graph. -- Translates to @smoothstep(edge0, edge1, x)@ in the shader language. -- Returns @0.0@ if @x@ is smaller than @edge0@ and @1.0@ if @x@ is larger than @edge1@. Otherwise the return value is interpolated between @0.0@ and @1.0@ using Hermite polynomials. newtype VisualShaderNodeScalarSmoothStep = VisualShaderNodeScalarSmoothStep Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarSmoothStep where type BaseClass VisualShaderNodeScalarSmoothStep = VisualShaderNode super = coerce -- | A boolean/scalar function for use within the visual shader graph. -- Returns an associated scalar if the provided boolean value is @true@ or @false@. newtype VisualShaderNodeScalarSwitch = VisualShaderNodeScalarSwitch Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarSwitch where type BaseClass VisualShaderNodeScalarSwitch = VisualShaderNodeSwitch super = coerce newtype VisualShaderNodeScalarUniform = VisualShaderNodeScalarUniform Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeScalarUniform where type BaseClass VisualShaderNodeScalarUniform = VisualShaderNodeUniform super = coerce -- | A boolean/vector function for use within the visual shader graph. -- Returns an associated vector if the provided boolean value is @true@ or @false@. newtype VisualShaderNodeSwitch = VisualShaderNodeSwitch Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeSwitch where type BaseClass VisualShaderNodeSwitch = VisualShaderNode super = coerce -- | Performs a texture lookup within the visual shader graph. -- Performs a lookup operation on the provided texture, with support for multiple texture sources to choose from. newtype VisualShaderNodeTexture = VisualShaderNodeTexture Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTexture where type BaseClass VisualShaderNodeTexture = VisualShaderNode super = coerce -- | Performs a uniform texture lookup within the visual shader graph. -- Performs a lookup operation on the texture provided as a uniform for the shader. newtype VisualShaderNodeTextureUniform = VisualShaderNodeTextureUniform Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTextureUniform where type BaseClass VisualShaderNodeTextureUniform = VisualShaderNodeUniform super = coerce -- | Performs a uniform texture lookup with triplanar within the visual shader graph. -- Performs a lookup operation on the texture provided as a uniform for the shader, with support for triplanar mapping. newtype VisualShaderNodeTextureUniformTriplanar = VisualShaderNodeTextureUniformTriplanar Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTextureUniformTriplanar where type BaseClass VisualShaderNodeTextureUniformTriplanar = VisualShaderNodeTextureUniform super = coerce -- | Composes a @Transform@ from four @Vector3@s within the visual shader graph. -- Creates a 4x4 transform matrix using four vectors of type @vec3@. Each vector is one row in the matrix and the last column is a @vec4(0, 0, 0, 1)@. newtype VisualShaderNodeTransformCompose = VisualShaderNodeTransformCompose Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTransformCompose where type BaseClass VisualShaderNodeTransformCompose = VisualShaderNode super = coerce -- | A @Transform@ constant for use within the visual shader graph. -- A constant @Transform@, which can be used as an input node. newtype VisualShaderNodeTransformConstant = VisualShaderNodeTransformConstant Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTransformConstant where type BaseClass VisualShaderNodeTransformConstant = VisualShaderNode super = coerce -- | Decomposes a @Transform@ into four @Vector3@s within the visual shader graph. -- Takes a 4x4 transform matrix and decomposes it into four @vec3@ values, one from each row of the matrix. newtype VisualShaderNodeTransformDecompose = VisualShaderNodeTransformDecompose Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTransformDecompose where type BaseClass VisualShaderNodeTransformDecompose = VisualShaderNode super = coerce -- | Computes a @Transform@ function within the visual shader graph. -- Computes an inverse or transpose function on the provided @Transform@. newtype VisualShaderNodeTransformFunc = VisualShaderNodeTransformFunc Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTransformFunc where type BaseClass VisualShaderNodeTransformFunc = VisualShaderNode super = coerce -- | Multiplies @Transform@ by @Transform@ within the visual shader graph. -- A multiplication operation on two transforms (4x4 matrices), with support for different multiplication operators. newtype VisualShaderNodeTransformMult = VisualShaderNodeTransformMult Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTransformMult where type BaseClass VisualShaderNodeTransformMult = VisualShaderNode super = coerce -- | A @Transform@ uniform for use within the visual shader graph. -- Translated to @uniform mat4@ in the shader language. newtype VisualShaderNodeTransformUniform = VisualShaderNodeTransformUniform Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTransformUniform where type BaseClass VisualShaderNodeTransformUniform = VisualShaderNodeUniform super = coerce -- | Multiplies a @Transform@ and a @Vector3@ within the visual shader graph. -- A multiplication operation on a transform (4x4 matrix) and a vector, with support for different multiplication operators. newtype VisualShaderNodeTransformVecMult = VisualShaderNodeTransformVecMult Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeTransformVecMult where type BaseClass VisualShaderNodeTransformVecMult = VisualShaderNode super = coerce -- | A base type for the uniforms within the visual shader graph. -- A uniform represents a variable in the shader which is set externally, i.e. from the @ShaderMaterial@. Uniforms are exposed as properties in the @ShaderMaterial@ and can be assigned from the inspector or from a script. newtype VisualShaderNodeUniform = VisualShaderNodeUniform Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeUniform where type BaseClass VisualShaderNodeUniform = VisualShaderNode super = coerce -- | A @Vector3@ constant to be used within the visual shader graph. -- A constant @Vector3@, which can be used as an input node. newtype VisualShaderNodeVec3Constant = VisualShaderNodeVec3Constant Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVec3Constant where type BaseClass VisualShaderNodeVec3Constant = VisualShaderNode super = coerce -- | A @Vector3@ uniform to be used within the visual shader graph. -- Translated to @uniform vec3@ in the shader language. newtype VisualShaderNodeVec3Uniform = VisualShaderNodeVec3Uniform Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVec3Uniform where type BaseClass VisualShaderNodeVec3Uniform = VisualShaderNodeUniform super = coerce -- | Clamps a vector value within the visual shader graph. -- Constrains a value to lie between @min@ and @max@ values. The operation is performed on each component of the vector individually. newtype VisualShaderNodeVectorClamp = VisualShaderNodeVectorClamp Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorClamp where type BaseClass VisualShaderNodeVectorClamp = VisualShaderNode super = coerce -- | Composes a @Vector3@ from three scalars within the visual shader graph. -- Creates a @vec3@ using three scalar values that can be provided from separate inputs. newtype VisualShaderNodeVectorCompose = VisualShaderNodeVectorCompose Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorCompose where type BaseClass VisualShaderNodeVectorCompose = VisualShaderNode super = coerce -- | Decomposes a @Vector3@ into three scalars within the visual shader graph. -- Takes a @vec3@ and decomposes it into three scalar values that can be used as separate inputs. newtype VisualShaderNodeVectorDecompose = VisualShaderNodeVectorDecompose Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorDecompose where type BaseClass VisualShaderNodeVectorDecompose = VisualShaderNode super = coerce -- | Calculates a vector derivative within the visual shader graph. -- This node is only available in @Fragment@ and @Light@ visual shaders. newtype VisualShaderNodeVectorDerivativeFunc = VisualShaderNodeVectorDerivativeFunc Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorDerivativeFunc where type BaseClass VisualShaderNodeVectorDerivativeFunc = VisualShaderNode super = coerce -- | Returns the distance between two points. To be used within the visual shader graph. -- Calculates distance from point represented by vector @p0@ to vector @p1@. -- Translated to @distance(p0, p1)@ in the shader language. newtype VisualShaderNodeVectorDistance = VisualShaderNodeVectorDistance Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorDistance where type BaseClass VisualShaderNodeVectorDistance = VisualShaderNode super = coerce -- | A vector function to be used within the visual shader graph. -- A visual shader node able to perform different functions using vectors. newtype VisualShaderNodeVectorFunc = VisualShaderNodeVectorFunc Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorFunc where type BaseClass VisualShaderNodeVectorFunc = VisualShaderNode super = coerce -- | Linearly interpolates between two vectors within the visual shader graph. -- Translates to @mix(a, b, weight)@ in the shader language, where @weight@ is a @Vector3@ with weights for each component. newtype VisualShaderNodeVectorInterp = VisualShaderNodeVectorInterp Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorInterp where type BaseClass VisualShaderNodeVectorInterp = VisualShaderNode super = coerce -- | Returns the length of a @Vector3@ within the visual shader graph. -- Translated to @length(p0)@ in the shader language. newtype VisualShaderNodeVectorLen = VisualShaderNodeVectorLen Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorLen where type BaseClass VisualShaderNodeVectorLen = VisualShaderNode super = coerce -- | A vector operator to be used within the visual shader graph. -- A visual shader node for use of vector operators. Operates on vector @a@ and vector @b@. newtype VisualShaderNodeVectorOp = VisualShaderNodeVectorOp Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorOp where type BaseClass VisualShaderNodeVectorOp = VisualShaderNode super = coerce -- | Returns the @Vector3@ that points in the direction of refraction. For use within the visual shader graph. -- Translated to @refract(I, N, eta)@ in the shader language, where @I@ is the incident vector, @N@ is the normal vector and @eta@ is the ratio of the indicies of the refraction. newtype VisualShaderNodeVectorRefract = VisualShaderNodeVectorRefract Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorRefract where type BaseClass VisualShaderNodeVectorRefract = VisualShaderNode super = coerce -- | Linearly interpolates between two vectors using a scalar. For use within the visual shader graph. -- Translates to @mix(a, b, weight)@ in the shader language, where @a@ and @b@ are vectors and @weight@ is a scalar. newtype VisualShaderNodeVectorScalarMix = VisualShaderNodeVectorScalarMix Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorScalarMix where type BaseClass VisualShaderNodeVectorScalarMix = VisualShaderNode super = coerce -- | Calculates a vector SmoothStep function using scalar within the visual shader graph. -- Translates to @smoothstep(edge0, edge1, x)@ in the shader language, where @x@ is a scalar. -- Returns @0.0@ if @x@ is smaller than @edge0@ and @1.0@ if @x@ is larger than @edge1@. Otherwise the return value is interpolated between @0.0@ and @1.0@ using Hermite polynomials. newtype VisualShaderNodeVectorScalarSmoothStep = VisualShaderNodeVectorScalarSmoothStep Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorScalarSmoothStep where type BaseClass VisualShaderNodeVectorScalarSmoothStep = VisualShaderNode super = coerce -- | Calculates a vector Step function within the visual shader graph. -- Translates to @step(edge, x)@ in the shader language. -- Returns @0.0@ if @x@ is smaller than @edge@ and @1.0@ otherwise. newtype VisualShaderNodeVectorScalarStep = VisualShaderNodeVectorScalarStep Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorScalarStep where type BaseClass VisualShaderNodeVectorScalarStep = VisualShaderNode super = coerce -- | Calculates a vector SmoothStep function within the visual shader graph. -- Translates to @smoothstep(edge0, edge1, x)@ in the shader language, where @x@ is a vector. -- Returns @0.0@ if @x@ is smaller than @edge0@ and @1.0@ if @x@ is larger than @edge1@. Otherwise the return value is interpolated between @0.0@ and @1.0@ using Hermite polynomials. newtype VisualShaderNodeVectorSmoothStep = VisualShaderNodeVectorSmoothStep Object deriving newtype AsVariant instance HasBaseClass VisualShaderNodeVectorSmoothStep where type BaseClass VisualShaderNodeVectorSmoothStep = VisualShaderNode super = coerce -- | Holds an @Object@, but does not contribute to the reference count if the object is a reference. -- A weakref can hold a @Reference@, without contributing to the reference counter. A weakref can be created from an @Object@ using @method @GDScript.weakref@. If this object is not a reference, weakref still works, however, it does not have any effect on the object. Weakrefs are useful in cases where multiple classes have variables that refer to each other. Without weakrefs, using these classes could lead to memory leaks, since both references keep each other from being released. Making part of the variables a weakref can prevent this cyclic dependency, and allows the references to be released. newtype WeakRef = WeakRef Object deriving newtype AsVariant instance HasBaseClass WeakRef where type BaseClass WeakRef = Reference super = coerce newtype WebRTCDataChannel = WebRTCDataChannel Object deriving newtype AsVariant instance HasBaseClass WebRTCDataChannel where type BaseClass WebRTCDataChannel = PacketPeer super = coerce newtype WebRTCDataChannelGDNative = WebRTCDataChannelGDNative Object deriving newtype AsVariant instance HasBaseClass WebRTCDataChannelGDNative where type BaseClass WebRTCDataChannelGDNative = WebRTCDataChannel super = coerce newtype WebRTCMultiplayer = WebRTCMultiplayer Object deriving newtype AsVariant instance HasBaseClass WebRTCMultiplayer where type BaseClass WebRTCMultiplayer = NetworkedMultiplayerPeer super = coerce newtype WebRTCPeerConnection = WebRTCPeerConnection Object deriving newtype AsVariant instance HasBaseClass WebRTCPeerConnection where type BaseClass WebRTCPeerConnection = Reference super = coerce newtype WebRTCPeerConnectionGDNative = WebRTCPeerConnectionGDNative Object deriving newtype AsVariant instance HasBaseClass WebRTCPeerConnectionGDNative where type BaseClass WebRTCPeerConnectionGDNative = WebRTCPeerConnection super = coerce newtype WebSocketClient = WebSocketClient Object deriving newtype AsVariant instance HasBaseClass WebSocketClient where type BaseClass WebSocketClient = WebSocketMultiplayerPeer super = coerce newtype WebSocketMultiplayerPeer = WebSocketMultiplayerPeer Object deriving newtype AsVariant instance HasBaseClass WebSocketMultiplayerPeer where type BaseClass WebSocketMultiplayerPeer = NetworkedMultiplayerPeer super = coerce newtype WebSocketPeer = WebSocketPeer Object deriving newtype AsVariant instance HasBaseClass WebSocketPeer where type BaseClass WebSocketPeer = PacketPeer super = coerce newtype WebSocketServer = WebSocketServer Object deriving newtype AsVariant instance HasBaseClass WebSocketServer where type BaseClass WebSocketServer = WebSocketMultiplayerPeer super = coerce -- | Base class for window dialogs. -- Windowdialog is the base class for all window-based dialogs. It's a by-default toplevel @Control@ that draws a window decoration and allows motion and resizing. newtype WindowDialog = WindowDialog Object deriving newtype AsVariant instance HasBaseClass WindowDialog where type BaseClass WindowDialog = Popup super = coerce -- | Class that has everything pertaining to a world. -- A physics space, a visual scenario and a sound space. Spatial nodes register their resources into the current world. newtype World = World Object deriving newtype AsVariant instance HasBaseClass World where type BaseClass World = Resource super = coerce -- | Class that has everything pertaining to a 2D world. -- A physics space, a visual scenario and a sound space. 2D nodes register their resources into the current 2D world. newtype World2D = World2D Object deriving newtype AsVariant instance HasBaseClass World2D where type BaseClass World2D = Resource super = coerce -- | Default environment properties for the entire scene (post-processing effects, lighting and background settings). -- The @WorldEnvironment@ node is used to configure the default @Environment@ for the scene. -- The parameters defined in the @WorldEnvironment@ can be overridden by an @Environment@ node set on the current @Camera@. Additionally, only one @WorldEnvironment@ may be instanced in a given scene at a time. -- The @WorldEnvironment@ allows the user to specify default lighting parameters (e.g. ambient lighting), various post-processing effects (e.g. SSAO, DOF, Tonemapping), and how to draw the background (e.g. solid color, skybox). Usually, these are added in order to improve the realism/color balance of the scene. newtype WorldEnvironment = WorldEnvironment Object deriving newtype AsVariant instance HasBaseClass WorldEnvironment where type BaseClass WorldEnvironment = Node super = coerce -- | An X509 certificate (e.g. for SSL). -- The X509Certificate class represents an X509 certificate. Certificates can be loaded and saved like any other @Resource@. -- They can be used as the server certificate in @method StreamPeerSSL.accept_stream@ (along with the proper @CryptoKey@), and to specify the only certificate that should be accepted when connecting to an SSL server via @method StreamPeerSSL.connect_to_stream@. -- __Note:__ Not available in HTML5 exports. newtype X509Certificate = X509Certificate Object deriving newtype AsVariant instance HasBaseClass X509Certificate where type BaseClass X509Certificate = Resource super = coerce -- | Low-level class for creating parsers for @url=https://en.wikipedia.org/wiki/XML@XML@/url@ files. -- This class can serve as base to make custom XML parsers. Since XML is a very flexible standard, this interface is low-level so it can be applied to any possible schema. newtype XMLParser = XMLParser Object deriving newtype AsVariant instance HasBaseClass XMLParser where type BaseClass XMLParser = Reference super = coerce -- | Sort all child nodes based on their Y positions. -- The child node must inherit from @CanvasItem@ for it to be sorted. Nodes that have a higher Y position will be drawn later, so they will appear on top of nodes that have a lower Y position. -- Nesting of YSort nodes is possible. Children YSort nodes will be sorted in the same space as the parent YSort, allowing to better organize a scene or divide it in multiple ones, yet keep the unique sorting. newtype YSort = YSort Object deriving newtype AsVariant instance HasBaseClass YSort where type BaseClass YSort = Node2D super = coerce -- | Class information repository. -- Provides access to metadata stored for every available class. newtype ClassDB = ClassDB Object deriving newtype AsVariant instance HasBaseClass ClassDB where type BaseClass ClassDB = Object super = coerce -- | Type used to handle the filesystem. -- Directory type. It is used to manage directories and their content (not restricted to the project folder). -- When creating a new @Directory@, its default opened directory will be @res://@. This may change in the future, so it is advised to always use @method open@ to initialize your @Directory@ where you want to operate, with explicit error checking. -- Here is an example on how to iterate through the files of a directory: -- -- @ -- -- func dir_contents(path): -- var dir = Directory.new() -- if dir.open(path) == OK: -- dir.list_dir_begin() -- var file_name = dir.get_next() -- while file_name != "": -- if dir.current_is_dir(): -- print("Found directory: " + file_name) -- else: -- print("Found file: " + file_name) -- file_name = dir.get_next() -- else: -- print("An error occurred when trying to access the path.") -- -- @ newtype Directory = Directory Object deriving newtype AsVariant instance HasBaseClass Directory where type BaseClass Directory = Reference super = coerce -- | Access to engine properties. -- The @Engine@ singleton allows you to query and modify the project's run-time parameters, such as frames per second, time scale, and others. newtype Engine = Engine Object deriving newtype AsVariant instance HasBaseClass Engine where type BaseClass Engine = Object super = coerce -- | Type to handle file reading and writing operations. -- File type. This is used to permanently store data into the user device's file system and to read from it. This can be used to store game save data or player configuration files, for example. -- Here's a sample on how to write and read from a file: -- -- @ -- -- func save(content): -- var file = File.new() -- file.open("user://save_game.dat", File.WRITE) -- file.store_string(content) -- file.close() -- -- func load(): -- var file = File.new() -- file.open("user://save_game.dat", File.READ) -- var content = file.get_as_text() -- file.close() -- return content -- -- @ -- -- In the example above, the file will be saved in the user data folder as specified in the @url=https://docs.godotengine.org/en/latest/tutorials/io/data_paths.html@Data paths@/url@ documentation. newtype File = File Object deriving newtype AsVariant instance HasBaseClass File where type BaseClass File = Reference super = coerce -- | Helper node to calculate generic geometry operations. -- Geometry provides users with a set of helper functions to create geometric shapes, compute intersections between shapes, and process various other geometric operations. newtype Geometry = Geometry Object deriving newtype AsVariant instance HasBaseClass Geometry where type BaseClass Geometry = Object super = coerce -- | Helper class for parsing JSON data. -- For usage example and other important hints, see @JSONParseResult@. newtype JSON = JSON Object deriving newtype AsVariant instance HasBaseClass JSON where type BaseClass JSON = Object super = coerce -- | Data transformation (marshalling) and encoding helpers. -- Provides data transformation and encoding utility functions. newtype Marshalls = Marshalls Object deriving newtype AsVariant instance HasBaseClass Marshalls where type BaseClass Marshalls = Reference super = coerce -- | A synchronization mutex (mutual exclusion). -- This is used to synchronize multiple @Thread@s, and is equivalent to a binary @Semaphore@. It guarantees that only one thread can ever acquire the lock at a time. A mutex can be used to protect a critical section; however, be careful to avoid deadlocks. newtype Mutex = Mutex Object deriving newtype AsVariant instance HasBaseClass Mutex where type BaseClass Mutex = Reference super = coerce -- | Operating System functions. -- OS wraps the most common functionality to communicate with the host operating system, such as the clipboard, video driver, date and time, timers, environment variables, execution of binaries, command line, etc. newtype OS = OS Object deriving newtype AsVariant instance HasBaseClass OS where type BaseClass OS = Object super = coerce -- | Singleton used to load resource files. -- Singleton used to load resource files from the filesystem. -- It uses the many @ResourceFormatLoader@ classes registered in the engine (either built-in or from a plugin) to load files into memory and convert them to a format that can be used by the engine. -- GDScript has a simplified @method @GDScript.load@ built-in method which can be used in most situations, leaving the use of @ResourceLoader@ for more advanced scenarios. newtype ResourceLoader = ResourceLoader Object deriving newtype AsVariant instance HasBaseClass ResourceLoader where type BaseClass ResourceLoader = Object super = coerce -- | Singleton for saving Godot-specific resource types. -- Singleton for saving Godot-specific resource types to the filesystem. -- It uses the many @ResourceFormatSaver@ classes registered in the engine (either built-in or from a plugin) to save engine-specific resource data to text-based (e.g. @.tres@ or @.tscn@) or binary files (e.g. @.res@ or @.scn@). newtype ResourceSaver = ResourceSaver Object deriving newtype AsVariant instance HasBaseClass ResourceSaver where type BaseClass ResourceSaver = Object super = coerce -- | A synchronization semaphore. -- A synchronization semaphore which can be used to synchronize multiple @Thread@s. Initialized to zero on creation. Be careful to avoid deadlocks. For a binary version, see @Mutex@. newtype Semaphore = Semaphore Object deriving newtype AsVariant instance HasBaseClass Semaphore where type BaseClass Semaphore = Reference super = coerce -- | A unit of execution in a process. -- Can run methods on @Object@s simultaneously. The use of synchronization via @Mutex@ or @Semaphore@ is advised if working with shared objects. -- __Note:__ Breakpoints won't break on code if it's running in a thread. This is a current limitation of the GDScript debugger. newtype Thread = Thread Object deriving newtype AsVariant instance HasBaseClass Thread where type BaseClass Thread = Reference super = coerce newtype VisualScriptEditor = VisualScriptEditor Object deriving newtype AsVariant instance HasBaseClass VisualScriptEditor where type BaseClass VisualScriptEditor = Object super = coerce deriveBase ''GlobalConstants deriveBase ''ARVRAnchor deriveBase ''ARVRCamera deriveBase ''ARVRController deriveBase ''ARVRInterface deriveBase ''ARVRInterfaceGDNative deriveBase ''ARVROrigin deriveBase ''ARVRPositionalTracker deriveBase ''ARVRServer deriveBase ''AStar deriveBase ''AStar2D deriveBase ''AcceptDialog deriveBase ''AnimatedSprite deriveBase ''AnimatedSprite3D deriveBase ''AnimatedTexture deriveBase ''Animation deriveBase ''AnimationNode deriveBase ''AnimationNodeAdd2 deriveBase ''AnimationNodeAdd3 deriveBase ''AnimationNodeAnimation deriveBase ''AnimationNodeBlend2 deriveBase ''AnimationNodeBlend3 deriveBase ''AnimationNodeBlendSpace1D deriveBase ''AnimationNodeBlendSpace2D deriveBase ''AnimationNodeBlendTree deriveBase ''AnimationNodeOneShot deriveBase ''AnimationNodeOutput deriveBase ''AnimationNodeStateMachine deriveBase ''AnimationNodeStateMachinePlayback deriveBase ''AnimationNodeStateMachineTransition deriveBase ''AnimationNodeTimeScale deriveBase ''AnimationNodeTimeSeek deriveBase ''AnimationNodeTransition deriveBase ''AnimationPlayer deriveBase ''AnimationRootNode deriveBase ''AnimationTrackEditPlugin deriveBase ''AnimationTree deriveBase ''AnimationTreePlayer deriveBase ''Area deriveBase ''Area2D deriveBase ''ArrayMesh deriveBase ''AtlasTexture deriveBase ''AudioBusLayout deriveBase ''AudioEffect deriveBase ''AudioEffectAmplify deriveBase ''AudioEffectBandLimitFilter deriveBase ''AudioEffectBandPassFilter deriveBase ''AudioEffectChorus deriveBase ''AudioEffectCompressor deriveBase ''AudioEffectDelay deriveBase ''AudioEffectDistortion deriveBase ''AudioEffectEQ deriveBase ''AudioEffectEQ10 deriveBase ''AudioEffectEQ21 deriveBase ''AudioEffectEQ6 deriveBase ''AudioEffectFilter deriveBase ''AudioEffectHighPassFilter deriveBase ''AudioEffectHighShelfFilter deriveBase ''AudioEffectInstance deriveBase ''AudioEffectLimiter deriveBase ''AudioEffectLowPassFilter deriveBase ''AudioEffectLowShelfFilter deriveBase ''AudioEffectNotchFilter deriveBase ''AudioEffectPanner deriveBase ''AudioEffectPhaser deriveBase ''AudioEffectPitchShift deriveBase ''AudioEffectRecord deriveBase ''AudioEffectReverb deriveBase ''AudioEffectSpectrumAnalyzer deriveBase ''AudioEffectSpectrumAnalyzerInstance deriveBase ''AudioEffectStereoEnhance deriveBase ''AudioServer deriveBase ''AudioStream deriveBase ''AudioStreamGenerator deriveBase ''AudioStreamGeneratorPlayback deriveBase ''AudioStreamMicrophone deriveBase ''AudioStreamOGGVorbis deriveBase ''AudioStreamPlayback deriveBase ''AudioStreamPlaybackResampled deriveBase ''AudioStreamPlayer deriveBase ''AudioStreamPlayer2D deriveBase ''AudioStreamPlayer3D deriveBase ''AudioStreamRandomPitch deriveBase ''AudioStreamSample deriveBase ''BackBufferCopy deriveBase ''BakedLightmap deriveBase ''BakedLightmapData deriveBase ''BaseButton deriveBase ''BitMap deriveBase ''BitmapFont deriveBase ''Bone2D deriveBase ''BoneAttachment deriveBase ''BoxContainer deriveBase ''BoxShape deriveBase ''BulletPhysicsDirectBodyState deriveBase ''BulletPhysicsServer deriveBase ''Button deriveBase ''ButtonGroup deriveBase ''CPUParticles deriveBase ''CPUParticles2D deriveBase ''CSGBox deriveBase ''CSGCombiner deriveBase ''CSGCylinder deriveBase ''CSGMesh deriveBase ''CSGPolygon deriveBase ''CSGPrimitive deriveBase ''CSGShape deriveBase ''CSGSphere deriveBase ''CSGTorus deriveBase ''Camera deriveBase ''Camera2D deriveBase ''CameraFeed deriveBase ''CameraServer deriveBase ''CameraTexture deriveBase ''CanvasItem deriveBase ''CanvasItemMaterial deriveBase ''CanvasLayer deriveBase ''CanvasModulate deriveBase ''CapsuleMesh deriveBase ''CapsuleShape deriveBase ''CapsuleShape2D deriveBase ''CenterContainer deriveBase ''CharFXTransform deriveBase ''CheckBox deriveBase ''CheckButton deriveBase ''CircleShape2D deriveBase ''ClippedCamera deriveBase ''CollisionObject deriveBase ''CollisionObject2D deriveBase ''CollisionPolygon deriveBase ''CollisionPolygon2D deriveBase ''CollisionShape deriveBase ''CollisionShape2D deriveBase ''ColorPicker deriveBase ''ColorPickerButton deriveBase ''ColorRect deriveBase ''ConcavePolygonShape deriveBase ''ConcavePolygonShape2D deriveBase ''ConeTwistJoint deriveBase ''ConfigFile deriveBase ''ConfirmationDialog deriveBase ''Container deriveBase ''Control deriveBase ''ConvexPolygonShape deriveBase ''ConvexPolygonShape2D deriveBase ''Crypto deriveBase ''CryptoKey deriveBase ''CubeMap deriveBase ''CubeMesh deriveBase ''Curve deriveBase ''Curve2D deriveBase ''Curve3D deriveBase ''CurveTexture deriveBase ''CylinderMesh deriveBase ''CylinderShape deriveBase ''DampedSpringJoint2D deriveBase ''DirectionalLight deriveBase ''DynamicFont deriveBase ''DynamicFontData deriveBase ''EditorExportPlugin deriveBase ''EditorFeatureProfile deriveBase ''EditorFileDialog deriveBase ''EditorFileSystem deriveBase ''EditorFileSystemDirectory deriveBase ''EditorImportPlugin deriveBase ''EditorInspector deriveBase ''EditorInspectorPlugin deriveBase ''EditorInterface deriveBase ''EditorNavigationMeshGenerator deriveBase ''EditorPlugin deriveBase ''EditorProperty deriveBase ''EditorResourceConversionPlugin deriveBase ''EditorResourcePreview deriveBase ''EditorResourcePreviewGenerator deriveBase ''EditorSceneImporter deriveBase ''EditorSceneImporterAssimp deriveBase ''EditorScenePostImport deriveBase ''EditorScript deriveBase ''EditorSelection deriveBase ''EditorSettings deriveBase ''EditorSpatialGizmo deriveBase ''EditorSpatialGizmoPlugin deriveBase ''EditorSpinSlider deriveBase ''EditorVCSInterface deriveBase ''EncodedObjectAsID deriveBase ''Environment deriveBase ''Expression deriveBase ''FileDialog deriveBase ''Font deriveBase ''FuncRef deriveBase ''GDNative deriveBase ''GDNativeLibrary deriveBase ''GDScript deriveBase ''GDScriptFunctionState deriveBase ''GIProbe deriveBase ''GIProbeData deriveBase ''Generic6DOFJoint deriveBase ''GeometryInstance deriveBase ''Gradient deriveBase ''GradientTexture deriveBase ''GraphEdit deriveBase ''GraphNode deriveBase ''GridContainer deriveBase ''GridMap deriveBase ''GrooveJoint2D deriveBase ''HBoxContainer deriveBase ''HScrollBar deriveBase ''HSeparator deriveBase ''HSlider deriveBase ''HSplitContainer deriveBase ''HTTPClient deriveBase ''HTTPRequest deriveBase ''HashingContext deriveBase ''HeightMapShape deriveBase ''HingeJoint deriveBase ''IP deriveBase ''IP_Unix deriveBase ''Image deriveBase ''ImageTexture deriveBase ''ImmediateGeometry deriveBase ''Input deriveBase ''InputDefault deriveBase ''InputEvent deriveBase ''InputEventAction deriveBase ''InputEventGesture deriveBase ''InputEventJoypadButton deriveBase ''InputEventJoypadMotion deriveBase ''InputEventKey deriveBase ''InputEventMIDI deriveBase ''InputEventMagnifyGesture deriveBase ''InputEventMouse deriveBase ''InputEventMouseButton deriveBase ''InputEventMouseMotion deriveBase ''InputEventPanGesture deriveBase ''InputEventScreenDrag deriveBase ''InputEventScreenTouch deriveBase ''InputEventWithModifiers deriveBase ''InputMap deriveBase ''InstancePlaceholder deriveBase ''InterpolatedCamera deriveBase ''ItemList deriveBase ''JSONParseResult deriveBase ''JSONRPC deriveBase ''JavaClass deriveBase ''JavaClassWrapper deriveBase ''JavaScript deriveBase ''Joint deriveBase ''Joint2D deriveBase ''KinematicBody deriveBase ''KinematicBody2D deriveBase ''KinematicCollision deriveBase ''KinematicCollision2D deriveBase ''Label deriveBase ''LargeTexture deriveBase ''Light deriveBase ''Light2D deriveBase ''LightOccluder2D deriveBase ''Line2D deriveBase ''LineEdit deriveBase ''LineShape2D deriveBase ''LinkButton deriveBase ''Listener deriveBase ''MainLoop deriveBase ''MarginContainer deriveBase ''Material deriveBase ''MenuButton deriveBase ''Mesh deriveBase ''MeshDataTool deriveBase ''MeshInstance deriveBase ''MeshInstance2D deriveBase ''MeshLibrary deriveBase ''MeshTexture deriveBase ''MobileVRInterface deriveBase ''MultiMesh deriveBase ''MultiMeshInstance deriveBase ''MultiMeshInstance2D deriveBase ''MultiplayerAPI deriveBase ''MultiplayerPeerGDNative deriveBase ''NativeScript deriveBase ''Navigation deriveBase ''Navigation2D deriveBase ''NavigationMesh deriveBase ''NavigationMeshInstance deriveBase ''NavigationPolygon deriveBase ''NavigationPolygonInstance deriveBase ''NetworkedMultiplayerENet deriveBase ''NetworkedMultiplayerPeer deriveBase ''NinePatchRect deriveBase ''Node deriveBase ''Node2D deriveBase ''NoiseTexture deriveBase ''OccluderPolygon2D deriveBase ''OmniLight deriveBase ''OpenSimplexNoise deriveBase ''OptionButton deriveBase ''PCKPacker deriveBase ''PHashTranslation deriveBase ''PackedDataContainer deriveBase ''PackedDataContainerRef deriveBase ''PackedScene deriveBase ''PacketPeer deriveBase ''PacketPeerGDNative deriveBase ''PacketPeerStream deriveBase ''PacketPeerUDP deriveBase ''Panel deriveBase ''PanelContainer deriveBase ''PanoramaSky deriveBase ''ParallaxBackground deriveBase ''ParallaxLayer deriveBase ''Particles deriveBase ''Particles2D deriveBase ''ParticlesMaterial deriveBase ''Path deriveBase ''Path2D deriveBase ''PathFollow deriveBase ''PathFollow2D deriveBase ''Performance deriveBase ''PhysicalBone deriveBase ''Physics2DDirectBodyState deriveBase ''Physics2DDirectBodyStateSW deriveBase ''Physics2DDirectSpaceState deriveBase ''Physics2DServer deriveBase ''Physics2DServerSW deriveBase ''Physics2DShapeQueryParameters deriveBase ''Physics2DShapeQueryResult deriveBase ''Physics2DTestMotionResult deriveBase ''PhysicsBody deriveBase ''PhysicsBody2D deriveBase ''PhysicsDirectBodyState deriveBase ''PhysicsDirectSpaceState deriveBase ''PhysicsMaterial deriveBase ''PhysicsServer deriveBase ''PhysicsShapeQueryParameters deriveBase ''PhysicsShapeQueryResult deriveBase ''PinJoint deriveBase ''PinJoint2D deriveBase ''PlaneMesh deriveBase ''PlaneShape deriveBase ''PluginScript deriveBase ''PointMesh deriveBase ''Polygon2D deriveBase ''PolygonPathFinder deriveBase ''Popup deriveBase ''PopupDialog deriveBase ''PopupMenu deriveBase ''PopupPanel deriveBase ''Position2D deriveBase ''Position3D deriveBase ''PrimitiveMesh deriveBase ''PrismMesh deriveBase ''ProceduralSky deriveBase ''ProgressBar deriveBase ''ProjectSettings deriveBase ''ProximityGroup deriveBase ''ProxyTexture deriveBase ''QuadMesh deriveBase ''RandomNumberGenerator deriveBase ''Range deriveBase ''RayCast deriveBase ''RayCast2D deriveBase ''RayShape deriveBase ''RayShape2D deriveBase ''RectangleShape2D deriveBase ''Reference deriveBase ''ReferenceRect deriveBase ''ReflectionProbe deriveBase ''RegEx deriveBase ''RegExMatch deriveBase ''RemoteTransform deriveBase ''RemoteTransform2D deriveBase ''Resource deriveBase ''ResourceFormatLoader deriveBase ''ResourceFormatLoaderCrypto deriveBase ''ResourceFormatSaver deriveBase ''ResourceFormatSaverCrypto deriveBase ''ResourceImporter deriveBase ''ResourceInteractiveLoader deriveBase ''ResourcePreloader deriveBase ''RichTextEffect deriveBase ''RichTextLabel deriveBase ''RigidBody deriveBase ''RigidBody2D deriveBase ''RootMotionView deriveBase ''SceneState deriveBase ''SceneTree deriveBase ''SceneTreeTimer deriveBase ''Script deriveBase ''ScriptCreateDialog deriveBase ''ScriptEditor deriveBase ''ScrollBar deriveBase ''ScrollContainer deriveBase ''SegmentShape2D deriveBase ''Separator deriveBase ''Shader deriveBase ''ShaderMaterial deriveBase ''Shape deriveBase ''Shape2D deriveBase ''ShortCut deriveBase ''Skeleton deriveBase ''Skeleton2D deriveBase ''SkeletonIK deriveBase ''Skin deriveBase ''SkinReference deriveBase ''Sky deriveBase ''Slider deriveBase ''SliderJoint deriveBase ''SoftBody deriveBase ''Spatial deriveBase ''SpatialGizmo deriveBase ''SpatialMaterial deriveBase ''SpatialVelocityTracker deriveBase ''SphereMesh deriveBase ''SphereShape deriveBase ''SpinBox deriveBase ''SplitContainer deriveBase ''SpotLight deriveBase ''SpringArm deriveBase ''Sprite deriveBase ''Sprite3D deriveBase ''SpriteBase3D deriveBase ''SpriteFrames deriveBase ''StaticBody deriveBase ''StaticBody2D deriveBase ''StreamPeer deriveBase ''StreamPeerBuffer deriveBase ''StreamPeerGDNative deriveBase ''StreamPeerSSL deriveBase ''StreamPeerTCP deriveBase ''StreamTexture deriveBase ''StyleBox deriveBase ''StyleBoxEmpty deriveBase ''StyleBoxFlat deriveBase ''StyleBoxLine deriveBase ''StyleBoxTexture deriveBase ''SurfaceTool deriveBase ''TCP_Server deriveBase ''TabContainer deriveBase ''Tabs deriveBase ''TextEdit deriveBase ''TextFile deriveBase ''Texture deriveBase ''Texture3D deriveBase ''TextureArray deriveBase ''TextureButton deriveBase ''TextureLayered deriveBase ''TextureProgress deriveBase ''TextureRect deriveBase ''Theme deriveBase ''TileMap deriveBase ''TileSet deriveBase ''Timer deriveBase ''ToolButton deriveBase ''TouchScreenButton deriveBase ''Translation deriveBase ''TranslationServer deriveBase ''Tree deriveBase ''TreeItem deriveBase ''TriangleMesh deriveBase ''Tween deriveBase ''UPNP deriveBase ''UPNPDevice deriveBase ''UndoRedo deriveBase ''VBoxContainer deriveBase ''VScrollBar deriveBase ''VSeparator deriveBase ''VSlider deriveBase ''VSplitContainer deriveBase ''VehicleBody deriveBase ''VehicleWheel deriveBase ''VideoPlayer deriveBase ''VideoStream deriveBase ''VideoStreamGDNative deriveBase ''VideoStreamTheora deriveBase ''VideoStreamWebm deriveBase ''Viewport deriveBase ''ViewportContainer deriveBase ''ViewportTexture deriveBase ''VisibilityEnabler deriveBase ''VisibilityEnabler2D deriveBase ''VisibilityNotifier deriveBase ''VisibilityNotifier2D deriveBase ''VisualInstance deriveBase ''VisualScript deriveBase ''VisualScriptBasicTypeConstant deriveBase ''VisualScriptBuiltinFunc deriveBase ''VisualScriptClassConstant deriveBase ''VisualScriptComment deriveBase ''VisualScriptComposeArray deriveBase ''VisualScriptCondition deriveBase ''VisualScriptConstant deriveBase ''VisualScriptConstructor deriveBase ''VisualScriptCustomNode deriveBase ''VisualScriptDeconstruct deriveBase ''VisualScriptEmitSignal deriveBase ''VisualScriptEngineSingleton deriveBase ''VisualScriptExpression deriveBase ''VisualScriptFunction deriveBase ''VisualScriptFunctionCall deriveBase ''VisualScriptFunctionState deriveBase ''VisualScriptGlobalConstant deriveBase ''VisualScriptIndexGet deriveBase ''VisualScriptIndexSet deriveBase ''VisualScriptInputAction deriveBase ''VisualScriptIterator deriveBase ''VisualScriptLists deriveBase ''VisualScriptLocalVar deriveBase ''VisualScriptLocalVarSet deriveBase ''VisualScriptMathConstant deriveBase ''VisualScriptNode deriveBase ''VisualScriptOperator deriveBase ''VisualScriptPreload deriveBase ''VisualScriptPropertyGet deriveBase ''VisualScriptPropertySet deriveBase ''VisualScriptResourcePath deriveBase ''VisualScriptReturn deriveBase ''VisualScriptSceneNode deriveBase ''VisualScriptSceneTree deriveBase ''VisualScriptSelect deriveBase ''VisualScriptSelf deriveBase ''VisualScriptSequence deriveBase ''VisualScriptSubCall deriveBase ''VisualScriptSwitch deriveBase ''VisualScriptTypeCast deriveBase ''VisualScriptVariableGet deriveBase ''VisualScriptVariableSet deriveBase ''VisualScriptWhile deriveBase ''VisualScriptYield deriveBase ''VisualScriptYieldSignal deriveBase ''VisualServer deriveBase ''VisualShader deriveBase ''VisualShaderNode deriveBase ''VisualShaderNodeBooleanConstant deriveBase ''VisualShaderNodeBooleanUniform deriveBase ''VisualShaderNodeColorConstant deriveBase ''VisualShaderNodeColorFunc deriveBase ''VisualShaderNodeColorOp deriveBase ''VisualShaderNodeColorUniform deriveBase ''VisualShaderNodeCompare deriveBase ''VisualShaderNodeCubeMap deriveBase ''VisualShaderNodeCubeMapUniform deriveBase ''VisualShaderNodeCustom deriveBase ''VisualShaderNodeDeterminant deriveBase ''VisualShaderNodeDotProduct deriveBase ''VisualShaderNodeExpression deriveBase ''VisualShaderNodeFaceForward deriveBase ''VisualShaderNodeFresnel deriveBase ''VisualShaderNodeGlobalExpression deriveBase ''VisualShaderNodeGroupBase deriveBase ''VisualShaderNodeIf deriveBase ''VisualShaderNodeInput deriveBase ''VisualShaderNodeIs deriveBase ''VisualShaderNodeOuterProduct deriveBase ''VisualShaderNodeOutput deriveBase ''VisualShaderNodeScalarClamp deriveBase ''VisualShaderNodeScalarConstant deriveBase ''VisualShaderNodeScalarDerivativeFunc deriveBase ''VisualShaderNodeScalarFunc deriveBase ''VisualShaderNodeScalarInterp deriveBase ''VisualShaderNodeScalarOp deriveBase ''VisualShaderNodeScalarSmoothStep deriveBase ''VisualShaderNodeScalarSwitch deriveBase ''VisualShaderNodeScalarUniform deriveBase ''VisualShaderNodeSwitch deriveBase ''VisualShaderNodeTexture deriveBase ''VisualShaderNodeTextureUniform deriveBase ''VisualShaderNodeTextureUniformTriplanar deriveBase ''VisualShaderNodeTransformCompose deriveBase ''VisualShaderNodeTransformConstant deriveBase ''VisualShaderNodeTransformDecompose deriveBase ''VisualShaderNodeTransformFunc deriveBase ''VisualShaderNodeTransformMult deriveBase ''VisualShaderNodeTransformUniform deriveBase ''VisualShaderNodeTransformVecMult deriveBase ''VisualShaderNodeUniform deriveBase ''VisualShaderNodeVec3Constant deriveBase ''VisualShaderNodeVec3Uniform deriveBase ''VisualShaderNodeVectorClamp deriveBase ''VisualShaderNodeVectorCompose deriveBase ''VisualShaderNodeVectorDecompose deriveBase ''VisualShaderNodeVectorDerivativeFunc deriveBase ''VisualShaderNodeVectorDistance deriveBase ''VisualShaderNodeVectorFunc deriveBase ''VisualShaderNodeVectorInterp deriveBase ''VisualShaderNodeVectorLen deriveBase ''VisualShaderNodeVectorOp deriveBase ''VisualShaderNodeVectorRefract deriveBase ''VisualShaderNodeVectorScalarMix deriveBase ''VisualShaderNodeVectorScalarSmoothStep deriveBase ''VisualShaderNodeVectorScalarStep deriveBase ''VisualShaderNodeVectorSmoothStep deriveBase ''WeakRef deriveBase ''WebRTCDataChannel deriveBase ''WebRTCDataChannelGDNative deriveBase ''WebRTCMultiplayer deriveBase ''WebRTCPeerConnection deriveBase ''WebRTCPeerConnectionGDNative deriveBase ''WebSocketClient deriveBase ''WebSocketMultiplayerPeer deriveBase ''WebSocketPeer deriveBase ''WebSocketServer deriveBase ''WindowDialog deriveBase ''World deriveBase ''World2D deriveBase ''WorldEnvironment deriveBase ''X509Certificate deriveBase ''XMLParser deriveBase ''YSort deriveBase ''ClassDB deriveBase ''Directory deriveBase ''Engine deriveBase ''File deriveBase ''Geometry deriveBase ''JSON deriveBase ''Marshalls deriveBase ''Mutex deriveBase ''OS deriveBase ''ResourceLoader deriveBase ''ResourceSaver deriveBase ''Semaphore deriveBase ''Thread deriveBase ''VisualScriptEditor ================================================ FILE: src/Godot/Api.hs ================================================ module Godot.Api (module M) where import Godot.Api.Types as M ================================================ FILE: src/Godot/Core/ARVRAnchor.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ARVRAnchor (Godot.Core.ARVRAnchor.sig_mesh_updated, Godot.Core.ARVRAnchor.get_anchor_id, Godot.Core.ARVRAnchor.get_anchor_name, Godot.Core.ARVRAnchor.get_is_active, Godot.Core.ARVRAnchor.get_mesh, Godot.Core.ARVRAnchor.get_plane, Godot.Core.ARVRAnchor.get_size, Godot.Core.ARVRAnchor.set_anchor_id) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() -- | Emitted when the mesh associated with the anchor changes or when one becomes available. This is especially important for topology that is constantly being @mesh_updated@. sig_mesh_updated :: Godot.Internal.Dispatch.Signal ARVRAnchor sig_mesh_updated = Godot.Internal.Dispatch.Signal "mesh_updated" instance NodeSignal ARVRAnchor "mesh_updated" '[Mesh] instance NodeProperty ARVRAnchor "anchor_id" Int 'False where nodeProperty = (get_anchor_id, wrapDroppingSetter set_anchor_id, Nothing) {-# NOINLINE bindARVRAnchor_get_anchor_id #-} -- | The anchor's ID. You can set this before the anchor itself exists. The first anchor gets an ID of @1@, the second an ID of @2@, etc. When anchors get removed, the engine can then assign the corresponding ID to new anchors. The most common situation where anchors "disappear" is when the AR server identifies that two anchors represent different parts of the same plane and merges them. bindARVRAnchor_get_anchor_id :: MethodBind bindARVRAnchor_get_anchor_id = unsafePerformIO $ withCString "ARVRAnchor" $ \ clsNamePtr -> withCString "get_anchor_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The anchor's ID. You can set this before the anchor itself exists. The first anchor gets an ID of @1@, the second an ID of @2@, etc. When anchors get removed, the engine can then assign the corresponding ID to new anchors. The most common situation where anchors "disappear" is when the AR server identifies that two anchors represent different parts of the same plane and merges them. get_anchor_id :: (ARVRAnchor :< cls, Object :< cls) => cls -> IO Int get_anchor_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRAnchor_get_anchor_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRAnchor "get_anchor_id" '[] (IO Int) where nodeMethod = Godot.Core.ARVRAnchor.get_anchor_id {-# NOINLINE bindARVRAnchor_get_anchor_name #-} -- | Returns the name given to this anchor. bindARVRAnchor_get_anchor_name :: MethodBind bindARVRAnchor_get_anchor_name = unsafePerformIO $ withCString "ARVRAnchor" $ \ clsNamePtr -> withCString "get_anchor_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name given to this anchor. get_anchor_name :: (ARVRAnchor :< cls, Object :< cls) => cls -> IO GodotString get_anchor_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRAnchor_get_anchor_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRAnchor "get_anchor_name" '[] (IO GodotString) where nodeMethod = Godot.Core.ARVRAnchor.get_anchor_name {-# NOINLINE bindARVRAnchor_get_is_active #-} -- | Returns @true@ if the anchor is being tracked and @false@ if no anchor with this ID is currently known. bindARVRAnchor_get_is_active :: MethodBind bindARVRAnchor_get_is_active = unsafePerformIO $ withCString "ARVRAnchor" $ \ clsNamePtr -> withCString "get_is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the anchor is being tracked and @false@ if no anchor with this ID is currently known. get_is_active :: (ARVRAnchor :< cls, Object :< cls) => cls -> IO Bool get_is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRAnchor_get_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRAnchor "get_is_active" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRAnchor.get_is_active {-# NOINLINE bindARVRAnchor_get_mesh #-} -- | If provided by the @ARVRInterface@, this returns a mesh object for the anchor. For an anchor, this can be a shape related to the object being tracked or it can be a mesh that provides topology related to the anchor and can be used to create shadows/reflections on surfaces or for generating collision shapes. bindARVRAnchor_get_mesh :: MethodBind bindARVRAnchor_get_mesh = unsafePerformIO $ withCString "ARVRAnchor" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If provided by the @ARVRInterface@, this returns a mesh object for the anchor. For an anchor, this can be a shape related to the object being tracked or it can be a mesh that provides topology related to the anchor and can be used to create shadows/reflections on surfaces or for generating collision shapes. get_mesh :: (ARVRAnchor :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRAnchor_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRAnchor "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.ARVRAnchor.get_mesh {-# NOINLINE bindARVRAnchor_get_plane #-} -- | Returns a plane aligned with our anchor; handy for intersection testing. bindARVRAnchor_get_plane :: MethodBind bindARVRAnchor_get_plane = unsafePerformIO $ withCString "ARVRAnchor" $ \ clsNamePtr -> withCString "get_plane" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a plane aligned with our anchor; handy for intersection testing. get_plane :: (ARVRAnchor :< cls, Object :< cls) => cls -> IO Plane get_plane cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRAnchor_get_plane (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRAnchor "get_plane" '[] (IO Plane) where nodeMethod = Godot.Core.ARVRAnchor.get_plane {-# NOINLINE bindARVRAnchor_get_size #-} -- | Returns the estimated size of the plane that was detected. Say when the anchor relates to a table in the real world, this is the estimated size of the surface of that table. bindARVRAnchor_get_size :: MethodBind bindARVRAnchor_get_size = unsafePerformIO $ withCString "ARVRAnchor" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the estimated size of the plane that was detected. Say when the anchor relates to a table in the real world, this is the estimated size of the surface of that table. get_size :: (ARVRAnchor :< cls, Object :< cls) => cls -> IO Vector3 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRAnchor_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRAnchor "get_size" '[] (IO Vector3) where nodeMethod = Godot.Core.ARVRAnchor.get_size {-# NOINLINE bindARVRAnchor_set_anchor_id #-} -- | The anchor's ID. You can set this before the anchor itself exists. The first anchor gets an ID of @1@, the second an ID of @2@, etc. When anchors get removed, the engine can then assign the corresponding ID to new anchors. The most common situation where anchors "disappear" is when the AR server identifies that two anchors represent different parts of the same plane and merges them. bindARVRAnchor_set_anchor_id :: MethodBind bindARVRAnchor_set_anchor_id = unsafePerformIO $ withCString "ARVRAnchor" $ \ clsNamePtr -> withCString "set_anchor_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The anchor's ID. You can set this before the anchor itself exists. The first anchor gets an ID of @1@, the second an ID of @2@, etc. When anchors get removed, the engine can then assign the corresponding ID to new anchors. The most common situation where anchors "disappear" is when the AR server identifies that two anchors represent different parts of the same plane and merges them. set_anchor_id :: (ARVRAnchor :< cls, Object :< cls) => cls -> Int -> IO () set_anchor_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRAnchor_set_anchor_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRAnchor "set_anchor_id" '[Int] (IO ()) where nodeMethod = Godot.Core.ARVRAnchor.set_anchor_id ================================================ FILE: src/Godot/Core/ARVRCamera.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ARVRCamera () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Camera() ================================================ FILE: src/Godot/Core/ARVRController.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ARVRController (Godot.Core.ARVRController.sig_button_pressed, Godot.Core.ARVRController.sig_button_release, Godot.Core.ARVRController.sig_mesh_updated, Godot.Core.ARVRController.get_controller_id, Godot.Core.ARVRController.get_controller_name, Godot.Core.ARVRController.get_hand, Godot.Core.ARVRController.get_is_active, Godot.Core.ARVRController.get_joystick_axis, Godot.Core.ARVRController.get_joystick_id, Godot.Core.ARVRController.get_mesh, Godot.Core.ARVRController.get_rumble, Godot.Core.ARVRController.is_button_pressed, Godot.Core.ARVRController.set_controller_id, Godot.Core.ARVRController.set_rumble) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() -- | Emitted when a button on this controller is pressed. sig_button_pressed :: Godot.Internal.Dispatch.Signal ARVRController sig_button_pressed = Godot.Internal.Dispatch.Signal "button_pressed" instance NodeSignal ARVRController "button_pressed" '[Int] -- | Emitted when a button on this controller is released. sig_button_release :: Godot.Internal.Dispatch.Signal ARVRController sig_button_release = Godot.Internal.Dispatch.Signal "button_release" instance NodeSignal ARVRController "button_release" '[Int] -- | Emitted when the mesh associated with the controller changes or when one becomes available. Generally speaking this will be a static mesh after becoming available. sig_mesh_updated :: Godot.Internal.Dispatch.Signal ARVRController sig_mesh_updated = Godot.Internal.Dispatch.Signal "mesh_updated" instance NodeSignal ARVRController "mesh_updated" '[Mesh] instance NodeProperty ARVRController "controller_id" Int 'False where nodeProperty = (get_controller_id, wrapDroppingSetter set_controller_id, Nothing) instance NodeProperty ARVRController "rumble" Float 'False where nodeProperty = (get_rumble, wrapDroppingSetter set_rumble, Nothing) {-# NOINLINE bindARVRController_get_controller_id #-} -- | The controller's ID. -- A controller ID of 0 is unbound and will always result in an inactive node. Controller ID 1 is reserved for the first controller that identifies itself as the left-hand controller and ID 2 is reserved for the first controller that identifies itself as the right-hand controller. -- For any other controller that the @ARVRServer@ detects, we continue with controller ID 3. -- When a controller is turned off, its slot is freed. This ensures controllers will keep the same ID even when controllers with lower IDs are turned off. bindARVRController_get_controller_id :: MethodBind bindARVRController_get_controller_id = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "get_controller_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The controller's ID. -- A controller ID of 0 is unbound and will always result in an inactive node. Controller ID 1 is reserved for the first controller that identifies itself as the left-hand controller and ID 2 is reserved for the first controller that identifies itself as the right-hand controller. -- For any other controller that the @ARVRServer@ detects, we continue with controller ID 3. -- When a controller is turned off, its slot is freed. This ensures controllers will keep the same ID even when controllers with lower IDs are turned off. get_controller_id :: (ARVRController :< cls, Object :< cls) => cls -> IO Int get_controller_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_get_controller_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "get_controller_id" '[] (IO Int) where nodeMethod = Godot.Core.ARVRController.get_controller_id {-# NOINLINE bindARVRController_get_controller_name #-} -- | If active, returns the name of the associated controller if provided by the AR/VR SDK used. bindARVRController_get_controller_name :: MethodBind bindARVRController_get_controller_name = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "get_controller_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If active, returns the name of the associated controller if provided by the AR/VR SDK used. get_controller_name :: (ARVRController :< cls, Object :< cls) => cls -> IO GodotString get_controller_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_get_controller_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "get_controller_name" '[] (IO GodotString) where nodeMethod = Godot.Core.ARVRController.get_controller_name {-# NOINLINE bindARVRController_get_hand #-} -- | Returns the hand holding this controller, if known. See @enum ARVRPositionalTracker.TrackerHand@. bindARVRController_get_hand :: MethodBind bindARVRController_get_hand = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "get_hand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the hand holding this controller, if known. See @enum ARVRPositionalTracker.TrackerHand@. get_hand :: (ARVRController :< cls, Object :< cls) => cls -> IO Int get_hand cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_get_hand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "get_hand" '[] (IO Int) where nodeMethod = Godot.Core.ARVRController.get_hand {-# NOINLINE bindARVRController_get_is_active #-} -- | Returns @true@ if the bound controller is active. ARVR systems attempt to track active controllers. bindARVRController_get_is_active :: MethodBind bindARVRController_get_is_active = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "get_is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the bound controller is active. ARVR systems attempt to track active controllers. get_is_active :: (ARVRController :< cls, Object :< cls) => cls -> IO Bool get_is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_get_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "get_is_active" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRController.get_is_active {-# NOINLINE bindARVRController_get_joystick_axis #-} -- | Returns the value of the given axis for things like triggers, touchpads, etc. that are embedded into the controller. bindARVRController_get_joystick_axis :: MethodBind bindARVRController_get_joystick_axis = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "get_joystick_axis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the given axis for things like triggers, touchpads, etc. that are embedded into the controller. get_joystick_axis :: (ARVRController :< cls, Object :< cls) => cls -> Int -> IO Float get_joystick_axis cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_get_joystick_axis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "get_joystick_axis" '[Int] (IO Float) where nodeMethod = Godot.Core.ARVRController.get_joystick_axis {-# NOINLINE bindARVRController_get_joystick_id #-} -- | Returns the ID of the joystick object bound to this. Every controller tracked by the @ARVRServer@ that has buttons and axis will also be registered as a joystick within Godot. This means that all the normal joystick tracking and input mapping will work for buttons and axis found on the AR/VR controllers. This ID is purely offered as information so you can link up the controller with its joystick entry. bindARVRController_get_joystick_id :: MethodBind bindARVRController_get_joystick_id = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "get_joystick_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the ID of the joystick object bound to this. Every controller tracked by the @ARVRServer@ that has buttons and axis will also be registered as a joystick within Godot. This means that all the normal joystick tracking and input mapping will work for buttons and axis found on the AR/VR controllers. This ID is purely offered as information so you can link up the controller with its joystick entry. get_joystick_id :: (ARVRController :< cls, Object :< cls) => cls -> IO Int get_joystick_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_get_joystick_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "get_joystick_id" '[] (IO Int) where nodeMethod = Godot.Core.ARVRController.get_joystick_id {-# NOINLINE bindARVRController_get_mesh #-} -- | If provided by the @ARVRInterface@, this returns a mesh associated with the controller. This can be used to visualize the controller. bindARVRController_get_mesh :: MethodBind bindARVRController_get_mesh = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If provided by the @ARVRInterface@, this returns a mesh associated with the controller. This can be used to visualize the controller. get_mesh :: (ARVRController :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.ARVRController.get_mesh {-# NOINLINE bindARVRController_get_rumble #-} -- | The degree to which the controller vibrates. Ranges from @0.0@ to @1.0@ with precision @.01@. If changed, updates @ARVRPositionalTracker.rumble@ accordingly. -- This is a useful property to animate if you want the controller to vibrate for a limited duration. bindARVRController_get_rumble :: MethodBind bindARVRController_get_rumble = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "get_rumble" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The degree to which the controller vibrates. Ranges from @0.0@ to @1.0@ with precision @.01@. If changed, updates @ARVRPositionalTracker.rumble@ accordingly. -- This is a useful property to animate if you want the controller to vibrate for a limited duration. get_rumble :: (ARVRController :< cls, Object :< cls) => cls -> IO Float get_rumble cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_get_rumble (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "get_rumble" '[] (IO Float) where nodeMethod = Godot.Core.ARVRController.get_rumble {-# NOINLINE bindARVRController_is_button_pressed #-} -- | Returns @true@ if the button at index @button@ is pressed. See @enum JoystickList@, in particular the @JOY_VR_*@ constants. bindARVRController_is_button_pressed :: MethodBind bindARVRController_is_button_pressed = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "is_button_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the button at index @button@ is pressed. See @enum JoystickList@, in particular the @JOY_VR_*@ constants. is_button_pressed :: (ARVRController :< cls, Object :< cls) => cls -> Int -> IO Int is_button_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_is_button_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "is_button_pressed" '[Int] (IO Int) where nodeMethod = Godot.Core.ARVRController.is_button_pressed {-# NOINLINE bindARVRController_set_controller_id #-} -- | The controller's ID. -- A controller ID of 0 is unbound and will always result in an inactive node. Controller ID 1 is reserved for the first controller that identifies itself as the left-hand controller and ID 2 is reserved for the first controller that identifies itself as the right-hand controller. -- For any other controller that the @ARVRServer@ detects, we continue with controller ID 3. -- When a controller is turned off, its slot is freed. This ensures controllers will keep the same ID even when controllers with lower IDs are turned off. bindARVRController_set_controller_id :: MethodBind bindARVRController_set_controller_id = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "set_controller_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The controller's ID. -- A controller ID of 0 is unbound and will always result in an inactive node. Controller ID 1 is reserved for the first controller that identifies itself as the left-hand controller and ID 2 is reserved for the first controller that identifies itself as the right-hand controller. -- For any other controller that the @ARVRServer@ detects, we continue with controller ID 3. -- When a controller is turned off, its slot is freed. This ensures controllers will keep the same ID even when controllers with lower IDs are turned off. set_controller_id :: (ARVRController :< cls, Object :< cls) => cls -> Int -> IO () set_controller_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_set_controller_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "set_controller_id" '[Int] (IO ()) where nodeMethod = Godot.Core.ARVRController.set_controller_id {-# NOINLINE bindARVRController_set_rumble #-} -- | The degree to which the controller vibrates. Ranges from @0.0@ to @1.0@ with precision @.01@. If changed, updates @ARVRPositionalTracker.rumble@ accordingly. -- This is a useful property to animate if you want the controller to vibrate for a limited duration. bindARVRController_set_rumble :: MethodBind bindARVRController_set_rumble = unsafePerformIO $ withCString "ARVRController" $ \ clsNamePtr -> withCString "set_rumble" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The degree to which the controller vibrates. Ranges from @0.0@ to @1.0@ with precision @.01@. If changed, updates @ARVRPositionalTracker.rumble@ accordingly. -- This is a useful property to animate if you want the controller to vibrate for a limited duration. set_rumble :: (ARVRController :< cls, Object :< cls) => cls -> Float -> IO () set_rumble cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRController_set_rumble (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRController "set_rumble" '[Float] (IO ()) where nodeMethod = Godot.Core.ARVRController.set_rumble ================================================ FILE: src/Godot/Core/ARVRInterface.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ARVRInterface (Godot.Core.ARVRInterface._ARVR_STEREO, Godot.Core.ARVRInterface._ARVR_INSUFFICIENT_FEATURES, Godot.Core.ARVRInterface._ARVR_NOT_TRACKING, Godot.Core.ARVRInterface._EYE_MONO, Godot.Core.ARVRInterface._EYE_LEFT, Godot.Core.ARVRInterface._ARVR_EXCESSIVE_MOTION, Godot.Core.ARVRInterface._ARVR_NORMAL_TRACKING, Godot.Core.ARVRInterface._EYE_RIGHT, Godot.Core.ARVRInterface._ARVR_NONE, Godot.Core.ARVRInterface._ARVR_EXTERNAL, Godot.Core.ARVRInterface._ARVR_UNKNOWN_TRACKING, Godot.Core.ARVRInterface._ARVR_AR, Godot.Core.ARVRInterface._ARVR_MONO, Godot.Core.ARVRInterface.get_anchor_detection_is_enabled, Godot.Core.ARVRInterface.get_camera_feed_id, Godot.Core.ARVRInterface.get_capabilities, Godot.Core.ARVRInterface.get_name, Godot.Core.ARVRInterface.get_render_targetsize, Godot.Core.ARVRInterface.get_tracking_status, Godot.Core.ARVRInterface.initialize, Godot.Core.ARVRInterface.is_initialized, Godot.Core.ARVRInterface.is_primary, Godot.Core.ARVRInterface.is_stereo, Godot.Core.ARVRInterface.set_anchor_detection_is_enabled, Godot.Core.ARVRInterface.set_is_initialized, Godot.Core.ARVRInterface.set_is_primary, Godot.Core.ARVRInterface.uninitialize) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _ARVR_STEREO :: Int _ARVR_STEREO = 2 _ARVR_INSUFFICIENT_FEATURES :: Int _ARVR_INSUFFICIENT_FEATURES = 2 _ARVR_NOT_TRACKING :: Int _ARVR_NOT_TRACKING = 4 _EYE_MONO :: Int _EYE_MONO = 0 _EYE_LEFT :: Int _EYE_LEFT = 1 _ARVR_EXCESSIVE_MOTION :: Int _ARVR_EXCESSIVE_MOTION = 1 _ARVR_NORMAL_TRACKING :: Int _ARVR_NORMAL_TRACKING = 0 _EYE_RIGHT :: Int _EYE_RIGHT = 2 _ARVR_NONE :: Int _ARVR_NONE = 0 _ARVR_EXTERNAL :: Int _ARVR_EXTERNAL = 8 _ARVR_UNKNOWN_TRACKING :: Int _ARVR_UNKNOWN_TRACKING = 3 _ARVR_AR :: Int _ARVR_AR = 4 _ARVR_MONO :: Int _ARVR_MONO = 1 instance NodeProperty ARVRInterface "ar_is_anchor_detection_enabled" Bool 'False where nodeProperty = (get_anchor_detection_is_enabled, wrapDroppingSetter set_anchor_detection_is_enabled, Nothing) instance NodeProperty ARVRInterface "interface_is_initialized" Bool 'False where nodeProperty = (is_initialized, wrapDroppingSetter set_is_initialized, Nothing) instance NodeProperty ARVRInterface "interface_is_primary" Bool 'False where nodeProperty = (is_primary, wrapDroppingSetter set_is_primary, Nothing) {-# NOINLINE bindARVRInterface_get_anchor_detection_is_enabled #-} -- | On an AR interface, @true@ if anchor detection is enabled. bindARVRInterface_get_anchor_detection_is_enabled :: MethodBind bindARVRInterface_get_anchor_detection_is_enabled = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "get_anchor_detection_is_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | On an AR interface, @true@ if anchor detection is enabled. get_anchor_detection_is_enabled :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Bool get_anchor_detection_is_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_get_anchor_detection_is_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "get_anchor_detection_is_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRInterface.get_anchor_detection_is_enabled {-# NOINLINE bindARVRInterface_get_camera_feed_id #-} -- | If this is an AR interface that requires displaying a camera feed as the background, this method returns the feed ID in the @CameraServer@ for this interface. bindARVRInterface_get_camera_feed_id :: MethodBind bindARVRInterface_get_camera_feed_id = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "get_camera_feed_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If this is an AR interface that requires displaying a camera feed as the background, this method returns the feed ID in the @CameraServer@ for this interface. get_camera_feed_id :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Int get_camera_feed_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_get_camera_feed_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "get_camera_feed_id" '[] (IO Int) where nodeMethod = Godot.Core.ARVRInterface.get_camera_feed_id {-# NOINLINE bindARVRInterface_get_capabilities #-} -- | Returns a combination of @enum Capabilities@ flags providing information about the capabilities of this interface. bindARVRInterface_get_capabilities :: MethodBind bindARVRInterface_get_capabilities = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "get_capabilities" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a combination of @enum Capabilities@ flags providing information about the capabilities of this interface. get_capabilities :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Int get_capabilities cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_get_capabilities (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "get_capabilities" '[] (IO Int) where nodeMethod = Godot.Core.ARVRInterface.get_capabilities {-# NOINLINE bindARVRInterface_get_name #-} -- | Returns the name of this interface (OpenVR, OpenHMD, ARKit, etc). bindARVRInterface_get_name :: MethodBind bindARVRInterface_get_name = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of this interface (OpenVR, OpenHMD, ARKit, etc). get_name :: (ARVRInterface :< cls, Object :< cls) => cls -> IO GodotString get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "get_name" '[] (IO GodotString) where nodeMethod = Godot.Core.ARVRInterface.get_name {-# NOINLINE bindARVRInterface_get_render_targetsize #-} -- | Returns the resolution at which we should render our intermediate results before things like lens distortion are applied by the VR platform. bindARVRInterface_get_render_targetsize :: MethodBind bindARVRInterface_get_render_targetsize = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "get_render_targetsize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the resolution at which we should render our intermediate results before things like lens distortion are applied by the VR platform. get_render_targetsize :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Vector2 get_render_targetsize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_get_render_targetsize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "get_render_targetsize" '[] (IO Vector2) where nodeMethod = Godot.Core.ARVRInterface.get_render_targetsize {-# NOINLINE bindARVRInterface_get_tracking_status #-} -- | If supported, returns the status of our tracking. This will allow you to provide feedback to the user whether there are issues with positional tracking. bindARVRInterface_get_tracking_status :: MethodBind bindARVRInterface_get_tracking_status = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "get_tracking_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If supported, returns the status of our tracking. This will allow you to provide feedback to the user whether there are issues with positional tracking. get_tracking_status :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Int get_tracking_status cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_get_tracking_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "get_tracking_status" '[] (IO Int) where nodeMethod = Godot.Core.ARVRInterface.get_tracking_status {-# NOINLINE bindARVRInterface_initialize #-} -- | Call this to initialize this interface. The first interface that is initialized is identified as the primary interface and it will be used for rendering output. -- After initializing the interface you want to use you then need to enable the AR/VR mode of a viewport and rendering should commence. -- __Note:__ You must enable the AR/VR mode on the main viewport for any device that uses the main output of Godot, such as for mobile VR. -- If you do this for a platform that handles its own output (such as OpenVR) Godot will show just one eye without distortion on screen. Alternatively, you can add a separate viewport node to your scene and enable AR/VR on that viewport. It will be used to output to the HMD, leaving you free to do anything you like in the main window, such as using a separate camera as a spectator camera or rendering something completely different. -- While currently not used, you can activate additional interfaces. You may wish to do this if you want to track controllers from other platforms. However, at this point in time only one interface can render to an HMD. bindARVRInterface_initialize :: MethodBind bindARVRInterface_initialize = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "initialize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Call this to initialize this interface. The first interface that is initialized is identified as the primary interface and it will be used for rendering output. -- After initializing the interface you want to use you then need to enable the AR/VR mode of a viewport and rendering should commence. -- __Note:__ You must enable the AR/VR mode on the main viewport for any device that uses the main output of Godot, such as for mobile VR. -- If you do this for a platform that handles its own output (such as OpenVR) Godot will show just one eye without distortion on screen. Alternatively, you can add a separate viewport node to your scene and enable AR/VR on that viewport. It will be used to output to the HMD, leaving you free to do anything you like in the main window, such as using a separate camera as a spectator camera or rendering something completely different. -- While currently not used, you can activate additional interfaces. You may wish to do this if you want to track controllers from other platforms. However, at this point in time only one interface can render to an HMD. initialize :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Bool initialize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_initialize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "initialize" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRInterface.initialize {-# NOINLINE bindARVRInterface_is_initialized #-} -- | @true@ if this interface been initialized. bindARVRInterface_is_initialized :: MethodBind bindARVRInterface_is_initialized = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "is_initialized" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @true@ if this interface been initialized. is_initialized :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Bool is_initialized cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_is_initialized (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "is_initialized" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRInterface.is_initialized {-# NOINLINE bindARVRInterface_is_primary #-} -- | @true@ if this is the primary interface. bindARVRInterface_is_primary :: MethodBind bindARVRInterface_is_primary = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "is_primary" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @true@ if this is the primary interface. is_primary :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Bool is_primary cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_is_primary (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "is_primary" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRInterface.is_primary {-# NOINLINE bindARVRInterface_is_stereo #-} -- | Returns @true@ if the current output of this interface is in stereo. bindARVRInterface_is_stereo :: MethodBind bindARVRInterface_is_stereo = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "is_stereo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the current output of this interface is in stereo. is_stereo :: (ARVRInterface :< cls, Object :< cls) => cls -> IO Bool is_stereo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_is_stereo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "is_stereo" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRInterface.is_stereo {-# NOINLINE bindARVRInterface_set_anchor_detection_is_enabled #-} -- | On an AR interface, @true@ if anchor detection is enabled. bindARVRInterface_set_anchor_detection_is_enabled :: MethodBind bindARVRInterface_set_anchor_detection_is_enabled = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "set_anchor_detection_is_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | On an AR interface, @true@ if anchor detection is enabled. set_anchor_detection_is_enabled :: (ARVRInterface :< cls, Object :< cls) => cls -> Bool -> IO () set_anchor_detection_is_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_set_anchor_detection_is_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "set_anchor_detection_is_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.ARVRInterface.set_anchor_detection_is_enabled {-# NOINLINE bindARVRInterface_set_is_initialized #-} -- | @true@ if this interface been initialized. bindARVRInterface_set_is_initialized :: MethodBind bindARVRInterface_set_is_initialized = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "set_is_initialized" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @true@ if this interface been initialized. set_is_initialized :: (ARVRInterface :< cls, Object :< cls) => cls -> Bool -> IO () set_is_initialized cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_set_is_initialized (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "set_is_initialized" '[Bool] (IO ()) where nodeMethod = Godot.Core.ARVRInterface.set_is_initialized {-# NOINLINE bindARVRInterface_set_is_primary #-} -- | @true@ if this is the primary interface. bindARVRInterface_set_is_primary :: MethodBind bindARVRInterface_set_is_primary = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "set_is_primary" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @true@ if this is the primary interface. set_is_primary :: (ARVRInterface :< cls, Object :< cls) => cls -> Bool -> IO () set_is_primary cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_set_is_primary (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "set_is_primary" '[Bool] (IO ()) where nodeMethod = Godot.Core.ARVRInterface.set_is_primary {-# NOINLINE bindARVRInterface_uninitialize #-} -- | Turns the interface off. bindARVRInterface_uninitialize :: MethodBind bindARVRInterface_uninitialize = unsafePerformIO $ withCString "ARVRInterface" $ \ clsNamePtr -> withCString "uninitialize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Turns the interface off. uninitialize :: (ARVRInterface :< cls, Object :< cls) => cls -> IO () uninitialize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRInterface_uninitialize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRInterface "uninitialize" '[] (IO ()) where nodeMethod = Godot.Core.ARVRInterface.uninitialize ================================================ FILE: src/Godot/Core/ARVRInterfaceGDNative.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ARVRInterfaceGDNative () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ARVRInterface() ================================================ FILE: src/Godot/Core/ARVROrigin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ARVROrigin (Godot.Core.ARVROrigin.get_world_scale, Godot.Core.ARVROrigin.set_world_scale) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty ARVROrigin "world_scale" Float 'False where nodeProperty = (get_world_scale, wrapDroppingSetter set_world_scale, Nothing) {-# NOINLINE bindARVROrigin_get_world_scale #-} -- | Allows you to adjust the scale to your game's units. Most AR/VR platforms assume a scale of 1 game world unit = 1 real world meter. -- __Note:__ This method is a passthrough to the @ARVRServer@ itself. bindARVROrigin_get_world_scale :: MethodBind bindARVROrigin_get_world_scale = unsafePerformIO $ withCString "ARVROrigin" $ \ clsNamePtr -> withCString "get_world_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows you to adjust the scale to your game's units. Most AR/VR platforms assume a scale of 1 game world unit = 1 real world meter. -- __Note:__ This method is a passthrough to the @ARVRServer@ itself. get_world_scale :: (ARVROrigin :< cls, Object :< cls) => cls -> IO Float get_world_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVROrigin_get_world_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVROrigin "get_world_scale" '[] (IO Float) where nodeMethod = Godot.Core.ARVROrigin.get_world_scale {-# NOINLINE bindARVROrigin_set_world_scale #-} -- | Allows you to adjust the scale to your game's units. Most AR/VR platforms assume a scale of 1 game world unit = 1 real world meter. -- __Note:__ This method is a passthrough to the @ARVRServer@ itself. bindARVROrigin_set_world_scale :: MethodBind bindARVROrigin_set_world_scale = unsafePerformIO $ withCString "ARVROrigin" $ \ clsNamePtr -> withCString "set_world_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows you to adjust the scale to your game's units. Most AR/VR platforms assume a scale of 1 game world unit = 1 real world meter. -- __Note:__ This method is a passthrough to the @ARVRServer@ itself. set_world_scale :: (ARVROrigin :< cls, Object :< cls) => cls -> Float -> IO () set_world_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVROrigin_set_world_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVROrigin "set_world_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.ARVROrigin.set_world_scale ================================================ FILE: src/Godot/Core/ARVRPositionalTracker.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ARVRPositionalTracker (Godot.Core.ARVRPositionalTracker._TRACKER_LEFT_HAND, Godot.Core.ARVRPositionalTracker._TRACKER_RIGHT_HAND, Godot.Core.ARVRPositionalTracker._TRACKER_HAND_UNKNOWN, Godot.Core.ARVRPositionalTracker._set_joy_id, Godot.Core.ARVRPositionalTracker._set_mesh, Godot.Core.ARVRPositionalTracker._set_name, Godot.Core.ARVRPositionalTracker._set_orientation, Godot.Core.ARVRPositionalTracker._set_rw_position, Godot.Core.ARVRPositionalTracker._set_type, Godot.Core.ARVRPositionalTracker.get_hand, Godot.Core.ARVRPositionalTracker.get_joy_id, Godot.Core.ARVRPositionalTracker.get_mesh, Godot.Core.ARVRPositionalTracker.get_name, Godot.Core.ARVRPositionalTracker.get_orientation, Godot.Core.ARVRPositionalTracker.get_position, Godot.Core.ARVRPositionalTracker.get_rumble, Godot.Core.ARVRPositionalTracker.get_tracks_orientation, Godot.Core.ARVRPositionalTracker.get_tracks_position, Godot.Core.ARVRPositionalTracker.get_transform, Godot.Core.ARVRPositionalTracker.get_type, Godot.Core.ARVRPositionalTracker.set_rumble) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _TRACKER_LEFT_HAND :: Int _TRACKER_LEFT_HAND = 1 _TRACKER_RIGHT_HAND :: Int _TRACKER_RIGHT_HAND = 2 _TRACKER_HAND_UNKNOWN :: Int _TRACKER_HAND_UNKNOWN = 0 instance NodeProperty ARVRPositionalTracker "rumble" Float 'False where nodeProperty = (get_rumble, wrapDroppingSetter set_rumble, Nothing) {-# NOINLINE bindARVRPositionalTracker__set_joy_id #-} bindARVRPositionalTracker__set_joy_id :: MethodBind bindARVRPositionalTracker__set_joy_id = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "_set_joy_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_joy_id :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> Int -> IO () _set_joy_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker__set_joy_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "_set_joy_id" '[Int] (IO ()) where nodeMethod = Godot.Core.ARVRPositionalTracker._set_joy_id {-# NOINLINE bindARVRPositionalTracker__set_mesh #-} bindARVRPositionalTracker__set_mesh :: MethodBind bindARVRPositionalTracker__set_mesh = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "_set_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_mesh :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> Mesh -> IO () _set_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker__set_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "_set_mesh" '[Mesh] (IO ()) where nodeMethod = Godot.Core.ARVRPositionalTracker._set_mesh {-# NOINLINE bindARVRPositionalTracker__set_name #-} bindARVRPositionalTracker__set_name :: MethodBind bindARVRPositionalTracker__set_name = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "_set_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_name :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> GodotString -> IO () _set_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker__set_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "_set_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.ARVRPositionalTracker._set_name {-# NOINLINE bindARVRPositionalTracker__set_orientation #-} bindARVRPositionalTracker__set_orientation :: MethodBind bindARVRPositionalTracker__set_orientation = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "_set_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_orientation :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> Basis -> IO () _set_orientation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker__set_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "_set_orientation" '[Basis] (IO ()) where nodeMethod = Godot.Core.ARVRPositionalTracker._set_orientation {-# NOINLINE bindARVRPositionalTracker__set_rw_position #-} bindARVRPositionalTracker__set_rw_position :: MethodBind bindARVRPositionalTracker__set_rw_position = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "_set_rw_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_rw_position :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> Vector3 -> IO () _set_rw_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker__set_rw_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "_set_rw_position" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ARVRPositionalTracker._set_rw_position {-# NOINLINE bindARVRPositionalTracker__set_type #-} bindARVRPositionalTracker__set_type :: MethodBind bindARVRPositionalTracker__set_type = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "_set_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_type :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> Int -> IO () _set_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker__set_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "_set_type" '[Int] (IO ()) where nodeMethod = Godot.Core.ARVRPositionalTracker._set_type {-# NOINLINE bindARVRPositionalTracker_get_hand #-} -- | Returns the hand holding this tracker, if known. See @enum TrackerHand@ constants. bindARVRPositionalTracker_get_hand :: MethodBind bindARVRPositionalTracker_get_hand = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_hand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the hand holding this tracker, if known. See @enum TrackerHand@ constants. get_hand :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Int get_hand cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_hand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_hand" '[] (IO Int) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_hand {-# NOINLINE bindARVRPositionalTracker_get_joy_id #-} -- | If this is a controller that is being tracked, the controller will also be represented by a joystick entry with this ID. bindARVRPositionalTracker_get_joy_id :: MethodBind bindARVRPositionalTracker_get_joy_id = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_joy_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If this is a controller that is being tracked, the controller will also be represented by a joystick entry with this ID. get_joy_id :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Int get_joy_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_joy_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_joy_id" '[] (IO Int) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_joy_id {-# NOINLINE bindARVRPositionalTracker_get_mesh #-} -- | Returns the mesh related to a controller or anchor point if one is available. bindARVRPositionalTracker_get_mesh :: MethodBind bindARVRPositionalTracker_get_mesh = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the mesh related to a controller or anchor point if one is available. get_mesh :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_mesh {-# NOINLINE bindARVRPositionalTracker_get_name #-} -- | Returns the controller or anchor point's name if available. bindARVRPositionalTracker_get_name :: MethodBind bindARVRPositionalTracker_get_name = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the controller or anchor point's name if available. get_name :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO GodotString get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_name" '[] (IO GodotString) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_name {-# NOINLINE bindARVRPositionalTracker_get_orientation #-} -- | Returns the controller's orientation matrix. bindARVRPositionalTracker_get_orientation :: MethodBind bindARVRPositionalTracker_get_orientation = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the controller's orientation matrix. get_orientation :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Basis get_orientation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_orientation" '[] (IO Basis) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_orientation {-# NOINLINE bindARVRPositionalTracker_get_position #-} -- | Returns the world-space controller position. bindARVRPositionalTracker_get_position :: MethodBind bindARVRPositionalTracker_get_position = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the world-space controller position. get_position :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Vector3 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_position" '[] (IO Vector3) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_position {-# NOINLINE bindARVRPositionalTracker_get_rumble #-} -- | The degree to which the tracker rumbles. Ranges from @0.0@ to @1.0@ with precision @.01@. bindARVRPositionalTracker_get_rumble :: MethodBind bindARVRPositionalTracker_get_rumble = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_rumble" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The degree to which the tracker rumbles. Ranges from @0.0@ to @1.0@ with precision @.01@. get_rumble :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Float get_rumble cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_rumble (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_rumble" '[] (IO Float) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_rumble {-# NOINLINE bindARVRPositionalTracker_get_tracks_orientation #-} -- | Returns @true@ if this device tracks orientation. bindARVRPositionalTracker_get_tracks_orientation :: MethodBind bindARVRPositionalTracker_get_tracks_orientation = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_tracks_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this device tracks orientation. get_tracks_orientation :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Bool get_tracks_orientation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_tracks_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_tracks_orientation" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_tracks_orientation {-# NOINLINE bindARVRPositionalTracker_get_tracks_position #-} -- | Returns @true@ if this device tracks position. bindARVRPositionalTracker_get_tracks_position :: MethodBind bindARVRPositionalTracker_get_tracks_position = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_tracks_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this device tracks position. get_tracks_position :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Bool get_tracks_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_tracks_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_tracks_position" '[] (IO Bool) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_tracks_position {-# NOINLINE bindARVRPositionalTracker_get_transform #-} -- | Returns the transform combining this device's orientation and position. bindARVRPositionalTracker_get_transform :: MethodBind bindARVRPositionalTracker_get_transform = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform combining this device's orientation and position. get_transform :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> Bool -> IO Transform get_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_transform" '[Bool] (IO Transform) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_transform {-# NOINLINE bindARVRPositionalTracker_get_type #-} -- | Returns the tracker's type. bindARVRPositionalTracker_get_type :: MethodBind bindARVRPositionalTracker_get_type = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "get_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tracker's type. get_type :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> IO Int get_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_get_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "get_type" '[] (IO Int) where nodeMethod = Godot.Core.ARVRPositionalTracker.get_type {-# NOINLINE bindARVRPositionalTracker_set_rumble #-} -- | The degree to which the tracker rumbles. Ranges from @0.0@ to @1.0@ with precision @.01@. bindARVRPositionalTracker_set_rumble :: MethodBind bindARVRPositionalTracker_set_rumble = unsafePerformIO $ withCString "ARVRPositionalTracker" $ \ clsNamePtr -> withCString "set_rumble" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The degree to which the tracker rumbles. Ranges from @0.0@ to @1.0@ with precision @.01@. set_rumble :: (ARVRPositionalTracker :< cls, Object :< cls) => cls -> Float -> IO () set_rumble cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRPositionalTracker_set_rumble (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRPositionalTracker "set_rumble" '[Float] (IO ()) where nodeMethod = Godot.Core.ARVRPositionalTracker.set_rumble ================================================ FILE: src/Godot/Core/ARVRServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ARVRServer (Godot.Core.ARVRServer._RESET_BUT_KEEP_TILT, Godot.Core.ARVRServer._RESET_FULL_ROTATION, Godot.Core.ARVRServer._TRACKER_CONTROLLER, Godot.Core.ARVRServer._TRACKER_UNKNOWN, Godot.Core.ARVRServer._TRACKER_ANY_KNOWN, Godot.Core.ARVRServer._DONT_RESET_ROTATION, Godot.Core.ARVRServer._TRACKER_BASESTATION, Godot.Core.ARVRServer._TRACKER_ANCHOR, Godot.Core.ARVRServer._TRACKER_ANY, Godot.Core.ARVRServer.sig_interface_added, Godot.Core.ARVRServer.sig_interface_removed, Godot.Core.ARVRServer.sig_tracker_added, Godot.Core.ARVRServer.sig_tracker_removed, Godot.Core.ARVRServer.center_on_hmd, Godot.Core.ARVRServer.find_interface, Godot.Core.ARVRServer.get_hmd_transform, Godot.Core.ARVRServer.get_interface, Godot.Core.ARVRServer.get_interface_count, Godot.Core.ARVRServer.get_interfaces, Godot.Core.ARVRServer.get_last_commit_usec, Godot.Core.ARVRServer.get_last_frame_usec, Godot.Core.ARVRServer.get_last_process_usec, Godot.Core.ARVRServer.get_primary_interface, Godot.Core.ARVRServer.get_reference_frame, Godot.Core.ARVRServer.get_tracker, Godot.Core.ARVRServer.get_tracker_count, Godot.Core.ARVRServer.get_world_scale, Godot.Core.ARVRServer.set_primary_interface, Godot.Core.ARVRServer.set_world_scale) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _RESET_BUT_KEEP_TILT :: Int _RESET_BUT_KEEP_TILT = 1 _RESET_FULL_ROTATION :: Int _RESET_FULL_ROTATION = 0 _TRACKER_CONTROLLER :: Int _TRACKER_CONTROLLER = 1 _TRACKER_UNKNOWN :: Int _TRACKER_UNKNOWN = 128 _TRACKER_ANY_KNOWN :: Int _TRACKER_ANY_KNOWN = 127 _DONT_RESET_ROTATION :: Int _DONT_RESET_ROTATION = 2 _TRACKER_BASESTATION :: Int _TRACKER_BASESTATION = 2 _TRACKER_ANCHOR :: Int _TRACKER_ANCHOR = 4 _TRACKER_ANY :: Int _TRACKER_ANY = 255 -- | Emitted when a new interface has been added. sig_interface_added :: Godot.Internal.Dispatch.Signal ARVRServer sig_interface_added = Godot.Internal.Dispatch.Signal "interface_added" instance NodeSignal ARVRServer "interface_added" '[GodotString] -- | Emitted when an interface is removed. sig_interface_removed :: Godot.Internal.Dispatch.Signal ARVRServer sig_interface_removed = Godot.Internal.Dispatch.Signal "interface_removed" instance NodeSignal ARVRServer "interface_removed" '[GodotString] -- | Emitted when a new tracker has been added. If you don't use a fixed number of controllers or if you're using @ARVRAnchor@s for an AR solution, it is important to react to this signal to add the appropriate @ARVRController@ or @ARVRAnchor@ nodes related to this new tracker. sig_tracker_added :: Godot.Internal.Dispatch.Signal ARVRServer sig_tracker_added = Godot.Internal.Dispatch.Signal "tracker_added" instance NodeSignal ARVRServer "tracker_added" '[GodotString, Int, Int] -- | Emitted when a tracker is removed. You should remove any @ARVRController@ or @ARVRAnchor@ points if applicable. This is not mandatory, the nodes simply become inactive and will be made active again when a new tracker becomes available (i.e. a new controller is switched on that takes the place of the previous one). sig_tracker_removed :: Godot.Internal.Dispatch.Signal ARVRServer sig_tracker_removed = Godot.Internal.Dispatch.Signal "tracker_removed" instance NodeSignal ARVRServer "tracker_removed" '[GodotString, Int, Int] instance NodeProperty ARVRServer "primary_interface" ARVRInterface 'False where nodeProperty = (get_primary_interface, wrapDroppingSetter set_primary_interface, Nothing) instance NodeProperty ARVRServer "world_scale" Float 'False where nodeProperty = (get_world_scale, wrapDroppingSetter set_world_scale, Nothing) {-# NOINLINE bindARVRServer_center_on_hmd #-} -- | This is an important function to understand correctly. AR and VR platforms all handle positioning slightly differently. -- For platforms that do not offer spatial tracking, our origin point (0,0,0) is the location of our HMD, but you have little control over the direction the player is facing in the real world. -- For platforms that do offer spatial tracking, our origin point depends very much on the system. For OpenVR, our origin point is usually the center of the tracking space, on the ground. For other platforms, it's often the location of the tracking camera. -- This method allows you to center your tracker on the location of the HMD. It will take the current location of the HMD and use that to adjust all your tracking data; in essence, realigning the real world to your player's current position in the game world. -- For this method to produce usable results, tracking information must be available. This often takes a few frames after starting your game. -- You should call this method after a few seconds have passed. For instance, when the user requests a realignment of the display holding a designated button on a controller for a short period of time, or when implementing a teleport mechanism. bindARVRServer_center_on_hmd :: MethodBind bindARVRServer_center_on_hmd = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "center_on_hmd" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This is an important function to understand correctly. AR and VR platforms all handle positioning slightly differently. -- For platforms that do not offer spatial tracking, our origin point (0,0,0) is the location of our HMD, but you have little control over the direction the player is facing in the real world. -- For platforms that do offer spatial tracking, our origin point depends very much on the system. For OpenVR, our origin point is usually the center of the tracking space, on the ground. For other platforms, it's often the location of the tracking camera. -- This method allows you to center your tracker on the location of the HMD. It will take the current location of the HMD and use that to adjust all your tracking data; in essence, realigning the real world to your player's current position in the game world. -- For this method to produce usable results, tracking information must be available. This often takes a few frames after starting your game. -- You should call this method after a few seconds have passed. For instance, when the user requests a realignment of the display holding a designated button on a controller for a short period of time, or when implementing a teleport mechanism. center_on_hmd :: (ARVRServer :< cls, Object :< cls) => cls -> Int -> Bool -> IO () center_on_hmd cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_center_on_hmd (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "center_on_hmd" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.ARVRServer.center_on_hmd {-# NOINLINE bindARVRServer_find_interface #-} -- | Finds an interface by its name. For instance, if your project uses capabilities of an AR/VR platform, you can find the interface for that platform by name and initialize it. bindARVRServer_find_interface :: MethodBind bindARVRServer_find_interface = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "find_interface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Finds an interface by its name. For instance, if your project uses capabilities of an AR/VR platform, you can find the interface for that platform by name and initialize it. find_interface :: (ARVRServer :< cls, Object :< cls) => cls -> GodotString -> IO ARVRInterface find_interface cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_find_interface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "find_interface" '[GodotString] (IO ARVRInterface) where nodeMethod = Godot.Core.ARVRServer.find_interface {-# NOINLINE bindARVRServer_get_hmd_transform #-} -- | Returns the primary interface's transformation. bindARVRServer_get_hmd_transform :: MethodBind bindARVRServer_get_hmd_transform = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_hmd_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the primary interface's transformation. get_hmd_transform :: (ARVRServer :< cls, Object :< cls) => cls -> IO Transform get_hmd_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_hmd_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_hmd_transform" '[] (IO Transform) where nodeMethod = Godot.Core.ARVRServer.get_hmd_transform {-# NOINLINE bindARVRServer_get_interface #-} -- | Returns the interface registered at a given index in our list of interfaces. bindARVRServer_get_interface :: MethodBind bindARVRServer_get_interface = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_interface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the interface registered at a given index in our list of interfaces. get_interface :: (ARVRServer :< cls, Object :< cls) => cls -> Int -> IO ARVRInterface get_interface cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_interface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_interface" '[Int] (IO ARVRInterface) where nodeMethod = Godot.Core.ARVRServer.get_interface {-# NOINLINE bindARVRServer_get_interface_count #-} -- | Returns the number of interfaces currently registered with the AR/VR server. If your project supports multiple AR/VR platforms, you can look through the available interface, and either present the user with a selection or simply try to initialize each interface and use the first one that returns @true@. bindARVRServer_get_interface_count :: MethodBind bindARVRServer_get_interface_count = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_interface_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of interfaces currently registered with the AR/VR server. If your project supports multiple AR/VR platforms, you can look through the available interface, and either present the user with a selection or simply try to initialize each interface and use the first one that returns @true@. get_interface_count :: (ARVRServer :< cls, Object :< cls) => cls -> IO Int get_interface_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_interface_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_interface_count" '[] (IO Int) where nodeMethod = Godot.Core.ARVRServer.get_interface_count {-# NOINLINE bindARVRServer_get_interfaces #-} -- | Returns a list of available interfaces the ID and name of each interface. bindARVRServer_get_interfaces :: MethodBind bindARVRServer_get_interfaces = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_interfaces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of available interfaces the ID and name of each interface. get_interfaces :: (ARVRServer :< cls, Object :< cls) => cls -> IO Array get_interfaces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_interfaces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_interfaces" '[] (IO Array) where nodeMethod = Godot.Core.ARVRServer.get_interfaces {-# NOINLINE bindARVRServer_get_last_commit_usec #-} -- | Returns the absolute timestamp (in μs) of the last @ARVRServer@ commit of the AR/VR eyes to @VisualServer@. The value comes from an internal call to @method OS.get_ticks_usec@. bindARVRServer_get_last_commit_usec :: MethodBind bindARVRServer_get_last_commit_usec = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_last_commit_usec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the absolute timestamp (in μs) of the last @ARVRServer@ commit of the AR/VR eyes to @VisualServer@. The value comes from an internal call to @method OS.get_ticks_usec@. get_last_commit_usec :: (ARVRServer :< cls, Object :< cls) => cls -> IO Int get_last_commit_usec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_last_commit_usec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_last_commit_usec" '[] (IO Int) where nodeMethod = Godot.Core.ARVRServer.get_last_commit_usec {-# NOINLINE bindARVRServer_get_last_frame_usec #-} -- | Returns the duration (in μs) of the last frame. This is computed as the difference between @method get_last_commit_usec@ and @method get_last_process_usec@ when committing. bindARVRServer_get_last_frame_usec :: MethodBind bindARVRServer_get_last_frame_usec = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_last_frame_usec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the duration (in μs) of the last frame. This is computed as the difference between @method get_last_commit_usec@ and @method get_last_process_usec@ when committing. get_last_frame_usec :: (ARVRServer :< cls, Object :< cls) => cls -> IO Int get_last_frame_usec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_last_frame_usec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_last_frame_usec" '[] (IO Int) where nodeMethod = Godot.Core.ARVRServer.get_last_frame_usec {-# NOINLINE bindARVRServer_get_last_process_usec #-} -- | Returns the absolute timestamp (in μs) of the last @ARVRServer@ process callback. The value comes from an internal call to @method OS.get_ticks_usec@. bindARVRServer_get_last_process_usec :: MethodBind bindARVRServer_get_last_process_usec = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_last_process_usec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the absolute timestamp (in μs) of the last @ARVRServer@ process callback. The value comes from an internal call to @method OS.get_ticks_usec@. get_last_process_usec :: (ARVRServer :< cls, Object :< cls) => cls -> IO Int get_last_process_usec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_last_process_usec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_last_process_usec" '[] (IO Int) where nodeMethod = Godot.Core.ARVRServer.get_last_process_usec {-# NOINLINE bindARVRServer_get_primary_interface #-} -- | The primary @ARVRInterface@ currently bound to the @ARVRServer@. bindARVRServer_get_primary_interface :: MethodBind bindARVRServer_get_primary_interface = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_primary_interface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The primary @ARVRInterface@ currently bound to the @ARVRServer@. get_primary_interface :: (ARVRServer :< cls, Object :< cls) => cls -> IO ARVRInterface get_primary_interface cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_primary_interface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_primary_interface" '[] (IO ARVRInterface) where nodeMethod = Godot.Core.ARVRServer.get_primary_interface {-# NOINLINE bindARVRServer_get_reference_frame #-} -- | Returns the reference frame transform. Mostly used internally and exposed for GDNative build interfaces. bindARVRServer_get_reference_frame :: MethodBind bindARVRServer_get_reference_frame = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_reference_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the reference frame transform. Mostly used internally and exposed for GDNative build interfaces. get_reference_frame :: (ARVRServer :< cls, Object :< cls) => cls -> IO Transform get_reference_frame cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_reference_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_reference_frame" '[] (IO Transform) where nodeMethod = Godot.Core.ARVRServer.get_reference_frame {-# NOINLINE bindARVRServer_get_tracker #-} -- | Returns the positional tracker at the given ID. bindARVRServer_get_tracker :: MethodBind bindARVRServer_get_tracker = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_tracker" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the positional tracker at the given ID. get_tracker :: (ARVRServer :< cls, Object :< cls) => cls -> Int -> IO ARVRPositionalTracker get_tracker cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_tracker (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_tracker" '[Int] (IO ARVRPositionalTracker) where nodeMethod = Godot.Core.ARVRServer.get_tracker {-# NOINLINE bindARVRServer_get_tracker_count #-} -- | Returns the number of trackers currently registered. bindARVRServer_get_tracker_count :: MethodBind bindARVRServer_get_tracker_count = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_tracker_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of trackers currently registered. get_tracker_count :: (ARVRServer :< cls, Object :< cls) => cls -> IO Int get_tracker_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_tracker_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_tracker_count" '[] (IO Int) where nodeMethod = Godot.Core.ARVRServer.get_tracker_count {-# NOINLINE bindARVRServer_get_world_scale #-} -- | Allows you to adjust the scale to your game's units. Most AR/VR platforms assume a scale of 1 game world unit = 1 real world meter. bindARVRServer_get_world_scale :: MethodBind bindARVRServer_get_world_scale = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "get_world_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows you to adjust the scale to your game's units. Most AR/VR platforms assume a scale of 1 game world unit = 1 real world meter. get_world_scale :: (ARVRServer :< cls, Object :< cls) => cls -> IO Float get_world_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_get_world_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "get_world_scale" '[] (IO Float) where nodeMethod = Godot.Core.ARVRServer.get_world_scale {-# NOINLINE bindARVRServer_set_primary_interface #-} -- | The primary @ARVRInterface@ currently bound to the @ARVRServer@. bindARVRServer_set_primary_interface :: MethodBind bindARVRServer_set_primary_interface = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "set_primary_interface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The primary @ARVRInterface@ currently bound to the @ARVRServer@. set_primary_interface :: (ARVRServer :< cls, Object :< cls) => cls -> ARVRInterface -> IO () set_primary_interface cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_set_primary_interface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "set_primary_interface" '[ARVRInterface] (IO ()) where nodeMethod = Godot.Core.ARVRServer.set_primary_interface {-# NOINLINE bindARVRServer_set_world_scale #-} -- | Allows you to adjust the scale to your game's units. Most AR/VR platforms assume a scale of 1 game world unit = 1 real world meter. bindARVRServer_set_world_scale :: MethodBind bindARVRServer_set_world_scale = unsafePerformIO $ withCString "ARVRServer" $ \ clsNamePtr -> withCString "set_world_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows you to adjust the scale to your game's units. Most AR/VR platforms assume a scale of 1 game world unit = 1 real world meter. set_world_scale :: (ARVRServer :< cls, Object :< cls) => cls -> Float -> IO () set_world_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindARVRServer_set_world_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ARVRServer "set_world_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.ARVRServer.set_world_scale ================================================ FILE: src/Godot/Core/AStar.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AStar (Godot.Core.AStar._compute_cost, Godot.Core.AStar._estimate_cost, Godot.Core.AStar.add_point, Godot.Core.AStar.are_points_connected, Godot.Core.AStar.clear, Godot.Core.AStar.connect_points, Godot.Core.AStar.disconnect_points, Godot.Core.AStar.get_available_point_id, Godot.Core.AStar.get_closest_point, Godot.Core.AStar.get_closest_position_in_segment, Godot.Core.AStar.get_id_path, Godot.Core.AStar.get_point_capacity, Godot.Core.AStar.get_point_connections, Godot.Core.AStar.get_point_count, Godot.Core.AStar.get_point_path, Godot.Core.AStar.get_point_position, Godot.Core.AStar.get_point_weight_scale, Godot.Core.AStar.get_points, Godot.Core.AStar.has_point, Godot.Core.AStar.is_point_disabled, Godot.Core.AStar.remove_point, Godot.Core.AStar.reserve_space, Godot.Core.AStar.set_point_disabled, Godot.Core.AStar.set_point_position, Godot.Core.AStar.set_point_weight_scale) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindAStar__compute_cost #-} -- | Called when computing the cost between two connected points. -- Note that this function is hidden in the default @AStar@ class. bindAStar__compute_cost :: MethodBind bindAStar__compute_cost = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "_compute_cost" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when computing the cost between two connected points. -- Note that this function is hidden in the default @AStar@ class. _compute_cost :: (AStar :< cls, Object :< cls) => cls -> Int -> Int -> IO Float _compute_cost cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar__compute_cost (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "_compute_cost" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.AStar._compute_cost {-# NOINLINE bindAStar__estimate_cost #-} -- | Called when estimating the cost between a point and the path's ending point. -- Note that this function is hidden in the default @AStar@ class. bindAStar__estimate_cost :: MethodBind bindAStar__estimate_cost = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "_estimate_cost" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when estimating the cost between a point and the path's ending point. -- Note that this function is hidden in the default @AStar@ class. _estimate_cost :: (AStar :< cls, Object :< cls) => cls -> Int -> Int -> IO Float _estimate_cost cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar__estimate_cost (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "_estimate_cost" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.AStar._estimate_cost {-# NOINLINE bindAStar_add_point #-} -- | Adds a new point at the given position with the given identifier. The algorithm prefers points with lower @weight_scale@ to form a path. The @id@ must be 0 or larger, and the @weight_scale@ must be 1 or larger. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(1, 0, 0), 4) # Adds the point (1, 0, 0) with weight_scale 4 and id 1 -- -- @ -- -- If there already exists a point for the given @id@, its position and weight scale are updated to the given values. bindAStar_add_point :: MethodBind bindAStar_add_point = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "add_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new point at the given position with the given identifier. The algorithm prefers points with lower @weight_scale@ to form a path. The @id@ must be 0 or larger, and the @weight_scale@ must be 1 or larger. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(1, 0, 0), 4) # Adds the point (1, 0, 0) with weight_scale 4 and id 1 -- -- @ -- -- If there already exists a point for the given @id@, its position and weight scale are updated to the given values. add_point :: (AStar :< cls, Object :< cls) => cls -> Int -> Vector3 -> Maybe Float -> IO () add_point cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantReal (1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_add_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "add_point" '[Int, Vector3, Maybe Float] (IO ()) where nodeMethod = Godot.Core.AStar.add_point {-# NOINLINE bindAStar_are_points_connected #-} -- | Returns whether the two given points are directly connected by a segment. If @bidirectional@ is @false@, returns whether movement from @id@ to @to_id@ is possible through this segment. bindAStar_are_points_connected :: MethodBind bindAStar_are_points_connected = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "are_points_connected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the two given points are directly connected by a segment. If @bidirectional@ is @false@, returns whether movement from @id@ to @to_id@ is possible through this segment. are_points_connected :: (AStar :< cls, Object :< cls) => cls -> Int -> Int -> Maybe Bool -> IO Bool are_points_connected cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_are_points_connected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "are_points_connected" '[Int, Int, Maybe Bool] (IO Bool) where nodeMethod = Godot.Core.AStar.are_points_connected {-# NOINLINE bindAStar_clear #-} -- | Clears all the points and segments. bindAStar_clear :: MethodBind bindAStar_clear = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all the points and segments. clear :: (AStar :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "clear" '[] (IO ()) where nodeMethod = Godot.Core.AStar.clear {-# NOINLINE bindAStar_connect_points #-} -- | Creates a segment between the given points. If @bidirectional@ is @false@, only movement from @id@ to @to_id@ is allowed, not the reverse direction. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(1, 1, 0)) -- astar.add_point(2, Vector3(0, 5, 0)) -- astar.connect_points(1, 2, false) -- -- @ bindAStar_connect_points :: MethodBind bindAStar_connect_points = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "connect_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a segment between the given points. If @bidirectional@ is @false@, only movement from @id@ to @to_id@ is allowed, not the reverse direction. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(1, 1, 0)) -- astar.add_point(2, Vector3(0, 5, 0)) -- astar.connect_points(1, 2, false) -- -- @ connect_points :: (AStar :< cls, Object :< cls) => cls -> Int -> Int -> Maybe Bool -> IO () connect_points cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_connect_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "connect_points" '[Int, Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AStar.connect_points {-# NOINLINE bindAStar_disconnect_points #-} -- | Deletes the segment between the given points. If @bidirectional@ is @false@, only movement from @id@ to @to_id@ is prevented, and a unidirectional segment possibly remains. bindAStar_disconnect_points :: MethodBind bindAStar_disconnect_points = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "disconnect_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the segment between the given points. If @bidirectional@ is @false@, only movement from @id@ to @to_id@ is prevented, and a unidirectional segment possibly remains. disconnect_points :: (AStar :< cls, Object :< cls) => cls -> Int -> Int -> Maybe Bool -> IO () disconnect_points cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_disconnect_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "disconnect_points" '[Int, Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AStar.disconnect_points {-# NOINLINE bindAStar_get_available_point_id #-} -- | Returns the next available point ID with no point associated to it. bindAStar_get_available_point_id :: MethodBind bindAStar_get_available_point_id = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_available_point_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next available point ID with no point associated to it. get_available_point_id :: (AStar :< cls, Object :< cls) => cls -> IO Int get_available_point_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_available_point_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_available_point_id" '[] (IO Int) where nodeMethod = Godot.Core.AStar.get_available_point_id {-# NOINLINE bindAStar_get_closest_point #-} -- | Returns the ID of the closest point to @to_position@, optionally taking disabled points into account. Returns @-1@ if there are no points in the points pool. -- __Note:__ If several points are the closest to @to_position@, the one with the smallest ID will be returned, ensuring a deterministic result. bindAStar_get_closest_point :: MethodBind bindAStar_get_closest_point = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_closest_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the ID of the closest point to @to_position@, optionally taking disabled points into account. Returns @-1@ if there are no points in the points pool. -- __Note:__ If several points are the closest to @to_position@, the one with the smallest ID will be returned, ensuring a deterministic result. get_closest_point :: (AStar :< cls, Object :< cls) => cls -> Vector3 -> Maybe Bool -> IO Int get_closest_point cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_closest_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_closest_point" '[Vector3, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.AStar.get_closest_point {-# NOINLINE bindAStar_get_closest_position_in_segment #-} -- | Returns the closest position to @to_position@ that resides inside a segment between two connected points. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(0, 0, 0)) -- astar.add_point(2, Vector3(0, 5, 0)) -- astar.connect_points(1, 2) -- var res = astar.get_closest_position_in_segment(Vector3(3, 3, 0)) # Returns (0, 3, 0) -- -- @ -- -- The result is in the segment that goes from @y = 0@ to @y = 5@. It's the closest position in the segment to the given point. bindAStar_get_closest_position_in_segment :: MethodBind bindAStar_get_closest_position_in_segment = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_closest_position_in_segment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the closest position to @to_position@ that resides inside a segment between two connected points. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(0, 0, 0)) -- astar.add_point(2, Vector3(0, 5, 0)) -- astar.connect_points(1, 2) -- var res = astar.get_closest_position_in_segment(Vector3(3, 3, 0)) # Returns (0, 3, 0) -- -- @ -- -- The result is in the segment that goes from @y = 0@ to @y = 5@. It's the closest position in the segment to the given point. get_closest_position_in_segment :: (AStar :< cls, Object :< cls) => cls -> Vector3 -> IO Vector3 get_closest_position_in_segment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_closest_position_in_segment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_closest_position_in_segment" '[Vector3] (IO Vector3) where nodeMethod = Godot.Core.AStar.get_closest_position_in_segment {-# NOINLINE bindAStar_get_id_path #-} -- | Returns an array with the IDs of the points that form the path found by AStar between the given points. The array is ordered from the starting point to the ending point of the path. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(0, 0, 0)) -- astar.add_point(2, Vector3(0, 1, 0), 1) # Default weight is 1 -- astar.add_point(3, Vector3(1, 1, 0)) -- astar.add_point(4, Vector3(2, 0, 0)) -- -- astar.connect_points(1, 2, false) -- astar.connect_points(2, 3, false) -- astar.connect_points(4, 3, false) -- astar.connect_points(1, 4, false) -- -- var res = astar.get_id_path(1, 3) # Returns @1, 2, 3@ -- -- @ -- -- If you change the 2nd point's weight to 3, then the result will be @@1, 4, 3@@ instead, because now even though the distance is longer, it's "easier" to get through point 4 than through point 2. bindAStar_get_id_path :: MethodBind bindAStar_get_id_path = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_id_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with the IDs of the points that form the path found by AStar between the given points. The array is ordered from the starting point to the ending point of the path. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(0, 0, 0)) -- astar.add_point(2, Vector3(0, 1, 0), 1) # Default weight is 1 -- astar.add_point(3, Vector3(1, 1, 0)) -- astar.add_point(4, Vector3(2, 0, 0)) -- -- astar.connect_points(1, 2, false) -- astar.connect_points(2, 3, false) -- astar.connect_points(4, 3, false) -- astar.connect_points(1, 4, false) -- -- var res = astar.get_id_path(1, 3) # Returns @1, 2, 3@ -- -- @ -- -- If you change the 2nd point's weight to 3, then the result will be @@1, 4, 3@@ instead, because now even though the distance is longer, it's "easier" to get through point 4 than through point 2. get_id_path :: (AStar :< cls, Object :< cls) => cls -> Int -> Int -> IO PoolIntArray get_id_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_id_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_id_path" '[Int, Int] (IO PoolIntArray) where nodeMethod = Godot.Core.AStar.get_id_path {-# NOINLINE bindAStar_get_point_capacity #-} -- | Returns the capacity of the structure backing the points, useful in conjunction with @reserve_space@. bindAStar_get_point_capacity :: MethodBind bindAStar_get_point_capacity = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_point_capacity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the capacity of the structure backing the points, useful in conjunction with @reserve_space@. get_point_capacity :: (AStar :< cls, Object :< cls) => cls -> IO Int get_point_capacity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_point_capacity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_point_capacity" '[] (IO Int) where nodeMethod = Godot.Core.AStar.get_point_capacity {-# NOINLINE bindAStar_get_point_connections #-} -- | Returns an array with the IDs of the points that form the connection with the given point. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(0, 0, 0)) -- astar.add_point(2, Vector3(0, 1, 0)) -- astar.add_point(3, Vector3(1, 1, 0)) -- astar.add_point(4, Vector3(2, 0, 0)) -- -- astar.connect_points(1, 2, true) -- astar.connect_points(1, 3, true) -- -- var neighbors = astar.get_point_connections(1) # Returns @2, 3@ -- -- @ bindAStar_get_point_connections :: MethodBind bindAStar_get_point_connections = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_point_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with the IDs of the points that form the connection with the given point. -- -- @ -- -- var astar = AStar.new() -- astar.add_point(1, Vector3(0, 0, 0)) -- astar.add_point(2, Vector3(0, 1, 0)) -- astar.add_point(3, Vector3(1, 1, 0)) -- astar.add_point(4, Vector3(2, 0, 0)) -- -- astar.connect_points(1, 2, true) -- astar.connect_points(1, 3, true) -- -- var neighbors = astar.get_point_connections(1) # Returns @2, 3@ -- -- @ get_point_connections :: (AStar :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_point_connections cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_point_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_point_connections" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.AStar.get_point_connections {-# NOINLINE bindAStar_get_point_count #-} -- | Returns the number of points currently in the points pool. bindAStar_get_point_count :: MethodBind bindAStar_get_point_count = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of points currently in the points pool. get_point_count :: (AStar :< cls, Object :< cls) => cls -> IO Int get_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_point_count" '[] (IO Int) where nodeMethod = Godot.Core.AStar.get_point_count {-# NOINLINE bindAStar_get_point_path #-} -- | Returns an array with the points that are in the path found by AStar between the given points. The array is ordered from the starting point to the ending point of the path. bindAStar_get_point_path :: MethodBind bindAStar_get_point_path = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_point_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with the points that are in the path found by AStar between the given points. The array is ordered from the starting point to the ending point of the path. get_point_path :: (AStar :< cls, Object :< cls) => cls -> Int -> Int -> IO PoolVector3Array get_point_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_point_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_point_path" '[Int, Int] (IO PoolVector3Array) where nodeMethod = Godot.Core.AStar.get_point_path {-# NOINLINE bindAStar_get_point_position #-} -- | Returns the position of the point associated with the given @id@. bindAStar_get_point_position :: MethodBind bindAStar_get_point_position = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the point associated with the given @id@. get_point_position :: (AStar :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_point_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_point_position" '[Int] (IO Vector3) where nodeMethod = Godot.Core.AStar.get_point_position {-# NOINLINE bindAStar_get_point_weight_scale #-} -- | Returns the weight scale of the point associated with the given @id@. bindAStar_get_point_weight_scale :: MethodBind bindAStar_get_point_weight_scale = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_point_weight_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the weight scale of the point associated with the given @id@. get_point_weight_scale :: (AStar :< cls, Object :< cls) => cls -> Int -> IO Float get_point_weight_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_point_weight_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_point_weight_scale" '[Int] (IO Float) where nodeMethod = Godot.Core.AStar.get_point_weight_scale {-# NOINLINE bindAStar_get_points #-} -- | Returns an array of all points. bindAStar_get_points :: MethodBind bindAStar_get_points = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "get_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of all points. get_points :: (AStar :< cls, Object :< cls) => cls -> IO Array get_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_get_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "get_points" '[] (IO Array) where nodeMethod = Godot.Core.AStar.get_points {-# NOINLINE bindAStar_has_point #-} -- | Returns whether a point associated with the given @id@ exists. bindAStar_has_point :: MethodBind bindAStar_has_point = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "has_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a point associated with the given @id@ exists. has_point :: (AStar :< cls, Object :< cls) => cls -> Int -> IO Bool has_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_has_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "has_point" '[Int] (IO Bool) where nodeMethod = Godot.Core.AStar.has_point {-# NOINLINE bindAStar_is_point_disabled #-} -- | Returns whether a point is disabled or not for pathfinding. By default, all points are enabled. bindAStar_is_point_disabled :: MethodBind bindAStar_is_point_disabled = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "is_point_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a point is disabled or not for pathfinding. By default, all points are enabled. is_point_disabled :: (AStar :< cls, Object :< cls) => cls -> Int -> IO Bool is_point_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_is_point_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "is_point_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.AStar.is_point_disabled {-# NOINLINE bindAStar_remove_point #-} -- | Removes the point associated with the given @id@ from the points pool. bindAStar_remove_point :: MethodBind bindAStar_remove_point = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "remove_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the point associated with the given @id@ from the points pool. remove_point :: (AStar :< cls, Object :< cls) => cls -> Int -> IO () remove_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_remove_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "remove_point" '[Int] (IO ()) where nodeMethod = Godot.Core.AStar.remove_point {-# NOINLINE bindAStar_reserve_space #-} -- | Reserves space internally for @num_nodes@ points, useful if you're adding a known large number of points at once, for a grid for instance. New capacity must be greater or equals to old capacity. bindAStar_reserve_space :: MethodBind bindAStar_reserve_space = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "reserve_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reserves space internally for @num_nodes@ points, useful if you're adding a known large number of points at once, for a grid for instance. New capacity must be greater or equals to old capacity. reserve_space :: (AStar :< cls, Object :< cls) => cls -> Int -> IO () reserve_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_reserve_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "reserve_space" '[Int] (IO ()) where nodeMethod = Godot.Core.AStar.reserve_space {-# NOINLINE bindAStar_set_point_disabled #-} -- | Disables or enables the specified point for pathfinding. Useful for making a temporary obstacle. bindAStar_set_point_disabled :: MethodBind bindAStar_set_point_disabled = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "set_point_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables or enables the specified point for pathfinding. Useful for making a temporary obstacle. set_point_disabled :: (AStar :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO () set_point_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_set_point_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "set_point_disabled" '[Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AStar.set_point_disabled {-# NOINLINE bindAStar_set_point_position #-} -- | Sets the @position@ for the point with the given @id@. bindAStar_set_point_position :: MethodBind bindAStar_set_point_position = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "set_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @position@ for the point with the given @id@. set_point_position :: (AStar :< cls, Object :< cls) => cls -> Int -> Vector3 -> IO () set_point_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_set_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "set_point_position" '[Int, Vector3] (IO ()) where nodeMethod = Godot.Core.AStar.set_point_position {-# NOINLINE bindAStar_set_point_weight_scale #-} -- | Sets the @weight_scale@ for the point with the given @id@. bindAStar_set_point_weight_scale :: MethodBind bindAStar_set_point_weight_scale = unsafePerformIO $ withCString "AStar" $ \ clsNamePtr -> withCString "set_point_weight_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @weight_scale@ for the point with the given @id@. set_point_weight_scale :: (AStar :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_point_weight_scale cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar_set_point_weight_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar "set_point_weight_scale" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AStar.set_point_weight_scale ================================================ FILE: src/Godot/Core/AStar2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AStar2D (Godot.Core.AStar2D.add_point, Godot.Core.AStar2D.are_points_connected, Godot.Core.AStar2D.clear, Godot.Core.AStar2D.connect_points, Godot.Core.AStar2D.disconnect_points, Godot.Core.AStar2D.get_available_point_id, Godot.Core.AStar2D.get_closest_point, Godot.Core.AStar2D.get_closest_position_in_segment, Godot.Core.AStar2D.get_id_path, Godot.Core.AStar2D.get_point_capacity, Godot.Core.AStar2D.get_point_connections, Godot.Core.AStar2D.get_point_count, Godot.Core.AStar2D.get_point_path, Godot.Core.AStar2D.get_point_position, Godot.Core.AStar2D.get_point_weight_scale, Godot.Core.AStar2D.get_points, Godot.Core.AStar2D.has_point, Godot.Core.AStar2D.is_point_disabled, Godot.Core.AStar2D.remove_point, Godot.Core.AStar2D.reserve_space, Godot.Core.AStar2D.set_point_disabled, Godot.Core.AStar2D.set_point_position, Godot.Core.AStar2D.set_point_weight_scale) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindAStar2D_add_point #-} -- | Adds a new point at the given position with the given identifier. The algorithm prefers points with lower @weight_scale@ to form a path. The @id@ must be 0 or larger, and the @weight_scale@ must be 1 or larger. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(1, 0), 4) # Adds the point (1, 0) with weight_scale 4 and id 1 -- -- @ -- -- If there already exists a point for the given @id@, its position and weight scale are updated to the given values. bindAStar2D_add_point :: MethodBind bindAStar2D_add_point = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "add_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new point at the given position with the given identifier. The algorithm prefers points with lower @weight_scale@ to form a path. The @id@ must be 0 or larger, and the @weight_scale@ must be 1 or larger. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(1, 0), 4) # Adds the point (1, 0) with weight_scale 4 and id 1 -- -- @ -- -- If there already exists a point for the given @id@, its position and weight scale are updated to the given values. add_point :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Vector2 -> Maybe Float -> IO () add_point cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantReal (1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_add_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "add_point" '[Int, Vector2, Maybe Float] (IO ()) where nodeMethod = Godot.Core.AStar2D.add_point {-# NOINLINE bindAStar2D_are_points_connected #-} -- | Returns whether there is a connection/segment between the given points. bindAStar2D_are_points_connected :: MethodBind bindAStar2D_are_points_connected = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "are_points_connected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether there is a connection/segment between the given points. are_points_connected :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool are_points_connected cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_are_points_connected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "are_points_connected" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.AStar2D.are_points_connected {-# NOINLINE bindAStar2D_clear #-} -- | Clears all the points and segments. bindAStar2D_clear :: MethodBind bindAStar2D_clear = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all the points and segments. clear :: (AStar2D :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "clear" '[] (IO ()) where nodeMethod = Godot.Core.AStar2D.clear {-# NOINLINE bindAStar2D_connect_points #-} -- | Creates a segment between the given points. If @bidirectional@ is @false@, only movement from @id@ to @to_id@ is allowed, not the reverse direction. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(1, 1)) -- astar.add_point(2, Vector2(0, 5)) -- astar.connect_points(1, 2, false) -- -- @ bindAStar2D_connect_points :: MethodBind bindAStar2D_connect_points = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "connect_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a segment between the given points. If @bidirectional@ is @false@, only movement from @id@ to @to_id@ is allowed, not the reverse direction. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(1, 1)) -- astar.add_point(2, Vector2(0, 5)) -- astar.connect_points(1, 2, false) -- -- @ connect_points :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Int -> Maybe Bool -> IO () connect_points cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_connect_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "connect_points" '[Int, Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AStar2D.connect_points {-# NOINLINE bindAStar2D_disconnect_points #-} -- | Deletes the segment between the given points. bindAStar2D_disconnect_points :: MethodBind bindAStar2D_disconnect_points = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "disconnect_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the segment between the given points. disconnect_points :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Int -> IO () disconnect_points cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_disconnect_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "disconnect_points" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.AStar2D.disconnect_points {-# NOINLINE bindAStar2D_get_available_point_id #-} -- | Returns the next available point ID with no point associated to it. bindAStar2D_get_available_point_id :: MethodBind bindAStar2D_get_available_point_id = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_available_point_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next available point ID with no point associated to it. get_available_point_id :: (AStar2D :< cls, Object :< cls) => cls -> IO Int get_available_point_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_available_point_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_available_point_id" '[] (IO Int) where nodeMethod = Godot.Core.AStar2D.get_available_point_id {-# NOINLINE bindAStar2D_get_closest_point #-} -- | Returns the ID of the closest point to @to_position@, optionally taking disabled points into account. Returns @-1@ if there are no points in the points pool. -- __Note:__ If several points are the closest to @to_position@, the one with the smallest ID will be returned, ensuring a deterministic result. bindAStar2D_get_closest_point :: MethodBind bindAStar2D_get_closest_point = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_closest_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the ID of the closest point to @to_position@, optionally taking disabled points into account. Returns @-1@ if there are no points in the points pool. -- __Note:__ If several points are the closest to @to_position@, the one with the smallest ID will be returned, ensuring a deterministic result. get_closest_point :: (AStar2D :< cls, Object :< cls) => cls -> Vector2 -> Maybe Bool -> IO Int get_closest_point cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_closest_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_closest_point" '[Vector2, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.AStar2D.get_closest_point {-# NOINLINE bindAStar2D_get_closest_position_in_segment #-} -- | Returns the closest position to @to_position@ that resides inside a segment between two connected points. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(0, 0)) -- astar.add_point(2, Vector2(0, 5)) -- astar.connect_points(1, 2) -- var res = astar.get_closest_position_in_segment(Vector2(3, 3)) # Returns (0, 3) -- -- @ -- -- The result is in the segment that goes from @y = 0@ to @y = 5@. It's the closest position in the segment to the given point. bindAStar2D_get_closest_position_in_segment :: MethodBind bindAStar2D_get_closest_position_in_segment = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_closest_position_in_segment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the closest position to @to_position@ that resides inside a segment between two connected points. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(0, 0)) -- astar.add_point(2, Vector2(0, 5)) -- astar.connect_points(1, 2) -- var res = astar.get_closest_position_in_segment(Vector2(3, 3)) # Returns (0, 3) -- -- @ -- -- The result is in the segment that goes from @y = 0@ to @y = 5@. It's the closest position in the segment to the given point. get_closest_position_in_segment :: (AStar2D :< cls, Object :< cls) => cls -> Vector2 -> IO Vector2 get_closest_position_in_segment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_closest_position_in_segment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_closest_position_in_segment" '[Vector2] (IO Vector2) where nodeMethod = Godot.Core.AStar2D.get_closest_position_in_segment {-# NOINLINE bindAStar2D_get_id_path #-} -- | Returns an array with the IDs of the points that form the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(0, 0)) -- astar.add_point(2, Vector2(0, 1), 1) # Default weight is 1 -- astar.add_point(3, Vector2(1, 1)) -- astar.add_point(4, Vector2(2, 0)) -- -- astar.connect_points(1, 2, false) -- astar.connect_points(2, 3, false) -- astar.connect_points(4, 3, false) -- astar.connect_points(1, 4, false) -- -- var res = astar.get_id_path(1, 3) # Returns @1, 2, 3@ -- -- @ -- -- If you change the 2nd point's weight to 3, then the result will be @@1, 4, 3@@ instead, because now even though the distance is longer, it's "easier" to get through point 4 than through point 2. bindAStar2D_get_id_path :: MethodBind bindAStar2D_get_id_path = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_id_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with the IDs of the points that form the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(0, 0)) -- astar.add_point(2, Vector2(0, 1), 1) # Default weight is 1 -- astar.add_point(3, Vector2(1, 1)) -- astar.add_point(4, Vector2(2, 0)) -- -- astar.connect_points(1, 2, false) -- astar.connect_points(2, 3, false) -- astar.connect_points(4, 3, false) -- astar.connect_points(1, 4, false) -- -- var res = astar.get_id_path(1, 3) # Returns @1, 2, 3@ -- -- @ -- -- If you change the 2nd point's weight to 3, then the result will be @@1, 4, 3@@ instead, because now even though the distance is longer, it's "easier" to get through point 4 than through point 2. get_id_path :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Int -> IO PoolIntArray get_id_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_id_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_id_path" '[Int, Int] (IO PoolIntArray) where nodeMethod = Godot.Core.AStar2D.get_id_path {-# NOINLINE bindAStar2D_get_point_capacity #-} -- | Returns the capacity of the structure backing the points, useful in conjunction with @reserve_space@. bindAStar2D_get_point_capacity :: MethodBind bindAStar2D_get_point_capacity = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_point_capacity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the capacity of the structure backing the points, useful in conjunction with @reserve_space@. get_point_capacity :: (AStar2D :< cls, Object :< cls) => cls -> IO Int get_point_capacity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_point_capacity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_point_capacity" '[] (IO Int) where nodeMethod = Godot.Core.AStar2D.get_point_capacity {-# NOINLINE bindAStar2D_get_point_connections #-} -- | Returns an array with the IDs of the points that form the connection with the given point. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(0, 0)) -- astar.add_point(2, Vector2(0, 1)) -- astar.add_point(3, Vector2(1, 1)) -- astar.add_point(4, Vector2(2, 0)) -- -- astar.connect_points(1, 2, true) -- astar.connect_points(1, 3, true) -- -- var neighbors = astar.get_point_connections(1) # Returns @2, 3@ -- -- @ bindAStar2D_get_point_connections :: MethodBind bindAStar2D_get_point_connections = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_point_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with the IDs of the points that form the connection with the given point. -- -- @ -- -- var astar = AStar2D.new() -- astar.add_point(1, Vector2(0, 0)) -- astar.add_point(2, Vector2(0, 1)) -- astar.add_point(3, Vector2(1, 1)) -- astar.add_point(4, Vector2(2, 0)) -- -- astar.connect_points(1, 2, true) -- astar.connect_points(1, 3, true) -- -- var neighbors = astar.get_point_connections(1) # Returns @2, 3@ -- -- @ get_point_connections :: (AStar2D :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_point_connections cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_point_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_point_connections" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.AStar2D.get_point_connections {-# NOINLINE bindAStar2D_get_point_count #-} -- | Returns the number of points currently in the points pool. bindAStar2D_get_point_count :: MethodBind bindAStar2D_get_point_count = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of points currently in the points pool. get_point_count :: (AStar2D :< cls, Object :< cls) => cls -> IO Int get_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_point_count" '[] (IO Int) where nodeMethod = Godot.Core.AStar2D.get_point_count {-# NOINLINE bindAStar2D_get_point_path #-} -- | Returns an array with the points that are in the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path. bindAStar2D_get_point_path :: MethodBind bindAStar2D_get_point_path = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_point_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with the points that are in the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path. get_point_path :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Int -> IO PoolVector2Array get_point_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_point_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_point_path" '[Int, Int] (IO PoolVector2Array) where nodeMethod = Godot.Core.AStar2D.get_point_path {-# NOINLINE bindAStar2D_get_point_position #-} -- | Returns the position of the point associated with the given @id@. bindAStar2D_get_point_position :: MethodBind bindAStar2D_get_point_position = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the point associated with the given @id@. get_point_position :: (AStar2D :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_point_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_point_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.AStar2D.get_point_position {-# NOINLINE bindAStar2D_get_point_weight_scale #-} -- | Returns the weight scale of the point associated with the given @id@. bindAStar2D_get_point_weight_scale :: MethodBind bindAStar2D_get_point_weight_scale = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_point_weight_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the weight scale of the point associated with the given @id@. get_point_weight_scale :: (AStar2D :< cls, Object :< cls) => cls -> Int -> IO Float get_point_weight_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_point_weight_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_point_weight_scale" '[Int] (IO Float) where nodeMethod = Godot.Core.AStar2D.get_point_weight_scale {-# NOINLINE bindAStar2D_get_points #-} -- | Returns an array of all points. bindAStar2D_get_points :: MethodBind bindAStar2D_get_points = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "get_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of all points. get_points :: (AStar2D :< cls, Object :< cls) => cls -> IO Array get_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_get_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "get_points" '[] (IO Array) where nodeMethod = Godot.Core.AStar2D.get_points {-# NOINLINE bindAStar2D_has_point #-} -- | Returns whether a point associated with the given @id@ exists. bindAStar2D_has_point :: MethodBind bindAStar2D_has_point = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "has_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a point associated with the given @id@ exists. has_point :: (AStar2D :< cls, Object :< cls) => cls -> Int -> IO Bool has_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_has_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "has_point" '[Int] (IO Bool) where nodeMethod = Godot.Core.AStar2D.has_point {-# NOINLINE bindAStar2D_is_point_disabled #-} -- | Returns whether a point is disabled or not for pathfinding. By default, all points are enabled. bindAStar2D_is_point_disabled :: MethodBind bindAStar2D_is_point_disabled = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "is_point_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a point is disabled or not for pathfinding. By default, all points are enabled. is_point_disabled :: (AStar2D :< cls, Object :< cls) => cls -> Int -> IO Bool is_point_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_is_point_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "is_point_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.AStar2D.is_point_disabled {-# NOINLINE bindAStar2D_remove_point #-} -- | Removes the point associated with the given @id@ from the points pool. bindAStar2D_remove_point :: MethodBind bindAStar2D_remove_point = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "remove_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the point associated with the given @id@ from the points pool. remove_point :: (AStar2D :< cls, Object :< cls) => cls -> Int -> IO () remove_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_remove_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "remove_point" '[Int] (IO ()) where nodeMethod = Godot.Core.AStar2D.remove_point {-# NOINLINE bindAStar2D_reserve_space #-} -- | Reserves space internally for @num_nodes@ points, useful if you're adding a known large number of points at once, for a grid for instance. New capacity must be greater or equals to old capacity. bindAStar2D_reserve_space :: MethodBind bindAStar2D_reserve_space = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "reserve_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reserves space internally for @num_nodes@ points, useful if you're adding a known large number of points at once, for a grid for instance. New capacity must be greater or equals to old capacity. reserve_space :: (AStar2D :< cls, Object :< cls) => cls -> Int -> IO () reserve_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_reserve_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "reserve_space" '[Int] (IO ()) where nodeMethod = Godot.Core.AStar2D.reserve_space {-# NOINLINE bindAStar2D_set_point_disabled #-} -- | Disables or enables the specified point for pathfinding. Useful for making a temporary obstacle. bindAStar2D_set_point_disabled :: MethodBind bindAStar2D_set_point_disabled = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "set_point_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables or enables the specified point for pathfinding. Useful for making a temporary obstacle. set_point_disabled :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO () set_point_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_set_point_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "set_point_disabled" '[Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AStar2D.set_point_disabled {-# NOINLINE bindAStar2D_set_point_position #-} -- | Sets the @position@ for the point with the given @id@. bindAStar2D_set_point_position :: MethodBind bindAStar2D_set_point_position = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "set_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @position@ for the point with the given @id@. set_point_position :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_point_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_set_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "set_point_position" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.AStar2D.set_point_position {-# NOINLINE bindAStar2D_set_point_weight_scale #-} -- | Sets the @weight_scale@ for the point with the given @id@. bindAStar2D_set_point_weight_scale :: MethodBind bindAStar2D_set_point_weight_scale = unsafePerformIO $ withCString "AStar2D" $ \ clsNamePtr -> withCString "set_point_weight_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @weight_scale@ for the point with the given @id@. set_point_weight_scale :: (AStar2D :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_point_weight_scale cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAStar2D_set_point_weight_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AStar2D "set_point_weight_scale" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AStar2D.set_point_weight_scale ================================================ FILE: src/Godot/Core/AcceptDialog.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AcceptDialog (Godot.Core.AcceptDialog.sig_confirmed, Godot.Core.AcceptDialog.sig_custom_action, Godot.Core.AcceptDialog._builtin_text_entered, Godot.Core.AcceptDialog._custom_action, Godot.Core.AcceptDialog._ok, Godot.Core.AcceptDialog.add_button, Godot.Core.AcceptDialog.add_cancel, Godot.Core.AcceptDialog.get_hide_on_ok, Godot.Core.AcceptDialog.get_label, Godot.Core.AcceptDialog.get_ok, Godot.Core.AcceptDialog.get_text, Godot.Core.AcceptDialog.has_autowrap, Godot.Core.AcceptDialog.register_text_enter, Godot.Core.AcceptDialog.set_autowrap, Godot.Core.AcceptDialog.set_hide_on_ok, Godot.Core.AcceptDialog.set_text) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.WindowDialog() -- | Emitted when the dialog is accepted, i.e. the OK button is pressed. sig_confirmed :: Godot.Internal.Dispatch.Signal AcceptDialog sig_confirmed = Godot.Internal.Dispatch.Signal "confirmed" instance NodeSignal AcceptDialog "confirmed" '[] -- | Emitted when a custom button is pressed. See @method add_button@. sig_custom_action :: Godot.Internal.Dispatch.Signal AcceptDialog sig_custom_action = Godot.Internal.Dispatch.Signal "custom_action" instance NodeSignal AcceptDialog "custom_action" '[GodotString] instance NodeProperty AcceptDialog "dialog_autowrap" Bool 'False where nodeProperty = (has_autowrap, wrapDroppingSetter set_autowrap, Nothing) instance NodeProperty AcceptDialog "dialog_hide_on_ok" Bool 'False where nodeProperty = (get_hide_on_ok, wrapDroppingSetter set_hide_on_ok, Nothing) instance NodeProperty AcceptDialog "dialog_text" GodotString 'False where nodeProperty = (get_text, wrapDroppingSetter set_text, Nothing) {-# NOINLINE bindAcceptDialog__builtin_text_entered #-} bindAcceptDialog__builtin_text_entered :: MethodBind bindAcceptDialog__builtin_text_entered = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "_builtin_text_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _builtin_text_entered :: (AcceptDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _builtin_text_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog__builtin_text_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "_builtin_text_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AcceptDialog._builtin_text_entered {-# NOINLINE bindAcceptDialog__custom_action #-} bindAcceptDialog__custom_action :: MethodBind bindAcceptDialog__custom_action = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "_custom_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _custom_action :: (AcceptDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _custom_action cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog__custom_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "_custom_action" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AcceptDialog._custom_action {-# NOINLINE bindAcceptDialog__ok #-} bindAcceptDialog__ok :: MethodBind bindAcceptDialog__ok = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "_ok" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _ok :: (AcceptDialog :< cls, Object :< cls) => cls -> IO () _ok cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog__ok (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "_ok" '[] (IO ()) where nodeMethod = Godot.Core.AcceptDialog._ok {-# NOINLINE bindAcceptDialog_add_button #-} -- | Adds a button with label @text@ and a custom @action@ to the dialog and returns the created button. @action@ will be passed to the @signal custom_action@ signal when pressed. -- If @true@, @right@ will place the button to the right of any sibling buttons. bindAcceptDialog_add_button :: MethodBind bindAcceptDialog_add_button = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "add_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a button with label @text@ and a custom @action@ to the dialog and returns the created button. @action@ will be passed to the @signal custom_action@ signal when pressed. -- If @true@, @right@ will place the button to the right of any sibling buttons. add_button :: (AcceptDialog :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> Maybe GodotString -> IO Button add_button cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2, defaultedVariant VariantString "" arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_add_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "add_button" '[GodotString, Maybe Bool, Maybe GodotString] (IO Button) where nodeMethod = Godot.Core.AcceptDialog.add_button {-# NOINLINE bindAcceptDialog_add_cancel #-} -- | Adds a button with label @name@ and a cancel action to the dialog and returns the created button. bindAcceptDialog_add_cancel :: MethodBind bindAcceptDialog_add_cancel = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "add_cancel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a button with label @name@ and a cancel action to the dialog and returns the created button. add_cancel :: (AcceptDialog :< cls, Object :< cls) => cls -> GodotString -> IO Button add_cancel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_add_cancel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "add_cancel" '[GodotString] (IO Button) where nodeMethod = Godot.Core.AcceptDialog.add_cancel {-# NOINLINE bindAcceptDialog_get_hide_on_ok #-} -- | If @true@, the dialog is hidden when the OK button is pressed. You can set it to @false@ if you want to do e.g. input validation when receiving the @signal confirmed@ signal, and handle hiding the dialog in your own logic. -- __Note:__ Some nodes derived from this class can have a different default value, and potentially their own built-in logic overriding this setting. For example @FileDialog@ defaults to @false@, and has its own input validation code that is called when you press OK, which eventually hides the dialog if the input is valid. As such, this property can't be used in @FileDialog@ to disable hiding the dialog when pressing OK. bindAcceptDialog_get_hide_on_ok :: MethodBind bindAcceptDialog_get_hide_on_ok = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "get_hide_on_ok" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the dialog is hidden when the OK button is pressed. You can set it to @false@ if you want to do e.g. input validation when receiving the @signal confirmed@ signal, and handle hiding the dialog in your own logic. -- __Note:__ Some nodes derived from this class can have a different default value, and potentially their own built-in logic overriding this setting. For example @FileDialog@ defaults to @false@, and has its own input validation code that is called when you press OK, which eventually hides the dialog if the input is valid. As such, this property can't be used in @FileDialog@ to disable hiding the dialog when pressing OK. get_hide_on_ok :: (AcceptDialog :< cls, Object :< cls) => cls -> IO Bool get_hide_on_ok cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_get_hide_on_ok (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "get_hide_on_ok" '[] (IO Bool) where nodeMethod = Godot.Core.AcceptDialog.get_hide_on_ok {-# NOINLINE bindAcceptDialog_get_label #-} -- | Returns the label used for built-in text. bindAcceptDialog_get_label :: MethodBind bindAcceptDialog_get_label = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "get_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the label used for built-in text. get_label :: (AcceptDialog :< cls, Object :< cls) => cls -> IO Label get_label cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_get_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "get_label" '[] (IO Label) where nodeMethod = Godot.Core.AcceptDialog.get_label {-# NOINLINE bindAcceptDialog_get_ok #-} -- | Returns the OK @Button@ instance. bindAcceptDialog_get_ok :: MethodBind bindAcceptDialog_get_ok = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "get_ok" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the OK @Button@ instance. get_ok :: (AcceptDialog :< cls, Object :< cls) => cls -> IO Button get_ok cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_get_ok (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "get_ok" '[] (IO Button) where nodeMethod = Godot.Core.AcceptDialog.get_ok {-# NOINLINE bindAcceptDialog_get_text #-} -- | The text displayed by the dialog. bindAcceptDialog_get_text :: MethodBind bindAcceptDialog_get_text = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The text displayed by the dialog. get_text :: (AcceptDialog :< cls, Object :< cls) => cls -> IO GodotString get_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "get_text" '[] (IO GodotString) where nodeMethod = Godot.Core.AcceptDialog.get_text {-# NOINLINE bindAcceptDialog_has_autowrap #-} -- | Sets autowrapping for the text in the dialog. bindAcceptDialog_has_autowrap :: MethodBind bindAcceptDialog_has_autowrap = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "has_autowrap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets autowrapping for the text in the dialog. has_autowrap :: (AcceptDialog :< cls, Object :< cls) => cls -> IO Bool has_autowrap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_has_autowrap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "has_autowrap" '[] (IO Bool) where nodeMethod = Godot.Core.AcceptDialog.has_autowrap {-# NOINLINE bindAcceptDialog_register_text_enter #-} -- | Registers a @LineEdit@ in the dialog. When the enter key is pressed, the dialog will be accepted. bindAcceptDialog_register_text_enter :: MethodBind bindAcceptDialog_register_text_enter = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "register_text_enter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Registers a @LineEdit@ in the dialog. When the enter key is pressed, the dialog will be accepted. register_text_enter :: (AcceptDialog :< cls, Object :< cls) => cls -> Node -> IO () register_text_enter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_register_text_enter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "register_text_enter" '[Node] (IO ()) where nodeMethod = Godot.Core.AcceptDialog.register_text_enter {-# NOINLINE bindAcceptDialog_set_autowrap #-} -- | Sets autowrapping for the text in the dialog. bindAcceptDialog_set_autowrap :: MethodBind bindAcceptDialog_set_autowrap = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "set_autowrap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets autowrapping for the text in the dialog. set_autowrap :: (AcceptDialog :< cls, Object :< cls) => cls -> Bool -> IO () set_autowrap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_set_autowrap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "set_autowrap" '[Bool] (IO ()) where nodeMethod = Godot.Core.AcceptDialog.set_autowrap {-# NOINLINE bindAcceptDialog_set_hide_on_ok #-} -- | If @true@, the dialog is hidden when the OK button is pressed. You can set it to @false@ if you want to do e.g. input validation when receiving the @signal confirmed@ signal, and handle hiding the dialog in your own logic. -- __Note:__ Some nodes derived from this class can have a different default value, and potentially their own built-in logic overriding this setting. For example @FileDialog@ defaults to @false@, and has its own input validation code that is called when you press OK, which eventually hides the dialog if the input is valid. As such, this property can't be used in @FileDialog@ to disable hiding the dialog when pressing OK. bindAcceptDialog_set_hide_on_ok :: MethodBind bindAcceptDialog_set_hide_on_ok = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "set_hide_on_ok" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the dialog is hidden when the OK button is pressed. You can set it to @false@ if you want to do e.g. input validation when receiving the @signal confirmed@ signal, and handle hiding the dialog in your own logic. -- __Note:__ Some nodes derived from this class can have a different default value, and potentially their own built-in logic overriding this setting. For example @FileDialog@ defaults to @false@, and has its own input validation code that is called when you press OK, which eventually hides the dialog if the input is valid. As such, this property can't be used in @FileDialog@ to disable hiding the dialog when pressing OK. set_hide_on_ok :: (AcceptDialog :< cls, Object :< cls) => cls -> Bool -> IO () set_hide_on_ok cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_set_hide_on_ok (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "set_hide_on_ok" '[Bool] (IO ()) where nodeMethod = Godot.Core.AcceptDialog.set_hide_on_ok {-# NOINLINE bindAcceptDialog_set_text #-} -- | The text displayed by the dialog. bindAcceptDialog_set_text :: MethodBind bindAcceptDialog_set_text = unsafePerformIO $ withCString "AcceptDialog" $ \ clsNamePtr -> withCString "set_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The text displayed by the dialog. set_text :: (AcceptDialog :< cls, Object :< cls) => cls -> GodotString -> IO () set_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAcceptDialog_set_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AcceptDialog "set_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AcceptDialog.set_text ================================================ FILE: src/Godot/Core/AnimatedSprite.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimatedSprite (Godot.Core.AnimatedSprite.sig_animation_finished, Godot.Core.AnimatedSprite.sig_frame_changed, Godot.Core.AnimatedSprite._is_playing, Godot.Core.AnimatedSprite._res_changed, Godot.Core.AnimatedSprite._set_playing, Godot.Core.AnimatedSprite.get_animation, Godot.Core.AnimatedSprite.get_frame, Godot.Core.AnimatedSprite.get_offset, Godot.Core.AnimatedSprite.get_speed_scale, Godot.Core.AnimatedSprite.get_sprite_frames, Godot.Core.AnimatedSprite.is_centered, Godot.Core.AnimatedSprite.is_flipped_h, Godot.Core.AnimatedSprite.is_flipped_v, Godot.Core.AnimatedSprite.is_playing, Godot.Core.AnimatedSprite.play, Godot.Core.AnimatedSprite.set_animation, Godot.Core.AnimatedSprite.set_centered, Godot.Core.AnimatedSprite.set_flip_h, Godot.Core.AnimatedSprite.set_flip_v, Godot.Core.AnimatedSprite.set_frame, Godot.Core.AnimatedSprite.set_offset, Godot.Core.AnimatedSprite.set_speed_scale, Godot.Core.AnimatedSprite.set_sprite_frames, Godot.Core.AnimatedSprite.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() -- | Emitted when the animation is finished (when it plays the last frame). If the animation is looping, this signal is emitted every time the last frame is drawn. sig_animation_finished :: Godot.Internal.Dispatch.Signal AnimatedSprite sig_animation_finished = Godot.Internal.Dispatch.Signal "animation_finished" instance NodeSignal AnimatedSprite "animation_finished" '[] -- | Emitted when @frame@ changed. sig_frame_changed :: Godot.Internal.Dispatch.Signal AnimatedSprite sig_frame_changed = Godot.Internal.Dispatch.Signal "frame_changed" instance NodeSignal AnimatedSprite "frame_changed" '[] instance NodeProperty AnimatedSprite "animation" GodotString 'False where nodeProperty = (get_animation, wrapDroppingSetter set_animation, Nothing) instance NodeProperty AnimatedSprite "centered" Bool 'False where nodeProperty = (is_centered, wrapDroppingSetter set_centered, Nothing) instance NodeProperty AnimatedSprite "flip_h" Bool 'False where nodeProperty = (is_flipped_h, wrapDroppingSetter set_flip_h, Nothing) instance NodeProperty AnimatedSprite "flip_v" Bool 'False where nodeProperty = (is_flipped_v, wrapDroppingSetter set_flip_v, Nothing) instance NodeProperty AnimatedSprite "frame" Int 'False where nodeProperty = (get_frame, wrapDroppingSetter set_frame, Nothing) instance NodeProperty AnimatedSprite "frames" SpriteFrames 'False where nodeProperty = (get_sprite_frames, wrapDroppingSetter set_sprite_frames, Nothing) instance NodeProperty AnimatedSprite "offset" Vector2 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty AnimatedSprite "playing" Bool 'False where nodeProperty = (_is_playing, wrapDroppingSetter _set_playing, Nothing) instance NodeProperty AnimatedSprite "speed_scale" Float 'False where nodeProperty = (get_speed_scale, wrapDroppingSetter set_speed_scale, Nothing) {-# NOINLINE bindAnimatedSprite__is_playing #-} -- | If @true@, the @animation@ is currently playing. bindAnimatedSprite__is_playing :: MethodBind bindAnimatedSprite__is_playing = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "_is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @animation@ is currently playing. _is_playing :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO Bool _is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite__is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "_is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AnimatedSprite._is_playing {-# NOINLINE bindAnimatedSprite__res_changed #-} bindAnimatedSprite__res_changed :: MethodBind bindAnimatedSprite__res_changed = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "_res_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _res_changed :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO () _res_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite__res_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "_res_changed" '[] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite._res_changed {-# NOINLINE bindAnimatedSprite__set_playing #-} -- | If @true@, the @animation@ is currently playing. bindAnimatedSprite__set_playing :: MethodBind bindAnimatedSprite__set_playing = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "_set_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @animation@ is currently playing. _set_playing :: (AnimatedSprite :< cls, Object :< cls) => cls -> Bool -> IO () _set_playing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite__set_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "_set_playing" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite._set_playing {-# NOINLINE bindAnimatedSprite_get_animation #-} -- | The current animation from the @frames@ resource. If this value changes, the @frame@ counter is reset. bindAnimatedSprite_get_animation :: MethodBind bindAnimatedSprite_get_animation = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "get_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current animation from the @frames@ resource. If this value changes, the @frame@ counter is reset. get_animation :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO GodotString get_animation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_get_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "get_animation" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimatedSprite.get_animation {-# NOINLINE bindAnimatedSprite_get_frame #-} -- | The displayed animation frame's index. bindAnimatedSprite_get_frame :: MethodBind bindAnimatedSprite_get_frame = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "get_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The displayed animation frame's index. get_frame :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO Int get_frame cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_get_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "get_frame" '[] (IO Int) where nodeMethod = Godot.Core.AnimatedSprite.get_frame {-# NOINLINE bindAnimatedSprite_get_offset #-} -- | The texture's drawing offset. bindAnimatedSprite_get_offset :: MethodBind bindAnimatedSprite_get_offset = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's drawing offset. get_offset :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.AnimatedSprite.get_offset {-# NOINLINE bindAnimatedSprite_get_speed_scale #-} -- | The animation speed is multiplied by this value. bindAnimatedSprite_get_speed_scale :: MethodBind bindAnimatedSprite_get_speed_scale = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "get_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The animation speed is multiplied by this value. get_speed_scale :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO Float get_speed_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_get_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "get_speed_scale" '[] (IO Float) where nodeMethod = Godot.Core.AnimatedSprite.get_speed_scale {-# NOINLINE bindAnimatedSprite_get_sprite_frames #-} -- | The @SpriteFrames@ resource containing the animation(s). bindAnimatedSprite_get_sprite_frames :: MethodBind bindAnimatedSprite_get_sprite_frames = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "get_sprite_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @SpriteFrames@ resource containing the animation(s). get_sprite_frames :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO SpriteFrames get_sprite_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_get_sprite_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "get_sprite_frames" '[] (IO SpriteFrames) where nodeMethod = Godot.Core.AnimatedSprite.get_sprite_frames {-# NOINLINE bindAnimatedSprite_is_centered #-} -- | If @true@, texture will be centered. bindAnimatedSprite_is_centered :: MethodBind bindAnimatedSprite_is_centered = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "is_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture will be centered. is_centered :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO Bool is_centered cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_is_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "is_centered" '[] (IO Bool) where nodeMethod = Godot.Core.AnimatedSprite.is_centered {-# NOINLINE bindAnimatedSprite_is_flipped_h #-} -- | If @true@, texture is flipped horizontally. bindAnimatedSprite_is_flipped_h :: MethodBind bindAnimatedSprite_is_flipped_h = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "is_flipped_h" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped horizontally. is_flipped_h :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO Bool is_flipped_h cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_is_flipped_h (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "is_flipped_h" '[] (IO Bool) where nodeMethod = Godot.Core.AnimatedSprite.is_flipped_h {-# NOINLINE bindAnimatedSprite_is_flipped_v #-} -- | If @true@, texture is flipped vertically. bindAnimatedSprite_is_flipped_v :: MethodBind bindAnimatedSprite_is_flipped_v = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "is_flipped_v" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped vertically. is_flipped_v :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO Bool is_flipped_v cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_is_flipped_v (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "is_flipped_v" '[] (IO Bool) where nodeMethod = Godot.Core.AnimatedSprite.is_flipped_v {-# NOINLINE bindAnimatedSprite_is_playing #-} -- | Returns @true@ if an animation is currently being played. bindAnimatedSprite_is_playing :: MethodBind bindAnimatedSprite_is_playing = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if an animation is currently being played. is_playing :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO Bool is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AnimatedSprite.is_playing {-# NOINLINE bindAnimatedSprite_play #-} -- | Plays the animation named @anim@. If no @anim@ is provided, the current animation is played. If @backwards@ is @true@, the animation will be played in reverse. bindAnimatedSprite_play :: MethodBind bindAnimatedSprite_play = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Plays the animation named @anim@. If no @anim@ is provided, the current animation is played. If @backwards@ is @true@, the animation will be played in reverse. play :: (AnimatedSprite :< cls, Object :< cls) => cls -> Maybe GodotString -> Maybe Bool -> IO () play cls arg1 arg2 = withVariantArray [defaultedVariant VariantString "" arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "play" '[Maybe GodotString, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.play {-# NOINLINE bindAnimatedSprite_set_animation #-} -- | The current animation from the @frames@ resource. If this value changes, the @frame@ counter is reset. bindAnimatedSprite_set_animation :: MethodBind bindAnimatedSprite_set_animation = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "set_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current animation from the @frames@ resource. If this value changes, the @frame@ counter is reset. set_animation :: (AnimatedSprite :< cls, Object :< cls) => cls -> GodotString -> IO () set_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_set_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "set_animation" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.set_animation {-# NOINLINE bindAnimatedSprite_set_centered #-} -- | If @true@, texture will be centered. bindAnimatedSprite_set_centered :: MethodBind bindAnimatedSprite_set_centered = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "set_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture will be centered. set_centered :: (AnimatedSprite :< cls, Object :< cls) => cls -> Bool -> IO () set_centered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_set_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "set_centered" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.set_centered {-# NOINLINE bindAnimatedSprite_set_flip_h #-} -- | If @true@, texture is flipped horizontally. bindAnimatedSprite_set_flip_h :: MethodBind bindAnimatedSprite_set_flip_h = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "set_flip_h" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped horizontally. set_flip_h :: (AnimatedSprite :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_h cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_set_flip_h (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "set_flip_h" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.set_flip_h {-# NOINLINE bindAnimatedSprite_set_flip_v #-} -- | If @true@, texture is flipped vertically. bindAnimatedSprite_set_flip_v :: MethodBind bindAnimatedSprite_set_flip_v = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "set_flip_v" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped vertically. set_flip_v :: (AnimatedSprite :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_v cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_set_flip_v (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "set_flip_v" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.set_flip_v {-# NOINLINE bindAnimatedSprite_set_frame #-} -- | The displayed animation frame's index. bindAnimatedSprite_set_frame :: MethodBind bindAnimatedSprite_set_frame = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "set_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The displayed animation frame's index. set_frame :: (AnimatedSprite :< cls, Object :< cls) => cls -> Int -> IO () set_frame cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_set_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "set_frame" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.set_frame {-# NOINLINE bindAnimatedSprite_set_offset #-} -- | The texture's drawing offset. bindAnimatedSprite_set_offset :: MethodBind bindAnimatedSprite_set_offset = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's drawing offset. set_offset :: (AnimatedSprite :< cls, Object :< cls) => cls -> Vector2 -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "set_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.set_offset {-# NOINLINE bindAnimatedSprite_set_speed_scale #-} -- | The animation speed is multiplied by this value. bindAnimatedSprite_set_speed_scale :: MethodBind bindAnimatedSprite_set_speed_scale = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "set_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The animation speed is multiplied by this value. set_speed_scale :: (AnimatedSprite :< cls, Object :< cls) => cls -> Float -> IO () set_speed_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_set_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "set_speed_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.set_speed_scale {-# NOINLINE bindAnimatedSprite_set_sprite_frames #-} -- | The @SpriteFrames@ resource containing the animation(s). bindAnimatedSprite_set_sprite_frames :: MethodBind bindAnimatedSprite_set_sprite_frames = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "set_sprite_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @SpriteFrames@ resource containing the animation(s). set_sprite_frames :: (AnimatedSprite :< cls, Object :< cls) => cls -> SpriteFrames -> IO () set_sprite_frames cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_set_sprite_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "set_sprite_frames" '[SpriteFrames] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.set_sprite_frames {-# NOINLINE bindAnimatedSprite_stop #-} -- | Stops the current animation (does not reset the frame counter). bindAnimatedSprite_stop :: MethodBind bindAnimatedSprite_stop = unsafePerformIO $ withCString "AnimatedSprite" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the current animation (does not reset the frame counter). stop :: (AnimatedSprite :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite "stop" '[] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite.stop ================================================ FILE: src/Godot/Core/AnimatedSprite3D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimatedSprite3D (Godot.Core.AnimatedSprite3D.sig_frame_changed, Godot.Core.AnimatedSprite3D._is_playing, Godot.Core.AnimatedSprite3D._res_changed, Godot.Core.AnimatedSprite3D._set_playing, Godot.Core.AnimatedSprite3D.get_animation, Godot.Core.AnimatedSprite3D.get_frame, Godot.Core.AnimatedSprite3D.get_sprite_frames, Godot.Core.AnimatedSprite3D.is_playing, Godot.Core.AnimatedSprite3D.play, Godot.Core.AnimatedSprite3D.set_animation, Godot.Core.AnimatedSprite3D.set_frame, Godot.Core.AnimatedSprite3D.set_sprite_frames, Godot.Core.AnimatedSprite3D.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.SpriteBase3D() -- | Emitted when @frame@ changed. sig_frame_changed :: Godot.Internal.Dispatch.Signal AnimatedSprite3D sig_frame_changed = Godot.Internal.Dispatch.Signal "frame_changed" instance NodeSignal AnimatedSprite3D "frame_changed" '[] instance NodeProperty AnimatedSprite3D "animation" GodotString 'False where nodeProperty = (get_animation, wrapDroppingSetter set_animation, Nothing) instance NodeProperty AnimatedSprite3D "frame" Int 'False where nodeProperty = (get_frame, wrapDroppingSetter set_frame, Nothing) instance NodeProperty AnimatedSprite3D "frames" SpriteFrames 'False where nodeProperty = (get_sprite_frames, wrapDroppingSetter set_sprite_frames, Nothing) instance NodeProperty AnimatedSprite3D "playing" Bool 'False where nodeProperty = (_is_playing, wrapDroppingSetter _set_playing, Nothing) {-# NOINLINE bindAnimatedSprite3D__is_playing #-} -- | If @true@, the @animation@ is currently playing. bindAnimatedSprite3D__is_playing :: MethodBind bindAnimatedSprite3D__is_playing = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "_is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @animation@ is currently playing. _is_playing :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> IO Bool _is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D__is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "_is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AnimatedSprite3D._is_playing {-# NOINLINE bindAnimatedSprite3D__res_changed #-} bindAnimatedSprite3D__res_changed :: MethodBind bindAnimatedSprite3D__res_changed = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "_res_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _res_changed :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> IO () _res_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D__res_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "_res_changed" '[] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite3D._res_changed {-# NOINLINE bindAnimatedSprite3D__set_playing #-} -- | If @true@, the @animation@ is currently playing. bindAnimatedSprite3D__set_playing :: MethodBind bindAnimatedSprite3D__set_playing = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "_set_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @animation@ is currently playing. _set_playing :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> Bool -> IO () _set_playing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D__set_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "_set_playing" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite3D._set_playing {-# NOINLINE bindAnimatedSprite3D_get_animation #-} -- | The current animation from the @frames@ resource. If this value changes, the @frame@ counter is reset. bindAnimatedSprite3D_get_animation :: MethodBind bindAnimatedSprite3D_get_animation = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "get_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current animation from the @frames@ resource. If this value changes, the @frame@ counter is reset. get_animation :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> IO GodotString get_animation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_get_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "get_animation" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimatedSprite3D.get_animation {-# NOINLINE bindAnimatedSprite3D_get_frame #-} -- | The displayed animation frame's index. bindAnimatedSprite3D_get_frame :: MethodBind bindAnimatedSprite3D_get_frame = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "get_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The displayed animation frame's index. get_frame :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> IO Int get_frame cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_get_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "get_frame" '[] (IO Int) where nodeMethod = Godot.Core.AnimatedSprite3D.get_frame {-# NOINLINE bindAnimatedSprite3D_get_sprite_frames #-} -- | The @SpriteFrames@ resource containing the animation(s). bindAnimatedSprite3D_get_sprite_frames :: MethodBind bindAnimatedSprite3D_get_sprite_frames = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "get_sprite_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @SpriteFrames@ resource containing the animation(s). get_sprite_frames :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> IO SpriteFrames get_sprite_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_get_sprite_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "get_sprite_frames" '[] (IO SpriteFrames) where nodeMethod = Godot.Core.AnimatedSprite3D.get_sprite_frames {-# NOINLINE bindAnimatedSprite3D_is_playing #-} -- | Returns @true@ if an animation is currently being played. bindAnimatedSprite3D_is_playing :: MethodBind bindAnimatedSprite3D_is_playing = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if an animation is currently being played. is_playing :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> IO Bool is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AnimatedSprite3D.is_playing {-# NOINLINE bindAnimatedSprite3D_play #-} -- | Plays the animation named @anim@. If no @anim@ is provided, the current animation is played. bindAnimatedSprite3D_play :: MethodBind bindAnimatedSprite3D_play = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Plays the animation named @anim@. If no @anim@ is provided, the current animation is played. play :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> Maybe GodotString -> IO () play cls arg1 = withVariantArray [defaultedVariant VariantString "" arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "play" '[Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite3D.play {-# NOINLINE bindAnimatedSprite3D_set_animation #-} -- | The current animation from the @frames@ resource. If this value changes, the @frame@ counter is reset. bindAnimatedSprite3D_set_animation :: MethodBind bindAnimatedSprite3D_set_animation = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "set_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current animation from the @frames@ resource. If this value changes, the @frame@ counter is reset. set_animation :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> GodotString -> IO () set_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_set_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "set_animation" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite3D.set_animation {-# NOINLINE bindAnimatedSprite3D_set_frame #-} -- | The displayed animation frame's index. bindAnimatedSprite3D_set_frame :: MethodBind bindAnimatedSprite3D_set_frame = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "set_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The displayed animation frame's index. set_frame :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> Int -> IO () set_frame cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_set_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "set_frame" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite3D.set_frame {-# NOINLINE bindAnimatedSprite3D_set_sprite_frames #-} -- | The @SpriteFrames@ resource containing the animation(s). bindAnimatedSprite3D_set_sprite_frames :: MethodBind bindAnimatedSprite3D_set_sprite_frames = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "set_sprite_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @SpriteFrames@ resource containing the animation(s). set_sprite_frames :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> SpriteFrames -> IO () set_sprite_frames cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_set_sprite_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "set_sprite_frames" '[SpriteFrames] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite3D.set_sprite_frames {-# NOINLINE bindAnimatedSprite3D_stop #-} -- | Stops the current animation (does not reset the frame counter). bindAnimatedSprite3D_stop :: MethodBind bindAnimatedSprite3D_stop = unsafePerformIO $ withCString "AnimatedSprite3D" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the current animation (does not reset the frame counter). stop :: (AnimatedSprite3D :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedSprite3D_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedSprite3D "stop" '[] (IO ()) where nodeMethod = Godot.Core.AnimatedSprite3D.stop ================================================ FILE: src/Godot/Core/AnimatedTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimatedTexture (Godot.Core.AnimatedTexture._MAX_FRAMES, Godot.Core.AnimatedTexture._update_proxy, Godot.Core.AnimatedTexture.get_fps, Godot.Core.AnimatedTexture.get_frame_delay, Godot.Core.AnimatedTexture.get_frame_texture, Godot.Core.AnimatedTexture.get_frames, Godot.Core.AnimatedTexture.set_fps, Godot.Core.AnimatedTexture.set_frame_delay, Godot.Core.AnimatedTexture.set_frame_texture, Godot.Core.AnimatedTexture.set_frames) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() _MAX_FRAMES :: Int _MAX_FRAMES = 256 instance NodeProperty AnimatedTexture "fps" Float 'False where nodeProperty = (get_fps, wrapDroppingSetter set_fps, Nothing) instance NodeProperty AnimatedTexture "frame_0/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_frame_delay, wrapIndexedSetter 0 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_0/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 0 get_frame_texture, wrapIndexedSetter 0 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_1/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_frame_delay, wrapIndexedSetter 1 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_1/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 1 get_frame_texture, wrapIndexedSetter 1 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_10/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_frame_delay, wrapIndexedSetter 10 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_10/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 10 get_frame_texture, wrapIndexedSetter 10 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_100/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 100 get_frame_delay, wrapIndexedSetter 100 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_100/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 100 get_frame_texture, wrapIndexedSetter 100 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_101/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 101 get_frame_delay, wrapIndexedSetter 101 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_101/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 101 get_frame_texture, wrapIndexedSetter 101 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_102/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 102 get_frame_delay, wrapIndexedSetter 102 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_102/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 102 get_frame_texture, wrapIndexedSetter 102 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_103/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 103 get_frame_delay, wrapIndexedSetter 103 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_103/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 103 get_frame_texture, wrapIndexedSetter 103 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_104/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 104 get_frame_delay, wrapIndexedSetter 104 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_104/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 104 get_frame_texture, wrapIndexedSetter 104 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_105/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 105 get_frame_delay, wrapIndexedSetter 105 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_105/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 105 get_frame_texture, wrapIndexedSetter 105 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_106/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 106 get_frame_delay, wrapIndexedSetter 106 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_106/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 106 get_frame_texture, wrapIndexedSetter 106 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_107/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 107 get_frame_delay, wrapIndexedSetter 107 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_107/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 107 get_frame_texture, wrapIndexedSetter 107 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_108/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 108 get_frame_delay, wrapIndexedSetter 108 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_108/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 108 get_frame_texture, wrapIndexedSetter 108 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_109/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 109 get_frame_delay, wrapIndexedSetter 109 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_109/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 109 get_frame_texture, wrapIndexedSetter 109 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_11/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_frame_delay, wrapIndexedSetter 11 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_11/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 11 get_frame_texture, wrapIndexedSetter 11 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_110/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 110 get_frame_delay, wrapIndexedSetter 110 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_110/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 110 get_frame_texture, wrapIndexedSetter 110 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_111/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 111 get_frame_delay, wrapIndexedSetter 111 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_111/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 111 get_frame_texture, wrapIndexedSetter 111 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_112/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 112 get_frame_delay, wrapIndexedSetter 112 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_112/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 112 get_frame_texture, wrapIndexedSetter 112 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_113/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 113 get_frame_delay, wrapIndexedSetter 113 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_113/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 113 get_frame_texture, wrapIndexedSetter 113 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_114/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 114 get_frame_delay, wrapIndexedSetter 114 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_114/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 114 get_frame_texture, wrapIndexedSetter 114 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_115/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 115 get_frame_delay, wrapIndexedSetter 115 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_115/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 115 get_frame_texture, wrapIndexedSetter 115 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_116/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 116 get_frame_delay, wrapIndexedSetter 116 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_116/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 116 get_frame_texture, wrapIndexedSetter 116 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_117/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 117 get_frame_delay, wrapIndexedSetter 117 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_117/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 117 get_frame_texture, wrapIndexedSetter 117 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_118/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 118 get_frame_delay, wrapIndexedSetter 118 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_118/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 118 get_frame_texture, wrapIndexedSetter 118 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_119/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 119 get_frame_delay, wrapIndexedSetter 119 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_119/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 119 get_frame_texture, wrapIndexedSetter 119 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_12/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 12 get_frame_delay, wrapIndexedSetter 12 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_12/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 12 get_frame_texture, wrapIndexedSetter 12 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_120/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 120 get_frame_delay, wrapIndexedSetter 120 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_120/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 120 get_frame_texture, wrapIndexedSetter 120 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_121/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 121 get_frame_delay, wrapIndexedSetter 121 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_121/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 121 get_frame_texture, wrapIndexedSetter 121 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_122/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 122 get_frame_delay, wrapIndexedSetter 122 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_122/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 122 get_frame_texture, wrapIndexedSetter 122 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_123/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 123 get_frame_delay, wrapIndexedSetter 123 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_123/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 123 get_frame_texture, wrapIndexedSetter 123 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_124/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 124 get_frame_delay, wrapIndexedSetter 124 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_124/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 124 get_frame_texture, wrapIndexedSetter 124 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_125/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 125 get_frame_delay, wrapIndexedSetter 125 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_125/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 125 get_frame_texture, wrapIndexedSetter 125 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_126/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 126 get_frame_delay, wrapIndexedSetter 126 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_126/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 126 get_frame_texture, wrapIndexedSetter 126 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_127/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 127 get_frame_delay, wrapIndexedSetter 127 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_127/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 127 get_frame_texture, wrapIndexedSetter 127 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_128/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 128 get_frame_delay, wrapIndexedSetter 128 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_128/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 128 get_frame_texture, wrapIndexedSetter 128 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_129/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 129 get_frame_delay, wrapIndexedSetter 129 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_129/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 129 get_frame_texture, wrapIndexedSetter 129 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_13/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 13 get_frame_delay, wrapIndexedSetter 13 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_13/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 13 get_frame_texture, wrapIndexedSetter 13 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_130/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 130 get_frame_delay, wrapIndexedSetter 130 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_130/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 130 get_frame_texture, wrapIndexedSetter 130 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_131/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 131 get_frame_delay, wrapIndexedSetter 131 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_131/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 131 get_frame_texture, wrapIndexedSetter 131 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_132/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 132 get_frame_delay, wrapIndexedSetter 132 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_132/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 132 get_frame_texture, wrapIndexedSetter 132 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_133/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 133 get_frame_delay, wrapIndexedSetter 133 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_133/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 133 get_frame_texture, wrapIndexedSetter 133 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_134/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 134 get_frame_delay, wrapIndexedSetter 134 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_134/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 134 get_frame_texture, wrapIndexedSetter 134 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_135/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 135 get_frame_delay, wrapIndexedSetter 135 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_135/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 135 get_frame_texture, wrapIndexedSetter 135 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_136/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 136 get_frame_delay, wrapIndexedSetter 136 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_136/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 136 get_frame_texture, wrapIndexedSetter 136 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_137/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 137 get_frame_delay, wrapIndexedSetter 137 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_137/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 137 get_frame_texture, wrapIndexedSetter 137 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_138/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 138 get_frame_delay, wrapIndexedSetter 138 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_138/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 138 get_frame_texture, wrapIndexedSetter 138 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_139/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 139 get_frame_delay, wrapIndexedSetter 139 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_139/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 139 get_frame_texture, wrapIndexedSetter 139 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_14/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 14 get_frame_delay, wrapIndexedSetter 14 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_14/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 14 get_frame_texture, wrapIndexedSetter 14 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_140/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 140 get_frame_delay, wrapIndexedSetter 140 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_140/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 140 get_frame_texture, wrapIndexedSetter 140 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_141/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 141 get_frame_delay, wrapIndexedSetter 141 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_141/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 141 get_frame_texture, wrapIndexedSetter 141 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_142/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 142 get_frame_delay, wrapIndexedSetter 142 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_142/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 142 get_frame_texture, wrapIndexedSetter 142 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_143/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 143 get_frame_delay, wrapIndexedSetter 143 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_143/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 143 get_frame_texture, wrapIndexedSetter 143 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_144/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 144 get_frame_delay, wrapIndexedSetter 144 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_144/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 144 get_frame_texture, wrapIndexedSetter 144 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_145/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 145 get_frame_delay, wrapIndexedSetter 145 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_145/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 145 get_frame_texture, wrapIndexedSetter 145 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_146/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 146 get_frame_delay, wrapIndexedSetter 146 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_146/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 146 get_frame_texture, wrapIndexedSetter 146 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_147/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 147 get_frame_delay, wrapIndexedSetter 147 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_147/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 147 get_frame_texture, wrapIndexedSetter 147 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_148/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 148 get_frame_delay, wrapIndexedSetter 148 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_148/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 148 get_frame_texture, wrapIndexedSetter 148 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_149/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 149 get_frame_delay, wrapIndexedSetter 149 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_149/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 149 get_frame_texture, wrapIndexedSetter 149 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_15/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 15 get_frame_delay, wrapIndexedSetter 15 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_15/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 15 get_frame_texture, wrapIndexedSetter 15 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_150/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 150 get_frame_delay, wrapIndexedSetter 150 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_150/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 150 get_frame_texture, wrapIndexedSetter 150 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_151/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 151 get_frame_delay, wrapIndexedSetter 151 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_151/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 151 get_frame_texture, wrapIndexedSetter 151 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_152/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 152 get_frame_delay, wrapIndexedSetter 152 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_152/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 152 get_frame_texture, wrapIndexedSetter 152 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_153/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 153 get_frame_delay, wrapIndexedSetter 153 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_153/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 153 get_frame_texture, wrapIndexedSetter 153 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_154/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 154 get_frame_delay, wrapIndexedSetter 154 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_154/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 154 get_frame_texture, wrapIndexedSetter 154 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_155/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 155 get_frame_delay, wrapIndexedSetter 155 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_155/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 155 get_frame_texture, wrapIndexedSetter 155 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_156/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 156 get_frame_delay, wrapIndexedSetter 156 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_156/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 156 get_frame_texture, wrapIndexedSetter 156 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_157/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 157 get_frame_delay, wrapIndexedSetter 157 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_157/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 157 get_frame_texture, wrapIndexedSetter 157 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_158/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 158 get_frame_delay, wrapIndexedSetter 158 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_158/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 158 get_frame_texture, wrapIndexedSetter 158 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_159/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 159 get_frame_delay, wrapIndexedSetter 159 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_159/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 159 get_frame_texture, wrapIndexedSetter 159 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_16/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 16 get_frame_delay, wrapIndexedSetter 16 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_16/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 16 get_frame_texture, wrapIndexedSetter 16 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_160/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 160 get_frame_delay, wrapIndexedSetter 160 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_160/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 160 get_frame_texture, wrapIndexedSetter 160 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_161/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 161 get_frame_delay, wrapIndexedSetter 161 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_161/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 161 get_frame_texture, wrapIndexedSetter 161 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_162/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 162 get_frame_delay, wrapIndexedSetter 162 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_162/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 162 get_frame_texture, wrapIndexedSetter 162 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_163/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 163 get_frame_delay, wrapIndexedSetter 163 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_163/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 163 get_frame_texture, wrapIndexedSetter 163 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_164/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 164 get_frame_delay, wrapIndexedSetter 164 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_164/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 164 get_frame_texture, wrapIndexedSetter 164 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_165/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 165 get_frame_delay, wrapIndexedSetter 165 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_165/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 165 get_frame_texture, wrapIndexedSetter 165 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_166/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 166 get_frame_delay, wrapIndexedSetter 166 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_166/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 166 get_frame_texture, wrapIndexedSetter 166 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_167/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 167 get_frame_delay, wrapIndexedSetter 167 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_167/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 167 get_frame_texture, wrapIndexedSetter 167 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_168/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 168 get_frame_delay, wrapIndexedSetter 168 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_168/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 168 get_frame_texture, wrapIndexedSetter 168 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_169/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 169 get_frame_delay, wrapIndexedSetter 169 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_169/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 169 get_frame_texture, wrapIndexedSetter 169 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_17/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 17 get_frame_delay, wrapIndexedSetter 17 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_17/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 17 get_frame_texture, wrapIndexedSetter 17 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_170/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 170 get_frame_delay, wrapIndexedSetter 170 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_170/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 170 get_frame_texture, wrapIndexedSetter 170 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_171/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 171 get_frame_delay, wrapIndexedSetter 171 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_171/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 171 get_frame_texture, wrapIndexedSetter 171 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_172/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 172 get_frame_delay, wrapIndexedSetter 172 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_172/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 172 get_frame_texture, wrapIndexedSetter 172 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_173/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 173 get_frame_delay, wrapIndexedSetter 173 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_173/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 173 get_frame_texture, wrapIndexedSetter 173 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_174/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 174 get_frame_delay, wrapIndexedSetter 174 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_174/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 174 get_frame_texture, wrapIndexedSetter 174 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_175/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 175 get_frame_delay, wrapIndexedSetter 175 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_175/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 175 get_frame_texture, wrapIndexedSetter 175 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_176/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 176 get_frame_delay, wrapIndexedSetter 176 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_176/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 176 get_frame_texture, wrapIndexedSetter 176 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_177/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 177 get_frame_delay, wrapIndexedSetter 177 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_177/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 177 get_frame_texture, wrapIndexedSetter 177 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_178/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 178 get_frame_delay, wrapIndexedSetter 178 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_178/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 178 get_frame_texture, wrapIndexedSetter 178 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_179/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 179 get_frame_delay, wrapIndexedSetter 179 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_179/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 179 get_frame_texture, wrapIndexedSetter 179 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_18/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 18 get_frame_delay, wrapIndexedSetter 18 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_18/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 18 get_frame_texture, wrapIndexedSetter 18 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_180/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 180 get_frame_delay, wrapIndexedSetter 180 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_180/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 180 get_frame_texture, wrapIndexedSetter 180 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_181/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 181 get_frame_delay, wrapIndexedSetter 181 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_181/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 181 get_frame_texture, wrapIndexedSetter 181 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_182/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 182 get_frame_delay, wrapIndexedSetter 182 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_182/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 182 get_frame_texture, wrapIndexedSetter 182 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_183/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 183 get_frame_delay, wrapIndexedSetter 183 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_183/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 183 get_frame_texture, wrapIndexedSetter 183 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_184/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 184 get_frame_delay, wrapIndexedSetter 184 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_184/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 184 get_frame_texture, wrapIndexedSetter 184 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_185/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 185 get_frame_delay, wrapIndexedSetter 185 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_185/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 185 get_frame_texture, wrapIndexedSetter 185 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_186/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 186 get_frame_delay, wrapIndexedSetter 186 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_186/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 186 get_frame_texture, wrapIndexedSetter 186 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_187/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 187 get_frame_delay, wrapIndexedSetter 187 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_187/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 187 get_frame_texture, wrapIndexedSetter 187 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_188/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 188 get_frame_delay, wrapIndexedSetter 188 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_188/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 188 get_frame_texture, wrapIndexedSetter 188 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_189/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 189 get_frame_delay, wrapIndexedSetter 189 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_189/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 189 get_frame_texture, wrapIndexedSetter 189 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_19/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 19 get_frame_delay, wrapIndexedSetter 19 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_19/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 19 get_frame_texture, wrapIndexedSetter 19 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_190/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 190 get_frame_delay, wrapIndexedSetter 190 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_190/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 190 get_frame_texture, wrapIndexedSetter 190 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_191/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 191 get_frame_delay, wrapIndexedSetter 191 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_191/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 191 get_frame_texture, wrapIndexedSetter 191 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_192/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 192 get_frame_delay, wrapIndexedSetter 192 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_192/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 192 get_frame_texture, wrapIndexedSetter 192 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_193/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 193 get_frame_delay, wrapIndexedSetter 193 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_193/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 193 get_frame_texture, wrapIndexedSetter 193 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_194/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 194 get_frame_delay, wrapIndexedSetter 194 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_194/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 194 get_frame_texture, wrapIndexedSetter 194 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_195/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 195 get_frame_delay, wrapIndexedSetter 195 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_195/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 195 get_frame_texture, wrapIndexedSetter 195 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_196/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 196 get_frame_delay, wrapIndexedSetter 196 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_196/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 196 get_frame_texture, wrapIndexedSetter 196 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_197/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 197 get_frame_delay, wrapIndexedSetter 197 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_197/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 197 get_frame_texture, wrapIndexedSetter 197 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_198/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 198 get_frame_delay, wrapIndexedSetter 198 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_198/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 198 get_frame_texture, wrapIndexedSetter 198 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_199/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 199 get_frame_delay, wrapIndexedSetter 199 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_199/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 199 get_frame_texture, wrapIndexedSetter 199 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_2/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_frame_delay, wrapIndexedSetter 2 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_2/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 2 get_frame_texture, wrapIndexedSetter 2 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_20/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 20 get_frame_delay, wrapIndexedSetter 20 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_20/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 20 get_frame_texture, wrapIndexedSetter 20 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_200/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 200 get_frame_delay, wrapIndexedSetter 200 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_200/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 200 get_frame_texture, wrapIndexedSetter 200 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_201/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 201 get_frame_delay, wrapIndexedSetter 201 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_201/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 201 get_frame_texture, wrapIndexedSetter 201 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_202/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 202 get_frame_delay, wrapIndexedSetter 202 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_202/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 202 get_frame_texture, wrapIndexedSetter 202 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_203/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 203 get_frame_delay, wrapIndexedSetter 203 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_203/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 203 get_frame_texture, wrapIndexedSetter 203 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_204/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 204 get_frame_delay, wrapIndexedSetter 204 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_204/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 204 get_frame_texture, wrapIndexedSetter 204 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_205/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 205 get_frame_delay, wrapIndexedSetter 205 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_205/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 205 get_frame_texture, wrapIndexedSetter 205 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_206/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 206 get_frame_delay, wrapIndexedSetter 206 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_206/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 206 get_frame_texture, wrapIndexedSetter 206 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_207/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 207 get_frame_delay, wrapIndexedSetter 207 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_207/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 207 get_frame_texture, wrapIndexedSetter 207 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_208/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 208 get_frame_delay, wrapIndexedSetter 208 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_208/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 208 get_frame_texture, wrapIndexedSetter 208 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_209/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 209 get_frame_delay, wrapIndexedSetter 209 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_209/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 209 get_frame_texture, wrapIndexedSetter 209 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_21/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 21 get_frame_delay, wrapIndexedSetter 21 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_21/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 21 get_frame_texture, wrapIndexedSetter 21 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_210/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 210 get_frame_delay, wrapIndexedSetter 210 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_210/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 210 get_frame_texture, wrapIndexedSetter 210 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_211/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 211 get_frame_delay, wrapIndexedSetter 211 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_211/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 211 get_frame_texture, wrapIndexedSetter 211 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_212/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 212 get_frame_delay, wrapIndexedSetter 212 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_212/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 212 get_frame_texture, wrapIndexedSetter 212 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_213/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 213 get_frame_delay, wrapIndexedSetter 213 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_213/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 213 get_frame_texture, wrapIndexedSetter 213 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_214/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 214 get_frame_delay, wrapIndexedSetter 214 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_214/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 214 get_frame_texture, wrapIndexedSetter 214 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_215/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 215 get_frame_delay, wrapIndexedSetter 215 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_215/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 215 get_frame_texture, wrapIndexedSetter 215 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_216/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 216 get_frame_delay, wrapIndexedSetter 216 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_216/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 216 get_frame_texture, wrapIndexedSetter 216 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_217/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 217 get_frame_delay, wrapIndexedSetter 217 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_217/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 217 get_frame_texture, wrapIndexedSetter 217 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_218/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 218 get_frame_delay, wrapIndexedSetter 218 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_218/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 218 get_frame_texture, wrapIndexedSetter 218 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_219/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 219 get_frame_delay, wrapIndexedSetter 219 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_219/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 219 get_frame_texture, wrapIndexedSetter 219 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_22/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 22 get_frame_delay, wrapIndexedSetter 22 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_22/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 22 get_frame_texture, wrapIndexedSetter 22 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_220/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 220 get_frame_delay, wrapIndexedSetter 220 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_220/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 220 get_frame_texture, wrapIndexedSetter 220 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_221/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 221 get_frame_delay, wrapIndexedSetter 221 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_221/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 221 get_frame_texture, wrapIndexedSetter 221 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_222/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 222 get_frame_delay, wrapIndexedSetter 222 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_222/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 222 get_frame_texture, wrapIndexedSetter 222 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_223/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 223 get_frame_delay, wrapIndexedSetter 223 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_223/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 223 get_frame_texture, wrapIndexedSetter 223 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_224/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 224 get_frame_delay, wrapIndexedSetter 224 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_224/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 224 get_frame_texture, wrapIndexedSetter 224 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_225/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 225 get_frame_delay, wrapIndexedSetter 225 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_225/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 225 get_frame_texture, wrapIndexedSetter 225 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_226/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 226 get_frame_delay, wrapIndexedSetter 226 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_226/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 226 get_frame_texture, wrapIndexedSetter 226 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_227/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 227 get_frame_delay, wrapIndexedSetter 227 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_227/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 227 get_frame_texture, wrapIndexedSetter 227 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_228/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 228 get_frame_delay, wrapIndexedSetter 228 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_228/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 228 get_frame_texture, wrapIndexedSetter 228 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_229/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 229 get_frame_delay, wrapIndexedSetter 229 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_229/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 229 get_frame_texture, wrapIndexedSetter 229 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_23/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 23 get_frame_delay, wrapIndexedSetter 23 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_23/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 23 get_frame_texture, wrapIndexedSetter 23 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_230/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 230 get_frame_delay, wrapIndexedSetter 230 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_230/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 230 get_frame_texture, wrapIndexedSetter 230 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_231/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 231 get_frame_delay, wrapIndexedSetter 231 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_231/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 231 get_frame_texture, wrapIndexedSetter 231 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_232/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 232 get_frame_delay, wrapIndexedSetter 232 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_232/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 232 get_frame_texture, wrapIndexedSetter 232 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_233/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 233 get_frame_delay, wrapIndexedSetter 233 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_233/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 233 get_frame_texture, wrapIndexedSetter 233 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_234/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 234 get_frame_delay, wrapIndexedSetter 234 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_234/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 234 get_frame_texture, wrapIndexedSetter 234 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_235/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 235 get_frame_delay, wrapIndexedSetter 235 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_235/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 235 get_frame_texture, wrapIndexedSetter 235 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_236/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 236 get_frame_delay, wrapIndexedSetter 236 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_236/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 236 get_frame_texture, wrapIndexedSetter 236 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_237/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 237 get_frame_delay, wrapIndexedSetter 237 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_237/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 237 get_frame_texture, wrapIndexedSetter 237 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_238/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 238 get_frame_delay, wrapIndexedSetter 238 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_238/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 238 get_frame_texture, wrapIndexedSetter 238 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_239/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 239 get_frame_delay, wrapIndexedSetter 239 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_239/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 239 get_frame_texture, wrapIndexedSetter 239 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_24/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 24 get_frame_delay, wrapIndexedSetter 24 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_24/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 24 get_frame_texture, wrapIndexedSetter 24 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_240/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 240 get_frame_delay, wrapIndexedSetter 240 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_240/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 240 get_frame_texture, wrapIndexedSetter 240 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_241/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 241 get_frame_delay, wrapIndexedSetter 241 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_241/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 241 get_frame_texture, wrapIndexedSetter 241 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_242/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 242 get_frame_delay, wrapIndexedSetter 242 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_242/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 242 get_frame_texture, wrapIndexedSetter 242 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_243/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 243 get_frame_delay, wrapIndexedSetter 243 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_243/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 243 get_frame_texture, wrapIndexedSetter 243 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_244/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 244 get_frame_delay, wrapIndexedSetter 244 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_244/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 244 get_frame_texture, wrapIndexedSetter 244 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_245/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 245 get_frame_delay, wrapIndexedSetter 245 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_245/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 245 get_frame_texture, wrapIndexedSetter 245 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_246/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 246 get_frame_delay, wrapIndexedSetter 246 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_246/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 246 get_frame_texture, wrapIndexedSetter 246 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_247/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 247 get_frame_delay, wrapIndexedSetter 247 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_247/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 247 get_frame_texture, wrapIndexedSetter 247 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_248/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 248 get_frame_delay, wrapIndexedSetter 248 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_248/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 248 get_frame_texture, wrapIndexedSetter 248 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_249/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 249 get_frame_delay, wrapIndexedSetter 249 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_249/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 249 get_frame_texture, wrapIndexedSetter 249 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_25/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 25 get_frame_delay, wrapIndexedSetter 25 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_25/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 25 get_frame_texture, wrapIndexedSetter 25 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_250/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 250 get_frame_delay, wrapIndexedSetter 250 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_250/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 250 get_frame_texture, wrapIndexedSetter 250 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_251/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 251 get_frame_delay, wrapIndexedSetter 251 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_251/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 251 get_frame_texture, wrapIndexedSetter 251 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_252/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 252 get_frame_delay, wrapIndexedSetter 252 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_252/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 252 get_frame_texture, wrapIndexedSetter 252 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_253/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 253 get_frame_delay, wrapIndexedSetter 253 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_253/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 253 get_frame_texture, wrapIndexedSetter 253 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_254/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 254 get_frame_delay, wrapIndexedSetter 254 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_254/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 254 get_frame_texture, wrapIndexedSetter 254 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_255/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 255 get_frame_delay, wrapIndexedSetter 255 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_255/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 255 get_frame_texture, wrapIndexedSetter 255 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_26/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 26 get_frame_delay, wrapIndexedSetter 26 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_26/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 26 get_frame_texture, wrapIndexedSetter 26 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_27/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 27 get_frame_delay, wrapIndexedSetter 27 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_27/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 27 get_frame_texture, wrapIndexedSetter 27 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_28/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 28 get_frame_delay, wrapIndexedSetter 28 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_28/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 28 get_frame_texture, wrapIndexedSetter 28 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_29/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 29 get_frame_delay, wrapIndexedSetter 29 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_29/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 29 get_frame_texture, wrapIndexedSetter 29 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_3/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_frame_delay, wrapIndexedSetter 3 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_3/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 3 get_frame_texture, wrapIndexedSetter 3 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_30/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 30 get_frame_delay, wrapIndexedSetter 30 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_30/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 30 get_frame_texture, wrapIndexedSetter 30 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_31/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 31 get_frame_delay, wrapIndexedSetter 31 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_31/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 31 get_frame_texture, wrapIndexedSetter 31 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_32/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 32 get_frame_delay, wrapIndexedSetter 32 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_32/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 32 get_frame_texture, wrapIndexedSetter 32 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_33/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 33 get_frame_delay, wrapIndexedSetter 33 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_33/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 33 get_frame_texture, wrapIndexedSetter 33 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_34/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 34 get_frame_delay, wrapIndexedSetter 34 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_34/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 34 get_frame_texture, wrapIndexedSetter 34 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_35/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 35 get_frame_delay, wrapIndexedSetter 35 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_35/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 35 get_frame_texture, wrapIndexedSetter 35 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_36/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 36 get_frame_delay, wrapIndexedSetter 36 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_36/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 36 get_frame_texture, wrapIndexedSetter 36 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_37/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 37 get_frame_delay, wrapIndexedSetter 37 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_37/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 37 get_frame_texture, wrapIndexedSetter 37 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_38/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 38 get_frame_delay, wrapIndexedSetter 38 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_38/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 38 get_frame_texture, wrapIndexedSetter 38 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_39/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 39 get_frame_delay, wrapIndexedSetter 39 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_39/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 39 get_frame_texture, wrapIndexedSetter 39 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_4/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_frame_delay, wrapIndexedSetter 4 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_4/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 4 get_frame_texture, wrapIndexedSetter 4 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_40/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 40 get_frame_delay, wrapIndexedSetter 40 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_40/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 40 get_frame_texture, wrapIndexedSetter 40 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_41/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 41 get_frame_delay, wrapIndexedSetter 41 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_41/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 41 get_frame_texture, wrapIndexedSetter 41 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_42/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 42 get_frame_delay, wrapIndexedSetter 42 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_42/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 42 get_frame_texture, wrapIndexedSetter 42 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_43/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 43 get_frame_delay, wrapIndexedSetter 43 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_43/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 43 get_frame_texture, wrapIndexedSetter 43 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_44/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 44 get_frame_delay, wrapIndexedSetter 44 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_44/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 44 get_frame_texture, wrapIndexedSetter 44 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_45/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 45 get_frame_delay, wrapIndexedSetter 45 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_45/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 45 get_frame_texture, wrapIndexedSetter 45 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_46/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 46 get_frame_delay, wrapIndexedSetter 46 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_46/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 46 get_frame_texture, wrapIndexedSetter 46 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_47/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 47 get_frame_delay, wrapIndexedSetter 47 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_47/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 47 get_frame_texture, wrapIndexedSetter 47 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_48/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 48 get_frame_delay, wrapIndexedSetter 48 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_48/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 48 get_frame_texture, wrapIndexedSetter 48 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_49/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 49 get_frame_delay, wrapIndexedSetter 49 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_49/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 49 get_frame_texture, wrapIndexedSetter 49 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_5/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_frame_delay, wrapIndexedSetter 5 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_5/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 5 get_frame_texture, wrapIndexedSetter 5 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_50/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 50 get_frame_delay, wrapIndexedSetter 50 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_50/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 50 get_frame_texture, wrapIndexedSetter 50 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_51/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 51 get_frame_delay, wrapIndexedSetter 51 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_51/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 51 get_frame_texture, wrapIndexedSetter 51 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_52/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 52 get_frame_delay, wrapIndexedSetter 52 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_52/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 52 get_frame_texture, wrapIndexedSetter 52 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_53/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 53 get_frame_delay, wrapIndexedSetter 53 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_53/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 53 get_frame_texture, wrapIndexedSetter 53 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_54/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 54 get_frame_delay, wrapIndexedSetter 54 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_54/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 54 get_frame_texture, wrapIndexedSetter 54 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_55/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 55 get_frame_delay, wrapIndexedSetter 55 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_55/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 55 get_frame_texture, wrapIndexedSetter 55 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_56/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 56 get_frame_delay, wrapIndexedSetter 56 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_56/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 56 get_frame_texture, wrapIndexedSetter 56 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_57/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 57 get_frame_delay, wrapIndexedSetter 57 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_57/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 57 get_frame_texture, wrapIndexedSetter 57 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_58/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 58 get_frame_delay, wrapIndexedSetter 58 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_58/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 58 get_frame_texture, wrapIndexedSetter 58 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_59/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 59 get_frame_delay, wrapIndexedSetter 59 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_59/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 59 get_frame_texture, wrapIndexedSetter 59 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_6/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_frame_delay, wrapIndexedSetter 6 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_6/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 6 get_frame_texture, wrapIndexedSetter 6 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_60/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 60 get_frame_delay, wrapIndexedSetter 60 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_60/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 60 get_frame_texture, wrapIndexedSetter 60 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_61/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 61 get_frame_delay, wrapIndexedSetter 61 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_61/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 61 get_frame_texture, wrapIndexedSetter 61 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_62/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 62 get_frame_delay, wrapIndexedSetter 62 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_62/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 62 get_frame_texture, wrapIndexedSetter 62 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_63/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 63 get_frame_delay, wrapIndexedSetter 63 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_63/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 63 get_frame_texture, wrapIndexedSetter 63 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_64/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 64 get_frame_delay, wrapIndexedSetter 64 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_64/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 64 get_frame_texture, wrapIndexedSetter 64 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_65/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 65 get_frame_delay, wrapIndexedSetter 65 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_65/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 65 get_frame_texture, wrapIndexedSetter 65 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_66/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 66 get_frame_delay, wrapIndexedSetter 66 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_66/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 66 get_frame_texture, wrapIndexedSetter 66 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_67/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 67 get_frame_delay, wrapIndexedSetter 67 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_67/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 67 get_frame_texture, wrapIndexedSetter 67 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_68/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 68 get_frame_delay, wrapIndexedSetter 68 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_68/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 68 get_frame_texture, wrapIndexedSetter 68 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_69/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 69 get_frame_delay, wrapIndexedSetter 69 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_69/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 69 get_frame_texture, wrapIndexedSetter 69 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_7/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_frame_delay, wrapIndexedSetter 7 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_7/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 7 get_frame_texture, wrapIndexedSetter 7 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_70/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 70 get_frame_delay, wrapIndexedSetter 70 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_70/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 70 get_frame_texture, wrapIndexedSetter 70 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_71/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 71 get_frame_delay, wrapIndexedSetter 71 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_71/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 71 get_frame_texture, wrapIndexedSetter 71 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_72/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 72 get_frame_delay, wrapIndexedSetter 72 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_72/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 72 get_frame_texture, wrapIndexedSetter 72 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_73/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 73 get_frame_delay, wrapIndexedSetter 73 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_73/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 73 get_frame_texture, wrapIndexedSetter 73 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_74/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 74 get_frame_delay, wrapIndexedSetter 74 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_74/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 74 get_frame_texture, wrapIndexedSetter 74 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_75/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 75 get_frame_delay, wrapIndexedSetter 75 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_75/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 75 get_frame_texture, wrapIndexedSetter 75 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_76/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 76 get_frame_delay, wrapIndexedSetter 76 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_76/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 76 get_frame_texture, wrapIndexedSetter 76 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_77/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 77 get_frame_delay, wrapIndexedSetter 77 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_77/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 77 get_frame_texture, wrapIndexedSetter 77 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_78/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 78 get_frame_delay, wrapIndexedSetter 78 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_78/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 78 get_frame_texture, wrapIndexedSetter 78 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_79/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 79 get_frame_delay, wrapIndexedSetter 79 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_79/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 79 get_frame_texture, wrapIndexedSetter 79 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_8/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_frame_delay, wrapIndexedSetter 8 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_8/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 8 get_frame_texture, wrapIndexedSetter 8 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_80/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 80 get_frame_delay, wrapIndexedSetter 80 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_80/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 80 get_frame_texture, wrapIndexedSetter 80 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_81/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 81 get_frame_delay, wrapIndexedSetter 81 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_81/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 81 get_frame_texture, wrapIndexedSetter 81 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_82/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 82 get_frame_delay, wrapIndexedSetter 82 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_82/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 82 get_frame_texture, wrapIndexedSetter 82 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_83/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 83 get_frame_delay, wrapIndexedSetter 83 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_83/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 83 get_frame_texture, wrapIndexedSetter 83 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_84/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 84 get_frame_delay, wrapIndexedSetter 84 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_84/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 84 get_frame_texture, wrapIndexedSetter 84 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_85/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 85 get_frame_delay, wrapIndexedSetter 85 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_85/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 85 get_frame_texture, wrapIndexedSetter 85 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_86/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 86 get_frame_delay, wrapIndexedSetter 86 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_86/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 86 get_frame_texture, wrapIndexedSetter 86 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_87/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 87 get_frame_delay, wrapIndexedSetter 87 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_87/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 87 get_frame_texture, wrapIndexedSetter 87 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_88/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 88 get_frame_delay, wrapIndexedSetter 88 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_88/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 88 get_frame_texture, wrapIndexedSetter 88 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_89/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 89 get_frame_delay, wrapIndexedSetter 89 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_89/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 89 get_frame_texture, wrapIndexedSetter 89 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_9/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_frame_delay, wrapIndexedSetter 9 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_9/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 9 get_frame_texture, wrapIndexedSetter 9 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_90/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 90 get_frame_delay, wrapIndexedSetter 90 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_90/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 90 get_frame_texture, wrapIndexedSetter 90 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_91/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 91 get_frame_delay, wrapIndexedSetter 91 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_91/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 91 get_frame_texture, wrapIndexedSetter 91 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_92/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 92 get_frame_delay, wrapIndexedSetter 92 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_92/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 92 get_frame_texture, wrapIndexedSetter 92 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_93/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 93 get_frame_delay, wrapIndexedSetter 93 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_93/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 93 get_frame_texture, wrapIndexedSetter 93 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_94/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 94 get_frame_delay, wrapIndexedSetter 94 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_94/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 94 get_frame_texture, wrapIndexedSetter 94 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_95/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 95 get_frame_delay, wrapIndexedSetter 95 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_95/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 95 get_frame_texture, wrapIndexedSetter 95 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_96/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 96 get_frame_delay, wrapIndexedSetter 96 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_96/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 96 get_frame_texture, wrapIndexedSetter 96 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_97/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 97 get_frame_delay, wrapIndexedSetter 97 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_97/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 97 get_frame_texture, wrapIndexedSetter 97 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_98/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 98 get_frame_delay, wrapIndexedSetter 98 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_98/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 98 get_frame_texture, wrapIndexedSetter 98 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frame_99/delay_sec" Float 'False where nodeProperty = (wrapIndexedGetter 99 get_frame_delay, wrapIndexedSetter 99 set_frame_delay, Nothing) instance NodeProperty AnimatedTexture "frame_99/texture" Texture 'False where nodeProperty = (wrapIndexedGetter 99 get_frame_texture, wrapIndexedSetter 99 set_frame_texture, Nothing) instance NodeProperty AnimatedTexture "frames" Int 'False where nodeProperty = (get_frames, wrapDroppingSetter set_frames, Nothing) {-# NOINLINE bindAnimatedTexture__update_proxy #-} bindAnimatedTexture__update_proxy :: MethodBind bindAnimatedTexture__update_proxy = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "_update_proxy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_proxy :: (AnimatedTexture :< cls, Object :< cls) => cls -> IO () _update_proxy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture__update_proxy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "_update_proxy" '[] (IO ()) where nodeMethod = Godot.Core.AnimatedTexture._update_proxy {-# NOINLINE bindAnimatedTexture_get_fps #-} -- | Animation speed in frames per second. This value defines the default time interval between two frames of the animation, and thus the overall duration of the animation loop based on the @frames@ property. A value of 0 means no predefined number of frames per second, the animation will play according to each frame's frame delay (see @method set_frame_delay@). -- For example, an animation with 8 frames, no frame delay and a @fps@ value of 2 will run for 4 seconds, with each frame lasting 0.5 seconds. bindAnimatedTexture_get_fps :: MethodBind bindAnimatedTexture_get_fps = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "get_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Animation speed in frames per second. This value defines the default time interval between two frames of the animation, and thus the overall duration of the animation loop based on the @frames@ property. A value of 0 means no predefined number of frames per second, the animation will play according to each frame's frame delay (see @method set_frame_delay@). -- For example, an animation with 8 frames, no frame delay and a @fps@ value of 2 will run for 4 seconds, with each frame lasting 0.5 seconds. get_fps :: (AnimatedTexture :< cls, Object :< cls) => cls -> IO Float get_fps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture_get_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "get_fps" '[] (IO Float) where nodeMethod = Godot.Core.AnimatedTexture.get_fps {-# NOINLINE bindAnimatedTexture_get_frame_delay #-} -- | Returns the given frame's delay value. bindAnimatedTexture_get_frame_delay :: MethodBind bindAnimatedTexture_get_frame_delay = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "get_frame_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given frame's delay value. get_frame_delay :: (AnimatedTexture :< cls, Object :< cls) => cls -> Int -> IO Float get_frame_delay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture_get_frame_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "get_frame_delay" '[Int] (IO Float) where nodeMethod = Godot.Core.AnimatedTexture.get_frame_delay {-# NOINLINE bindAnimatedTexture_get_frame_texture #-} -- | Returns the given frame's @Texture@. bindAnimatedTexture_get_frame_texture :: MethodBind bindAnimatedTexture_get_frame_texture = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "get_frame_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given frame's @Texture@. get_frame_texture :: (AnimatedTexture :< cls, Object :< cls) => cls -> Int -> IO Texture get_frame_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture_get_frame_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "get_frame_texture" '[Int] (IO Texture) where nodeMethod = Godot.Core.AnimatedTexture.get_frame_texture {-# NOINLINE bindAnimatedTexture_get_frames #-} -- | Number of frames to use in the animation. While you can create the frames independently with @method set_frame_texture@, you need to set this value for the animation to take new frames into account. The maximum number of frames is @MAX_FRAMES@. bindAnimatedTexture_get_frames :: MethodBind bindAnimatedTexture_get_frames = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "get_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of frames to use in the animation. While you can create the frames independently with @method set_frame_texture@, you need to set this value for the animation to take new frames into account. The maximum number of frames is @MAX_FRAMES@. get_frames :: (AnimatedTexture :< cls, Object :< cls) => cls -> IO Int get_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture_get_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "get_frames" '[] (IO Int) where nodeMethod = Godot.Core.AnimatedTexture.get_frames {-# NOINLINE bindAnimatedTexture_set_fps #-} -- | Animation speed in frames per second. This value defines the default time interval between two frames of the animation, and thus the overall duration of the animation loop based on the @frames@ property. A value of 0 means no predefined number of frames per second, the animation will play according to each frame's frame delay (see @method set_frame_delay@). -- For example, an animation with 8 frames, no frame delay and a @fps@ value of 2 will run for 4 seconds, with each frame lasting 0.5 seconds. bindAnimatedTexture_set_fps :: MethodBind bindAnimatedTexture_set_fps = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "set_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Animation speed in frames per second. This value defines the default time interval between two frames of the animation, and thus the overall duration of the animation loop based on the @frames@ property. A value of 0 means no predefined number of frames per second, the animation will play according to each frame's frame delay (see @method set_frame_delay@). -- For example, an animation with 8 frames, no frame delay and a @fps@ value of 2 will run for 4 seconds, with each frame lasting 0.5 seconds. set_fps :: (AnimatedTexture :< cls, Object :< cls) => cls -> Float -> IO () set_fps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture_set_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "set_fps" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimatedTexture.set_fps {-# NOINLINE bindAnimatedTexture_set_frame_delay #-} -- | Sets an additional delay (in seconds) between this frame and the next one, that will be added to the time interval defined by @fps@. By default, frames have no delay defined. If a delay value is defined, the final time interval between this frame and the next will be @1.0 / fps + delay@. -- For example, for an animation with 3 frames, 2 FPS and a frame delay on the second frame of 1.2, the resulting playback will be: -- -- @ -- -- Frame 0: 0.5 s (1 / fps) -- Frame 1: 1.7 s (1 / fps + 1.2) -- Frame 2: 0.5 s (1 / fps) -- Total duration: 2.7 s -- -- @ bindAnimatedTexture_set_frame_delay :: MethodBind bindAnimatedTexture_set_frame_delay = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "set_frame_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an additional delay (in seconds) between this frame and the next one, that will be added to the time interval defined by @fps@. By default, frames have no delay defined. If a delay value is defined, the final time interval between this frame and the next will be @1.0 / fps + delay@. -- For example, for an animation with 3 frames, 2 FPS and a frame delay on the second frame of 1.2, the resulting playback will be: -- -- @ -- -- Frame 0: 0.5 s (1 / fps) -- Frame 1: 1.7 s (1 / fps + 1.2) -- Frame 2: 0.5 s (1 / fps) -- Total duration: 2.7 s -- -- @ set_frame_delay :: (AnimatedTexture :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_frame_delay cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture_set_frame_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "set_frame_delay" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AnimatedTexture.set_frame_delay {-# NOINLINE bindAnimatedTexture_set_frame_texture #-} -- | Assigns a @Texture@ to the given frame. Frame IDs start at 0, so the first frame has ID 0, and the last frame of the animation has ID @frames@ - 1. -- You can define any number of textures up to @MAX_FRAMES@, but keep in mind that only frames from 0 to @frames@ - 1 will be part of the animation. bindAnimatedTexture_set_frame_texture :: MethodBind bindAnimatedTexture_set_frame_texture = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "set_frame_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a @Texture@ to the given frame. Frame IDs start at 0, so the first frame has ID 0, and the last frame of the animation has ID @frames@ - 1. -- You can define any number of textures up to @MAX_FRAMES@, but keep in mind that only frames from 0 to @frames@ - 1 will be part of the animation. set_frame_texture :: (AnimatedTexture :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_frame_texture cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture_set_frame_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "set_frame_texture" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.AnimatedTexture.set_frame_texture {-# NOINLINE bindAnimatedTexture_set_frames #-} -- | Number of frames to use in the animation. While you can create the frames independently with @method set_frame_texture@, you need to set this value for the animation to take new frames into account. The maximum number of frames is @MAX_FRAMES@. bindAnimatedTexture_set_frames :: MethodBind bindAnimatedTexture_set_frames = unsafePerformIO $ withCString "AnimatedTexture" $ \ clsNamePtr -> withCString "set_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of frames to use in the animation. While you can create the frames independently with @method set_frame_texture@, you need to set this value for the animation to take new frames into account. The maximum number of frames is @MAX_FRAMES@. set_frames :: (AnimatedTexture :< cls, Object :< cls) => cls -> Int -> IO () set_frames cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimatedTexture_set_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimatedTexture "set_frames" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimatedTexture.set_frames ================================================ FILE: src/Godot/Core/Animation.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Animation (Godot.Core.Animation._TYPE_BEZIER, Godot.Core.Animation._INTERPOLATION_NEAREST, Godot.Core.Animation._UPDATE_DISCRETE, Godot.Core.Animation._INTERPOLATION_LINEAR, Godot.Core.Animation._TYPE_VALUE, Godot.Core.Animation._UPDATE_CAPTURE, Godot.Core.Animation._TYPE_METHOD, Godot.Core.Animation._UPDATE_CONTINUOUS, Godot.Core.Animation._INTERPOLATION_CUBIC, Godot.Core.Animation._TYPE_TRANSFORM, Godot.Core.Animation._UPDATE_TRIGGER, Godot.Core.Animation._TYPE_AUDIO, Godot.Core.Animation._TYPE_ANIMATION, Godot.Core.Animation.sig_tracks_changed, Godot.Core.Animation.add_track, Godot.Core.Animation.animation_track_get_key_animation, Godot.Core.Animation.animation_track_insert_key, Godot.Core.Animation.animation_track_set_key_animation, Godot.Core.Animation.audio_track_get_key_end_offset, Godot.Core.Animation.audio_track_get_key_start_offset, Godot.Core.Animation.audio_track_get_key_stream, Godot.Core.Animation.audio_track_insert_key, Godot.Core.Animation.audio_track_set_key_end_offset, Godot.Core.Animation.audio_track_set_key_start_offset, Godot.Core.Animation.audio_track_set_key_stream, Godot.Core.Animation.bezier_track_get_key_in_handle, Godot.Core.Animation.bezier_track_get_key_out_handle, Godot.Core.Animation.bezier_track_get_key_value, Godot.Core.Animation.bezier_track_insert_key, Godot.Core.Animation.bezier_track_interpolate, Godot.Core.Animation.bezier_track_set_key_in_handle, Godot.Core.Animation.bezier_track_set_key_out_handle, Godot.Core.Animation.bezier_track_set_key_value, Godot.Core.Animation.clear, Godot.Core.Animation.copy_track, Godot.Core.Animation.find_track, Godot.Core.Animation.get_length, Godot.Core.Animation.get_step, Godot.Core.Animation.get_track_count, Godot.Core.Animation.has_loop, Godot.Core.Animation.method_track_get_key_indices, Godot.Core.Animation.method_track_get_name, Godot.Core.Animation.method_track_get_params, Godot.Core.Animation.remove_track, Godot.Core.Animation.set_length, Godot.Core.Animation.set_loop, Godot.Core.Animation.set_step, Godot.Core.Animation.track_find_key, Godot.Core.Animation.track_get_interpolation_loop_wrap, Godot.Core.Animation.track_get_interpolation_type, Godot.Core.Animation.track_get_key_count, Godot.Core.Animation.track_get_key_time, Godot.Core.Animation.track_get_key_transition, Godot.Core.Animation.track_get_key_value, Godot.Core.Animation.track_get_path, Godot.Core.Animation.track_get_type, Godot.Core.Animation.track_insert_key, Godot.Core.Animation.track_is_enabled, Godot.Core.Animation.track_is_imported, Godot.Core.Animation.track_move_down, Godot.Core.Animation.track_move_to, Godot.Core.Animation.track_move_up, Godot.Core.Animation.track_remove_key, Godot.Core.Animation.track_remove_key_at_position, Godot.Core.Animation.track_set_enabled, Godot.Core.Animation.track_set_imported, Godot.Core.Animation.track_set_interpolation_loop_wrap, Godot.Core.Animation.track_set_interpolation_type, Godot.Core.Animation.track_set_key_time, Godot.Core.Animation.track_set_key_transition, Godot.Core.Animation.track_set_key_value, Godot.Core.Animation.track_set_path, Godot.Core.Animation.track_swap, Godot.Core.Animation.transform_track_insert_key, Godot.Core.Animation.transform_track_interpolate, Godot.Core.Animation.value_track_get_key_indices, Godot.Core.Animation.value_track_get_update_mode, Godot.Core.Animation.value_track_set_update_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _TYPE_BEZIER :: Int _TYPE_BEZIER = 3 _INTERPOLATION_NEAREST :: Int _INTERPOLATION_NEAREST = 0 _UPDATE_DISCRETE :: Int _UPDATE_DISCRETE = 1 _INTERPOLATION_LINEAR :: Int _INTERPOLATION_LINEAR = 1 _TYPE_VALUE :: Int _TYPE_VALUE = 0 _UPDATE_CAPTURE :: Int _UPDATE_CAPTURE = 3 _TYPE_METHOD :: Int _TYPE_METHOD = 2 _UPDATE_CONTINUOUS :: Int _UPDATE_CONTINUOUS = 0 _INTERPOLATION_CUBIC :: Int _INTERPOLATION_CUBIC = 2 _TYPE_TRANSFORM :: Int _TYPE_TRANSFORM = 1 _UPDATE_TRIGGER :: Int _UPDATE_TRIGGER = 2 _TYPE_AUDIO :: Int _TYPE_AUDIO = 4 _TYPE_ANIMATION :: Int _TYPE_ANIMATION = 5 -- | Emitted when there's a change in the list of tracks, e.g. tracks are added, moved or have changed paths. sig_tracks_changed :: Godot.Internal.Dispatch.Signal Animation sig_tracks_changed = Godot.Internal.Dispatch.Signal "tracks_changed" instance NodeSignal Animation "tracks_changed" '[] instance NodeProperty Animation "length" Float 'False where nodeProperty = (get_length, wrapDroppingSetter set_length, Nothing) instance NodeProperty Animation "loop" Bool 'False where nodeProperty = (has_loop, wrapDroppingSetter set_loop, Nothing) instance NodeProperty Animation "step" Float 'False where nodeProperty = (get_step, wrapDroppingSetter set_step, Nothing) {-# NOINLINE bindAnimation_add_track #-} -- | Adds a track to the Animation. bindAnimation_add_track :: MethodBind bindAnimation_add_track = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "add_track" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a track to the Animation. add_track :: (Animation :< cls, Object :< cls) => cls -> Int -> Maybe Int -> IO Int add_track cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_add_track (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "add_track" '[Int, Maybe Int] (IO Int) where nodeMethod = Godot.Core.Animation.add_track {-# NOINLINE bindAnimation_animation_track_get_key_animation #-} -- | Returns the animation name at the key identified by @key_idx@. The @track_idx@ must be the index of an Animation Track. bindAnimation_animation_track_get_key_animation :: MethodBind bindAnimation_animation_track_get_key_animation = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "animation_track_get_key_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the animation name at the key identified by @key_idx@. The @track_idx@ must be the index of an Animation Track. animation_track_get_key_animation :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO GodotString animation_track_get_key_animation cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_animation_track_get_key_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "animation_track_get_key_animation" '[Int, Int] (IO GodotString) where nodeMethod = Godot.Core.Animation.animation_track_get_key_animation {-# NOINLINE bindAnimation_animation_track_insert_key #-} -- | Inserts a key with value @animation@ at the given @time@ (in seconds). The @track_idx@ must be the index of an Animation Track. bindAnimation_animation_track_insert_key :: MethodBind bindAnimation_animation_track_insert_key = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "animation_track_insert_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Inserts a key with value @animation@ at the given @time@ (in seconds). The @track_idx@ must be the index of an Animation Track. animation_track_insert_key :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> GodotString -> IO Int animation_track_insert_key cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_animation_track_insert_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "animation_track_insert_key" '[Int, Float, GodotString] (IO Int) where nodeMethod = Godot.Core.Animation.animation_track_insert_key {-# NOINLINE bindAnimation_animation_track_set_key_animation #-} -- | Sets the key identified by @key_idx@ to value @animation@. The @track_idx@ must be the index of an Animation Track. bindAnimation_animation_track_set_key_animation :: MethodBind bindAnimation_animation_track_set_key_animation = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "animation_track_set_key_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the key identified by @key_idx@ to value @animation@. The @track_idx@ must be the index of an Animation Track. animation_track_set_key_animation :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> GodotString -> IO () animation_track_set_key_animation cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_animation_track_set_key_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "animation_track_set_key_animation" '[Int, Int, GodotString] (IO ()) where nodeMethod = Godot.Core.Animation.animation_track_set_key_animation {-# NOINLINE bindAnimation_audio_track_get_key_end_offset #-} -- | Returns the end offset of the key identified by @key_idx@. The @track_idx@ must be the index of an Audio Track. -- End offset is the number of seconds cut off at the ending of the audio stream. bindAnimation_audio_track_get_key_end_offset :: MethodBind bindAnimation_audio_track_get_key_end_offset = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "audio_track_get_key_end_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the end offset of the key identified by @key_idx@. The @track_idx@ must be the index of an Audio Track. -- End offset is the number of seconds cut off at the ending of the audio stream. audio_track_get_key_end_offset :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Float audio_track_get_key_end_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_audio_track_get_key_end_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "audio_track_get_key_end_offset" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.Animation.audio_track_get_key_end_offset {-# NOINLINE bindAnimation_audio_track_get_key_start_offset #-} -- | Returns the start offset of the key identified by @key_idx@. The @track_idx@ must be the index of an Audio Track. -- Start offset is the number of seconds cut off at the beginning of the audio stream. bindAnimation_audio_track_get_key_start_offset :: MethodBind bindAnimation_audio_track_get_key_start_offset = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "audio_track_get_key_start_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the start offset of the key identified by @key_idx@. The @track_idx@ must be the index of an Audio Track. -- Start offset is the number of seconds cut off at the beginning of the audio stream. audio_track_get_key_start_offset :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Float audio_track_get_key_start_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_audio_track_get_key_start_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "audio_track_get_key_start_offset" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.Animation.audio_track_get_key_start_offset {-# NOINLINE bindAnimation_audio_track_get_key_stream #-} -- | Returns the audio stream of the key identified by @key_idx@. The @track_idx@ must be the index of an Audio Track. bindAnimation_audio_track_get_key_stream :: MethodBind bindAnimation_audio_track_get_key_stream = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "audio_track_get_key_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the audio stream of the key identified by @key_idx@. The @track_idx@ must be the index of an Audio Track. audio_track_get_key_stream :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Resource audio_track_get_key_stream cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_audio_track_get_key_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "audio_track_get_key_stream" '[Int, Int] (IO Resource) where nodeMethod = Godot.Core.Animation.audio_track_get_key_stream {-# NOINLINE bindAnimation_audio_track_insert_key #-} -- | Inserts an Audio Track key at the given @time@ in seconds. The @track_idx@ must be the index of an Audio Track. -- @stream@ is the @AudioStream@ resource to play. @start_offset@ is the number of seconds cut off at the beginning of the audio stream, while @end_offset@ is at the ending. bindAnimation_audio_track_insert_key :: MethodBind bindAnimation_audio_track_insert_key = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "audio_track_insert_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Inserts an Audio Track key at the given @time@ in seconds. The @track_idx@ must be the index of an Audio Track. -- @stream@ is the @AudioStream@ resource to play. @start_offset@ is the number of seconds cut off at the beginning of the audio stream, while @end_offset@ is at the ending. audio_track_insert_key :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> Resource -> Maybe Float -> Maybe Float -> IO Int audio_track_insert_key cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantReal (0)) toVariant arg4, maybe (VariantReal (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_audio_track_insert_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "audio_track_insert_key" '[Int, Float, Resource, Maybe Float, Maybe Float] (IO Int) where nodeMethod = Godot.Core.Animation.audio_track_insert_key {-# NOINLINE bindAnimation_audio_track_set_key_end_offset #-} -- | Sets the end offset of the key identified by @key_idx@ to value @offset@. The @track_idx@ must be the index of an Audio Track. bindAnimation_audio_track_set_key_end_offset :: MethodBind bindAnimation_audio_track_set_key_end_offset = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "audio_track_set_key_end_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the end offset of the key identified by @key_idx@ to value @offset@. The @track_idx@ must be the index of an Audio Track. audio_track_set_key_end_offset :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> Float -> IO () audio_track_set_key_end_offset cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_audio_track_set_key_end_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "audio_track_set_key_end_offset" '[Int, Int, Float] (IO ()) where nodeMethod = Godot.Core.Animation.audio_track_set_key_end_offset {-# NOINLINE bindAnimation_audio_track_set_key_start_offset #-} -- | Sets the start offset of the key identified by @key_idx@ to value @offset@. The @track_idx@ must be the index of an Audio Track. bindAnimation_audio_track_set_key_start_offset :: MethodBind bindAnimation_audio_track_set_key_start_offset = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "audio_track_set_key_start_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the start offset of the key identified by @key_idx@ to value @offset@. The @track_idx@ must be the index of an Audio Track. audio_track_set_key_start_offset :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> Float -> IO () audio_track_set_key_start_offset cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_audio_track_set_key_start_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "audio_track_set_key_start_offset" '[Int, Int, Float] (IO ()) where nodeMethod = Godot.Core.Animation.audio_track_set_key_start_offset {-# NOINLINE bindAnimation_audio_track_set_key_stream #-} -- | Sets the stream of the key identified by @key_idx@ to value @offset@. The @track_idx@ must be the index of an Audio Track. bindAnimation_audio_track_set_key_stream :: MethodBind bindAnimation_audio_track_set_key_stream = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "audio_track_set_key_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the stream of the key identified by @key_idx@ to value @offset@. The @track_idx@ must be the index of an Audio Track. audio_track_set_key_stream :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> Resource -> IO () audio_track_set_key_stream cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_audio_track_set_key_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "audio_track_set_key_stream" '[Int, Int, Resource] (IO ()) where nodeMethod = Godot.Core.Animation.audio_track_set_key_stream {-# NOINLINE bindAnimation_bezier_track_get_key_in_handle #-} -- | Returns the in handle of the key identified by @key_idx@. The @track_idx@ must be the index of a Bezier Track. bindAnimation_bezier_track_get_key_in_handle :: MethodBind bindAnimation_bezier_track_get_key_in_handle = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "bezier_track_get_key_in_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the in handle of the key identified by @key_idx@. The @track_idx@ must be the index of a Bezier Track. bezier_track_get_key_in_handle :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Vector2 bezier_track_get_key_in_handle cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_bezier_track_get_key_in_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "bezier_track_get_key_in_handle" '[Int, Int] (IO Vector2) where nodeMethod = Godot.Core.Animation.bezier_track_get_key_in_handle {-# NOINLINE bindAnimation_bezier_track_get_key_out_handle #-} -- | Returns the out handle of the key identified by @key_idx@. The @track_idx@ must be the index of a Bezier Track. bindAnimation_bezier_track_get_key_out_handle :: MethodBind bindAnimation_bezier_track_get_key_out_handle = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "bezier_track_get_key_out_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the out handle of the key identified by @key_idx@. The @track_idx@ must be the index of a Bezier Track. bezier_track_get_key_out_handle :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Vector2 bezier_track_get_key_out_handle cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_bezier_track_get_key_out_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "bezier_track_get_key_out_handle" '[Int, Int] (IO Vector2) where nodeMethod = Godot.Core.Animation.bezier_track_get_key_out_handle {-# NOINLINE bindAnimation_bezier_track_get_key_value #-} -- | Returns the value of the key identified by @key_idx@. The @track_idx@ must be the index of a Bezier Track. bindAnimation_bezier_track_get_key_value :: MethodBind bindAnimation_bezier_track_get_key_value = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "bezier_track_get_key_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the key identified by @key_idx@. The @track_idx@ must be the index of a Bezier Track. bezier_track_get_key_value :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Float bezier_track_get_key_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_bezier_track_get_key_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "bezier_track_get_key_value" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.Animation.bezier_track_get_key_value {-# NOINLINE bindAnimation_bezier_track_insert_key #-} -- | Inserts a Bezier Track key at the given @time@ in seconds. The @track_idx@ must be the index of a Bezier Track. -- @in_handle@ is the left-side weight of the added Bezier curve point, @out_handle@ is the right-side one, while @value@ is the actual value at this point. bindAnimation_bezier_track_insert_key :: MethodBind bindAnimation_bezier_track_insert_key = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "bezier_track_insert_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Inserts a Bezier Track key at the given @time@ in seconds. The @track_idx@ must be the index of a Bezier Track. -- @in_handle@ is the left-side weight of the added Bezier curve point, @out_handle@ is the right-side one, while @value@ is the actual value at this point. bezier_track_insert_key :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> Float -> Maybe Vector2 -> Maybe Vector2 -> IO Int bezier_track_insert_key cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantVector2 (V2 0 0) arg4, defaultedVariant VariantVector2 (V2 0 0) arg5] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_bezier_track_insert_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "bezier_track_insert_key" '[Int, Float, Float, Maybe Vector2, Maybe Vector2] (IO Int) where nodeMethod = Godot.Core.Animation.bezier_track_insert_key {-# NOINLINE bindAnimation_bezier_track_interpolate #-} -- | Returns the interpolated value at the given @time@ (in seconds). The @track_idx@ must be the index of a Bezier Track. bindAnimation_bezier_track_interpolate :: MethodBind bindAnimation_bezier_track_interpolate = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "bezier_track_interpolate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the interpolated value at the given @time@ (in seconds). The @track_idx@ must be the index of a Bezier Track. bezier_track_interpolate :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> IO Float bezier_track_interpolate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_bezier_track_interpolate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "bezier_track_interpolate" '[Int, Float] (IO Float) where nodeMethod = Godot.Core.Animation.bezier_track_interpolate {-# NOINLINE bindAnimation_bezier_track_set_key_in_handle #-} -- | Sets the in handle of the key identified by @key_idx@ to value @in_handle@. The @track_idx@ must be the index of a Bezier Track. bindAnimation_bezier_track_set_key_in_handle :: MethodBind bindAnimation_bezier_track_set_key_in_handle = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "bezier_track_set_key_in_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the in handle of the key identified by @key_idx@ to value @in_handle@. The @track_idx@ must be the index of a Bezier Track. bezier_track_set_key_in_handle :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> Vector2 -> IO () bezier_track_set_key_in_handle cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_bezier_track_set_key_in_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "bezier_track_set_key_in_handle" '[Int, Int, Vector2] (IO ()) where nodeMethod = Godot.Core.Animation.bezier_track_set_key_in_handle {-# NOINLINE bindAnimation_bezier_track_set_key_out_handle #-} -- | Sets the out handle of the key identified by @key_idx@ to value @out_handle@. The @track_idx@ must be the index of a Bezier Track. bindAnimation_bezier_track_set_key_out_handle :: MethodBind bindAnimation_bezier_track_set_key_out_handle = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "bezier_track_set_key_out_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the out handle of the key identified by @key_idx@ to value @out_handle@. The @track_idx@ must be the index of a Bezier Track. bezier_track_set_key_out_handle :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> Vector2 -> IO () bezier_track_set_key_out_handle cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_bezier_track_set_key_out_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "bezier_track_set_key_out_handle" '[Int, Int, Vector2] (IO ()) where nodeMethod = Godot.Core.Animation.bezier_track_set_key_out_handle {-# NOINLINE bindAnimation_bezier_track_set_key_value #-} -- | Sets the value of the key identified by @key_idx@ to the given value. The @track_idx@ must be the index of a Bezier Track. bindAnimation_bezier_track_set_key_value :: MethodBind bindAnimation_bezier_track_set_key_value = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "bezier_track_set_key_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value of the key identified by @key_idx@ to the given value. The @track_idx@ must be the index of a Bezier Track. bezier_track_set_key_value :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> Float -> IO () bezier_track_set_key_value cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_bezier_track_set_key_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "bezier_track_set_key_value" '[Int, Int, Float] (IO ()) where nodeMethod = Godot.Core.Animation.bezier_track_set_key_value {-# NOINLINE bindAnimation_clear #-} -- | Clear the animation (clear all tracks and reset all). bindAnimation_clear :: MethodBind bindAnimation_clear = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear the animation (clear all tracks and reset all). clear :: (Animation :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "clear" '[] (IO ()) where nodeMethod = Godot.Core.Animation.clear {-# NOINLINE bindAnimation_copy_track #-} -- | Adds a new track that is a copy of the given track from @to_animation@. bindAnimation_copy_track :: MethodBind bindAnimation_copy_track = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "copy_track" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new track that is a copy of the given track from @to_animation@. copy_track :: (Animation :< cls, Object :< cls) => cls -> Int -> Animation -> IO () copy_track cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_copy_track (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "copy_track" '[Int, Animation] (IO ()) where nodeMethod = Godot.Core.Animation.copy_track {-# NOINLINE bindAnimation_find_track #-} -- | Returns the index of the specified track. If the track is not found, return -1. bindAnimation_find_track :: MethodBind bindAnimation_find_track = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "find_track" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the specified track. If the track is not found, return -1. find_track :: (Animation :< cls, Object :< cls) => cls -> NodePath -> IO Int find_track cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_find_track (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "find_track" '[NodePath] (IO Int) where nodeMethod = Godot.Core.Animation.find_track {-# NOINLINE bindAnimation_get_length #-} -- | The total length of the animation (in seconds). -- __Note:__ Length is not delimited by the last key, as this one may be before or after the end to ensure correct interpolation and looping. bindAnimation_get_length :: MethodBind bindAnimation_get_length = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "get_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The total length of the animation (in seconds). -- __Note:__ Length is not delimited by the last key, as this one may be before or after the end to ensure correct interpolation and looping. get_length :: (Animation :< cls, Object :< cls) => cls -> IO Float get_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_get_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "get_length" '[] (IO Float) where nodeMethod = Godot.Core.Animation.get_length {-# NOINLINE bindAnimation_get_step #-} -- | The animation step value. bindAnimation_get_step :: MethodBind bindAnimation_get_step = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "get_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The animation step value. get_step :: (Animation :< cls, Object :< cls) => cls -> IO Float get_step cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_get_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "get_step" '[] (IO Float) where nodeMethod = Godot.Core.Animation.get_step {-# NOINLINE bindAnimation_get_track_count #-} -- | Returns the amount of tracks in the animation. bindAnimation_get_track_count :: MethodBind bindAnimation_get_track_count = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "get_track_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of tracks in the animation. get_track_count :: (Animation :< cls, Object :< cls) => cls -> IO Int get_track_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_get_track_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "get_track_count" '[] (IO Int) where nodeMethod = Godot.Core.Animation.get_track_count {-# NOINLINE bindAnimation_has_loop #-} -- | A flag indicating that the animation must loop. This is uses for correct interpolation of animation cycles, and for hinting the player that it must restart the animation. bindAnimation_has_loop :: MethodBind bindAnimation_has_loop = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "has_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A flag indicating that the animation must loop. This is uses for correct interpolation of animation cycles, and for hinting the player that it must restart the animation. has_loop :: (Animation :< cls, Object :< cls) => cls -> IO Bool has_loop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_has_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "has_loop" '[] (IO Bool) where nodeMethod = Godot.Core.Animation.has_loop {-# NOINLINE bindAnimation_method_track_get_key_indices #-} -- | Returns all the key indices of a method track, given a position and delta time. bindAnimation_method_track_get_key_indices :: MethodBind bindAnimation_method_track_get_key_indices = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "method_track_get_key_indices" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the key indices of a method track, given a position and delta time. method_track_get_key_indices :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> Float -> IO PoolIntArray method_track_get_key_indices cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_method_track_get_key_indices (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "method_track_get_key_indices" '[Int, Float, Float] (IO PoolIntArray) where nodeMethod = Godot.Core.Animation.method_track_get_key_indices {-# NOINLINE bindAnimation_method_track_get_name #-} -- | Returns the method name of a method track. bindAnimation_method_track_get_name :: MethodBind bindAnimation_method_track_get_name = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "method_track_get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the method name of a method track. method_track_get_name :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO GodotString method_track_get_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_method_track_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "method_track_get_name" '[Int, Int] (IO GodotString) where nodeMethod = Godot.Core.Animation.method_track_get_name {-# NOINLINE bindAnimation_method_track_get_params #-} -- | Returns the arguments values to be called on a method track for a given key in a given track. bindAnimation_method_track_get_params :: MethodBind bindAnimation_method_track_get_params = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "method_track_get_params" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the arguments values to be called on a method track for a given key in a given track. method_track_get_params :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Array method_track_get_params cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_method_track_get_params (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "method_track_get_params" '[Int, Int] (IO Array) where nodeMethod = Godot.Core.Animation.method_track_get_params {-# NOINLINE bindAnimation_remove_track #-} -- | Removes a track by specifying the track index. bindAnimation_remove_track :: MethodBind bindAnimation_remove_track = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "remove_track" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a track by specifying the track index. remove_track :: (Animation :< cls, Object :< cls) => cls -> Int -> IO () remove_track cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_remove_track (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "remove_track" '[Int] (IO ()) where nodeMethod = Godot.Core.Animation.remove_track {-# NOINLINE bindAnimation_set_length #-} -- | The total length of the animation (in seconds). -- __Note:__ Length is not delimited by the last key, as this one may be before or after the end to ensure correct interpolation and looping. bindAnimation_set_length :: MethodBind bindAnimation_set_length = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "set_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The total length of the animation (in seconds). -- __Note:__ Length is not delimited by the last key, as this one may be before or after the end to ensure correct interpolation and looping. set_length :: (Animation :< cls, Object :< cls) => cls -> Float -> IO () set_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_set_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "set_length" '[Float] (IO ()) where nodeMethod = Godot.Core.Animation.set_length {-# NOINLINE bindAnimation_set_loop #-} -- | A flag indicating that the animation must loop. This is uses for correct interpolation of animation cycles, and for hinting the player that it must restart the animation. bindAnimation_set_loop :: MethodBind bindAnimation_set_loop = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "set_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A flag indicating that the animation must loop. This is uses for correct interpolation of animation cycles, and for hinting the player that it must restart the animation. set_loop :: (Animation :< cls, Object :< cls) => cls -> Bool -> IO () set_loop cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_set_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "set_loop" '[Bool] (IO ()) where nodeMethod = Godot.Core.Animation.set_loop {-# NOINLINE bindAnimation_set_step #-} -- | The animation step value. bindAnimation_set_step :: MethodBind bindAnimation_set_step = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "set_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The animation step value. set_step :: (Animation :< cls, Object :< cls) => cls -> Float -> IO () set_step cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_set_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "set_step" '[Float] (IO ()) where nodeMethod = Godot.Core.Animation.set_step {-# NOINLINE bindAnimation_track_find_key #-} -- | Finds the key index by time in a given track. Optionally, only find it if the exact time is given. bindAnimation_track_find_key :: MethodBind bindAnimation_track_find_key = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_find_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Finds the key index by time in a given track. Optionally, only find it if the exact time is given. track_find_key :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> Maybe Bool -> IO Int track_find_key cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_find_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_find_key" '[Int, Float, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.Animation.track_find_key {-# NOINLINE bindAnimation_track_get_interpolation_loop_wrap #-} -- | Returns @true@ if the track at @idx@ wraps the interpolation loop. New tracks wrap the interpolation loop by default. bindAnimation_track_get_interpolation_loop_wrap :: MethodBind bindAnimation_track_get_interpolation_loop_wrap = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_get_interpolation_loop_wrap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the track at @idx@ wraps the interpolation loop. New tracks wrap the interpolation loop by default. track_get_interpolation_loop_wrap :: (Animation :< cls, Object :< cls) => cls -> Int -> IO Bool track_get_interpolation_loop_wrap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_get_interpolation_loop_wrap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_get_interpolation_loop_wrap" '[Int] (IO Bool) where nodeMethod = Godot.Core.Animation.track_get_interpolation_loop_wrap {-# NOINLINE bindAnimation_track_get_interpolation_type #-} -- | Returns the interpolation type of a given track. bindAnimation_track_get_interpolation_type :: MethodBind bindAnimation_track_get_interpolation_type = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_get_interpolation_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the interpolation type of a given track. track_get_interpolation_type :: (Animation :< cls, Object :< cls) => cls -> Int -> IO Int track_get_interpolation_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_get_interpolation_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_get_interpolation_type" '[Int] (IO Int) where nodeMethod = Godot.Core.Animation.track_get_interpolation_type {-# NOINLINE bindAnimation_track_get_key_count #-} -- | Returns the amount of keys in a given track. bindAnimation_track_get_key_count :: MethodBind bindAnimation_track_get_key_count = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_get_key_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of keys in a given track. track_get_key_count :: (Animation :< cls, Object :< cls) => cls -> Int -> IO Int track_get_key_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_get_key_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_get_key_count" '[Int] (IO Int) where nodeMethod = Godot.Core.Animation.track_get_key_count {-# NOINLINE bindAnimation_track_get_key_time #-} -- | Returns the time at which the key is located. bindAnimation_track_get_key_time :: MethodBind bindAnimation_track_get_key_time = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_get_key_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the time at which the key is located. track_get_key_time :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Float track_get_key_time cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_get_key_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_get_key_time" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.Animation.track_get_key_time {-# NOINLINE bindAnimation_track_get_key_transition #-} -- | Returns the transition curve (easing) for a specific key (see the built-in math function @method @GDScript.ease@). bindAnimation_track_get_key_transition :: MethodBind bindAnimation_track_get_key_transition = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_get_key_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transition curve (easing) for a specific key (see the built-in math function @method @GDScript.ease@). track_get_key_transition :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO Float track_get_key_transition cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_get_key_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_get_key_transition" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.Animation.track_get_key_transition {-# NOINLINE bindAnimation_track_get_key_value #-} -- | Returns the value of a given key in a given track. bindAnimation_track_get_key_value :: MethodBind bindAnimation_track_get_key_value = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_get_key_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a given key in a given track. track_get_key_value :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO GodotVariant track_get_key_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_get_key_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_get_key_value" '[Int, Int] (IO GodotVariant) where nodeMethod = Godot.Core.Animation.track_get_key_value {-# NOINLINE bindAnimation_track_get_path #-} -- | Gets the path of a track. For more information on the path format, see @method track_set_path@. bindAnimation_track_get_path :: MethodBind bindAnimation_track_get_path = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_get_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the path of a track. For more information on the path format, see @method track_set_path@. track_get_path :: (Animation :< cls, Object :< cls) => cls -> Int -> IO NodePath track_get_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_get_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_get_path" '[Int] (IO NodePath) where nodeMethod = Godot.Core.Animation.track_get_path {-# NOINLINE bindAnimation_track_get_type #-} -- | Gets the type of a track. bindAnimation_track_get_type :: MethodBind bindAnimation_track_get_type = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_get_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the type of a track. track_get_type :: (Animation :< cls, Object :< cls) => cls -> Int -> IO Int track_get_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_get_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_get_type" '[Int] (IO Int) where nodeMethod = Godot.Core.Animation.track_get_type {-# NOINLINE bindAnimation_track_insert_key #-} -- | Insert a generic key in a given track. bindAnimation_track_insert_key :: MethodBind bindAnimation_track_insert_key = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_insert_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Insert a generic key in a given track. track_insert_key :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> GodotVariant -> Maybe Float -> IO () track_insert_key cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantReal (1)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_insert_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_insert_key" '[Int, Float, GodotVariant, Maybe Float] (IO ()) where nodeMethod = Godot.Core.Animation.track_insert_key {-# NOINLINE bindAnimation_track_is_enabled #-} -- | Returns @true@ if the track at index @idx@ is enabled. bindAnimation_track_is_enabled :: MethodBind bindAnimation_track_is_enabled = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_is_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the track at index @idx@ is enabled. track_is_enabled :: (Animation :< cls, Object :< cls) => cls -> Int -> IO Bool track_is_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_is_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_is_enabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.Animation.track_is_enabled {-# NOINLINE bindAnimation_track_is_imported #-} -- | Returns @true@ if the given track is imported. Else, return @false@. bindAnimation_track_is_imported :: MethodBind bindAnimation_track_is_imported = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_is_imported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given track is imported. Else, return @false@. track_is_imported :: (Animation :< cls, Object :< cls) => cls -> Int -> IO Bool track_is_imported cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_is_imported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_is_imported" '[Int] (IO Bool) where nodeMethod = Godot.Core.Animation.track_is_imported {-# NOINLINE bindAnimation_track_move_down #-} -- | Moves a track down. bindAnimation_track_move_down :: MethodBind bindAnimation_track_move_down = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_move_down" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves a track down. track_move_down :: (Animation :< cls, Object :< cls) => cls -> Int -> IO () track_move_down cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_move_down (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_move_down" '[Int] (IO ()) where nodeMethod = Godot.Core.Animation.track_move_down {-# NOINLINE bindAnimation_track_move_to #-} -- | Changes the index position of track @idx@ to the one defined in @to_idx@. bindAnimation_track_move_to :: MethodBind bindAnimation_track_move_to = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_move_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the index position of track @idx@ to the one defined in @to_idx@. track_move_to :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO () track_move_to cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_move_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_move_to" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Animation.track_move_to {-# NOINLINE bindAnimation_track_move_up #-} -- | Moves a track up. bindAnimation_track_move_up :: MethodBind bindAnimation_track_move_up = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_move_up" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves a track up. track_move_up :: (Animation :< cls, Object :< cls) => cls -> Int -> IO () track_move_up cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_move_up (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_move_up" '[Int] (IO ()) where nodeMethod = Godot.Core.Animation.track_move_up {-# NOINLINE bindAnimation_track_remove_key #-} -- | Removes a key by index in a given track. bindAnimation_track_remove_key :: MethodBind bindAnimation_track_remove_key = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_remove_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a key by index in a given track. track_remove_key :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO () track_remove_key cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_remove_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_remove_key" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Animation.track_remove_key {-# NOINLINE bindAnimation_track_remove_key_at_position #-} -- | Removes a key by position (seconds) in a given track. bindAnimation_track_remove_key_at_position :: MethodBind bindAnimation_track_remove_key_at_position = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_remove_key_at_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a key by position (seconds) in a given track. track_remove_key_at_position :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> IO () track_remove_key_at_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_remove_key_at_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_remove_key_at_position" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Animation.track_remove_key_at_position {-# NOINLINE bindAnimation_track_set_enabled #-} -- | Enables/disables the given track. Tracks are enabled by default. bindAnimation_track_set_enabled :: MethodBind bindAnimation_track_set_enabled = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_set_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables/disables the given track. Tracks are enabled by default. track_set_enabled :: (Animation :< cls, Object :< cls) => cls -> Int -> Bool -> IO () track_set_enabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_set_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_set_enabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Animation.track_set_enabled {-# NOINLINE bindAnimation_track_set_imported #-} -- | Sets the given track as imported or not. bindAnimation_track_set_imported :: MethodBind bindAnimation_track_set_imported = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_set_imported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given track as imported or not. track_set_imported :: (Animation :< cls, Object :< cls) => cls -> Int -> Bool -> IO () track_set_imported cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_set_imported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_set_imported" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Animation.track_set_imported {-# NOINLINE bindAnimation_track_set_interpolation_loop_wrap #-} -- | If @true@, the track at @idx@ wraps the interpolation loop. bindAnimation_track_set_interpolation_loop_wrap :: MethodBind bindAnimation_track_set_interpolation_loop_wrap = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_set_interpolation_loop_wrap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the track at @idx@ wraps the interpolation loop. track_set_interpolation_loop_wrap :: (Animation :< cls, Object :< cls) => cls -> Int -> Bool -> IO () track_set_interpolation_loop_wrap cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_set_interpolation_loop_wrap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_set_interpolation_loop_wrap" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Animation.track_set_interpolation_loop_wrap {-# NOINLINE bindAnimation_track_set_interpolation_type #-} -- | Sets the interpolation type of a given track. bindAnimation_track_set_interpolation_type :: MethodBind bindAnimation_track_set_interpolation_type = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_set_interpolation_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the interpolation type of a given track. track_set_interpolation_type :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO () track_set_interpolation_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_set_interpolation_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_set_interpolation_type" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Animation.track_set_interpolation_type {-# NOINLINE bindAnimation_track_set_key_time #-} -- | Sets the time of an existing key. bindAnimation_track_set_key_time :: MethodBind bindAnimation_track_set_key_time = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_set_key_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the time of an existing key. track_set_key_time :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> Float -> IO () track_set_key_time cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_set_key_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_set_key_time" '[Int, Int, Float] (IO ()) where nodeMethod = Godot.Core.Animation.track_set_key_time {-# NOINLINE bindAnimation_track_set_key_transition #-} -- | Sets the transition curve (easing) for a specific key (see the built-in math function @method @GDScript.ease@). bindAnimation_track_set_key_transition :: MethodBind bindAnimation_track_set_key_transition = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_set_key_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transition curve (easing) for a specific key (see the built-in math function @method @GDScript.ease@). track_set_key_transition :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> Float -> IO () track_set_key_transition cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_set_key_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_set_key_transition" '[Int, Int, Float] (IO ()) where nodeMethod = Godot.Core.Animation.track_set_key_transition {-# NOINLINE bindAnimation_track_set_key_value #-} -- | Sets the value of an existing key. bindAnimation_track_set_key_value :: MethodBind bindAnimation_track_set_key_value = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_set_key_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value of an existing key. track_set_key_value :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> GodotVariant -> IO () track_set_key_value cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_set_key_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_set_key_value" '[Int, Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Animation.track_set_key_value {-# NOINLINE bindAnimation_track_set_path #-} -- | Sets the path of a track. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. Tracks that control properties or bones must append their name after the path, separated by @":"@. -- For example, @"character/skeleton:ankle"@ or @"character/mesh:transform/local"@. bindAnimation_track_set_path :: MethodBind bindAnimation_track_set_path = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_set_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the path of a track. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. Tracks that control properties or bones must append their name after the path, separated by @":"@. -- For example, @"character/skeleton:ankle"@ or @"character/mesh:transform/local"@. track_set_path :: (Animation :< cls, Object :< cls) => cls -> Int -> NodePath -> IO () track_set_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_set_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_set_path" '[Int, NodePath] (IO ()) where nodeMethod = Godot.Core.Animation.track_set_path {-# NOINLINE bindAnimation_track_swap #-} -- | Swaps the track @idx@'s index position with the track @with_idx@. bindAnimation_track_swap :: MethodBind bindAnimation_track_swap = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "track_swap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Swaps the track @idx@'s index position with the track @with_idx@. track_swap :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO () track_swap cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_track_swap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "track_swap" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Animation.track_swap {-# NOINLINE bindAnimation_transform_track_insert_key #-} -- | Insert a transform key for a transform track. bindAnimation_transform_track_insert_key :: MethodBind bindAnimation_transform_track_insert_key = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "transform_track_insert_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Insert a transform key for a transform track. transform_track_insert_key :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> Vector3 -> Quat -> Vector3 -> IO Int transform_track_insert_key cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_transform_track_insert_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "transform_track_insert_key" '[Int, Float, Vector3, Quat, Vector3] (IO Int) where nodeMethod = Godot.Core.Animation.transform_track_insert_key {-# NOINLINE bindAnimation_transform_track_interpolate #-} -- | Returns the interpolated value of a transform track at a given time (in seconds). An array consisting of 3 elements: position (@Vector3@), rotation (@Quat@) and scale (@Vector3@). bindAnimation_transform_track_interpolate :: MethodBind bindAnimation_transform_track_interpolate = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "transform_track_interpolate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the interpolated value of a transform track at a given time (in seconds). An array consisting of 3 elements: position (@Vector3@), rotation (@Quat@) and scale (@Vector3@). transform_track_interpolate :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> IO Array transform_track_interpolate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_transform_track_interpolate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "transform_track_interpolate" '[Int, Float] (IO Array) where nodeMethod = Godot.Core.Animation.transform_track_interpolate {-# NOINLINE bindAnimation_value_track_get_key_indices #-} -- | Returns all the key indices of a value track, given a position and delta time. bindAnimation_value_track_get_key_indices :: MethodBind bindAnimation_value_track_get_key_indices = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "value_track_get_key_indices" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the key indices of a value track, given a position and delta time. value_track_get_key_indices :: (Animation :< cls, Object :< cls) => cls -> Int -> Float -> Float -> IO PoolIntArray value_track_get_key_indices cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_value_track_get_key_indices (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "value_track_get_key_indices" '[Int, Float, Float] (IO PoolIntArray) where nodeMethod = Godot.Core.Animation.value_track_get_key_indices {-# NOINLINE bindAnimation_value_track_get_update_mode #-} -- | Returns the update mode of a value track. bindAnimation_value_track_get_update_mode :: MethodBind bindAnimation_value_track_get_update_mode = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "value_track_get_update_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the update mode of a value track. value_track_get_update_mode :: (Animation :< cls, Object :< cls) => cls -> Int -> IO Int value_track_get_update_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_value_track_get_update_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "value_track_get_update_mode" '[Int] (IO Int) where nodeMethod = Godot.Core.Animation.value_track_get_update_mode {-# NOINLINE bindAnimation_value_track_set_update_mode #-} -- | Sets the update mode (see @enum UpdateMode@) of a value track. bindAnimation_value_track_set_update_mode :: MethodBind bindAnimation_value_track_set_update_mode = unsafePerformIO $ withCString "Animation" $ \ clsNamePtr -> withCString "value_track_set_update_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the update mode (see @enum UpdateMode@) of a value track. value_track_set_update_mode :: (Animation :< cls, Object :< cls) => cls -> Int -> Int -> IO () value_track_set_update_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimation_value_track_set_update_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Animation "value_track_set_update_mode" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Animation.value_track_set_update_mode ================================================ FILE: src/Godot/Core/AnimationNode.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNode (Godot.Core.AnimationNode._FILTER_IGNORE, Godot.Core.AnimationNode._FILTER_BLEND, Godot.Core.AnimationNode._FILTER_PASS, Godot.Core.AnimationNode._FILTER_STOP, Godot.Core.AnimationNode.sig_removed_from_graph, Godot.Core.AnimationNode.sig_tree_changed, Godot.Core.AnimationNode._get_filters, Godot.Core.AnimationNode._set_filters, Godot.Core.AnimationNode.add_input, Godot.Core.AnimationNode.blend_animation, Godot.Core.AnimationNode.blend_input, Godot.Core.AnimationNode.blend_node, Godot.Core.AnimationNode.get_caption, Godot.Core.AnimationNode.get_child_by_name, Godot.Core.AnimationNode.get_child_nodes, Godot.Core.AnimationNode.get_input_count, Godot.Core.AnimationNode.get_input_name, Godot.Core.AnimationNode.get_parameter, Godot.Core.AnimationNode.get_parameter_default_value, Godot.Core.AnimationNode.get_parameter_list, Godot.Core.AnimationNode.has_filter, Godot.Core.AnimationNode.is_filter_enabled, Godot.Core.AnimationNode.is_path_filtered, Godot.Core.AnimationNode.process, Godot.Core.AnimationNode.remove_input, Godot.Core.AnimationNode.set_filter_enabled, Godot.Core.AnimationNode.set_filter_path, Godot.Core.AnimationNode.set_parameter) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _FILTER_IGNORE :: Int _FILTER_IGNORE = 0 _FILTER_BLEND :: Int _FILTER_BLEND = 3 _FILTER_PASS :: Int _FILTER_PASS = 1 _FILTER_STOP :: Int _FILTER_STOP = 2 -- | Called when the node was removed from the graph. sig_removed_from_graph :: Godot.Internal.Dispatch.Signal AnimationNode sig_removed_from_graph = Godot.Internal.Dispatch.Signal "removed_from_graph" instance NodeSignal AnimationNode "removed_from_graph" '[] -- | Emitted by nodes that inherit from this class and that have an internal tree when one of their nodes changes. The nodes that emit this signal are @AnimationNodeBlendSpace1D@, @AnimationNodeBlendSpace2D@, @AnimationNodeStateMachine@, and @AnimationNodeBlendTree@. sig_tree_changed :: Godot.Internal.Dispatch.Signal AnimationNode sig_tree_changed = Godot.Internal.Dispatch.Signal "tree_changed" instance NodeSignal AnimationNode "tree_changed" '[] instance NodeProperty AnimationNode "filter_enabled" Bool 'False where nodeProperty = (is_filter_enabled, wrapDroppingSetter set_filter_enabled, Nothing) instance NodeProperty AnimationNode "filters" Array 'False where nodeProperty = (_get_filters, wrapDroppingSetter _set_filters, Nothing) {-# NOINLINE bindAnimationNode__get_filters #-} bindAnimationNode__get_filters :: MethodBind bindAnimationNode__get_filters = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "_get_filters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_filters :: (AnimationNode :< cls, Object :< cls) => cls -> IO Array _get_filters cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode__get_filters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "_get_filters" '[] (IO Array) where nodeMethod = Godot.Core.AnimationNode._get_filters {-# NOINLINE bindAnimationNode__set_filters #-} bindAnimationNode__set_filters :: MethodBind bindAnimationNode__set_filters = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "_set_filters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_filters :: (AnimationNode :< cls, Object :< cls) => cls -> Array -> IO () _set_filters cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode__set_filters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "_set_filters" '[Array] (IO ()) where nodeMethod = Godot.Core.AnimationNode._set_filters {-# NOINLINE bindAnimationNode_add_input #-} -- | Adds an input to the node. This is only useful for nodes created for use in an @AnimationNodeBlendTree@. bindAnimationNode_add_input :: MethodBind bindAnimationNode_add_input = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "add_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an input to the node. This is only useful for nodes created for use in an @AnimationNodeBlendTree@. add_input :: (AnimationNode :< cls, Object :< cls) => cls -> GodotString -> IO () add_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_add_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "add_input" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNode.add_input {-# NOINLINE bindAnimationNode_blend_animation #-} -- | Blend an animation by @blend@ amount (name must be valid in the linked @AnimationPlayer@). A @time@ and @delta@ may be passed, as well as whether @seek@ happened. bindAnimationNode_blend_animation :: MethodBind bindAnimationNode_blend_animation = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "blend_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Blend an animation by @blend@ amount (name must be valid in the linked @AnimationPlayer@). A @time@ and @delta@ may be passed, as well as whether @seek@ happened. blend_animation :: (AnimationNode :< cls, Object :< cls) => cls -> GodotString -> Float -> Float -> Bool -> Float -> IO () blend_animation cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_blend_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "blend_animation" '[GodotString, Float, Float, Bool, Float] (IO ()) where nodeMethod = Godot.Core.AnimationNode.blend_animation {-# NOINLINE bindAnimationNode_blend_input #-} -- | Blend an input. This is only useful for nodes created for an @AnimationNodeBlendTree@. The @time@ parameter is a relative delta, unless @seek@ is @true@, in which case it is absolute. A filter mode may be optionally passed (see @enum FilterAction@ for options). bindAnimationNode_blend_input :: MethodBind bindAnimationNode_blend_input = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "blend_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Blend an input. This is only useful for nodes created for an @AnimationNodeBlendTree@. The @time@ parameter is a relative delta, unless @seek@ is @true@, in which case it is absolute. A filter mode may be optionally passed (see @enum FilterAction@ for options). blend_input :: (AnimationNode :< cls, Object :< cls) => cls -> Int -> Float -> Bool -> Float -> Maybe Int -> Maybe Bool -> IO Float blend_input cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantInt (0)) toVariant arg5, maybe (VariantBool True) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_blend_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "blend_input" '[Int, Float, Bool, Float, Maybe Int, Maybe Bool] (IO Float) where nodeMethod = Godot.Core.AnimationNode.blend_input {-# NOINLINE bindAnimationNode_blend_node #-} -- | Blend another animation node (in case this node contains children animation nodes). This function is only useful if you inherit from @AnimationRootNode@ instead, else editors will not display your node for addition. bindAnimationNode_blend_node :: MethodBind bindAnimationNode_blend_node = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "blend_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Blend another animation node (in case this node contains children animation nodes). This function is only useful if you inherit from @AnimationRootNode@ instead, else editors will not display your node for addition. blend_node :: (AnimationNode :< cls, Object :< cls) => cls -> GodotString -> AnimationNode -> Float -> Bool -> Float -> Maybe Int -> Maybe Bool -> IO Float blend_node cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, maybe (VariantInt (0)) toVariant arg6, maybe (VariantBool True) toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_blend_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "blend_node" '[GodotString, AnimationNode, Float, Bool, Float, Maybe Int, Maybe Bool] (IO Float) where nodeMethod = Godot.Core.AnimationNode.blend_node {-# NOINLINE bindAnimationNode_get_caption #-} -- | Gets the text caption for this node (used by some editors). bindAnimationNode_get_caption :: MethodBind bindAnimationNode_get_caption = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "get_caption" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the text caption for this node (used by some editors). get_caption :: (AnimationNode :< cls, Object :< cls) => cls -> IO GodotString get_caption cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_get_caption (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "get_caption" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNode.get_caption {-# NOINLINE bindAnimationNode_get_child_by_name #-} -- | Gets a child node by index (used by editors inheriting from @AnimationRootNode@). bindAnimationNode_get_child_by_name :: MethodBind bindAnimationNode_get_child_by_name = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "get_child_by_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a child node by index (used by editors inheriting from @AnimationRootNode@). get_child_by_name :: (AnimationNode :< cls, Object :< cls) => cls -> GodotString -> IO Object get_child_by_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_get_child_by_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "get_child_by_name" '[GodotString] (IO Object) where nodeMethod = Godot.Core.AnimationNode.get_child_by_name {-# NOINLINE bindAnimationNode_get_child_nodes #-} -- | Gets all children nodes in order as a @name: node@ dictionary. Only useful when inheriting @AnimationRootNode@. bindAnimationNode_get_child_nodes :: MethodBind bindAnimationNode_get_child_nodes = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "get_child_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets all children nodes in order as a @name: node@ dictionary. Only useful when inheriting @AnimationRootNode@. get_child_nodes :: (AnimationNode :< cls, Object :< cls) => cls -> IO Dictionary get_child_nodes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_get_child_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "get_child_nodes" '[] (IO Dictionary) where nodeMethod = Godot.Core.AnimationNode.get_child_nodes {-# NOINLINE bindAnimationNode_get_input_count #-} -- | Amount of inputs in this node, only useful for nodes that go into @AnimationNodeBlendTree@. bindAnimationNode_get_input_count :: MethodBind bindAnimationNode_get_input_count = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "get_input_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of inputs in this node, only useful for nodes that go into @AnimationNodeBlendTree@. get_input_count :: (AnimationNode :< cls, Object :< cls) => cls -> IO Int get_input_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_get_input_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "get_input_count" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNode.get_input_count {-# NOINLINE bindAnimationNode_get_input_name #-} -- | Gets the name of an input by index. bindAnimationNode_get_input_name :: MethodBind bindAnimationNode_get_input_name = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "get_input_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the name of an input by index. get_input_name :: (AnimationNode :< cls, Object :< cls) => cls -> Int -> IO GodotString get_input_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_get_input_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "get_input_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.AnimationNode.get_input_name {-# NOINLINE bindAnimationNode_get_parameter #-} -- | Gets the value of a parameter. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees. bindAnimationNode_get_parameter :: MethodBind bindAnimationNode_get_parameter = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "get_parameter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the value of a parameter. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees. get_parameter :: (AnimationNode :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get_parameter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_get_parameter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "get_parameter" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.AnimationNode.get_parameter {-# NOINLINE bindAnimationNode_get_parameter_default_value #-} -- | Gets the default value of a parameter. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees. bindAnimationNode_get_parameter_default_value :: MethodBind bindAnimationNode_get_parameter_default_value = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "get_parameter_default_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the default value of a parameter. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees. get_parameter_default_value :: (AnimationNode :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get_parameter_default_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_get_parameter_default_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "get_parameter_default_value" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.AnimationNode.get_parameter_default_value {-# NOINLINE bindAnimationNode_get_parameter_list #-} -- | Gets the property information for parameter. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees. Format is similar to @method Object.get_property_list@. bindAnimationNode_get_parameter_list :: MethodBind bindAnimationNode_get_parameter_list = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "get_parameter_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the property information for parameter. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees. Format is similar to @method Object.get_property_list@. get_parameter_list :: (AnimationNode :< cls, Object :< cls) => cls -> IO Array get_parameter_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_get_parameter_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "get_parameter_list" '[] (IO Array) where nodeMethod = Godot.Core.AnimationNode.get_parameter_list {-# NOINLINE bindAnimationNode_has_filter #-} -- | Returns @true@ whether you want the blend tree editor to display filter editing on this node. bindAnimationNode_has_filter :: MethodBind bindAnimationNode_has_filter = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "has_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ whether you want the blend tree editor to display filter editing on this node. has_filter :: (AnimationNode :< cls, Object :< cls) => cls -> IO GodotString has_filter cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_has_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "has_filter" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNode.has_filter {-# NOINLINE bindAnimationNode_is_filter_enabled #-} -- | If @true@, filtering is enabled. bindAnimationNode_is_filter_enabled :: MethodBind bindAnimationNode_is_filter_enabled = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "is_filter_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, filtering is enabled. is_filter_enabled :: (AnimationNode :< cls, Object :< cls) => cls -> IO Bool is_filter_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_is_filter_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "is_filter_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNode.is_filter_enabled {-# NOINLINE bindAnimationNode_is_path_filtered #-} -- | Returns @true@ whether a given path is filtered. bindAnimationNode_is_path_filtered :: MethodBind bindAnimationNode_is_path_filtered = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "is_path_filtered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ whether a given path is filtered. is_path_filtered :: (AnimationNode :< cls, Object :< cls) => cls -> NodePath -> IO Bool is_path_filtered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_is_path_filtered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "is_path_filtered" '[NodePath] (IO Bool) where nodeMethod = Godot.Core.AnimationNode.is_path_filtered {-# NOINLINE bindAnimationNode_process #-} -- | User-defined callback called when a custom node is processed. The @time@ parameter is a relative delta, unless @seek@ is @true@, in which case it is absolute. -- Here, call the @method blend_input@, @method blend_node@ or @method blend_animation@ functions. You can also use @method get_parameter@ and @method set_parameter@ to modify local memory. -- This function should return the time left for the current animation to finish (if unsure, pass the value from the main blend being called). bindAnimationNode_process :: MethodBind bindAnimationNode_process = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "process" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | User-defined callback called when a custom node is processed. The @time@ parameter is a relative delta, unless @seek@ is @true@, in which case it is absolute. -- Here, call the @method blend_input@, @method blend_node@ or @method blend_animation@ functions. You can also use @method get_parameter@ and @method set_parameter@ to modify local memory. -- This function should return the time left for the current animation to finish (if unsure, pass the value from the main blend being called). process :: (AnimationNode :< cls, Object :< cls) => cls -> Float -> Bool -> IO () process cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_process (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "process" '[Float, Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNode.process {-# NOINLINE bindAnimationNode_remove_input #-} -- | Removes an input, call this only when inactive. bindAnimationNode_remove_input :: MethodBind bindAnimationNode_remove_input = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "remove_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes an input, call this only when inactive. remove_input :: (AnimationNode :< cls, Object :< cls) => cls -> Int -> IO () remove_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_remove_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "remove_input" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNode.remove_input {-# NOINLINE bindAnimationNode_set_filter_enabled #-} -- | If @true@, filtering is enabled. bindAnimationNode_set_filter_enabled :: MethodBind bindAnimationNode_set_filter_enabled = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "set_filter_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, filtering is enabled. set_filter_enabled :: (AnimationNode :< cls, Object :< cls) => cls -> Bool -> IO () set_filter_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_set_filter_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "set_filter_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNode.set_filter_enabled {-# NOINLINE bindAnimationNode_set_filter_path #-} -- | Adds or removes a path for the filter. bindAnimationNode_set_filter_path :: MethodBind bindAnimationNode_set_filter_path = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "set_filter_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds or removes a path for the filter. set_filter_path :: (AnimationNode :< cls, Object :< cls) => cls -> NodePath -> Bool -> IO () set_filter_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_set_filter_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "set_filter_path" '[NodePath, Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNode.set_filter_path {-# NOINLINE bindAnimationNode_set_parameter #-} -- | Sets a custom parameter. These are used as local storage, because resources can be reused across the tree or scenes. bindAnimationNode_set_parameter :: MethodBind bindAnimationNode_set_parameter = unsafePerformIO $ withCString "AnimationNode" $ \ clsNamePtr -> withCString "set_parameter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a custom parameter. These are used as local storage, because resources can be reused across the tree or scenes. set_parameter :: (AnimationNode :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set_parameter cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNode_set_parameter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNode "set_parameter" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.AnimationNode.set_parameter ================================================ FILE: src/Godot/Core/AnimationNodeAdd2.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeAdd2 (Godot.Core.AnimationNodeAdd2.is_using_sync, Godot.Core.AnimationNodeAdd2.set_use_sync) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() instance NodeProperty AnimationNodeAdd2 "sync" Bool 'False where nodeProperty = (is_using_sync, wrapDroppingSetter set_use_sync, Nothing) {-# NOINLINE bindAnimationNodeAdd2_is_using_sync #-} -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. bindAnimationNodeAdd2_is_using_sync :: MethodBind bindAnimationNodeAdd2_is_using_sync = unsafePerformIO $ withCString "AnimationNodeAdd2" $ \ clsNamePtr -> withCString "is_using_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. is_using_sync :: (AnimationNodeAdd2 :< cls, Object :< cls) => cls -> IO Bool is_using_sync cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeAdd2_is_using_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeAdd2 "is_using_sync" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeAdd2.is_using_sync {-# NOINLINE bindAnimationNodeAdd2_set_use_sync #-} -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. bindAnimationNodeAdd2_set_use_sync :: MethodBind bindAnimationNodeAdd2_set_use_sync = unsafePerformIO $ withCString "AnimationNodeAdd2" $ \ clsNamePtr -> withCString "set_use_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. set_use_sync :: (AnimationNodeAdd2 :< cls, Object :< cls) => cls -> Bool -> IO () set_use_sync cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeAdd2_set_use_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeAdd2 "set_use_sync" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeAdd2.set_use_sync ================================================ FILE: src/Godot/Core/AnimationNodeAdd3.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeAdd3 (Godot.Core.AnimationNodeAdd3.is_using_sync, Godot.Core.AnimationNodeAdd3.set_use_sync) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() instance NodeProperty AnimationNodeAdd3 "sync" Bool 'False where nodeProperty = (is_using_sync, wrapDroppingSetter set_use_sync, Nothing) {-# NOINLINE bindAnimationNodeAdd3_is_using_sync #-} -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. bindAnimationNodeAdd3_is_using_sync :: MethodBind bindAnimationNodeAdd3_is_using_sync = unsafePerformIO $ withCString "AnimationNodeAdd3" $ \ clsNamePtr -> withCString "is_using_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. is_using_sync :: (AnimationNodeAdd3 :< cls, Object :< cls) => cls -> IO Bool is_using_sync cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeAdd3_is_using_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeAdd3 "is_using_sync" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeAdd3.is_using_sync {-# NOINLINE bindAnimationNodeAdd3_set_use_sync #-} -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. bindAnimationNodeAdd3_set_use_sync :: MethodBind bindAnimationNodeAdd3_set_use_sync = unsafePerformIO $ withCString "AnimationNodeAdd3" $ \ clsNamePtr -> withCString "set_use_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. set_use_sync :: (AnimationNodeAdd3 :< cls, Object :< cls) => cls -> Bool -> IO () set_use_sync cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeAdd3_set_use_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeAdd3 "set_use_sync" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeAdd3.set_use_sync ================================================ FILE: src/Godot/Core/AnimationNodeAnimation.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeAnimation (Godot.Core.AnimationNodeAnimation.get_animation, Godot.Core.AnimationNodeAnimation.set_animation) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationRootNode() instance NodeProperty AnimationNodeAnimation "animation" GodotString 'False where nodeProperty = (get_animation, wrapDroppingSetter set_animation, Nothing) {-# NOINLINE bindAnimationNodeAnimation_get_animation #-} -- | Animation to use as an output. It is one of the animations provided by @AnimationTree.anim_player@. bindAnimationNodeAnimation_get_animation :: MethodBind bindAnimationNodeAnimation_get_animation = unsafePerformIO $ withCString "AnimationNodeAnimation" $ \ clsNamePtr -> withCString "get_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Animation to use as an output. It is one of the animations provided by @AnimationTree.anim_player@. get_animation :: (AnimationNodeAnimation :< cls, Object :< cls) => cls -> IO GodotString get_animation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeAnimation_get_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeAnimation "get_animation" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeAnimation.get_animation {-# NOINLINE bindAnimationNodeAnimation_set_animation #-} -- | Animation to use as an output. It is one of the animations provided by @AnimationTree.anim_player@. bindAnimationNodeAnimation_set_animation :: MethodBind bindAnimationNodeAnimation_set_animation = unsafePerformIO $ withCString "AnimationNodeAnimation" $ \ clsNamePtr -> withCString "set_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Animation to use as an output. It is one of the animations provided by @AnimationTree.anim_player@. set_animation :: (AnimationNodeAnimation :< cls, Object :< cls) => cls -> GodotString -> IO () set_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeAnimation_set_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeAnimation "set_animation" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeAnimation.set_animation ================================================ FILE: src/Godot/Core/AnimationNodeBlend2.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeBlend2 (Godot.Core.AnimationNodeBlend2.is_using_sync, Godot.Core.AnimationNodeBlend2.set_use_sync) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() instance NodeProperty AnimationNodeBlend2 "sync" Bool 'False where nodeProperty = (is_using_sync, wrapDroppingSetter set_use_sync, Nothing) {-# NOINLINE bindAnimationNodeBlend2_is_using_sync #-} -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. bindAnimationNodeBlend2_is_using_sync :: MethodBind bindAnimationNodeBlend2_is_using_sync = unsafePerformIO $ withCString "AnimationNodeBlend2" $ \ clsNamePtr -> withCString "is_using_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. is_using_sync :: (AnimationNodeBlend2 :< cls, Object :< cls) => cls -> IO Bool is_using_sync cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlend2_is_using_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlend2 "is_using_sync" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeBlend2.is_using_sync {-# NOINLINE bindAnimationNodeBlend2_set_use_sync #-} -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. bindAnimationNodeBlend2_set_use_sync :: MethodBind bindAnimationNodeBlend2_set_use_sync = unsafePerformIO $ withCString "AnimationNodeBlend2" $ \ clsNamePtr -> withCString "set_use_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. set_use_sync :: (AnimationNodeBlend2 :< cls, Object :< cls) => cls -> Bool -> IO () set_use_sync cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlend2_set_use_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlend2 "set_use_sync" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlend2.set_use_sync ================================================ FILE: src/Godot/Core/AnimationNodeBlend3.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeBlend3 (Godot.Core.AnimationNodeBlend3.is_using_sync, Godot.Core.AnimationNodeBlend3.set_use_sync) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() instance NodeProperty AnimationNodeBlend3 "sync" Bool 'False where nodeProperty = (is_using_sync, wrapDroppingSetter set_use_sync, Nothing) {-# NOINLINE bindAnimationNodeBlend3_is_using_sync #-} -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. bindAnimationNodeBlend3_is_using_sync :: MethodBind bindAnimationNodeBlend3_is_using_sync = unsafePerformIO $ withCString "AnimationNodeBlend3" $ \ clsNamePtr -> withCString "is_using_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. is_using_sync :: (AnimationNodeBlend3 :< cls, Object :< cls) => cls -> IO Bool is_using_sync cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlend3_is_using_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlend3 "is_using_sync" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeBlend3.is_using_sync {-# NOINLINE bindAnimationNodeBlend3_set_use_sync #-} -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. bindAnimationNodeBlend3_set_use_sync :: MethodBind bindAnimationNodeBlend3_set_use_sync = unsafePerformIO $ withCString "AnimationNodeBlend3" $ \ clsNamePtr -> withCString "set_use_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @optimization@ to @false@ when calling @method AnimationNode.blend_input@, forcing the blended animations to update every frame. set_use_sync :: (AnimationNodeBlend3 :< cls, Object :< cls) => cls -> Bool -> IO () set_use_sync cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlend3_set_use_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlend3 "set_use_sync" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlend3.set_use_sync ================================================ FILE: src/Godot/Core/AnimationNodeBlendSpace1D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeBlendSpace1D (Godot.Core.AnimationNodeBlendSpace1D._add_blend_point, Godot.Core.AnimationNodeBlendSpace1D._tree_changed, Godot.Core.AnimationNodeBlendSpace1D.add_blend_point, Godot.Core.AnimationNodeBlendSpace1D.get_blend_point_count, Godot.Core.AnimationNodeBlendSpace1D.get_blend_point_node, Godot.Core.AnimationNodeBlendSpace1D.get_blend_point_position, Godot.Core.AnimationNodeBlendSpace1D.get_max_space, Godot.Core.AnimationNodeBlendSpace1D.get_min_space, Godot.Core.AnimationNodeBlendSpace1D.get_snap, Godot.Core.AnimationNodeBlendSpace1D.get_value_label, Godot.Core.AnimationNodeBlendSpace1D.remove_blend_point, Godot.Core.AnimationNodeBlendSpace1D.set_blend_point_node, Godot.Core.AnimationNodeBlendSpace1D.set_blend_point_position, Godot.Core.AnimationNodeBlendSpace1D.set_max_space, Godot.Core.AnimationNodeBlendSpace1D.set_min_space, Godot.Core.AnimationNodeBlendSpace1D.set_snap, Godot.Core.AnimationNodeBlendSpace1D.set_value_label) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationRootNode() instance NodeProperty AnimationNodeBlendSpace1D "blend_point_0/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 0 get_blend_point_node, wrapIndexedSetter 0 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_0/pos" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_blend_point_position, wrapIndexedSetter 0 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_1/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 1 get_blend_point_node, wrapIndexedSetter 1 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_1/pos" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_blend_point_position, wrapIndexedSetter 1 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_10/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 10 get_blend_point_node, wrapIndexedSetter 10 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_10/pos" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_blend_point_position, wrapIndexedSetter 10 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_11/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 11 get_blend_point_node, wrapIndexedSetter 11 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_11/pos" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_blend_point_position, wrapIndexedSetter 11 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_12/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 12 get_blend_point_node, wrapIndexedSetter 12 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_12/pos" Float 'False where nodeProperty = (wrapIndexedGetter 12 get_blend_point_position, wrapIndexedSetter 12 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_13/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 13 get_blend_point_node, wrapIndexedSetter 13 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_13/pos" Float 'False where nodeProperty = (wrapIndexedGetter 13 get_blend_point_position, wrapIndexedSetter 13 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_14/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 14 get_blend_point_node, wrapIndexedSetter 14 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_14/pos" Float 'False where nodeProperty = (wrapIndexedGetter 14 get_blend_point_position, wrapIndexedSetter 14 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_15/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 15 get_blend_point_node, wrapIndexedSetter 15 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_15/pos" Float 'False where nodeProperty = (wrapIndexedGetter 15 get_blend_point_position, wrapIndexedSetter 15 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_16/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 16 get_blend_point_node, wrapIndexedSetter 16 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_16/pos" Float 'False where nodeProperty = (wrapIndexedGetter 16 get_blend_point_position, wrapIndexedSetter 16 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_17/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 17 get_blend_point_node, wrapIndexedSetter 17 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_17/pos" Float 'False where nodeProperty = (wrapIndexedGetter 17 get_blend_point_position, wrapIndexedSetter 17 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_18/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 18 get_blend_point_node, wrapIndexedSetter 18 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_18/pos" Float 'False where nodeProperty = (wrapIndexedGetter 18 get_blend_point_position, wrapIndexedSetter 18 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_19/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 19 get_blend_point_node, wrapIndexedSetter 19 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_19/pos" Float 'False where nodeProperty = (wrapIndexedGetter 19 get_blend_point_position, wrapIndexedSetter 19 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_2/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 2 get_blend_point_node, wrapIndexedSetter 2 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_2/pos" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_blend_point_position, wrapIndexedSetter 2 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_20/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 20 get_blend_point_node, wrapIndexedSetter 20 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_20/pos" Float 'False where nodeProperty = (wrapIndexedGetter 20 get_blend_point_position, wrapIndexedSetter 20 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_21/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 21 get_blend_point_node, wrapIndexedSetter 21 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_21/pos" Float 'False where nodeProperty = (wrapIndexedGetter 21 get_blend_point_position, wrapIndexedSetter 21 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_22/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 22 get_blend_point_node, wrapIndexedSetter 22 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_22/pos" Float 'False where nodeProperty = (wrapIndexedGetter 22 get_blend_point_position, wrapIndexedSetter 22 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_23/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 23 get_blend_point_node, wrapIndexedSetter 23 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_23/pos" Float 'False where nodeProperty = (wrapIndexedGetter 23 get_blend_point_position, wrapIndexedSetter 23 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_24/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 24 get_blend_point_node, wrapIndexedSetter 24 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_24/pos" Float 'False where nodeProperty = (wrapIndexedGetter 24 get_blend_point_position, wrapIndexedSetter 24 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_25/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 25 get_blend_point_node, wrapIndexedSetter 25 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_25/pos" Float 'False where nodeProperty = (wrapIndexedGetter 25 get_blend_point_position, wrapIndexedSetter 25 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_26/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 26 get_blend_point_node, wrapIndexedSetter 26 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_26/pos" Float 'False where nodeProperty = (wrapIndexedGetter 26 get_blend_point_position, wrapIndexedSetter 26 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_27/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 27 get_blend_point_node, wrapIndexedSetter 27 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_27/pos" Float 'False where nodeProperty = (wrapIndexedGetter 27 get_blend_point_position, wrapIndexedSetter 27 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_28/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 28 get_blend_point_node, wrapIndexedSetter 28 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_28/pos" Float 'False where nodeProperty = (wrapIndexedGetter 28 get_blend_point_position, wrapIndexedSetter 28 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_29/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 29 get_blend_point_node, wrapIndexedSetter 29 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_29/pos" Float 'False where nodeProperty = (wrapIndexedGetter 29 get_blend_point_position, wrapIndexedSetter 29 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_3/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 3 get_blend_point_node, wrapIndexedSetter 3 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_3/pos" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_blend_point_position, wrapIndexedSetter 3 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_30/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 30 get_blend_point_node, wrapIndexedSetter 30 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_30/pos" Float 'False where nodeProperty = (wrapIndexedGetter 30 get_blend_point_position, wrapIndexedSetter 30 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_31/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 31 get_blend_point_node, wrapIndexedSetter 31 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_31/pos" Float 'False where nodeProperty = (wrapIndexedGetter 31 get_blend_point_position, wrapIndexedSetter 31 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_32/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 32 get_blend_point_node, wrapIndexedSetter 32 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_32/pos" Float 'False where nodeProperty = (wrapIndexedGetter 32 get_blend_point_position, wrapIndexedSetter 32 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_33/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 33 get_blend_point_node, wrapIndexedSetter 33 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_33/pos" Float 'False where nodeProperty = (wrapIndexedGetter 33 get_blend_point_position, wrapIndexedSetter 33 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_34/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 34 get_blend_point_node, wrapIndexedSetter 34 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_34/pos" Float 'False where nodeProperty = (wrapIndexedGetter 34 get_blend_point_position, wrapIndexedSetter 34 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_35/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 35 get_blend_point_node, wrapIndexedSetter 35 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_35/pos" Float 'False where nodeProperty = (wrapIndexedGetter 35 get_blend_point_position, wrapIndexedSetter 35 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_36/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 36 get_blend_point_node, wrapIndexedSetter 36 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_36/pos" Float 'False where nodeProperty = (wrapIndexedGetter 36 get_blend_point_position, wrapIndexedSetter 36 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_37/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 37 get_blend_point_node, wrapIndexedSetter 37 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_37/pos" Float 'False where nodeProperty = (wrapIndexedGetter 37 get_blend_point_position, wrapIndexedSetter 37 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_38/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 38 get_blend_point_node, wrapIndexedSetter 38 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_38/pos" Float 'False where nodeProperty = (wrapIndexedGetter 38 get_blend_point_position, wrapIndexedSetter 38 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_39/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 39 get_blend_point_node, wrapIndexedSetter 39 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_39/pos" Float 'False where nodeProperty = (wrapIndexedGetter 39 get_blend_point_position, wrapIndexedSetter 39 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_4/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 4 get_blend_point_node, wrapIndexedSetter 4 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_4/pos" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_blend_point_position, wrapIndexedSetter 4 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_40/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 40 get_blend_point_node, wrapIndexedSetter 40 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_40/pos" Float 'False where nodeProperty = (wrapIndexedGetter 40 get_blend_point_position, wrapIndexedSetter 40 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_41/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 41 get_blend_point_node, wrapIndexedSetter 41 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_41/pos" Float 'False where nodeProperty = (wrapIndexedGetter 41 get_blend_point_position, wrapIndexedSetter 41 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_42/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 42 get_blend_point_node, wrapIndexedSetter 42 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_42/pos" Float 'False where nodeProperty = (wrapIndexedGetter 42 get_blend_point_position, wrapIndexedSetter 42 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_43/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 43 get_blend_point_node, wrapIndexedSetter 43 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_43/pos" Float 'False where nodeProperty = (wrapIndexedGetter 43 get_blend_point_position, wrapIndexedSetter 43 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_44/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 44 get_blend_point_node, wrapIndexedSetter 44 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_44/pos" Float 'False where nodeProperty = (wrapIndexedGetter 44 get_blend_point_position, wrapIndexedSetter 44 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_45/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 45 get_blend_point_node, wrapIndexedSetter 45 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_45/pos" Float 'False where nodeProperty = (wrapIndexedGetter 45 get_blend_point_position, wrapIndexedSetter 45 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_46/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 46 get_blend_point_node, wrapIndexedSetter 46 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_46/pos" Float 'False where nodeProperty = (wrapIndexedGetter 46 get_blend_point_position, wrapIndexedSetter 46 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_47/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 47 get_blend_point_node, wrapIndexedSetter 47 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_47/pos" Float 'False where nodeProperty = (wrapIndexedGetter 47 get_blend_point_position, wrapIndexedSetter 47 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_48/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 48 get_blend_point_node, wrapIndexedSetter 48 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_48/pos" Float 'False where nodeProperty = (wrapIndexedGetter 48 get_blend_point_position, wrapIndexedSetter 48 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_49/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 49 get_blend_point_node, wrapIndexedSetter 49 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_49/pos" Float 'False where nodeProperty = (wrapIndexedGetter 49 get_blend_point_position, wrapIndexedSetter 49 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_5/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 5 get_blend_point_node, wrapIndexedSetter 5 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_5/pos" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_blend_point_position, wrapIndexedSetter 5 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_50/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 50 get_blend_point_node, wrapIndexedSetter 50 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_50/pos" Float 'False where nodeProperty = (wrapIndexedGetter 50 get_blend_point_position, wrapIndexedSetter 50 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_51/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 51 get_blend_point_node, wrapIndexedSetter 51 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_51/pos" Float 'False where nodeProperty = (wrapIndexedGetter 51 get_blend_point_position, wrapIndexedSetter 51 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_52/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 52 get_blend_point_node, wrapIndexedSetter 52 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_52/pos" Float 'False where nodeProperty = (wrapIndexedGetter 52 get_blend_point_position, wrapIndexedSetter 52 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_53/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 53 get_blend_point_node, wrapIndexedSetter 53 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_53/pos" Float 'False where nodeProperty = (wrapIndexedGetter 53 get_blend_point_position, wrapIndexedSetter 53 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_54/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 54 get_blend_point_node, wrapIndexedSetter 54 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_54/pos" Float 'False where nodeProperty = (wrapIndexedGetter 54 get_blend_point_position, wrapIndexedSetter 54 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_55/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 55 get_blend_point_node, wrapIndexedSetter 55 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_55/pos" Float 'False where nodeProperty = (wrapIndexedGetter 55 get_blend_point_position, wrapIndexedSetter 55 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_56/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 56 get_blend_point_node, wrapIndexedSetter 56 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_56/pos" Float 'False where nodeProperty = (wrapIndexedGetter 56 get_blend_point_position, wrapIndexedSetter 56 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_57/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 57 get_blend_point_node, wrapIndexedSetter 57 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_57/pos" Float 'False where nodeProperty = (wrapIndexedGetter 57 get_blend_point_position, wrapIndexedSetter 57 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_58/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 58 get_blend_point_node, wrapIndexedSetter 58 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_58/pos" Float 'False where nodeProperty = (wrapIndexedGetter 58 get_blend_point_position, wrapIndexedSetter 58 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_59/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 59 get_blend_point_node, wrapIndexedSetter 59 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_59/pos" Float 'False where nodeProperty = (wrapIndexedGetter 59 get_blend_point_position, wrapIndexedSetter 59 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_6/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 6 get_blend_point_node, wrapIndexedSetter 6 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_6/pos" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_blend_point_position, wrapIndexedSetter 6 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_60/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 60 get_blend_point_node, wrapIndexedSetter 60 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_60/pos" Float 'False where nodeProperty = (wrapIndexedGetter 60 get_blend_point_position, wrapIndexedSetter 60 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_61/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 61 get_blend_point_node, wrapIndexedSetter 61 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_61/pos" Float 'False where nodeProperty = (wrapIndexedGetter 61 get_blend_point_position, wrapIndexedSetter 61 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_62/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 62 get_blend_point_node, wrapIndexedSetter 62 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_62/pos" Float 'False where nodeProperty = (wrapIndexedGetter 62 get_blend_point_position, wrapIndexedSetter 62 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_63/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 63 get_blend_point_node, wrapIndexedSetter 63 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_63/pos" Float 'False where nodeProperty = (wrapIndexedGetter 63 get_blend_point_position, wrapIndexedSetter 63 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_7/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 7 get_blend_point_node, wrapIndexedSetter 7 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_7/pos" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_blend_point_position, wrapIndexedSetter 7 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_8/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 8 get_blend_point_node, wrapIndexedSetter 8 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_8/pos" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_blend_point_position, wrapIndexedSetter 8 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_9/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 9 get_blend_point_node, wrapIndexedSetter 9 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "blend_point_9/pos" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_blend_point_position, wrapIndexedSetter 9 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "max_space" Float 'False where nodeProperty = (get_max_space, wrapDroppingSetter set_max_space, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "min_space" Float 'False where nodeProperty = (get_min_space, wrapDroppingSetter set_min_space, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "snap" Float 'False where nodeProperty = (get_snap, wrapDroppingSetter set_snap, Nothing) instance NodeProperty AnimationNodeBlendSpace1D "value_label" GodotString 'False where nodeProperty = (get_value_label, wrapDroppingSetter set_value_label, Nothing) {-# NOINLINE bindAnimationNodeBlendSpace1D__add_blend_point #-} bindAnimationNodeBlendSpace1D__add_blend_point :: MethodBind bindAnimationNodeBlendSpace1D__add_blend_point = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "_add_blend_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _add_blend_point :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Int -> AnimationRootNode -> IO () _add_blend_point cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D__add_blend_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "_add_blend_point" '[Int, AnimationRootNode] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D._add_blend_point {-# NOINLINE bindAnimationNodeBlendSpace1D__tree_changed #-} bindAnimationNodeBlendSpace1D__tree_changed :: MethodBind bindAnimationNodeBlendSpace1D__tree_changed = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "_tree_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_changed :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> IO () _tree_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D__tree_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "_tree_changed" '[] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D._tree_changed {-# NOINLINE bindAnimationNodeBlendSpace1D_add_blend_point #-} -- | Adds a new point that represents a @node@ on the virtual axis at a given position set by @pos@. You can insert it at a specific index using the @at_index@ argument. If you use the default value for @at_index@, the point is inserted at the end of the blend points array. bindAnimationNodeBlendSpace1D_add_blend_point :: MethodBind bindAnimationNodeBlendSpace1D_add_blend_point = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "add_blend_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new point that represents a @node@ on the virtual axis at a given position set by @pos@. You can insert it at a specific index using the @at_index@ argument. If you use the default value for @at_index@, the point is inserted at the end of the blend points array. add_blend_point :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> AnimationRootNode -> Float -> Maybe Int -> IO () add_blend_point cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_add_blend_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "add_blend_point" '[AnimationRootNode, Float, Maybe Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.add_blend_point {-# NOINLINE bindAnimationNodeBlendSpace1D_get_blend_point_count #-} -- | Returns the number of points on the blend axis. bindAnimationNodeBlendSpace1D_get_blend_point_count :: MethodBind bindAnimationNodeBlendSpace1D_get_blend_point_count = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "get_blend_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of points on the blend axis. get_blend_point_count :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> IO Int get_blend_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_get_blend_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "get_blend_point_count" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.get_blend_point_count {-# NOINLINE bindAnimationNodeBlendSpace1D_get_blend_point_node #-} -- | Returns the @AnimationNode@ referenced by the point at index @point@. bindAnimationNodeBlendSpace1D_get_blend_point_node :: MethodBind bindAnimationNodeBlendSpace1D_get_blend_point_node = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "get_blend_point_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AnimationNode@ referenced by the point at index @point@. get_blend_point_node :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Int -> IO AnimationRootNode get_blend_point_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_get_blend_point_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "get_blend_point_node" '[Int] (IO AnimationRootNode) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.get_blend_point_node {-# NOINLINE bindAnimationNodeBlendSpace1D_get_blend_point_position #-} -- | Returns the position of the point at index @point@. bindAnimationNodeBlendSpace1D_get_blend_point_position :: MethodBind bindAnimationNodeBlendSpace1D_get_blend_point_position = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "get_blend_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the point at index @point@. get_blend_point_position :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Int -> IO Float get_blend_point_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_get_blend_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "get_blend_point_position" '[Int] (IO Float) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.get_blend_point_position {-# NOINLINE bindAnimationNodeBlendSpace1D_get_max_space #-} -- | The blend space's axis's upper limit for the points' position. See @method add_blend_point@. bindAnimationNodeBlendSpace1D_get_max_space :: MethodBind bindAnimationNodeBlendSpace1D_get_max_space = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "get_max_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The blend space's axis's upper limit for the points' position. See @method add_blend_point@. get_max_space :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> IO Float get_max_space cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_get_max_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "get_max_space" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.get_max_space {-# NOINLINE bindAnimationNodeBlendSpace1D_get_min_space #-} -- | The blend space's axis's lower limit for the points' position. See @method add_blend_point@. bindAnimationNodeBlendSpace1D_get_min_space :: MethodBind bindAnimationNodeBlendSpace1D_get_min_space = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "get_min_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The blend space's axis's lower limit for the points' position. See @method add_blend_point@. get_min_space :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> IO Float get_min_space cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_get_min_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "get_min_space" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.get_min_space {-# NOINLINE bindAnimationNodeBlendSpace1D_get_snap #-} -- | Position increment to snap to when moving a point on the axis. bindAnimationNodeBlendSpace1D_get_snap :: MethodBind bindAnimationNodeBlendSpace1D_get_snap = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "get_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Position increment to snap to when moving a point on the axis. get_snap :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> IO Float get_snap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_get_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "get_snap" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.get_snap {-# NOINLINE bindAnimationNodeBlendSpace1D_get_value_label #-} -- | Label of the virtual axis of the blend space. bindAnimationNodeBlendSpace1D_get_value_label :: MethodBind bindAnimationNodeBlendSpace1D_get_value_label = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "get_value_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Label of the virtual axis of the blend space. get_value_label :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> IO GodotString get_value_label cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_get_value_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "get_value_label" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.get_value_label {-# NOINLINE bindAnimationNodeBlendSpace1D_remove_blend_point #-} -- | Removes the point at index @point@ from the blend axis. bindAnimationNodeBlendSpace1D_remove_blend_point :: MethodBind bindAnimationNodeBlendSpace1D_remove_blend_point = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "remove_blend_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the point at index @point@ from the blend axis. remove_blend_point :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Int -> IO () remove_blend_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_remove_blend_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "remove_blend_point" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.remove_blend_point {-# NOINLINE bindAnimationNodeBlendSpace1D_set_blend_point_node #-} -- | Changes the @AnimationNode@ referenced by the point at index @point@. bindAnimationNodeBlendSpace1D_set_blend_point_node :: MethodBind bindAnimationNodeBlendSpace1D_set_blend_point_node = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "set_blend_point_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the @AnimationNode@ referenced by the point at index @point@. set_blend_point_node :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Int -> AnimationRootNode -> IO () set_blend_point_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_set_blend_point_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "set_blend_point_node" '[Int, AnimationRootNode] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.set_blend_point_node {-# NOINLINE bindAnimationNodeBlendSpace1D_set_blend_point_position #-} -- | Updates the position of the point at index @point@ on the blend axis. bindAnimationNodeBlendSpace1D_set_blend_point_position :: MethodBind bindAnimationNodeBlendSpace1D_set_blend_point_position = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "set_blend_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the position of the point at index @point@ on the blend axis. set_blend_point_position :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_blend_point_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_set_blend_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "set_blend_point_position" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.set_blend_point_position {-# NOINLINE bindAnimationNodeBlendSpace1D_set_max_space #-} -- | The blend space's axis's upper limit for the points' position. See @method add_blend_point@. bindAnimationNodeBlendSpace1D_set_max_space :: MethodBind bindAnimationNodeBlendSpace1D_set_max_space = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "set_max_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The blend space's axis's upper limit for the points' position. See @method add_blend_point@. set_max_space :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Float -> IO () set_max_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_set_max_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "set_max_space" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.set_max_space {-# NOINLINE bindAnimationNodeBlendSpace1D_set_min_space #-} -- | The blend space's axis's lower limit for the points' position. See @method add_blend_point@. bindAnimationNodeBlendSpace1D_set_min_space :: MethodBind bindAnimationNodeBlendSpace1D_set_min_space = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "set_min_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The blend space's axis's lower limit for the points' position. See @method add_blend_point@. set_min_space :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Float -> IO () set_min_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_set_min_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "set_min_space" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.set_min_space {-# NOINLINE bindAnimationNodeBlendSpace1D_set_snap #-} -- | Position increment to snap to when moving a point on the axis. bindAnimationNodeBlendSpace1D_set_snap :: MethodBind bindAnimationNodeBlendSpace1D_set_snap = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "set_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Position increment to snap to when moving a point on the axis. set_snap :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> Float -> IO () set_snap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_set_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "set_snap" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.set_snap {-# NOINLINE bindAnimationNodeBlendSpace1D_set_value_label #-} -- | Label of the virtual axis of the blend space. bindAnimationNodeBlendSpace1D_set_value_label :: MethodBind bindAnimationNodeBlendSpace1D_set_value_label = unsafePerformIO $ withCString "AnimationNodeBlendSpace1D" $ \ clsNamePtr -> withCString "set_value_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Label of the virtual axis of the blend space. set_value_label :: (AnimationNodeBlendSpace1D :< cls, Object :< cls) => cls -> GodotString -> IO () set_value_label cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace1D_set_value_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace1D "set_value_label" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace1D.set_value_label ================================================ FILE: src/Godot/Core/AnimationNodeBlendSpace2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeBlendSpace2D (Godot.Core.AnimationNodeBlendSpace2D._BLEND_MODE_DISCRETE_CARRY, Godot.Core.AnimationNodeBlendSpace2D._BLEND_MODE_DISCRETE, Godot.Core.AnimationNodeBlendSpace2D._BLEND_MODE_INTERPOLATED, Godot.Core.AnimationNodeBlendSpace2D.sig_triangles_updated, Godot.Core.AnimationNodeBlendSpace2D._add_blend_point, Godot.Core.AnimationNodeBlendSpace2D._get_triangles, Godot.Core.AnimationNodeBlendSpace2D._set_triangles, Godot.Core.AnimationNodeBlendSpace2D._tree_changed, Godot.Core.AnimationNodeBlendSpace2D._update_triangles, Godot.Core.AnimationNodeBlendSpace2D.add_blend_point, Godot.Core.AnimationNodeBlendSpace2D.add_triangle, Godot.Core.AnimationNodeBlendSpace2D.get_auto_triangles, Godot.Core.AnimationNodeBlendSpace2D.get_blend_mode, Godot.Core.AnimationNodeBlendSpace2D.get_blend_point_count, Godot.Core.AnimationNodeBlendSpace2D.get_blend_point_node, Godot.Core.AnimationNodeBlendSpace2D.get_blend_point_position, Godot.Core.AnimationNodeBlendSpace2D.get_max_space, Godot.Core.AnimationNodeBlendSpace2D.get_min_space, Godot.Core.AnimationNodeBlendSpace2D.get_snap, Godot.Core.AnimationNodeBlendSpace2D.get_triangle_count, Godot.Core.AnimationNodeBlendSpace2D.get_triangle_point, Godot.Core.AnimationNodeBlendSpace2D.get_x_label, Godot.Core.AnimationNodeBlendSpace2D.get_y_label, Godot.Core.AnimationNodeBlendSpace2D.remove_blend_point, Godot.Core.AnimationNodeBlendSpace2D.remove_triangle, Godot.Core.AnimationNodeBlendSpace2D.set_auto_triangles, Godot.Core.AnimationNodeBlendSpace2D.set_blend_mode, Godot.Core.AnimationNodeBlendSpace2D.set_blend_point_node, Godot.Core.AnimationNodeBlendSpace2D.set_blend_point_position, Godot.Core.AnimationNodeBlendSpace2D.set_max_space, Godot.Core.AnimationNodeBlendSpace2D.set_min_space, Godot.Core.AnimationNodeBlendSpace2D.set_snap, Godot.Core.AnimationNodeBlendSpace2D.set_x_label, Godot.Core.AnimationNodeBlendSpace2D.set_y_label) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationRootNode() _BLEND_MODE_DISCRETE_CARRY :: Int _BLEND_MODE_DISCRETE_CARRY = 2 _BLEND_MODE_DISCRETE :: Int _BLEND_MODE_DISCRETE = 1 _BLEND_MODE_INTERPOLATED :: Int _BLEND_MODE_INTERPOLATED = 0 -- | Emitted every time the blend space's triangles are created, removed, or when one of their vertices changes position. sig_triangles_updated :: Godot.Internal.Dispatch.Signal AnimationNodeBlendSpace2D sig_triangles_updated = Godot.Internal.Dispatch.Signal "triangles_updated" instance NodeSignal AnimationNodeBlendSpace2D "triangles_updated" '[] instance NodeProperty AnimationNodeBlendSpace2D "auto_triangles" Bool 'False where nodeProperty = (get_auto_triangles, wrapDroppingSetter set_auto_triangles, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_mode" Int 'False where nodeProperty = (get_blend_mode, wrapDroppingSetter set_blend_mode, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_0/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 0 get_blend_point_node, wrapIndexedSetter 0 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_0/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 0 get_blend_point_position, wrapIndexedSetter 0 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_1/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 1 get_blend_point_node, wrapIndexedSetter 1 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_1/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 1 get_blend_point_position, wrapIndexedSetter 1 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_10/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 10 get_blend_point_node, wrapIndexedSetter 10 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_10/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 10 get_blend_point_position, wrapIndexedSetter 10 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_11/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 11 get_blend_point_node, wrapIndexedSetter 11 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_11/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 11 get_blend_point_position, wrapIndexedSetter 11 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_12/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 12 get_blend_point_node, wrapIndexedSetter 12 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_12/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 12 get_blend_point_position, wrapIndexedSetter 12 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_13/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 13 get_blend_point_node, wrapIndexedSetter 13 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_13/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 13 get_blend_point_position, wrapIndexedSetter 13 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_14/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 14 get_blend_point_node, wrapIndexedSetter 14 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_14/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 14 get_blend_point_position, wrapIndexedSetter 14 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_15/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 15 get_blend_point_node, wrapIndexedSetter 15 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_15/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 15 get_blend_point_position, wrapIndexedSetter 15 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_16/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 16 get_blend_point_node, wrapIndexedSetter 16 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_16/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 16 get_blend_point_position, wrapIndexedSetter 16 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_17/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 17 get_blend_point_node, wrapIndexedSetter 17 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_17/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 17 get_blend_point_position, wrapIndexedSetter 17 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_18/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 18 get_blend_point_node, wrapIndexedSetter 18 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_18/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 18 get_blend_point_position, wrapIndexedSetter 18 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_19/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 19 get_blend_point_node, wrapIndexedSetter 19 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_19/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 19 get_blend_point_position, wrapIndexedSetter 19 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_2/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 2 get_blend_point_node, wrapIndexedSetter 2 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_2/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 2 get_blend_point_position, wrapIndexedSetter 2 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_20/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 20 get_blend_point_node, wrapIndexedSetter 20 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_20/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 20 get_blend_point_position, wrapIndexedSetter 20 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_21/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 21 get_blend_point_node, wrapIndexedSetter 21 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_21/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 21 get_blend_point_position, wrapIndexedSetter 21 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_22/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 22 get_blend_point_node, wrapIndexedSetter 22 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_22/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 22 get_blend_point_position, wrapIndexedSetter 22 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_23/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 23 get_blend_point_node, wrapIndexedSetter 23 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_23/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 23 get_blend_point_position, wrapIndexedSetter 23 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_24/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 24 get_blend_point_node, wrapIndexedSetter 24 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_24/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 24 get_blend_point_position, wrapIndexedSetter 24 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_25/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 25 get_blend_point_node, wrapIndexedSetter 25 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_25/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 25 get_blend_point_position, wrapIndexedSetter 25 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_26/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 26 get_blend_point_node, wrapIndexedSetter 26 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_26/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 26 get_blend_point_position, wrapIndexedSetter 26 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_27/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 27 get_blend_point_node, wrapIndexedSetter 27 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_27/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 27 get_blend_point_position, wrapIndexedSetter 27 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_28/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 28 get_blend_point_node, wrapIndexedSetter 28 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_28/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 28 get_blend_point_position, wrapIndexedSetter 28 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_29/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 29 get_blend_point_node, wrapIndexedSetter 29 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_29/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 29 get_blend_point_position, wrapIndexedSetter 29 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_3/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 3 get_blend_point_node, wrapIndexedSetter 3 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_3/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 3 get_blend_point_position, wrapIndexedSetter 3 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_30/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 30 get_blend_point_node, wrapIndexedSetter 30 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_30/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 30 get_blend_point_position, wrapIndexedSetter 30 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_31/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 31 get_blend_point_node, wrapIndexedSetter 31 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_31/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 31 get_blend_point_position, wrapIndexedSetter 31 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_32/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 32 get_blend_point_node, wrapIndexedSetter 32 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_32/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 32 get_blend_point_position, wrapIndexedSetter 32 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_33/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 33 get_blend_point_node, wrapIndexedSetter 33 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_33/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 33 get_blend_point_position, wrapIndexedSetter 33 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_34/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 34 get_blend_point_node, wrapIndexedSetter 34 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_34/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 34 get_blend_point_position, wrapIndexedSetter 34 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_35/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 35 get_blend_point_node, wrapIndexedSetter 35 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_35/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 35 get_blend_point_position, wrapIndexedSetter 35 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_36/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 36 get_blend_point_node, wrapIndexedSetter 36 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_36/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 36 get_blend_point_position, wrapIndexedSetter 36 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_37/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 37 get_blend_point_node, wrapIndexedSetter 37 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_37/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 37 get_blend_point_position, wrapIndexedSetter 37 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_38/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 38 get_blend_point_node, wrapIndexedSetter 38 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_38/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 38 get_blend_point_position, wrapIndexedSetter 38 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_39/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 39 get_blend_point_node, wrapIndexedSetter 39 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_39/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 39 get_blend_point_position, wrapIndexedSetter 39 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_4/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 4 get_blend_point_node, wrapIndexedSetter 4 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_4/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 4 get_blend_point_position, wrapIndexedSetter 4 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_40/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 40 get_blend_point_node, wrapIndexedSetter 40 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_40/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 40 get_blend_point_position, wrapIndexedSetter 40 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_41/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 41 get_blend_point_node, wrapIndexedSetter 41 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_41/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 41 get_blend_point_position, wrapIndexedSetter 41 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_42/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 42 get_blend_point_node, wrapIndexedSetter 42 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_42/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 42 get_blend_point_position, wrapIndexedSetter 42 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_43/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 43 get_blend_point_node, wrapIndexedSetter 43 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_43/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 43 get_blend_point_position, wrapIndexedSetter 43 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_44/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 44 get_blend_point_node, wrapIndexedSetter 44 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_44/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 44 get_blend_point_position, wrapIndexedSetter 44 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_45/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 45 get_blend_point_node, wrapIndexedSetter 45 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_45/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 45 get_blend_point_position, wrapIndexedSetter 45 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_46/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 46 get_blend_point_node, wrapIndexedSetter 46 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_46/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 46 get_blend_point_position, wrapIndexedSetter 46 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_47/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 47 get_blend_point_node, wrapIndexedSetter 47 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_47/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 47 get_blend_point_position, wrapIndexedSetter 47 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_48/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 48 get_blend_point_node, wrapIndexedSetter 48 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_48/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 48 get_blend_point_position, wrapIndexedSetter 48 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_49/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 49 get_blend_point_node, wrapIndexedSetter 49 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_49/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 49 get_blend_point_position, wrapIndexedSetter 49 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_5/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 5 get_blend_point_node, wrapIndexedSetter 5 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_5/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 5 get_blend_point_position, wrapIndexedSetter 5 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_50/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 50 get_blend_point_node, wrapIndexedSetter 50 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_50/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 50 get_blend_point_position, wrapIndexedSetter 50 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_51/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 51 get_blend_point_node, wrapIndexedSetter 51 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_51/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 51 get_blend_point_position, wrapIndexedSetter 51 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_52/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 52 get_blend_point_node, wrapIndexedSetter 52 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_52/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 52 get_blend_point_position, wrapIndexedSetter 52 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_53/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 53 get_blend_point_node, wrapIndexedSetter 53 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_53/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 53 get_blend_point_position, wrapIndexedSetter 53 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_54/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 54 get_blend_point_node, wrapIndexedSetter 54 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_54/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 54 get_blend_point_position, wrapIndexedSetter 54 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_55/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 55 get_blend_point_node, wrapIndexedSetter 55 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_55/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 55 get_blend_point_position, wrapIndexedSetter 55 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_56/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 56 get_blend_point_node, wrapIndexedSetter 56 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_56/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 56 get_blend_point_position, wrapIndexedSetter 56 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_57/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 57 get_blend_point_node, wrapIndexedSetter 57 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_57/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 57 get_blend_point_position, wrapIndexedSetter 57 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_58/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 58 get_blend_point_node, wrapIndexedSetter 58 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_58/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 58 get_blend_point_position, wrapIndexedSetter 58 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_59/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 59 get_blend_point_node, wrapIndexedSetter 59 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_59/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 59 get_blend_point_position, wrapIndexedSetter 59 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_6/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 6 get_blend_point_node, wrapIndexedSetter 6 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_6/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 6 get_blend_point_position, wrapIndexedSetter 6 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_60/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 60 get_blend_point_node, wrapIndexedSetter 60 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_60/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 60 get_blend_point_position, wrapIndexedSetter 60 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_61/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 61 get_blend_point_node, wrapIndexedSetter 61 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_61/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 61 get_blend_point_position, wrapIndexedSetter 61 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_62/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 62 get_blend_point_node, wrapIndexedSetter 62 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_62/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 62 get_blend_point_position, wrapIndexedSetter 62 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_63/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 63 get_blend_point_node, wrapIndexedSetter 63 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_63/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 63 get_blend_point_position, wrapIndexedSetter 63 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_7/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 7 get_blend_point_node, wrapIndexedSetter 7 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_7/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 7 get_blend_point_position, wrapIndexedSetter 7 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_8/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 8 get_blend_point_node, wrapIndexedSetter 8 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_8/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 8 get_blend_point_position, wrapIndexedSetter 8 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_9/node" AnimationRootNode 'False where nodeProperty = (wrapIndexedGetter 9 get_blend_point_node, wrapIndexedSetter 9 _add_blend_point, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "blend_point_9/pos" Vector2 'False where nodeProperty = (wrapIndexedGetter 9 get_blend_point_position, wrapIndexedSetter 9 set_blend_point_position, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "max_space" Vector2 'False where nodeProperty = (get_max_space, wrapDroppingSetter set_max_space, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "min_space" Vector2 'False where nodeProperty = (get_min_space, wrapDroppingSetter set_min_space, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "snap" Vector2 'False where nodeProperty = (get_snap, wrapDroppingSetter set_snap, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "triangles" PoolIntArray 'False where nodeProperty = (_get_triangles, wrapDroppingSetter _set_triangles, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "x_label" GodotString 'False where nodeProperty = (get_x_label, wrapDroppingSetter set_x_label, Nothing) instance NodeProperty AnimationNodeBlendSpace2D "y_label" GodotString 'False where nodeProperty = (get_y_label, wrapDroppingSetter set_y_label, Nothing) {-# NOINLINE bindAnimationNodeBlendSpace2D__add_blend_point #-} bindAnimationNodeBlendSpace2D__add_blend_point :: MethodBind bindAnimationNodeBlendSpace2D__add_blend_point = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "_add_blend_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _add_blend_point :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> AnimationRootNode -> IO () _add_blend_point cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D__add_blend_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "_add_blend_point" '[Int, AnimationRootNode] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D._add_blend_point {-# NOINLINE bindAnimationNodeBlendSpace2D__get_triangles #-} bindAnimationNodeBlendSpace2D__get_triangles :: MethodBind bindAnimationNodeBlendSpace2D__get_triangles = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "_get_triangles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_triangles :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO PoolIntArray _get_triangles cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D__get_triangles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "_get_triangles" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D._get_triangles {-# NOINLINE bindAnimationNodeBlendSpace2D__set_triangles #-} bindAnimationNodeBlendSpace2D__set_triangles :: MethodBind bindAnimationNodeBlendSpace2D__set_triangles = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "_set_triangles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_triangles :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> PoolIntArray -> IO () _set_triangles cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D__set_triangles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "_set_triangles" '[PoolIntArray] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D._set_triangles {-# NOINLINE bindAnimationNodeBlendSpace2D__tree_changed #-} bindAnimationNodeBlendSpace2D__tree_changed :: MethodBind bindAnimationNodeBlendSpace2D__tree_changed = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "_tree_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_changed :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO () _tree_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D__tree_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "_tree_changed" '[] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D._tree_changed {-# NOINLINE bindAnimationNodeBlendSpace2D__update_triangles #-} bindAnimationNodeBlendSpace2D__update_triangles :: MethodBind bindAnimationNodeBlendSpace2D__update_triangles = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "_update_triangles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_triangles :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO () _update_triangles cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D__update_triangles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "_update_triangles" '[] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D._update_triangles {-# NOINLINE bindAnimationNodeBlendSpace2D_add_blend_point #-} -- | Adds a new point that represents a @node@ at the position set by @pos@. You can insert it at a specific index using the @at_index@ argument. If you use the default value for @at_index@, the point is inserted at the end of the blend points array. bindAnimationNodeBlendSpace2D_add_blend_point :: MethodBind bindAnimationNodeBlendSpace2D_add_blend_point = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "add_blend_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new point that represents a @node@ at the position set by @pos@. You can insert it at a specific index using the @at_index@ argument. If you use the default value for @at_index@, the point is inserted at the end of the blend points array. add_blend_point :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> AnimationRootNode -> Vector2 -> Maybe Int -> IO () add_blend_point cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_add_blend_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "add_blend_point" '[AnimationRootNode, Vector2, Maybe Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.add_blend_point {-# NOINLINE bindAnimationNodeBlendSpace2D_add_triangle #-} -- | Creates a new triangle using three points @x@, @y@, and @z@. Triangles can overlap. You can insert the triangle at a specific index using the @at_index@ argument. If you use the default value for @at_index@, the point is inserted at the end of the blend points array. bindAnimationNodeBlendSpace2D_add_triangle :: MethodBind bindAnimationNodeBlendSpace2D_add_triangle = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "add_triangle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new triangle using three points @x@, @y@, and @z@. Triangles can overlap. You can insert the triangle at a specific index using the @at_index@ argument. If you use the default value for @at_index@, the point is inserted at the end of the blend points array. add_triangle :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Maybe Int -> IO () add_triangle cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantInt (-1)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_add_triangle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "add_triangle" '[Int, Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.add_triangle {-# NOINLINE bindAnimationNodeBlendSpace2D_get_auto_triangles #-} -- | If @true@, the blend space is triangulated automatically. The mesh updates every time you add or remove points with @method add_blend_point@ and @method remove_blend_point@. bindAnimationNodeBlendSpace2D_get_auto_triangles :: MethodBind bindAnimationNodeBlendSpace2D_get_auto_triangles = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_auto_triangles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the blend space is triangulated automatically. The mesh updates every time you add or remove points with @method add_blend_point@ and @method remove_blend_point@. get_auto_triangles :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO Bool get_auto_triangles cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_auto_triangles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_auto_triangles" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_auto_triangles {-# NOINLINE bindAnimationNodeBlendSpace2D_get_blend_mode #-} -- | Controls the interpolation between animations. See @enum BlendMode@ constants. bindAnimationNodeBlendSpace2D_get_blend_mode :: MethodBind bindAnimationNodeBlendSpace2D_get_blend_mode = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the interpolation between animations. See @enum BlendMode@ constants. get_blend_mode :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO Int get_blend_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_blend_mode" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_blend_mode {-# NOINLINE bindAnimationNodeBlendSpace2D_get_blend_point_count #-} -- | Returns the number of points in the blend space. bindAnimationNodeBlendSpace2D_get_blend_point_count :: MethodBind bindAnimationNodeBlendSpace2D_get_blend_point_count = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_blend_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of points in the blend space. get_blend_point_count :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO Int get_blend_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_blend_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_blend_point_count" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_blend_point_count {-# NOINLINE bindAnimationNodeBlendSpace2D_get_blend_point_node #-} -- | Returns the @AnimationRootNode@ referenced by the point at index @point@. bindAnimationNodeBlendSpace2D_get_blend_point_node :: MethodBind bindAnimationNodeBlendSpace2D_get_blend_point_node = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_blend_point_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AnimationRootNode@ referenced by the point at index @point@. get_blend_point_node :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> IO AnimationRootNode get_blend_point_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_blend_point_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_blend_point_node" '[Int] (IO AnimationRootNode) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_blend_point_node {-# NOINLINE bindAnimationNodeBlendSpace2D_get_blend_point_position #-} -- | Returns the position of the point at index @point@. bindAnimationNodeBlendSpace2D_get_blend_point_position :: MethodBind bindAnimationNodeBlendSpace2D_get_blend_point_position = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_blend_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the point at index @point@. get_blend_point_position :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_blend_point_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_blend_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_blend_point_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_blend_point_position {-# NOINLINE bindAnimationNodeBlendSpace2D_get_max_space #-} -- | The blend space's X and Y axes' upper limit for the points' position. See @method add_blend_point@. bindAnimationNodeBlendSpace2D_get_max_space :: MethodBind bindAnimationNodeBlendSpace2D_get_max_space = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_max_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The blend space's X and Y axes' upper limit for the points' position. See @method add_blend_point@. get_max_space :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO Vector2 get_max_space cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_max_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_max_space" '[] (IO Vector2) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_max_space {-# NOINLINE bindAnimationNodeBlendSpace2D_get_min_space #-} -- | The blend space's X and Y axes' lower limit for the points' position. See @method add_blend_point@. bindAnimationNodeBlendSpace2D_get_min_space :: MethodBind bindAnimationNodeBlendSpace2D_get_min_space = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_min_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The blend space's X and Y axes' lower limit for the points' position. See @method add_blend_point@. get_min_space :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO Vector2 get_min_space cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_min_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_min_space" '[] (IO Vector2) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_min_space {-# NOINLINE bindAnimationNodeBlendSpace2D_get_snap #-} -- | Position increment to snap to when moving a point. bindAnimationNodeBlendSpace2D_get_snap :: MethodBind bindAnimationNodeBlendSpace2D_get_snap = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Position increment to snap to when moving a point. get_snap :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO Vector2 get_snap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_snap" '[] (IO Vector2) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_snap {-# NOINLINE bindAnimationNodeBlendSpace2D_get_triangle_count #-} -- | Returns the number of triangles in the blend space. bindAnimationNodeBlendSpace2D_get_triangle_count :: MethodBind bindAnimationNodeBlendSpace2D_get_triangle_count = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_triangle_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of triangles in the blend space. get_triangle_count :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO Int get_triangle_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_triangle_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_triangle_count" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_triangle_count {-# NOINLINE bindAnimationNodeBlendSpace2D_get_triangle_point #-} -- | Returns the position of the point at index @point@ in the triangle of index @triangle@. bindAnimationNodeBlendSpace2D_get_triangle_point :: MethodBind bindAnimationNodeBlendSpace2D_get_triangle_point = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_triangle_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the point at index @point@ in the triangle of index @triangle@. get_triangle_point :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> Int -> IO Int get_triangle_point cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_triangle_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_triangle_point" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_triangle_point {-# NOINLINE bindAnimationNodeBlendSpace2D_get_x_label #-} -- | Name of the blend space's X axis. bindAnimationNodeBlendSpace2D_get_x_label :: MethodBind bindAnimationNodeBlendSpace2D_get_x_label = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_x_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the blend space's X axis. get_x_label :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO GodotString get_x_label cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_x_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_x_label" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_x_label {-# NOINLINE bindAnimationNodeBlendSpace2D_get_y_label #-} -- | Name of the blend space's Y axis. bindAnimationNodeBlendSpace2D_get_y_label :: MethodBind bindAnimationNodeBlendSpace2D_get_y_label = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "get_y_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the blend space's Y axis. get_y_label :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> IO GodotString get_y_label cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_get_y_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "get_y_label" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.get_y_label {-# NOINLINE bindAnimationNodeBlendSpace2D_remove_blend_point #-} -- | Removes the point at index @point@ from the blend space. bindAnimationNodeBlendSpace2D_remove_blend_point :: MethodBind bindAnimationNodeBlendSpace2D_remove_blend_point = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "remove_blend_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the point at index @point@ from the blend space. remove_blend_point :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> IO () remove_blend_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_remove_blend_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "remove_blend_point" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.remove_blend_point {-# NOINLINE bindAnimationNodeBlendSpace2D_remove_triangle #-} -- | Removes the triangle at index @triangle@ from the blend space. bindAnimationNodeBlendSpace2D_remove_triangle :: MethodBind bindAnimationNodeBlendSpace2D_remove_triangle = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "remove_triangle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the triangle at index @triangle@ from the blend space. remove_triangle :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> IO () remove_triangle cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_remove_triangle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "remove_triangle" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.remove_triangle {-# NOINLINE bindAnimationNodeBlendSpace2D_set_auto_triangles #-} -- | If @true@, the blend space is triangulated automatically. The mesh updates every time you add or remove points with @method add_blend_point@ and @method remove_blend_point@. bindAnimationNodeBlendSpace2D_set_auto_triangles :: MethodBind bindAnimationNodeBlendSpace2D_set_auto_triangles = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_auto_triangles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the blend space is triangulated automatically. The mesh updates every time you add or remove points with @method add_blend_point@ and @method remove_blend_point@. set_auto_triangles :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Bool -> IO () set_auto_triangles cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_auto_triangles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_auto_triangles" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_auto_triangles {-# NOINLINE bindAnimationNodeBlendSpace2D_set_blend_mode #-} -- | Controls the interpolation between animations. See @enum BlendMode@ constants. bindAnimationNodeBlendSpace2D_set_blend_mode :: MethodBind bindAnimationNodeBlendSpace2D_set_blend_mode = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the interpolation between animations. See @enum BlendMode@ constants. set_blend_mode :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> IO () set_blend_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_blend_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_blend_mode {-# NOINLINE bindAnimationNodeBlendSpace2D_set_blend_point_node #-} -- | Changes the @AnimationNode@ referenced by the point at index @point@. bindAnimationNodeBlendSpace2D_set_blend_point_node :: MethodBind bindAnimationNodeBlendSpace2D_set_blend_point_node = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_blend_point_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the @AnimationNode@ referenced by the point at index @point@. set_blend_point_node :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> AnimationRootNode -> IO () set_blend_point_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_blend_point_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_blend_point_node" '[Int, AnimationRootNode] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_blend_point_node {-# NOINLINE bindAnimationNodeBlendSpace2D_set_blend_point_position #-} -- | Updates the position of the point at index @point@ on the blend axis. bindAnimationNodeBlendSpace2D_set_blend_point_position :: MethodBind bindAnimationNodeBlendSpace2D_set_blend_point_position = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_blend_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the position of the point at index @point@ on the blend axis. set_blend_point_position :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_blend_point_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_blend_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_blend_point_position" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_blend_point_position {-# NOINLINE bindAnimationNodeBlendSpace2D_set_max_space #-} -- | The blend space's X and Y axes' upper limit for the points' position. See @method add_blend_point@. bindAnimationNodeBlendSpace2D_set_max_space :: MethodBind bindAnimationNodeBlendSpace2D_set_max_space = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_max_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The blend space's X and Y axes' upper limit for the points' position. See @method add_blend_point@. set_max_space :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_max_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_max_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_max_space" '[Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_max_space {-# NOINLINE bindAnimationNodeBlendSpace2D_set_min_space #-} -- | The blend space's X and Y axes' lower limit for the points' position. See @method add_blend_point@. bindAnimationNodeBlendSpace2D_set_min_space :: MethodBind bindAnimationNodeBlendSpace2D_set_min_space = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_min_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The blend space's X and Y axes' lower limit for the points' position. See @method add_blend_point@. set_min_space :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_min_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_min_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_min_space" '[Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_min_space {-# NOINLINE bindAnimationNodeBlendSpace2D_set_snap #-} -- | Position increment to snap to when moving a point. bindAnimationNodeBlendSpace2D_set_snap :: MethodBind bindAnimationNodeBlendSpace2D_set_snap = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Position increment to snap to when moving a point. set_snap :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_snap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_snap" '[Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_snap {-# NOINLINE bindAnimationNodeBlendSpace2D_set_x_label #-} -- | Name of the blend space's X axis. bindAnimationNodeBlendSpace2D_set_x_label :: MethodBind bindAnimationNodeBlendSpace2D_set_x_label = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_x_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the blend space's X axis. set_x_label :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> GodotString -> IO () set_x_label cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_x_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_x_label" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_x_label {-# NOINLINE bindAnimationNodeBlendSpace2D_set_y_label #-} -- | Name of the blend space's Y axis. bindAnimationNodeBlendSpace2D_set_y_label :: MethodBind bindAnimationNodeBlendSpace2D_set_y_label = unsafePerformIO $ withCString "AnimationNodeBlendSpace2D" $ \ clsNamePtr -> withCString "set_y_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the blend space's Y axis. set_y_label :: (AnimationNodeBlendSpace2D :< cls, Object :< cls) => cls -> GodotString -> IO () set_y_label cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendSpace2D_set_y_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendSpace2D "set_y_label" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendSpace2D.set_y_label ================================================ FILE: src/Godot/Core/AnimationNodeBlendTree.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeBlendTree (Godot.Core.AnimationNodeBlendTree._CONNECTION_ERROR_NO_INPUT_INDEX, Godot.Core.AnimationNodeBlendTree._CONNECTION_ERROR_NO_OUTPUT, Godot.Core.AnimationNodeBlendTree._CONNECTION_OK, Godot.Core.AnimationNodeBlendTree._CONNECTION_ERROR_SAME_NODE, Godot.Core.AnimationNodeBlendTree._CONNECTION_ERROR_CONNECTION_EXISTS, Godot.Core.AnimationNodeBlendTree._CONNECTION_ERROR_NO_INPUT, Godot.Core.AnimationNodeBlendTree._node_changed, Godot.Core.AnimationNodeBlendTree._tree_changed, Godot.Core.AnimationNodeBlendTree.add_node, Godot.Core.AnimationNodeBlendTree.connect_node, Godot.Core.AnimationNodeBlendTree.disconnect_node, Godot.Core.AnimationNodeBlendTree.get_graph_offset, Godot.Core.AnimationNodeBlendTree.get_node, Godot.Core.AnimationNodeBlendTree.get_node_position, Godot.Core.AnimationNodeBlendTree.has_node, Godot.Core.AnimationNodeBlendTree.remove_node, Godot.Core.AnimationNodeBlendTree.rename_node, Godot.Core.AnimationNodeBlendTree.set_graph_offset, Godot.Core.AnimationNodeBlendTree.set_node_position) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationRootNode() _CONNECTION_ERROR_NO_INPUT_INDEX :: Int _CONNECTION_ERROR_NO_INPUT_INDEX = 2 _CONNECTION_ERROR_NO_OUTPUT :: Int _CONNECTION_ERROR_NO_OUTPUT = 3 _CONNECTION_OK :: Int _CONNECTION_OK = 0 _CONNECTION_ERROR_SAME_NODE :: Int _CONNECTION_ERROR_SAME_NODE = 4 _CONNECTION_ERROR_CONNECTION_EXISTS :: Int _CONNECTION_ERROR_CONNECTION_EXISTS = 5 _CONNECTION_ERROR_NO_INPUT :: Int _CONNECTION_ERROR_NO_INPUT = 1 instance NodeProperty AnimationNodeBlendTree "graph_offset" Vector2 'False where nodeProperty = (get_graph_offset, wrapDroppingSetter set_graph_offset, Nothing) {-# NOINLINE bindAnimationNodeBlendTree__node_changed #-} bindAnimationNodeBlendTree__node_changed :: MethodBind bindAnimationNodeBlendTree__node_changed = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "_node_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _node_changed :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> IO () _node_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree__node_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "_node_changed" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree._node_changed {-# NOINLINE bindAnimationNodeBlendTree__tree_changed #-} bindAnimationNodeBlendTree__tree_changed :: MethodBind bindAnimationNodeBlendTree__tree_changed = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "_tree_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_changed :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> IO () _tree_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree__tree_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "_tree_changed" '[] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree._tree_changed {-# NOINLINE bindAnimationNodeBlendTree_add_node #-} -- | Adds an @AnimationNode@ at the given @position@. The @name@ is used to identify the created sub-node later. bindAnimationNodeBlendTree_add_node :: MethodBind bindAnimationNodeBlendTree_add_node = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "add_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an @AnimationNode@ at the given @position@. The @name@ is used to identify the created sub-node later. add_node :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> AnimationNode -> Maybe Vector2 -> IO () add_node cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantVector2 (V2 0 0) arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_add_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "add_node" '[GodotString, AnimationNode, Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree.add_node {-# NOINLINE bindAnimationNodeBlendTree_connect_node #-} -- | Connects the output of an @AnimationNode@ as input for another @AnimationNode@, at the input port specified by @input_index@. bindAnimationNodeBlendTree_connect_node :: MethodBind bindAnimationNodeBlendTree_connect_node = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "connect_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects the output of an @AnimationNode@ as input for another @AnimationNode@, at the input port specified by @input_index@. connect_node :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> IO () connect_node cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_connect_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "connect_node" '[GodotString, Int, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree.connect_node {-# NOINLINE bindAnimationNodeBlendTree_disconnect_node #-} -- | Disconnects the node connected to the specified input. bindAnimationNodeBlendTree_disconnect_node :: MethodBind bindAnimationNodeBlendTree_disconnect_node = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "disconnect_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disconnects the node connected to the specified input. disconnect_node :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () disconnect_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_disconnect_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "disconnect_node" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree.disconnect_node {-# NOINLINE bindAnimationNodeBlendTree_get_graph_offset #-} -- | The global offset of all sub-nodes. bindAnimationNodeBlendTree_get_graph_offset :: MethodBind bindAnimationNodeBlendTree_get_graph_offset = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "get_graph_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global offset of all sub-nodes. get_graph_offset :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> IO Vector2 get_graph_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_get_graph_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "get_graph_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.AnimationNodeBlendTree.get_graph_offset {-# NOINLINE bindAnimationNodeBlendTree_get_node #-} -- | Returns the sub-node with the specified @name@. bindAnimationNodeBlendTree_get_node :: MethodBind bindAnimationNodeBlendTree_get_node = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "get_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the sub-node with the specified @name@. get_node :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> IO AnimationNode get_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_get_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "get_node" '[GodotString] (IO AnimationNode) where nodeMethod = Godot.Core.AnimationNodeBlendTree.get_node {-# NOINLINE bindAnimationNodeBlendTree_get_node_position #-} -- | Returns the position of the sub-node with the specified @name@. bindAnimationNodeBlendTree_get_node_position :: MethodBind bindAnimationNodeBlendTree_get_node_position = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "get_node_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the sub-node with the specified @name@. get_node_position :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> IO Vector2 get_node_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_get_node_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "get_node_position" '[GodotString] (IO Vector2) where nodeMethod = Godot.Core.AnimationNodeBlendTree.get_node_position {-# NOINLINE bindAnimationNodeBlendTree_has_node #-} -- | Returns @true@ if a sub-node with specified @name@ exists. bindAnimationNodeBlendTree_has_node :: MethodBind bindAnimationNodeBlendTree_has_node = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "has_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a sub-node with specified @name@ exists. has_node :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_has_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "has_node" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeBlendTree.has_node {-# NOINLINE bindAnimationNodeBlendTree_remove_node #-} -- | Removes a sub-node. bindAnimationNodeBlendTree_remove_node :: MethodBind bindAnimationNodeBlendTree_remove_node = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "remove_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a sub-node. remove_node :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> IO () remove_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_remove_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "remove_node" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree.remove_node {-# NOINLINE bindAnimationNodeBlendTree_rename_node #-} -- | Changes the name of a sub-node. bindAnimationNodeBlendTree_rename_node :: MethodBind bindAnimationNodeBlendTree_rename_node = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "rename_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the name of a sub-node. rename_node :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_rename_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "rename_node" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree.rename_node {-# NOINLINE bindAnimationNodeBlendTree_set_graph_offset #-} -- | The global offset of all sub-nodes. bindAnimationNodeBlendTree_set_graph_offset :: MethodBind bindAnimationNodeBlendTree_set_graph_offset = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "set_graph_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global offset of all sub-nodes. set_graph_offset :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> Vector2 -> IO () set_graph_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_set_graph_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "set_graph_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree.set_graph_offset {-# NOINLINE bindAnimationNodeBlendTree_set_node_position #-} -- | Modifies the position of a sub-node. bindAnimationNodeBlendTree_set_node_position :: MethodBind bindAnimationNodeBlendTree_set_node_position = unsafePerformIO $ withCString "AnimationNodeBlendTree" $ \ clsNamePtr -> withCString "set_node_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Modifies the position of a sub-node. set_node_position :: (AnimationNodeBlendTree :< cls, Object :< cls) => cls -> GodotString -> Vector2 -> IO () set_node_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeBlendTree_set_node_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeBlendTree "set_node_position" '[GodotString, Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeBlendTree.set_node_position ================================================ FILE: src/Godot/Core/AnimationNodeOneShot.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeOneShot (Godot.Core.AnimationNodeOneShot._MIX_MODE_ADD, Godot.Core.AnimationNodeOneShot._MIX_MODE_BLEND, Godot.Core.AnimationNodeOneShot.get_autorestart_delay, Godot.Core.AnimationNodeOneShot.get_autorestart_random_delay, Godot.Core.AnimationNodeOneShot.get_fadein_time, Godot.Core.AnimationNodeOneShot.get_fadeout_time, Godot.Core.AnimationNodeOneShot.get_mix_mode, Godot.Core.AnimationNodeOneShot.has_autorestart, Godot.Core.AnimationNodeOneShot.is_using_sync, Godot.Core.AnimationNodeOneShot.set_autorestart, Godot.Core.AnimationNodeOneShot.set_autorestart_delay, Godot.Core.AnimationNodeOneShot.set_autorestart_random_delay, Godot.Core.AnimationNodeOneShot.set_fadein_time, Godot.Core.AnimationNodeOneShot.set_fadeout_time, Godot.Core.AnimationNodeOneShot.set_mix_mode, Godot.Core.AnimationNodeOneShot.set_use_sync) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() _MIX_MODE_ADD :: Int _MIX_MODE_ADD = 1 _MIX_MODE_BLEND :: Int _MIX_MODE_BLEND = 0 instance NodeProperty AnimationNodeOneShot "autorestart" Bool 'False where nodeProperty = (has_autorestart, wrapDroppingSetter set_autorestart, Nothing) instance NodeProperty AnimationNodeOneShot "autorestart_delay" Float 'False where nodeProperty = (get_autorestart_delay, wrapDroppingSetter set_autorestart_delay, Nothing) instance NodeProperty AnimationNodeOneShot "autorestart_random_delay" Float 'False where nodeProperty = (get_autorestart_random_delay, wrapDroppingSetter set_autorestart_random_delay, Nothing) instance NodeProperty AnimationNodeOneShot "fadein_time" Float 'False where nodeProperty = (get_fadein_time, wrapDroppingSetter set_fadein_time, Nothing) instance NodeProperty AnimationNodeOneShot "fadeout_time" Float 'False where nodeProperty = (get_fadeout_time, wrapDroppingSetter set_fadeout_time, Nothing) instance NodeProperty AnimationNodeOneShot "sync" Bool 'False where nodeProperty = (is_using_sync, wrapDroppingSetter set_use_sync, Nothing) {-# NOINLINE bindAnimationNodeOneShot_get_autorestart_delay #-} -- | The delay after which the automatic restart is triggered, in seconds. bindAnimationNodeOneShot_get_autorestart_delay :: MethodBind bindAnimationNodeOneShot_get_autorestart_delay = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "get_autorestart_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The delay after which the automatic restart is triggered, in seconds. get_autorestart_delay :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> IO Float get_autorestart_delay cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_get_autorestart_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "get_autorestart_delay" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeOneShot.get_autorestart_delay {-# NOINLINE bindAnimationNodeOneShot_get_autorestart_random_delay #-} -- | If @autorestart@ is @true@, a random additional delay (in seconds) between 0 and this value will be added to @autorestart_delay@. bindAnimationNodeOneShot_get_autorestart_random_delay :: MethodBind bindAnimationNodeOneShot_get_autorestart_random_delay = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "get_autorestart_random_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @autorestart@ is @true@, a random additional delay (in seconds) between 0 and this value will be added to @autorestart_delay@. get_autorestart_random_delay :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> IO Float get_autorestart_random_delay cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_get_autorestart_random_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "get_autorestart_random_delay" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeOneShot.get_autorestart_random_delay {-# NOINLINE bindAnimationNodeOneShot_get_fadein_time #-} bindAnimationNodeOneShot_get_fadein_time :: MethodBind bindAnimationNodeOneShot_get_fadein_time = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "get_fadein_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_fadein_time :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> IO Float get_fadein_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_get_fadein_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "get_fadein_time" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeOneShot.get_fadein_time {-# NOINLINE bindAnimationNodeOneShot_get_fadeout_time #-} bindAnimationNodeOneShot_get_fadeout_time :: MethodBind bindAnimationNodeOneShot_get_fadeout_time = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "get_fadeout_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_fadeout_time :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> IO Float get_fadeout_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_get_fadeout_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "get_fadeout_time" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeOneShot.get_fadeout_time {-# NOINLINE bindAnimationNodeOneShot_get_mix_mode #-} bindAnimationNodeOneShot_get_mix_mode :: MethodBind bindAnimationNodeOneShot_get_mix_mode = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "get_mix_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_mix_mode :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> IO Int get_mix_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_get_mix_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "get_mix_mode" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeOneShot.get_mix_mode {-# NOINLINE bindAnimationNodeOneShot_has_autorestart #-} -- | If @true@, the sub-animation will restart automatically after finishing. bindAnimationNodeOneShot_has_autorestart :: MethodBind bindAnimationNodeOneShot_has_autorestart = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "has_autorestart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the sub-animation will restart automatically after finishing. has_autorestart :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> IO Bool has_autorestart cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_has_autorestart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "has_autorestart" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeOneShot.has_autorestart {-# NOINLINE bindAnimationNodeOneShot_is_using_sync #-} bindAnimationNodeOneShot_is_using_sync :: MethodBind bindAnimationNodeOneShot_is_using_sync = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "is_using_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_using_sync :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> IO Bool is_using_sync cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_is_using_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "is_using_sync" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeOneShot.is_using_sync {-# NOINLINE bindAnimationNodeOneShot_set_autorestart #-} -- | If @true@, the sub-animation will restart automatically after finishing. bindAnimationNodeOneShot_set_autorestart :: MethodBind bindAnimationNodeOneShot_set_autorestart = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "set_autorestart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the sub-animation will restart automatically after finishing. set_autorestart :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> Bool -> IO () set_autorestart cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_set_autorestart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "set_autorestart" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeOneShot.set_autorestart {-# NOINLINE bindAnimationNodeOneShot_set_autorestart_delay #-} -- | The delay after which the automatic restart is triggered, in seconds. bindAnimationNodeOneShot_set_autorestart_delay :: MethodBind bindAnimationNodeOneShot_set_autorestart_delay = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "set_autorestart_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The delay after which the automatic restart is triggered, in seconds. set_autorestart_delay :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> Float -> IO () set_autorestart_delay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_set_autorestart_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "set_autorestart_delay" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeOneShot.set_autorestart_delay {-# NOINLINE bindAnimationNodeOneShot_set_autorestart_random_delay #-} -- | If @autorestart@ is @true@, a random additional delay (in seconds) between 0 and this value will be added to @autorestart_delay@. bindAnimationNodeOneShot_set_autorestart_random_delay :: MethodBind bindAnimationNodeOneShot_set_autorestart_random_delay = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "set_autorestart_random_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @autorestart@ is @true@, a random additional delay (in seconds) between 0 and this value will be added to @autorestart_delay@. set_autorestart_random_delay :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> Float -> IO () set_autorestart_random_delay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_set_autorestart_random_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "set_autorestart_random_delay" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeOneShot.set_autorestart_random_delay {-# NOINLINE bindAnimationNodeOneShot_set_fadein_time #-} bindAnimationNodeOneShot_set_fadein_time :: MethodBind bindAnimationNodeOneShot_set_fadein_time = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "set_fadein_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_fadein_time :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> Float -> IO () set_fadein_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_set_fadein_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "set_fadein_time" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeOneShot.set_fadein_time {-# NOINLINE bindAnimationNodeOneShot_set_fadeout_time #-} bindAnimationNodeOneShot_set_fadeout_time :: MethodBind bindAnimationNodeOneShot_set_fadeout_time = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "set_fadeout_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_fadeout_time :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> Float -> IO () set_fadeout_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_set_fadeout_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "set_fadeout_time" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeOneShot.set_fadeout_time {-# NOINLINE bindAnimationNodeOneShot_set_mix_mode #-} bindAnimationNodeOneShot_set_mix_mode :: MethodBind bindAnimationNodeOneShot_set_mix_mode = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "set_mix_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_mix_mode :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> Int -> IO () set_mix_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_set_mix_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "set_mix_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeOneShot.set_mix_mode {-# NOINLINE bindAnimationNodeOneShot_set_use_sync #-} bindAnimationNodeOneShot_set_use_sync :: MethodBind bindAnimationNodeOneShot_set_use_sync = unsafePerformIO $ withCString "AnimationNodeOneShot" $ \ clsNamePtr -> withCString "set_use_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_use_sync :: (AnimationNodeOneShot :< cls, Object :< cls) => cls -> Bool -> IO () set_use_sync cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeOneShot_set_use_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeOneShot "set_use_sync" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeOneShot.set_use_sync ================================================ FILE: src/Godot/Core/AnimationNodeOutput.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeOutput () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() ================================================ FILE: src/Godot/Core/AnimationNodeStateMachine.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeStateMachine (Godot.Core.AnimationNodeStateMachine._tree_changed, Godot.Core.AnimationNodeStateMachine.add_node, Godot.Core.AnimationNodeStateMachine.add_transition, Godot.Core.AnimationNodeStateMachine.get_end_node, Godot.Core.AnimationNodeStateMachine.get_graph_offset, Godot.Core.AnimationNodeStateMachine.get_node, Godot.Core.AnimationNodeStateMachine.get_node_name, Godot.Core.AnimationNodeStateMachine.get_node_position, Godot.Core.AnimationNodeStateMachine.get_start_node, Godot.Core.AnimationNodeStateMachine.get_transition, Godot.Core.AnimationNodeStateMachine.get_transition_count, Godot.Core.AnimationNodeStateMachine.get_transition_from, Godot.Core.AnimationNodeStateMachine.get_transition_to, Godot.Core.AnimationNodeStateMachine.has_node, Godot.Core.AnimationNodeStateMachine.has_transition, Godot.Core.AnimationNodeStateMachine.remove_node, Godot.Core.AnimationNodeStateMachine.remove_transition, Godot.Core.AnimationNodeStateMachine.remove_transition_by_index, Godot.Core.AnimationNodeStateMachine.rename_node, Godot.Core.AnimationNodeStateMachine.set_end_node, Godot.Core.AnimationNodeStateMachine.set_graph_offset, Godot.Core.AnimationNodeStateMachine.set_node_position, Godot.Core.AnimationNodeStateMachine.set_start_node) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationRootNode() {-# NOINLINE bindAnimationNodeStateMachine__tree_changed #-} bindAnimationNodeStateMachine__tree_changed :: MethodBind bindAnimationNodeStateMachine__tree_changed = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "_tree_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_changed :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> IO () _tree_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine__tree_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "_tree_changed" '[] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine._tree_changed {-# NOINLINE bindAnimationNodeStateMachine_add_node #-} -- | Adds a new node to the graph. The @position@ is used for display in the editor. bindAnimationNodeStateMachine_add_node :: MethodBind bindAnimationNodeStateMachine_add_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "add_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new node to the graph. The @position@ is used for display in the editor. add_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> AnimationNode -> Maybe Vector2 -> IO () add_node cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantVector2 (V2 0 0) arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_add_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "add_node" '[GodotString, AnimationNode, Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.add_node {-# NOINLINE bindAnimationNodeStateMachine_add_transition #-} -- | Adds a transition between the given nodes. bindAnimationNodeStateMachine_add_transition :: MethodBind bindAnimationNodeStateMachine_add_transition = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "add_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a transition between the given nodes. add_transition :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> GodotString -> AnimationNodeStateMachineTransition -> IO () add_transition cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_add_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "add_transition" '[GodotString, GodotString, AnimationNodeStateMachineTransition] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.add_transition {-# NOINLINE bindAnimationNodeStateMachine_get_end_node #-} -- | Returns the graph's end node. bindAnimationNodeStateMachine_get_end_node :: MethodBind bindAnimationNodeStateMachine_get_end_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_end_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the graph's end node. get_end_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> IO GodotString get_end_node cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_end_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_end_node" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_end_node {-# NOINLINE bindAnimationNodeStateMachine_get_graph_offset #-} -- | Returns the draw offset of the graph. Used for display in the editor. bindAnimationNodeStateMachine_get_graph_offset :: MethodBind bindAnimationNodeStateMachine_get_graph_offset = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_graph_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the draw offset of the graph. Used for display in the editor. get_graph_offset :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> IO Vector2 get_graph_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_graph_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_graph_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_graph_offset {-# NOINLINE bindAnimationNodeStateMachine_get_node #-} -- | Returns the animation node with the given name. bindAnimationNodeStateMachine_get_node :: MethodBind bindAnimationNodeStateMachine_get_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the animation node with the given name. get_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> IO AnimationNode get_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_node" '[GodotString] (IO AnimationNode) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_node {-# NOINLINE bindAnimationNodeStateMachine_get_node_name #-} -- | Returns the given animation node's name. bindAnimationNodeStateMachine_get_node_name :: MethodBind bindAnimationNodeStateMachine_get_node_name = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_node_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given animation node's name. get_node_name :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> AnimationNode -> IO GodotString get_node_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_node_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_node_name" '[AnimationNode] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_node_name {-# NOINLINE bindAnimationNodeStateMachine_get_node_position #-} -- | Returns the given node's coordinates. Used for display in the editor. bindAnimationNodeStateMachine_get_node_position :: MethodBind bindAnimationNodeStateMachine_get_node_position = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_node_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given node's coordinates. Used for display in the editor. get_node_position :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> IO Vector2 get_node_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_node_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_node_position" '[GodotString] (IO Vector2) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_node_position {-# NOINLINE bindAnimationNodeStateMachine_get_start_node #-} -- | Returns the graph's end node. bindAnimationNodeStateMachine_get_start_node :: MethodBind bindAnimationNodeStateMachine_get_start_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_start_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the graph's end node. get_start_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> IO GodotString get_start_node cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_start_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_start_node" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_start_node {-# NOINLINE bindAnimationNodeStateMachine_get_transition #-} -- | Returns the given transition. bindAnimationNodeStateMachine_get_transition :: MethodBind bindAnimationNodeStateMachine_get_transition = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given transition. get_transition :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> Int -> IO AnimationNodeStateMachineTransition get_transition cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_transition" '[Int] (IO AnimationNodeStateMachineTransition) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_transition {-# NOINLINE bindAnimationNodeStateMachine_get_transition_count #-} -- | Returns the number of connections in the graph. bindAnimationNodeStateMachine_get_transition_count :: MethodBind bindAnimationNodeStateMachine_get_transition_count = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_transition_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of connections in the graph. get_transition_count :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> IO Int get_transition_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_transition_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_transition_count" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_transition_count {-# NOINLINE bindAnimationNodeStateMachine_get_transition_from #-} -- | Returns the given transition's start node. bindAnimationNodeStateMachine_get_transition_from :: MethodBind bindAnimationNodeStateMachine_get_transition_from = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_transition_from" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given transition's start node. get_transition_from :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> Int -> IO GodotString get_transition_from cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_transition_from (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_transition_from" '[Int] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_transition_from {-# NOINLINE bindAnimationNodeStateMachine_get_transition_to #-} -- | Returns the given transition's end node. bindAnimationNodeStateMachine_get_transition_to :: MethodBind bindAnimationNodeStateMachine_get_transition_to = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "get_transition_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given transition's end node. get_transition_to :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> Int -> IO GodotString get_transition_to cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_get_transition_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "get_transition_to" '[Int] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeStateMachine.get_transition_to {-# NOINLINE bindAnimationNodeStateMachine_has_node #-} -- | Returns @true@ if the graph contains the given node. bindAnimationNodeStateMachine_has_node :: MethodBind bindAnimationNodeStateMachine_has_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "has_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the graph contains the given node. has_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_has_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "has_node" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeStateMachine.has_node {-# NOINLINE bindAnimationNodeStateMachine_has_transition #-} -- | Returns @true@ if there is a transition between the given nodes. bindAnimationNodeStateMachine_has_transition :: MethodBind bindAnimationNodeStateMachine_has_transition = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "has_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if there is a transition between the given nodes. has_transition :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool has_transition cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_has_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "has_transition" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeStateMachine.has_transition {-# NOINLINE bindAnimationNodeStateMachine_remove_node #-} -- | Deletes the given node from the graph. bindAnimationNodeStateMachine_remove_node :: MethodBind bindAnimationNodeStateMachine_remove_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "remove_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the given node from the graph. remove_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> IO () remove_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_remove_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "remove_node" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.remove_node {-# NOINLINE bindAnimationNodeStateMachine_remove_transition #-} -- | Deletes the transition between the two specified nodes. bindAnimationNodeStateMachine_remove_transition :: MethodBind bindAnimationNodeStateMachine_remove_transition = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "remove_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the transition between the two specified nodes. remove_transition :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () remove_transition cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_remove_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "remove_transition" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.remove_transition {-# NOINLINE bindAnimationNodeStateMachine_remove_transition_by_index #-} -- | Deletes the given transition by index. bindAnimationNodeStateMachine_remove_transition_by_index :: MethodBind bindAnimationNodeStateMachine_remove_transition_by_index = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "remove_transition_by_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the given transition by index. remove_transition_by_index :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> Int -> IO () remove_transition_by_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_remove_transition_by_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "remove_transition_by_index" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.remove_transition_by_index {-# NOINLINE bindAnimationNodeStateMachine_rename_node #-} -- | Renames the given node. bindAnimationNodeStateMachine_rename_node :: MethodBind bindAnimationNodeStateMachine_rename_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "rename_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Renames the given node. rename_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_rename_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "rename_node" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.rename_node {-# NOINLINE bindAnimationNodeStateMachine_set_end_node #-} -- | Sets the given node as the graph end point. bindAnimationNodeStateMachine_set_end_node :: MethodBind bindAnimationNodeStateMachine_set_end_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "set_end_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given node as the graph end point. set_end_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> IO () set_end_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_set_end_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "set_end_node" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.set_end_node {-# NOINLINE bindAnimationNodeStateMachine_set_graph_offset #-} -- | Sets the draw offset of the graph. Used for display in the editor. bindAnimationNodeStateMachine_set_graph_offset :: MethodBind bindAnimationNodeStateMachine_set_graph_offset = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "set_graph_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the draw offset of the graph. Used for display in the editor. set_graph_offset :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> Vector2 -> IO () set_graph_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_set_graph_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "set_graph_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.set_graph_offset {-# NOINLINE bindAnimationNodeStateMachine_set_node_position #-} -- | Sets the node's coordinates. Used for display in the editor. bindAnimationNodeStateMachine_set_node_position :: MethodBind bindAnimationNodeStateMachine_set_node_position = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "set_node_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the node's coordinates. Used for display in the editor. set_node_position :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> Vector2 -> IO () set_node_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_set_node_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "set_node_position" '[GodotString, Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.set_node_position {-# NOINLINE bindAnimationNodeStateMachine_set_start_node #-} -- | Sets the given node as the graph start point. bindAnimationNodeStateMachine_set_start_node :: MethodBind bindAnimationNodeStateMachine_set_start_node = unsafePerformIO $ withCString "AnimationNodeStateMachine" $ \ clsNamePtr -> withCString "set_start_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given node as the graph start point. set_start_node :: (AnimationNodeStateMachine :< cls, Object :< cls) => cls -> GodotString -> IO () set_start_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachine_set_start_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachine "set_start_node" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachine.set_start_node ================================================ FILE: src/Godot/Core/AnimationNodeStateMachinePlayback.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeStateMachinePlayback (Godot.Core.AnimationNodeStateMachinePlayback.get_current_node, Godot.Core.AnimationNodeStateMachinePlayback.get_travel_path, Godot.Core.AnimationNodeStateMachinePlayback.is_playing, Godot.Core.AnimationNodeStateMachinePlayback.start, Godot.Core.AnimationNodeStateMachinePlayback.stop, Godot.Core.AnimationNodeStateMachinePlayback.travel) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindAnimationNodeStateMachinePlayback_get_current_node #-} -- | Returns the currently playing animation state. bindAnimationNodeStateMachinePlayback_get_current_node :: MethodBind bindAnimationNodeStateMachinePlayback_get_current_node = unsafePerformIO $ withCString "AnimationNodeStateMachinePlayback" $ \ clsNamePtr -> withCString "get_current_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the currently playing animation state. get_current_node :: (AnimationNodeStateMachinePlayback :< cls, Object :< cls) => cls -> IO GodotString get_current_node cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachinePlayback_get_current_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachinePlayback "get_current_node" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeStateMachinePlayback.get_current_node {-# NOINLINE bindAnimationNodeStateMachinePlayback_get_travel_path #-} -- | Returns the current travel path as computed internally by the A* algorithm. bindAnimationNodeStateMachinePlayback_get_travel_path :: MethodBind bindAnimationNodeStateMachinePlayback_get_travel_path = unsafePerformIO $ withCString "AnimationNodeStateMachinePlayback" $ \ clsNamePtr -> withCString "get_travel_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current travel path as computed internally by the A* algorithm. get_travel_path :: (AnimationNodeStateMachinePlayback :< cls, Object :< cls) => cls -> IO PoolStringArray get_travel_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachinePlayback_get_travel_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachinePlayback "get_travel_path" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.AnimationNodeStateMachinePlayback.get_travel_path {-# NOINLINE bindAnimationNodeStateMachinePlayback_is_playing #-} -- | Returns @true@ if an animation is playing. bindAnimationNodeStateMachinePlayback_is_playing :: MethodBind bindAnimationNodeStateMachinePlayback_is_playing = unsafePerformIO $ withCString "AnimationNodeStateMachinePlayback" $ \ clsNamePtr -> withCString "is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if an animation is playing. is_playing :: (AnimationNodeStateMachinePlayback :< cls, Object :< cls) => cls -> IO Bool is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachinePlayback_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachinePlayback "is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeStateMachinePlayback.is_playing {-# NOINLINE bindAnimationNodeStateMachinePlayback_start #-} -- | Starts playing the given animation. bindAnimationNodeStateMachinePlayback_start :: MethodBind bindAnimationNodeStateMachinePlayback_start = unsafePerformIO $ withCString "AnimationNodeStateMachinePlayback" $ \ clsNamePtr -> withCString "start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts playing the given animation. start :: (AnimationNodeStateMachinePlayback :< cls, Object :< cls) => cls -> GodotString -> IO () start cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachinePlayback_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachinePlayback "start" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachinePlayback.start {-# NOINLINE bindAnimationNodeStateMachinePlayback_stop #-} -- | Stops the currently playing animation. bindAnimationNodeStateMachinePlayback_stop :: MethodBind bindAnimationNodeStateMachinePlayback_stop = unsafePerformIO $ withCString "AnimationNodeStateMachinePlayback" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the currently playing animation. stop :: (AnimationNodeStateMachinePlayback :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachinePlayback_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachinePlayback "stop" '[] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachinePlayback.stop {-# NOINLINE bindAnimationNodeStateMachinePlayback_travel #-} -- | Transitions from the current state to another one, following the shortest path. bindAnimationNodeStateMachinePlayback_travel :: MethodBind bindAnimationNodeStateMachinePlayback_travel = unsafePerformIO $ withCString "AnimationNodeStateMachinePlayback" $ \ clsNamePtr -> withCString "travel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Transitions from the current state to another one, following the shortest path. travel :: (AnimationNodeStateMachinePlayback :< cls, Object :< cls) => cls -> GodotString -> IO () travel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachinePlayback_travel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachinePlayback "travel" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachinePlayback.travel ================================================ FILE: src/Godot/Core/AnimationNodeStateMachineTransition.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeStateMachineTransition (Godot.Core.AnimationNodeStateMachineTransition._SWITCH_MODE_IMMEDIATE, Godot.Core.AnimationNodeStateMachineTransition._SWITCH_MODE_SYNC, Godot.Core.AnimationNodeStateMachineTransition._SWITCH_MODE_AT_END, Godot.Core.AnimationNodeStateMachineTransition.sig_advance_condition_changed, Godot.Core.AnimationNodeStateMachineTransition.get_advance_condition, Godot.Core.AnimationNodeStateMachineTransition.get_priority, Godot.Core.AnimationNodeStateMachineTransition.get_switch_mode, Godot.Core.AnimationNodeStateMachineTransition.get_xfade_time, Godot.Core.AnimationNodeStateMachineTransition.has_auto_advance, Godot.Core.AnimationNodeStateMachineTransition.is_disabled, Godot.Core.AnimationNodeStateMachineTransition.set_advance_condition, Godot.Core.AnimationNodeStateMachineTransition.set_auto_advance, Godot.Core.AnimationNodeStateMachineTransition.set_disabled, Godot.Core.AnimationNodeStateMachineTransition.set_priority, Godot.Core.AnimationNodeStateMachineTransition.set_switch_mode, Godot.Core.AnimationNodeStateMachineTransition.set_xfade_time) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _SWITCH_MODE_IMMEDIATE :: Int _SWITCH_MODE_IMMEDIATE = 0 _SWITCH_MODE_SYNC :: Int _SWITCH_MODE_SYNC = 1 _SWITCH_MODE_AT_END :: Int _SWITCH_MODE_AT_END = 2 -- | Emitted when @advance_condition@ is changed. sig_advance_condition_changed :: Godot.Internal.Dispatch.Signal AnimationNodeStateMachineTransition sig_advance_condition_changed = Godot.Internal.Dispatch.Signal "advance_condition_changed" instance NodeSignal AnimationNodeStateMachineTransition "advance_condition_changed" '[] instance NodeProperty AnimationNodeStateMachineTransition "advance_condition" GodotString 'False where nodeProperty = (get_advance_condition, wrapDroppingSetter set_advance_condition, Nothing) instance NodeProperty AnimationNodeStateMachineTransition "auto_advance" Bool 'False where nodeProperty = (has_auto_advance, wrapDroppingSetter set_auto_advance, Nothing) instance NodeProperty AnimationNodeStateMachineTransition "disabled" Bool 'False where nodeProperty = (is_disabled, wrapDroppingSetter set_disabled, Nothing) instance NodeProperty AnimationNodeStateMachineTransition "priority" Int 'False where nodeProperty = (get_priority, wrapDroppingSetter set_priority, Nothing) instance NodeProperty AnimationNodeStateMachineTransition "switch_mode" Int 'False where nodeProperty = (get_switch_mode, wrapDroppingSetter set_switch_mode, Nothing) instance NodeProperty AnimationNodeStateMachineTransition "xfade_time" Float 'False where nodeProperty = (get_xfade_time, wrapDroppingSetter set_xfade_time, Nothing) {-# NOINLINE bindAnimationNodeStateMachineTransition_get_advance_condition #-} -- | Turn on auto advance when this condition is set. The provided name will become a boolean parameter on the @AnimationTree@ that can be controlled from code (see @url=https://docs.godotengine.org/en/latest/tutorials/animation/animation_tree.html#controlling-from-code@@/url@). For example, if @AnimationTree.tree_root@ is an @AnimationNodeStateMachine@ and @advance_condition@ is set to @"idle"@: -- -- @ -- -- $animation_tree@"parameters/conditions/idle"@ = is_on_floor and (linear_velocity.x == 0) -- -- @ bindAnimationNodeStateMachineTransition_get_advance_condition :: MethodBind bindAnimationNodeStateMachineTransition_get_advance_condition = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "get_advance_condition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Turn on auto advance when this condition is set. The provided name will become a boolean parameter on the @AnimationTree@ that can be controlled from code (see @url=https://docs.godotengine.org/en/latest/tutorials/animation/animation_tree.html#controlling-from-code@@/url@). For example, if @AnimationTree.tree_root@ is an @AnimationNodeStateMachine@ and @advance_condition@ is set to @"idle"@: -- -- @ -- -- $animation_tree@"parameters/conditions/idle"@ = is_on_floor and (linear_velocity.x == 0) -- -- @ get_advance_condition :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> IO GodotString get_advance_condition cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_get_advance_condition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "get_advance_condition" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.get_advance_condition {-# NOINLINE bindAnimationNodeStateMachineTransition_get_priority #-} -- | Lower priority transitions are preferred when travelling through the tree via @method AnimationNodeStateMachinePlayback.travel@ or @auto_advance@. bindAnimationNodeStateMachineTransition_get_priority :: MethodBind bindAnimationNodeStateMachineTransition_get_priority = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "get_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Lower priority transitions are preferred when travelling through the tree via @method AnimationNodeStateMachinePlayback.travel@ or @auto_advance@. get_priority :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> IO Int get_priority cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_get_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "get_priority" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.get_priority {-# NOINLINE bindAnimationNodeStateMachineTransition_get_switch_mode #-} -- | The transition type. bindAnimationNodeStateMachineTransition_get_switch_mode :: MethodBind bindAnimationNodeStateMachineTransition_get_switch_mode = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "get_switch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The transition type. get_switch_mode :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> IO Int get_switch_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_get_switch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "get_switch_mode" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.get_switch_mode {-# NOINLINE bindAnimationNodeStateMachineTransition_get_xfade_time #-} -- | The time to cross-fade between this state and the next. bindAnimationNodeStateMachineTransition_get_xfade_time :: MethodBind bindAnimationNodeStateMachineTransition_get_xfade_time = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "get_xfade_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The time to cross-fade between this state and the next. get_xfade_time :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> IO Float get_xfade_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_get_xfade_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "get_xfade_time" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.get_xfade_time {-# NOINLINE bindAnimationNodeStateMachineTransition_has_auto_advance #-} -- | Turn on the transition automatically when this state is reached. This works best with @SWITCH_MODE_AT_END@. bindAnimationNodeStateMachineTransition_has_auto_advance :: MethodBind bindAnimationNodeStateMachineTransition_has_auto_advance = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "has_auto_advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Turn on the transition automatically when this state is reached. This works best with @SWITCH_MODE_AT_END@. has_auto_advance :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> IO Bool has_auto_advance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_has_auto_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "has_auto_advance" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.has_auto_advance {-# NOINLINE bindAnimationNodeStateMachineTransition_is_disabled #-} -- | Don't use this transition during @method AnimationNodeStateMachinePlayback.travel@ or @auto_advance@. bindAnimationNodeStateMachineTransition_is_disabled :: MethodBind bindAnimationNodeStateMachineTransition_is_disabled = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "is_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Don't use this transition during @method AnimationNodeStateMachinePlayback.travel@ or @auto_advance@. is_disabled :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> IO Bool is_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_is_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "is_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.is_disabled {-# NOINLINE bindAnimationNodeStateMachineTransition_set_advance_condition #-} -- | Turn on auto advance when this condition is set. The provided name will become a boolean parameter on the @AnimationTree@ that can be controlled from code (see @url=https://docs.godotengine.org/en/latest/tutorials/animation/animation_tree.html#controlling-from-code@@/url@). For example, if @AnimationTree.tree_root@ is an @AnimationNodeStateMachine@ and @advance_condition@ is set to @"idle"@: -- -- @ -- -- $animation_tree@"parameters/conditions/idle"@ = is_on_floor and (linear_velocity.x == 0) -- -- @ bindAnimationNodeStateMachineTransition_set_advance_condition :: MethodBind bindAnimationNodeStateMachineTransition_set_advance_condition = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "set_advance_condition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Turn on auto advance when this condition is set. The provided name will become a boolean parameter on the @AnimationTree@ that can be controlled from code (see @url=https://docs.godotengine.org/en/latest/tutorials/animation/animation_tree.html#controlling-from-code@@/url@). For example, if @AnimationTree.tree_root@ is an @AnimationNodeStateMachine@ and @advance_condition@ is set to @"idle"@: -- -- @ -- -- $animation_tree@"parameters/conditions/idle"@ = is_on_floor and (linear_velocity.x == 0) -- -- @ set_advance_condition :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> GodotString -> IO () set_advance_condition cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_set_advance_condition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "set_advance_condition" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.set_advance_condition {-# NOINLINE bindAnimationNodeStateMachineTransition_set_auto_advance #-} -- | Turn on the transition automatically when this state is reached. This works best with @SWITCH_MODE_AT_END@. bindAnimationNodeStateMachineTransition_set_auto_advance :: MethodBind bindAnimationNodeStateMachineTransition_set_auto_advance = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "set_auto_advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Turn on the transition automatically when this state is reached. This works best with @SWITCH_MODE_AT_END@. set_auto_advance :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> Bool -> IO () set_auto_advance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_set_auto_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "set_auto_advance" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.set_auto_advance {-# NOINLINE bindAnimationNodeStateMachineTransition_set_disabled #-} -- | Don't use this transition during @method AnimationNodeStateMachinePlayback.travel@ or @auto_advance@. bindAnimationNodeStateMachineTransition_set_disabled :: MethodBind bindAnimationNodeStateMachineTransition_set_disabled = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "set_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Don't use this transition during @method AnimationNodeStateMachinePlayback.travel@ or @auto_advance@. set_disabled :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> Bool -> IO () set_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_set_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "set_disabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.set_disabled {-# NOINLINE bindAnimationNodeStateMachineTransition_set_priority #-} -- | Lower priority transitions are preferred when travelling through the tree via @method AnimationNodeStateMachinePlayback.travel@ or @auto_advance@. bindAnimationNodeStateMachineTransition_set_priority :: MethodBind bindAnimationNodeStateMachineTransition_set_priority = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "set_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Lower priority transitions are preferred when travelling through the tree via @method AnimationNodeStateMachinePlayback.travel@ or @auto_advance@. set_priority :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> Int -> IO () set_priority cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_set_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "set_priority" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.set_priority {-# NOINLINE bindAnimationNodeStateMachineTransition_set_switch_mode #-} -- | The transition type. bindAnimationNodeStateMachineTransition_set_switch_mode :: MethodBind bindAnimationNodeStateMachineTransition_set_switch_mode = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "set_switch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The transition type. set_switch_mode :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> Int -> IO () set_switch_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_set_switch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "set_switch_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.set_switch_mode {-# NOINLINE bindAnimationNodeStateMachineTransition_set_xfade_time #-} -- | The time to cross-fade between this state and the next. bindAnimationNodeStateMachineTransition_set_xfade_time :: MethodBind bindAnimationNodeStateMachineTransition_set_xfade_time = unsafePerformIO $ withCString "AnimationNodeStateMachineTransition" $ \ clsNamePtr -> withCString "set_xfade_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The time to cross-fade between this state and the next. set_xfade_time :: (AnimationNodeStateMachineTransition :< cls, Object :< cls) => cls -> Float -> IO () set_xfade_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeStateMachineTransition_set_xfade_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeStateMachineTransition "set_xfade_time" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeStateMachineTransition.set_xfade_time ================================================ FILE: src/Godot/Core/AnimationNodeTimeScale.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeTimeScale () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() ================================================ FILE: src/Godot/Core/AnimationNodeTimeSeek.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeTimeSeek () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() ================================================ FILE: src/Godot/Core/AnimationNodeTransition.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationNodeTransition (Godot.Core.AnimationNodeTransition.get_cross_fade_time, Godot.Core.AnimationNodeTransition.get_enabled_inputs, Godot.Core.AnimationNodeTransition.get_input_caption, Godot.Core.AnimationNodeTransition.is_input_set_as_auto_advance, Godot.Core.AnimationNodeTransition.set_cross_fade_time, Godot.Core.AnimationNodeTransition.set_enabled_inputs, Godot.Core.AnimationNodeTransition.set_input_as_auto_advance, Godot.Core.AnimationNodeTransition.set_input_caption) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() instance NodeProperty AnimationNodeTransition "input_0/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 0 is_input_set_as_auto_advance, wrapIndexedSetter 0 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_0/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 0 get_input_caption, wrapIndexedSetter 0 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_1/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 1 is_input_set_as_auto_advance, wrapIndexedSetter 1 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_1/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 1 get_input_caption, wrapIndexedSetter 1 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_10/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 10 is_input_set_as_auto_advance, wrapIndexedSetter 10 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_10/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 10 get_input_caption, wrapIndexedSetter 10 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_11/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 11 is_input_set_as_auto_advance, wrapIndexedSetter 11 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_11/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 11 get_input_caption, wrapIndexedSetter 11 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_12/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 12 is_input_set_as_auto_advance, wrapIndexedSetter 12 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_12/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 12 get_input_caption, wrapIndexedSetter 12 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_13/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 13 is_input_set_as_auto_advance, wrapIndexedSetter 13 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_13/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 13 get_input_caption, wrapIndexedSetter 13 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_14/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 14 is_input_set_as_auto_advance, wrapIndexedSetter 14 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_14/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 14 get_input_caption, wrapIndexedSetter 14 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_15/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 15 is_input_set_as_auto_advance, wrapIndexedSetter 15 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_15/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 15 get_input_caption, wrapIndexedSetter 15 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_16/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 16 is_input_set_as_auto_advance, wrapIndexedSetter 16 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_16/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 16 get_input_caption, wrapIndexedSetter 16 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_17/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 17 is_input_set_as_auto_advance, wrapIndexedSetter 17 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_17/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 17 get_input_caption, wrapIndexedSetter 17 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_18/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 18 is_input_set_as_auto_advance, wrapIndexedSetter 18 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_18/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 18 get_input_caption, wrapIndexedSetter 18 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_19/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 19 is_input_set_as_auto_advance, wrapIndexedSetter 19 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_19/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 19 get_input_caption, wrapIndexedSetter 19 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_2/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 2 is_input_set_as_auto_advance, wrapIndexedSetter 2 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_2/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 2 get_input_caption, wrapIndexedSetter 2 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_20/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 20 is_input_set_as_auto_advance, wrapIndexedSetter 20 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_20/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 20 get_input_caption, wrapIndexedSetter 20 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_21/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 21 is_input_set_as_auto_advance, wrapIndexedSetter 21 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_21/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 21 get_input_caption, wrapIndexedSetter 21 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_22/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 22 is_input_set_as_auto_advance, wrapIndexedSetter 22 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_22/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 22 get_input_caption, wrapIndexedSetter 22 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_23/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 23 is_input_set_as_auto_advance, wrapIndexedSetter 23 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_23/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 23 get_input_caption, wrapIndexedSetter 23 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_24/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 24 is_input_set_as_auto_advance, wrapIndexedSetter 24 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_24/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 24 get_input_caption, wrapIndexedSetter 24 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_25/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 25 is_input_set_as_auto_advance, wrapIndexedSetter 25 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_25/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 25 get_input_caption, wrapIndexedSetter 25 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_26/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 26 is_input_set_as_auto_advance, wrapIndexedSetter 26 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_26/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 26 get_input_caption, wrapIndexedSetter 26 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_27/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 27 is_input_set_as_auto_advance, wrapIndexedSetter 27 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_27/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 27 get_input_caption, wrapIndexedSetter 27 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_28/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 28 is_input_set_as_auto_advance, wrapIndexedSetter 28 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_28/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 28 get_input_caption, wrapIndexedSetter 28 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_29/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 29 is_input_set_as_auto_advance, wrapIndexedSetter 29 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_29/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 29 get_input_caption, wrapIndexedSetter 29 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_3/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 3 is_input_set_as_auto_advance, wrapIndexedSetter 3 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_3/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 3 get_input_caption, wrapIndexedSetter 3 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_30/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 30 is_input_set_as_auto_advance, wrapIndexedSetter 30 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_30/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 30 get_input_caption, wrapIndexedSetter 30 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_31/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 31 is_input_set_as_auto_advance, wrapIndexedSetter 31 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_31/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 31 get_input_caption, wrapIndexedSetter 31 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_4/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 4 is_input_set_as_auto_advance, wrapIndexedSetter 4 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_4/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 4 get_input_caption, wrapIndexedSetter 4 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_5/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 5 is_input_set_as_auto_advance, wrapIndexedSetter 5 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_5/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 5 get_input_caption, wrapIndexedSetter 5 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_6/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 6 is_input_set_as_auto_advance, wrapIndexedSetter 6 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_6/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 6 get_input_caption, wrapIndexedSetter 6 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_7/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 7 is_input_set_as_auto_advance, wrapIndexedSetter 7 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_7/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 7 get_input_caption, wrapIndexedSetter 7 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_8/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 8 is_input_set_as_auto_advance, wrapIndexedSetter 8 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_8/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 8 get_input_caption, wrapIndexedSetter 8 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_9/auto_advance" Bool 'False where nodeProperty = (wrapIndexedGetter 9 is_input_set_as_auto_advance, wrapIndexedSetter 9 set_input_as_auto_advance, Nothing) instance NodeProperty AnimationNodeTransition "input_9/name" GodotString 'False where nodeProperty = (wrapIndexedGetter 9 get_input_caption, wrapIndexedSetter 9 set_input_caption, Nothing) instance NodeProperty AnimationNodeTransition "input_count" Int 'False where nodeProperty = (get_enabled_inputs, wrapDroppingSetter set_enabled_inputs, Nothing) instance NodeProperty AnimationNodeTransition "xfade_time" Float 'False where nodeProperty = (get_cross_fade_time, wrapDroppingSetter set_cross_fade_time, Nothing) {-# NOINLINE bindAnimationNodeTransition_get_cross_fade_time #-} -- | Cross-fading time (in seconds) between each animation connected to the inputs. bindAnimationNodeTransition_get_cross_fade_time :: MethodBind bindAnimationNodeTransition_get_cross_fade_time = unsafePerformIO $ withCString "AnimationNodeTransition" $ \ clsNamePtr -> withCString "get_cross_fade_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Cross-fading time (in seconds) between each animation connected to the inputs. get_cross_fade_time :: (AnimationNodeTransition :< cls, Object :< cls) => cls -> IO Float get_cross_fade_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeTransition_get_cross_fade_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeTransition "get_cross_fade_time" '[] (IO Float) where nodeMethod = Godot.Core.AnimationNodeTransition.get_cross_fade_time {-# NOINLINE bindAnimationNodeTransition_get_enabled_inputs #-} -- | The number of available input ports for this node. bindAnimationNodeTransition_get_enabled_inputs :: MethodBind bindAnimationNodeTransition_get_enabled_inputs = unsafePerformIO $ withCString "AnimationNodeTransition" $ \ clsNamePtr -> withCString "get_enabled_inputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of available input ports for this node. get_enabled_inputs :: (AnimationNodeTransition :< cls, Object :< cls) => cls -> IO Int get_enabled_inputs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeTransition_get_enabled_inputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeTransition "get_enabled_inputs" '[] (IO Int) where nodeMethod = Godot.Core.AnimationNodeTransition.get_enabled_inputs {-# NOINLINE bindAnimationNodeTransition_get_input_caption #-} bindAnimationNodeTransition_get_input_caption :: MethodBind bindAnimationNodeTransition_get_input_caption = unsafePerformIO $ withCString "AnimationNodeTransition" $ \ clsNamePtr -> withCString "get_input_caption" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_input_caption :: (AnimationNodeTransition :< cls, Object :< cls) => cls -> Int -> IO GodotString get_input_caption cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeTransition_get_input_caption (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeTransition "get_input_caption" '[Int] (IO GodotString) where nodeMethod = Godot.Core.AnimationNodeTransition.get_input_caption {-# NOINLINE bindAnimationNodeTransition_is_input_set_as_auto_advance #-} bindAnimationNodeTransition_is_input_set_as_auto_advance :: MethodBind bindAnimationNodeTransition_is_input_set_as_auto_advance = unsafePerformIO $ withCString "AnimationNodeTransition" $ \ clsNamePtr -> withCString "is_input_set_as_auto_advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_input_set_as_auto_advance :: (AnimationNodeTransition :< cls, Object :< cls) => cls -> Int -> IO Bool is_input_set_as_auto_advance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeTransition_is_input_set_as_auto_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeTransition "is_input_set_as_auto_advance" '[Int] (IO Bool) where nodeMethod = Godot.Core.AnimationNodeTransition.is_input_set_as_auto_advance {-# NOINLINE bindAnimationNodeTransition_set_cross_fade_time #-} -- | Cross-fading time (in seconds) between each animation connected to the inputs. bindAnimationNodeTransition_set_cross_fade_time :: MethodBind bindAnimationNodeTransition_set_cross_fade_time = unsafePerformIO $ withCString "AnimationNodeTransition" $ \ clsNamePtr -> withCString "set_cross_fade_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Cross-fading time (in seconds) between each animation connected to the inputs. set_cross_fade_time :: (AnimationNodeTransition :< cls, Object :< cls) => cls -> Float -> IO () set_cross_fade_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeTransition_set_cross_fade_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeTransition "set_cross_fade_time" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationNodeTransition.set_cross_fade_time {-# NOINLINE bindAnimationNodeTransition_set_enabled_inputs #-} -- | The number of available input ports for this node. bindAnimationNodeTransition_set_enabled_inputs :: MethodBind bindAnimationNodeTransition_set_enabled_inputs = unsafePerformIO $ withCString "AnimationNodeTransition" $ \ clsNamePtr -> withCString "set_enabled_inputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of available input ports for this node. set_enabled_inputs :: (AnimationNodeTransition :< cls, Object :< cls) => cls -> Int -> IO () set_enabled_inputs cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeTransition_set_enabled_inputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeTransition "set_enabled_inputs" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationNodeTransition.set_enabled_inputs {-# NOINLINE bindAnimationNodeTransition_set_input_as_auto_advance #-} bindAnimationNodeTransition_set_input_as_auto_advance :: MethodBind bindAnimationNodeTransition_set_input_as_auto_advance = unsafePerformIO $ withCString "AnimationNodeTransition" $ \ clsNamePtr -> withCString "set_input_as_auto_advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_input_as_auto_advance :: (AnimationNodeTransition :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_input_as_auto_advance cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeTransition_set_input_as_auto_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeTransition "set_input_as_auto_advance" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.AnimationNodeTransition.set_input_as_auto_advance {-# NOINLINE bindAnimationNodeTransition_set_input_caption #-} bindAnimationNodeTransition_set_input_caption :: MethodBind bindAnimationNodeTransition_set_input_caption = unsafePerformIO $ withCString "AnimationNodeTransition" $ \ clsNamePtr -> withCString "set_input_caption" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_input_caption :: (AnimationNodeTransition :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_input_caption cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationNodeTransition_set_input_caption (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationNodeTransition "set_input_caption" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationNodeTransition.set_input_caption ================================================ FILE: src/Godot/Core/AnimationPlayer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationPlayer (Godot.Core.AnimationPlayer._ANIMATION_METHOD_CALL_IMMEDIATE, Godot.Core.AnimationPlayer._ANIMATION_METHOD_CALL_DEFERRED, Godot.Core.AnimationPlayer._ANIMATION_PROCESS_MANUAL, Godot.Core.AnimationPlayer._ANIMATION_PROCESS_PHYSICS, Godot.Core.AnimationPlayer._ANIMATION_PROCESS_IDLE, Godot.Core.AnimationPlayer.sig_animation_changed, Godot.Core.AnimationPlayer.sig_animation_finished, Godot.Core.AnimationPlayer.sig_animation_started, Godot.Core.AnimationPlayer.sig_caches_cleared, Godot.Core.AnimationPlayer._animation_changed, Godot.Core.AnimationPlayer._node_removed, Godot.Core.AnimationPlayer.add_animation, Godot.Core.AnimationPlayer.advance, Godot.Core.AnimationPlayer.animation_get_next, Godot.Core.AnimationPlayer.animation_set_next, Godot.Core.AnimationPlayer.clear_caches, Godot.Core.AnimationPlayer.clear_queue, Godot.Core.AnimationPlayer.find_animation, Godot.Core.AnimationPlayer.get_animation, Godot.Core.AnimationPlayer.get_animation_list, Godot.Core.AnimationPlayer.get_animation_process_mode, Godot.Core.AnimationPlayer.get_assigned_animation, Godot.Core.AnimationPlayer.get_autoplay, Godot.Core.AnimationPlayer.get_blend_time, Godot.Core.AnimationPlayer.get_current_animation, Godot.Core.AnimationPlayer.get_current_animation_length, Godot.Core.AnimationPlayer.get_current_animation_position, Godot.Core.AnimationPlayer.get_default_blend_time, Godot.Core.AnimationPlayer.get_method_call_mode, Godot.Core.AnimationPlayer.get_playing_speed, Godot.Core.AnimationPlayer.get_queue, Godot.Core.AnimationPlayer.get_root, Godot.Core.AnimationPlayer.get_speed_scale, Godot.Core.AnimationPlayer.has_animation, Godot.Core.AnimationPlayer.is_active, Godot.Core.AnimationPlayer.is_playing, Godot.Core.AnimationPlayer.play, Godot.Core.AnimationPlayer.play_backwards, Godot.Core.AnimationPlayer.queue, Godot.Core.AnimationPlayer.remove_animation, Godot.Core.AnimationPlayer.rename_animation, Godot.Core.AnimationPlayer.seek, Godot.Core.AnimationPlayer.set_active, Godot.Core.AnimationPlayer.set_animation_process_mode, Godot.Core.AnimationPlayer.set_assigned_animation, Godot.Core.AnimationPlayer.set_autoplay, Godot.Core.AnimationPlayer.set_blend_time, Godot.Core.AnimationPlayer.set_current_animation, Godot.Core.AnimationPlayer.set_default_blend_time, Godot.Core.AnimationPlayer.set_method_call_mode, Godot.Core.AnimationPlayer.set_root, Godot.Core.AnimationPlayer.set_speed_scale, Godot.Core.AnimationPlayer.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _ANIMATION_METHOD_CALL_IMMEDIATE :: Int _ANIMATION_METHOD_CALL_IMMEDIATE = 1 _ANIMATION_METHOD_CALL_DEFERRED :: Int _ANIMATION_METHOD_CALL_DEFERRED = 0 _ANIMATION_PROCESS_MANUAL :: Int _ANIMATION_PROCESS_MANUAL = 2 _ANIMATION_PROCESS_PHYSICS :: Int _ANIMATION_PROCESS_PHYSICS = 0 _ANIMATION_PROCESS_IDLE :: Int _ANIMATION_PROCESS_IDLE = 1 -- | If the currently being played animation changes, this signal will notify of such change. sig_animation_changed :: Godot.Internal.Dispatch.Signal AnimationPlayer sig_animation_changed = Godot.Internal.Dispatch.Signal "animation_changed" instance NodeSignal AnimationPlayer "animation_changed" '[GodotString, GodotString] -- | Notifies when an animation finished playing. sig_animation_finished :: Godot.Internal.Dispatch.Signal AnimationPlayer sig_animation_finished = Godot.Internal.Dispatch.Signal "animation_finished" instance NodeSignal AnimationPlayer "animation_finished" '[GodotString] -- | Notifies when an animation starts playing. sig_animation_started :: Godot.Internal.Dispatch.Signal AnimationPlayer sig_animation_started = Godot.Internal.Dispatch.Signal "animation_started" instance NodeSignal AnimationPlayer "animation_started" '[GodotString] -- | Notifies when the caches have been cleared, either automatically, or manually via @method clear_caches@. sig_caches_cleared :: Godot.Internal.Dispatch.Signal AnimationPlayer sig_caches_cleared = Godot.Internal.Dispatch.Signal "caches_cleared" instance NodeSignal AnimationPlayer "caches_cleared" '[] instance NodeProperty AnimationPlayer "assigned_animation" GodotString 'False where nodeProperty = (get_assigned_animation, wrapDroppingSetter set_assigned_animation, Nothing) instance NodeProperty AnimationPlayer "autoplay" GodotString 'False where nodeProperty = (get_autoplay, wrapDroppingSetter set_autoplay, Nothing) instance NodeProperty AnimationPlayer "current_animation" GodotString 'False where nodeProperty = (get_current_animation, wrapDroppingSetter set_current_animation, Nothing) instance NodeProperty AnimationPlayer "current_animation_length" Float 'True where nodeProperty = (get_current_animation_length, (), Nothing) instance NodeProperty AnimationPlayer "current_animation_position" Float 'True where nodeProperty = (get_current_animation_position, (), Nothing) instance NodeProperty AnimationPlayer "method_call_mode" Int 'False where nodeProperty = (get_method_call_mode, wrapDroppingSetter set_method_call_mode, Nothing) instance NodeProperty AnimationPlayer "playback_active" Bool 'False where nodeProperty = (is_active, wrapDroppingSetter set_active, Nothing) instance NodeProperty AnimationPlayer "playback_default_blend_time" Float 'False where nodeProperty = (get_default_blend_time, wrapDroppingSetter set_default_blend_time, Nothing) instance NodeProperty AnimationPlayer "playback_process_mode" Int 'False where nodeProperty = (get_animation_process_mode, wrapDroppingSetter set_animation_process_mode, Nothing) instance NodeProperty AnimationPlayer "playback_speed" Float 'False where nodeProperty = (get_speed_scale, wrapDroppingSetter set_speed_scale, Nothing) instance NodeProperty AnimationPlayer "root_node" NodePath 'False where nodeProperty = (get_root, wrapDroppingSetter set_root, Nothing) {-# NOINLINE bindAnimationPlayer__animation_changed #-} bindAnimationPlayer__animation_changed :: MethodBind bindAnimationPlayer__animation_changed = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "_animation_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _animation_changed :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO () _animation_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer__animation_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "_animation_changed" '[] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer._animation_changed {-# NOINLINE bindAnimationPlayer__node_removed #-} bindAnimationPlayer__node_removed :: MethodBind bindAnimationPlayer__node_removed = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "_node_removed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _node_removed :: (AnimationPlayer :< cls, Object :< cls) => cls -> Node -> IO () _node_removed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer__node_removed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "_node_removed" '[Node] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer._node_removed {-# NOINLINE bindAnimationPlayer_add_animation #-} -- | Adds @animation@ to the player accessible with the key @name@. bindAnimationPlayer_add_animation :: MethodBind bindAnimationPlayer_add_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "add_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds @animation@ to the player accessible with the key @name@. add_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> Animation -> IO Int add_animation cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_add_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "add_animation" '[GodotString, Animation] (IO Int) where nodeMethod = Godot.Core.AnimationPlayer.add_animation {-# NOINLINE bindAnimationPlayer_advance #-} -- | Shifts position in the animation timeline and immediately updates the animation. @delta@ is the time in seconds to shift. Events between the current frame and @delta@ are handled. bindAnimationPlayer_advance :: MethodBind bindAnimationPlayer_advance = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shifts position in the animation timeline and immediately updates the animation. @delta@ is the time in seconds to shift. Events between the current frame and @delta@ are handled. advance :: (AnimationPlayer :< cls, Object :< cls) => cls -> Float -> IO () advance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "advance" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.advance {-# NOINLINE bindAnimationPlayer_animation_get_next #-} -- | Returns the name of the next animation in the queue. bindAnimationPlayer_animation_get_next :: MethodBind bindAnimationPlayer_animation_get_next = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "animation_get_next" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the next animation in the queue. animation_get_next :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> IO GodotString animation_get_next cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_animation_get_next (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "animation_get_next" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.AnimationPlayer.animation_get_next {-# NOINLINE bindAnimationPlayer_animation_set_next #-} -- | Triggers the @anim_to@ animation when the @anim_from@ animation completes. bindAnimationPlayer_animation_set_next :: MethodBind bindAnimationPlayer_animation_set_next = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "animation_set_next" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Triggers the @anim_to@ animation when the @anim_from@ animation completes. animation_set_next :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () animation_set_next cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_animation_set_next (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "animation_set_next" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.animation_set_next {-# NOINLINE bindAnimationPlayer_clear_caches #-} -- | @AnimationPlayer@ caches animated nodes. It may not notice if a node disappears; @method clear_caches@ forces it to update the cache again. bindAnimationPlayer_clear_caches :: MethodBind bindAnimationPlayer_clear_caches = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "clear_caches" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @AnimationPlayer@ caches animated nodes. It may not notice if a node disappears; @method clear_caches@ forces it to update the cache again. clear_caches :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO () clear_caches cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_clear_caches (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "clear_caches" '[] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.clear_caches {-# NOINLINE bindAnimationPlayer_clear_queue #-} -- | Clears all queued, unplayed animations. bindAnimationPlayer_clear_queue :: MethodBind bindAnimationPlayer_clear_queue = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "clear_queue" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all queued, unplayed animations. clear_queue :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO () clear_queue cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_clear_queue (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "clear_queue" '[] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.clear_queue {-# NOINLINE bindAnimationPlayer_find_animation #-} -- | Returns the name of @animation@ or an empty string if not found. bindAnimationPlayer_find_animation :: MethodBind bindAnimationPlayer_find_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "find_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of @animation@ or an empty string if not found. find_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> Animation -> IO GodotString find_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_find_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "find_animation" '[Animation] (IO GodotString) where nodeMethod = Godot.Core.AnimationPlayer.find_animation {-# NOINLINE bindAnimationPlayer_get_animation #-} -- | Returns the @Animation@ with key @name@ or @null@ if not found. bindAnimationPlayer_get_animation :: MethodBind bindAnimationPlayer_get_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Animation@ with key @name@ or @null@ if not found. get_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> IO Animation get_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_animation" '[GodotString] (IO Animation) where nodeMethod = Godot.Core.AnimationPlayer.get_animation {-# NOINLINE bindAnimationPlayer_get_animation_list #-} -- | Returns the list of stored animation names. bindAnimationPlayer_get_animation_list :: MethodBind bindAnimationPlayer_get_animation_list = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_animation_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of stored animation names. get_animation_list :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO PoolStringArray get_animation_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_animation_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_animation_list" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.AnimationPlayer.get_animation_list {-# NOINLINE bindAnimationPlayer_get_animation_process_mode #-} -- | The process notification in which to update animations. bindAnimationPlayer_get_animation_process_mode :: MethodBind bindAnimationPlayer_get_animation_process_mode = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_animation_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The process notification in which to update animations. get_animation_process_mode :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Int get_animation_process_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_animation_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_animation_process_mode" '[] (IO Int) where nodeMethod = Godot.Core.AnimationPlayer.get_animation_process_mode {-# NOINLINE bindAnimationPlayer_get_assigned_animation #-} -- | If playing, the current animation; otherwise, the animation last played. When set, would change the animation, but would not play it unless currently playing. See also @current_animation@. bindAnimationPlayer_get_assigned_animation :: MethodBind bindAnimationPlayer_get_assigned_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_assigned_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If playing, the current animation; otherwise, the animation last played. When set, would change the animation, but would not play it unless currently playing. See also @current_animation@. get_assigned_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO GodotString get_assigned_animation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_assigned_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_assigned_animation" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationPlayer.get_assigned_animation {-# NOINLINE bindAnimationPlayer_get_autoplay #-} -- | The name of the animation to play when the scene loads. bindAnimationPlayer_get_autoplay :: MethodBind bindAnimationPlayer_get_autoplay = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_autoplay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the animation to play when the scene loads. get_autoplay :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO GodotString get_autoplay cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_autoplay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_autoplay" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationPlayer.get_autoplay {-# NOINLINE bindAnimationPlayer_get_blend_time #-} -- | Gets the blend time (in seconds) between two animations, referenced by their names. bindAnimationPlayer_get_blend_time :: MethodBind bindAnimationPlayer_get_blend_time = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_blend_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the blend time (in seconds) between two animations, referenced by their names. get_blend_time :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Float get_blend_time cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_blend_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_blend_time" '[GodotString, GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationPlayer.get_blend_time {-# NOINLINE bindAnimationPlayer_get_current_animation #-} -- | The name of the currently playing animation. If no animation is playing, the property's value is an empty string. Changing this value does not restart the animation. See @method play@ for more information on playing animations. -- __Note__: while this property appears in the inspector, it's not meant to be edited and it's not saved in the scene. This property is mainly used to get the currently playing animation, and internally for animation playback tracks. For more information, see @Animation@. bindAnimationPlayer_get_current_animation :: MethodBind bindAnimationPlayer_get_current_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_current_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the currently playing animation. If no animation is playing, the property's value is an empty string. Changing this value does not restart the animation. See @method play@ for more information on playing animations. -- __Note__: while this property appears in the inspector, it's not meant to be edited and it's not saved in the scene. This property is mainly used to get the currently playing animation, and internally for animation playback tracks. For more information, see @Animation@. get_current_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO GodotString get_current_animation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_current_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_current_animation" '[] (IO GodotString) where nodeMethod = Godot.Core.AnimationPlayer.get_current_animation {-# NOINLINE bindAnimationPlayer_get_current_animation_length #-} -- | The length (in seconds) of the currently being played animation. bindAnimationPlayer_get_current_animation_length :: MethodBind bindAnimationPlayer_get_current_animation_length = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_current_animation_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The length (in seconds) of the currently being played animation. get_current_animation_length :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Float get_current_animation_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_current_animation_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_current_animation_length" '[] (IO Float) where nodeMethod = Godot.Core.AnimationPlayer.get_current_animation_length {-# NOINLINE bindAnimationPlayer_get_current_animation_position #-} -- | The position (in seconds) of the currently playing animation. bindAnimationPlayer_get_current_animation_position :: MethodBind bindAnimationPlayer_get_current_animation_position = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_current_animation_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The position (in seconds) of the currently playing animation. get_current_animation_position :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Float get_current_animation_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_current_animation_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_current_animation_position" '[] (IO Float) where nodeMethod = Godot.Core.AnimationPlayer.get_current_animation_position {-# NOINLINE bindAnimationPlayer_get_default_blend_time #-} -- | The default time in which to blend animations. Ranges from 0 to 4096 with 0.01 precision. bindAnimationPlayer_get_default_blend_time :: MethodBind bindAnimationPlayer_get_default_blend_time = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_default_blend_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The default time in which to blend animations. Ranges from 0 to 4096 with 0.01 precision. get_default_blend_time :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Float get_default_blend_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_default_blend_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_default_blend_time" '[] (IO Float) where nodeMethod = Godot.Core.AnimationPlayer.get_default_blend_time {-# NOINLINE bindAnimationPlayer_get_method_call_mode #-} -- | The call mode to use for Call Method tracks. bindAnimationPlayer_get_method_call_mode :: MethodBind bindAnimationPlayer_get_method_call_mode = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_method_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The call mode to use for Call Method tracks. get_method_call_mode :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Int get_method_call_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_method_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_method_call_mode" '[] (IO Int) where nodeMethod = Godot.Core.AnimationPlayer.get_method_call_mode {-# NOINLINE bindAnimationPlayer_get_playing_speed #-} -- | Gets the actual playing speed of current animation or 0 if not playing. This speed is the @playback_speed@ property multiplied by @custom_speed@ argument specified when calling the @method play@ method. bindAnimationPlayer_get_playing_speed :: MethodBind bindAnimationPlayer_get_playing_speed = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_playing_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the actual playing speed of current animation or 0 if not playing. This speed is the @playback_speed@ property multiplied by @custom_speed@ argument specified when calling the @method play@ method. get_playing_speed :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Float get_playing_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_playing_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_playing_speed" '[] (IO Float) where nodeMethod = Godot.Core.AnimationPlayer.get_playing_speed {-# NOINLINE bindAnimationPlayer_get_queue #-} -- | Returns a list of the animation names that are currently queued to play. bindAnimationPlayer_get_queue :: MethodBind bindAnimationPlayer_get_queue = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_queue" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of the animation names that are currently queued to play. get_queue :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO PoolStringArray get_queue cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_queue (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_queue" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.AnimationPlayer.get_queue {-# NOINLINE bindAnimationPlayer_get_root #-} -- | The node from which node path references will travel. bindAnimationPlayer_get_root :: MethodBind bindAnimationPlayer_get_root = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node from which node path references will travel. get_root :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO NodePath get_root cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_root" '[] (IO NodePath) where nodeMethod = Godot.Core.AnimationPlayer.get_root {-# NOINLINE bindAnimationPlayer_get_speed_scale #-} -- | The speed scaling ratio. For instance, if this value is 1, then the animation plays at normal speed. If it's 0.5, then it plays at half speed. If it's 2, then it plays at double speed. bindAnimationPlayer_get_speed_scale :: MethodBind bindAnimationPlayer_get_speed_scale = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "get_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The speed scaling ratio. For instance, if this value is 1, then the animation plays at normal speed. If it's 0.5, then it plays at half speed. If it's 2, then it plays at double speed. get_speed_scale :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Float get_speed_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_get_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "get_speed_scale" '[] (IO Float) where nodeMethod = Godot.Core.AnimationPlayer.get_speed_scale {-# NOINLINE bindAnimationPlayer_has_animation #-} -- | Returns @true@ if the @AnimationPlayer@ stores an @Animation@ with key @name@. bindAnimationPlayer_has_animation :: MethodBind bindAnimationPlayer_has_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "has_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the @AnimationPlayer@ stores an @Animation@ with key @name@. has_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_has_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "has_animation" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.AnimationPlayer.has_animation {-# NOINLINE bindAnimationPlayer_is_active #-} -- | If @true@, updates animations in response to process-related notifications. bindAnimationPlayer_is_active :: MethodBind bindAnimationPlayer_is_active = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, updates animations in response to process-related notifications. is_active :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Bool is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "is_active" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationPlayer.is_active {-# NOINLINE bindAnimationPlayer_is_playing #-} -- | Returns @true@ if playing an animation. bindAnimationPlayer_is_playing :: MethodBind bindAnimationPlayer_is_playing = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if playing an animation. is_playing :: (AnimationPlayer :< cls, Object :< cls) => cls -> IO Bool is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationPlayer.is_playing {-# NOINLINE bindAnimationPlayer_play #-} -- | Plays the animation with key @name@. Custom blend times and speed can be set. If @custom_speed@ is negative and @from_end@ is @true@, the animation will play backwards (which is equivalent to calling @method play_backwards@). -- The @AnimationPlayer@ keeps track of its current or last played animation with @assigned_animation@. If this method is called with that same animation @name@, or with no @name@ parameter, the assigned animation will resume playing if it was paused, or restart if it was stopped (see @method stop@ for both pause and stop). If the animation was already playing, it will keep playing. -- __Note:__ The animation will be updated the next time the @AnimationPlayer@ is processed. If other variables are updated at the same time this is called, they may be updated too early. To perform the update immediately, call @advance(0)@. bindAnimationPlayer_play :: MethodBind bindAnimationPlayer_play = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Plays the animation with key @name@. Custom blend times and speed can be set. If @custom_speed@ is negative and @from_end@ is @true@, the animation will play backwards (which is equivalent to calling @method play_backwards@). -- The @AnimationPlayer@ keeps track of its current or last played animation with @assigned_animation@. If this method is called with that same animation @name@, or with no @name@ parameter, the assigned animation will resume playing if it was paused, or restart if it was stopped (see @method stop@ for both pause and stop). If the animation was already playing, it will keep playing. -- __Note:__ The animation will be updated the next time the @AnimationPlayer@ is processed. If other variables are updated at the same time this is called, they may be updated too early. To perform the update immediately, call @advance(0)@. play :: (AnimationPlayer :< cls, Object :< cls) => cls -> Maybe GodotString -> Maybe Float -> Maybe Float -> Maybe Bool -> IO () play cls arg1 arg2 arg3 arg4 = withVariantArray [defaultedVariant VariantString "" arg1, maybe (VariantReal (-1)) toVariant arg2, maybe (VariantReal (1)) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "play" '[Maybe GodotString, Maybe Float, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.play {-# NOINLINE bindAnimationPlayer_play_backwards #-} -- | Plays the animation with key @name@ in reverse. -- This method is a shorthand for @method play@ with @custom_speed = -1.0@ and @from_end = true@, so see its description for more information. bindAnimationPlayer_play_backwards :: MethodBind bindAnimationPlayer_play_backwards = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "play_backwards" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Plays the animation with key @name@ in reverse. -- This method is a shorthand for @method play@ with @custom_speed = -1.0@ and @from_end = true@, so see its description for more information. play_backwards :: (AnimationPlayer :< cls, Object :< cls) => cls -> Maybe GodotString -> Maybe Float -> IO () play_backwards cls arg1 arg2 = withVariantArray [defaultedVariant VariantString "" arg1, maybe (VariantReal (-1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_play_backwards (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "play_backwards" '[Maybe GodotString, Maybe Float] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.play_backwards {-# NOINLINE bindAnimationPlayer_queue #-} -- | Queues an animation for playback once the current one is done. -- __Note:__ If a looped animation is currently playing, the queued animation will never play unless the looped animation is stopped somehow. bindAnimationPlayer_queue :: MethodBind bindAnimationPlayer_queue = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "queue" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Queues an animation for playback once the current one is done. -- __Note:__ If a looped animation is currently playing, the queued animation will never play unless the looped animation is stopped somehow. queue :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> IO () queue cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_queue (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "queue" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.queue {-# NOINLINE bindAnimationPlayer_remove_animation #-} -- | Removes the animation with key @name@. bindAnimationPlayer_remove_animation :: MethodBind bindAnimationPlayer_remove_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "remove_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the animation with key @name@. remove_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> IO () remove_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_remove_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "remove_animation" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.remove_animation {-# NOINLINE bindAnimationPlayer_rename_animation #-} -- | Renames an existing animation with key @name@ to @newname@. bindAnimationPlayer_rename_animation :: MethodBind bindAnimationPlayer_rename_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "rename_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Renames an existing animation with key @name@ to @newname@. rename_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_animation cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_rename_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "rename_animation" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.rename_animation {-# NOINLINE bindAnimationPlayer_seek #-} -- | Seeks the animation to the @seconds@ point in time (in seconds). If @update@ is @true@, the animation updates too, otherwise it updates at process time. Events between the current frame and @seconds@ are skipped. bindAnimationPlayer_seek :: MethodBind bindAnimationPlayer_seek = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Seeks the animation to the @seconds@ point in time (in seconds). If @update@ is @true@, the animation updates too, otherwise it updates at process time. Events between the current frame and @seconds@ are skipped. seek :: (AnimationPlayer :< cls, Object :< cls) => cls -> Float -> Maybe Bool -> IO () seek cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "seek" '[Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.seek {-# NOINLINE bindAnimationPlayer_set_active #-} -- | If @true@, updates animations in response to process-related notifications. bindAnimationPlayer_set_active :: MethodBind bindAnimationPlayer_set_active = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, updates animations in response to process-related notifications. set_active :: (AnimationPlayer :< cls, Object :< cls) => cls -> Bool -> IO () set_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_active {-# NOINLINE bindAnimationPlayer_set_animation_process_mode #-} -- | The process notification in which to update animations. bindAnimationPlayer_set_animation_process_mode :: MethodBind bindAnimationPlayer_set_animation_process_mode = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_animation_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The process notification in which to update animations. set_animation_process_mode :: (AnimationPlayer :< cls, Object :< cls) => cls -> Int -> IO () set_animation_process_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_animation_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_animation_process_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_animation_process_mode {-# NOINLINE bindAnimationPlayer_set_assigned_animation #-} -- | If playing, the current animation; otherwise, the animation last played. When set, would change the animation, but would not play it unless currently playing. See also @current_animation@. bindAnimationPlayer_set_assigned_animation :: MethodBind bindAnimationPlayer_set_assigned_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_assigned_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If playing, the current animation; otherwise, the animation last played. When set, would change the animation, but would not play it unless currently playing. See also @current_animation@. set_assigned_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> IO () set_assigned_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_assigned_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_assigned_animation" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_assigned_animation {-# NOINLINE bindAnimationPlayer_set_autoplay #-} -- | The name of the animation to play when the scene loads. bindAnimationPlayer_set_autoplay :: MethodBind bindAnimationPlayer_set_autoplay = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_autoplay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the animation to play when the scene loads. set_autoplay :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> IO () set_autoplay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_autoplay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_autoplay" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_autoplay {-# NOINLINE bindAnimationPlayer_set_blend_time #-} -- | Specifies a blend time (in seconds) between two animations, referenced by their names. bindAnimationPlayer_set_blend_time :: MethodBind bindAnimationPlayer_set_blend_time = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_blend_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies a blend time (in seconds) between two animations, referenced by their names. set_blend_time :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Float -> IO () set_blend_time cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_blend_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_blend_time" '[GodotString, GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_blend_time {-# NOINLINE bindAnimationPlayer_set_current_animation #-} -- | The name of the currently playing animation. If no animation is playing, the property's value is an empty string. Changing this value does not restart the animation. See @method play@ for more information on playing animations. -- __Note__: while this property appears in the inspector, it's not meant to be edited and it's not saved in the scene. This property is mainly used to get the currently playing animation, and internally for animation playback tracks. For more information, see @Animation@. bindAnimationPlayer_set_current_animation :: MethodBind bindAnimationPlayer_set_current_animation = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_current_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the currently playing animation. If no animation is playing, the property's value is an empty string. Changing this value does not restart the animation. See @method play@ for more information on playing animations. -- __Note__: while this property appears in the inspector, it's not meant to be edited and it's not saved in the scene. This property is mainly used to get the currently playing animation, and internally for animation playback tracks. For more information, see @Animation@. set_current_animation :: (AnimationPlayer :< cls, Object :< cls) => cls -> GodotString -> IO () set_current_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_current_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_current_animation" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_current_animation {-# NOINLINE bindAnimationPlayer_set_default_blend_time #-} -- | The default time in which to blend animations. Ranges from 0 to 4096 with 0.01 precision. bindAnimationPlayer_set_default_blend_time :: MethodBind bindAnimationPlayer_set_default_blend_time = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_default_blend_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The default time in which to blend animations. Ranges from 0 to 4096 with 0.01 precision. set_default_blend_time :: (AnimationPlayer :< cls, Object :< cls) => cls -> Float -> IO () set_default_blend_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_default_blend_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_default_blend_time" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_default_blend_time {-# NOINLINE bindAnimationPlayer_set_method_call_mode #-} -- | The call mode to use for Call Method tracks. bindAnimationPlayer_set_method_call_mode :: MethodBind bindAnimationPlayer_set_method_call_mode = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_method_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The call mode to use for Call Method tracks. set_method_call_mode :: (AnimationPlayer :< cls, Object :< cls) => cls -> Int -> IO () set_method_call_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_method_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_method_call_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_method_call_mode {-# NOINLINE bindAnimationPlayer_set_root #-} -- | The node from which node path references will travel. bindAnimationPlayer_set_root :: MethodBind bindAnimationPlayer_set_root = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node from which node path references will travel. set_root :: (AnimationPlayer :< cls, Object :< cls) => cls -> NodePath -> IO () set_root cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_root" '[NodePath] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_root {-# NOINLINE bindAnimationPlayer_set_speed_scale #-} -- | The speed scaling ratio. For instance, if this value is 1, then the animation plays at normal speed. If it's 0.5, then it plays at half speed. If it's 2, then it plays at double speed. bindAnimationPlayer_set_speed_scale :: MethodBind bindAnimationPlayer_set_speed_scale = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "set_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The speed scaling ratio. For instance, if this value is 1, then the animation plays at normal speed. If it's 0.5, then it plays at half speed. If it's 2, then it plays at double speed. set_speed_scale :: (AnimationPlayer :< cls, Object :< cls) => cls -> Float -> IO () set_speed_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_set_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "set_speed_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.set_speed_scale {-# NOINLINE bindAnimationPlayer_stop #-} -- | Stops or pauses the currently playing animation. If @reset@ is @true@, the animation position is reset to @0@ and the playback speed is reset to @1.0@. -- If @reset@ is @false@, the @current_animation_position@ will be kept and calling @method play@ or @method play_backwards@ without arguments or with the same animation name as @assigned_animation@ will resume the animation. bindAnimationPlayer_stop :: MethodBind bindAnimationPlayer_stop = unsafePerformIO $ withCString "AnimationPlayer" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops or pauses the currently playing animation. If @reset@ is @true@, the animation position is reset to @0@ and the playback speed is reset to @1.0@. -- If @reset@ is @false@, the @current_animation_position@ will be kept and calling @method play@ or @method play_backwards@ without arguments or with the same animation name as @assigned_animation@ will resume the animation. stop :: (AnimationPlayer :< cls, Object :< cls) => cls -> Maybe Bool -> IO () stop cls arg1 = withVariantArray [maybe (VariantBool True) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationPlayer_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationPlayer "stop" '[Maybe Bool] (IO ()) where nodeMethod = Godot.Core.AnimationPlayer.stop ================================================ FILE: src/Godot/Core/AnimationRootNode.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationRootNode () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AnimationNode() ================================================ FILE: src/Godot/Core/AnimationTree.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationTree (Godot.Core.AnimationTree._ANIMATION_PROCESS_MANUAL, Godot.Core.AnimationTree._ANIMATION_PROCESS_PHYSICS, Godot.Core.AnimationTree._ANIMATION_PROCESS_IDLE, Godot.Core.AnimationTree._clear_caches, Godot.Core.AnimationTree._node_removed, Godot.Core.AnimationTree._tree_changed, Godot.Core.AnimationTree._update_properties, Godot.Core.AnimationTree.advance, Godot.Core.AnimationTree.get_animation_player, Godot.Core.AnimationTree.get_process_mode, Godot.Core.AnimationTree.get_root_motion_track, Godot.Core.AnimationTree.get_root_motion_transform, Godot.Core.AnimationTree.get_tree_root, Godot.Core.AnimationTree.is_active, Godot.Core.AnimationTree.rename_parameter, Godot.Core.AnimationTree.set_active, Godot.Core.AnimationTree.set_animation_player, Godot.Core.AnimationTree.set_process_mode, Godot.Core.AnimationTree.set_root_motion_track, Godot.Core.AnimationTree.set_tree_root) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _ANIMATION_PROCESS_MANUAL :: Int _ANIMATION_PROCESS_MANUAL = 2 _ANIMATION_PROCESS_PHYSICS :: Int _ANIMATION_PROCESS_PHYSICS = 0 _ANIMATION_PROCESS_IDLE :: Int _ANIMATION_PROCESS_IDLE = 1 instance NodeProperty AnimationTree "active" Bool 'False where nodeProperty = (is_active, wrapDroppingSetter set_active, Nothing) instance NodeProperty AnimationTree "anim_player" NodePath 'False where nodeProperty = (get_animation_player, wrapDroppingSetter set_animation_player, Nothing) instance NodeProperty AnimationTree "process_mode" Int 'False where nodeProperty = (get_process_mode, wrapDroppingSetter set_process_mode, Nothing) instance NodeProperty AnimationTree "root_motion_track" NodePath 'False where nodeProperty = (get_root_motion_track, wrapDroppingSetter set_root_motion_track, Nothing) instance NodeProperty AnimationTree "tree_root" AnimationNode 'False where nodeProperty = (get_tree_root, wrapDroppingSetter set_tree_root, Nothing) {-# NOINLINE bindAnimationTree__clear_caches #-} bindAnimationTree__clear_caches :: MethodBind bindAnimationTree__clear_caches = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "_clear_caches" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _clear_caches :: (AnimationTree :< cls, Object :< cls) => cls -> IO () _clear_caches cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree__clear_caches (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "_clear_caches" '[] (IO ()) where nodeMethod = Godot.Core.AnimationTree._clear_caches {-# NOINLINE bindAnimationTree__node_removed #-} bindAnimationTree__node_removed :: MethodBind bindAnimationTree__node_removed = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "_node_removed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _node_removed :: (AnimationTree :< cls, Object :< cls) => cls -> Node -> IO () _node_removed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree__node_removed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "_node_removed" '[Node] (IO ()) where nodeMethod = Godot.Core.AnimationTree._node_removed {-# NOINLINE bindAnimationTree__tree_changed #-} bindAnimationTree__tree_changed :: MethodBind bindAnimationTree__tree_changed = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "_tree_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_changed :: (AnimationTree :< cls, Object :< cls) => cls -> IO () _tree_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree__tree_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "_tree_changed" '[] (IO ()) where nodeMethod = Godot.Core.AnimationTree._tree_changed {-# NOINLINE bindAnimationTree__update_properties #-} bindAnimationTree__update_properties :: MethodBind bindAnimationTree__update_properties = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "_update_properties" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_properties :: (AnimationTree :< cls, Object :< cls) => cls -> IO () _update_properties cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree__update_properties (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "_update_properties" '[] (IO ()) where nodeMethod = Godot.Core.AnimationTree._update_properties {-# NOINLINE bindAnimationTree_advance #-} -- | Manually advance the animations by the specified time (in seconds). bindAnimationTree_advance :: MethodBind bindAnimationTree_advance = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Manually advance the animations by the specified time (in seconds). advance :: (AnimationTree :< cls, Object :< cls) => cls -> Float -> IO () advance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "advance" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationTree.advance {-# NOINLINE bindAnimationTree_get_animation_player #-} -- | The path to the @AnimationPlayer@ used for animating. bindAnimationTree_get_animation_player :: MethodBind bindAnimationTree_get_animation_player = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "get_animation_player" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the @AnimationPlayer@ used for animating. get_animation_player :: (AnimationTree :< cls, Object :< cls) => cls -> IO NodePath get_animation_player cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_get_animation_player (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "get_animation_player" '[] (IO NodePath) where nodeMethod = Godot.Core.AnimationTree.get_animation_player {-# NOINLINE bindAnimationTree_get_process_mode #-} -- | The process mode of this @AnimationTree@. See @enum AnimationProcessMode@ for available modes. bindAnimationTree_get_process_mode :: MethodBind bindAnimationTree_get_process_mode = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "get_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The process mode of this @AnimationTree@. See @enum AnimationProcessMode@ for available modes. get_process_mode :: (AnimationTree :< cls, Object :< cls) => cls -> IO Int get_process_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_get_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "get_process_mode" '[] (IO Int) where nodeMethod = Godot.Core.AnimationTree.get_process_mode {-# NOINLINE bindAnimationTree_get_root_motion_track #-} -- | The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. To specify a track that controls properties or bones, append its name after the path, separated by @":"@. For example, @"character/skeleton:ankle"@ or @"character/mesh:transform/local"@. -- If the track has type @Animation.TYPE_TRANSFORM@, the transformation will be cancelled visually, and the animation will appear to stay in place. bindAnimationTree_get_root_motion_track :: MethodBind bindAnimationTree_get_root_motion_track = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "get_root_motion_track" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. To specify a track that controls properties or bones, append its name after the path, separated by @":"@. For example, @"character/skeleton:ankle"@ or @"character/mesh:transform/local"@. -- If the track has type @Animation.TYPE_TRANSFORM@, the transformation will be cancelled visually, and the animation will appear to stay in place. get_root_motion_track :: (AnimationTree :< cls, Object :< cls) => cls -> IO NodePath get_root_motion_track cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_get_root_motion_track (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "get_root_motion_track" '[] (IO NodePath) where nodeMethod = Godot.Core.AnimationTree.get_root_motion_track {-# NOINLINE bindAnimationTree_get_root_motion_transform #-} -- | Retrieve the motion of the @root_motion_track@ as a @Transform@ that can be used elsewhere. If @root_motion_track@ is not a path to a track of type @Animation.TYPE_TRANSFORM@, returns an identity transformation. bindAnimationTree_get_root_motion_transform :: MethodBind bindAnimationTree_get_root_motion_transform = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "get_root_motion_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Retrieve the motion of the @root_motion_track@ as a @Transform@ that can be used elsewhere. If @root_motion_track@ is not a path to a track of type @Animation.TYPE_TRANSFORM@, returns an identity transformation. get_root_motion_transform :: (AnimationTree :< cls, Object :< cls) => cls -> IO Transform get_root_motion_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_get_root_motion_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "get_root_motion_transform" '[] (IO Transform) where nodeMethod = Godot.Core.AnimationTree.get_root_motion_transform {-# NOINLINE bindAnimationTree_get_tree_root #-} -- | The root animation node of this @AnimationTree@. See @AnimationNode@. bindAnimationTree_get_tree_root :: MethodBind bindAnimationTree_get_tree_root = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "get_tree_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The root animation node of this @AnimationTree@. See @AnimationNode@. get_tree_root :: (AnimationTree :< cls, Object :< cls) => cls -> IO AnimationNode get_tree_root cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_get_tree_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "get_tree_root" '[] (IO AnimationNode) where nodeMethod = Godot.Core.AnimationTree.get_tree_root {-# NOINLINE bindAnimationTree_is_active #-} -- | If @true@, the @AnimationTree@ will be processing. bindAnimationTree_is_active :: MethodBind bindAnimationTree_is_active = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @AnimationTree@ will be processing. is_active :: (AnimationTree :< cls, Object :< cls) => cls -> IO Bool is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "is_active" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationTree.is_active {-# NOINLINE bindAnimationTree_rename_parameter #-} bindAnimationTree_rename_parameter :: MethodBind bindAnimationTree_rename_parameter = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "rename_parameter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr rename_parameter :: (AnimationTree :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_parameter cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_rename_parameter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "rename_parameter" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationTree.rename_parameter {-# NOINLINE bindAnimationTree_set_active #-} -- | If @true@, the @AnimationTree@ will be processing. bindAnimationTree_set_active :: MethodBind bindAnimationTree_set_active = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @AnimationTree@ will be processing. set_active :: (AnimationTree :< cls, Object :< cls) => cls -> Bool -> IO () set_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "set_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationTree.set_active {-# NOINLINE bindAnimationTree_set_animation_player #-} -- | The path to the @AnimationPlayer@ used for animating. bindAnimationTree_set_animation_player :: MethodBind bindAnimationTree_set_animation_player = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "set_animation_player" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the @AnimationPlayer@ used for animating. set_animation_player :: (AnimationTree :< cls, Object :< cls) => cls -> NodePath -> IO () set_animation_player cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_set_animation_player (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "set_animation_player" '[NodePath] (IO ()) where nodeMethod = Godot.Core.AnimationTree.set_animation_player {-# NOINLINE bindAnimationTree_set_process_mode #-} -- | The process mode of this @AnimationTree@. See @enum AnimationProcessMode@ for available modes. bindAnimationTree_set_process_mode :: MethodBind bindAnimationTree_set_process_mode = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "set_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The process mode of this @AnimationTree@. See @enum AnimationProcessMode@ for available modes. set_process_mode :: (AnimationTree :< cls, Object :< cls) => cls -> Int -> IO () set_process_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_set_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "set_process_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationTree.set_process_mode {-# NOINLINE bindAnimationTree_set_root_motion_track #-} -- | The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. To specify a track that controls properties or bones, append its name after the path, separated by @":"@. For example, @"character/skeleton:ankle"@ or @"character/mesh:transform/local"@. -- If the track has type @Animation.TYPE_TRANSFORM@, the transformation will be cancelled visually, and the animation will appear to stay in place. bindAnimationTree_set_root_motion_track :: MethodBind bindAnimationTree_set_root_motion_track = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "set_root_motion_track" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. To specify a track that controls properties or bones, append its name after the path, separated by @":"@. For example, @"character/skeleton:ankle"@ or @"character/mesh:transform/local"@. -- If the track has type @Animation.TYPE_TRANSFORM@, the transformation will be cancelled visually, and the animation will appear to stay in place. set_root_motion_track :: (AnimationTree :< cls, Object :< cls) => cls -> NodePath -> IO () set_root_motion_track cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_set_root_motion_track (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "set_root_motion_track" '[NodePath] (IO ()) where nodeMethod = Godot.Core.AnimationTree.set_root_motion_track {-# NOINLINE bindAnimationTree_set_tree_root #-} -- | The root animation node of this @AnimationTree@. See @AnimationNode@. bindAnimationTree_set_tree_root :: MethodBind bindAnimationTree_set_tree_root = unsafePerformIO $ withCString "AnimationTree" $ \ clsNamePtr -> withCString "set_tree_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The root animation node of this @AnimationTree@. See @AnimationNode@. set_tree_root :: (AnimationTree :< cls, Object :< cls) => cls -> AnimationNode -> IO () set_tree_root cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTree_set_tree_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTree "set_tree_root" '[AnimationNode] (IO ()) where nodeMethod = Godot.Core.AnimationTree.set_tree_root ================================================ FILE: src/Godot/Core/AnimationTreePlayer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AnimationTreePlayer (Godot.Core.AnimationTreePlayer._NODE_TIMESEEK, Godot.Core.AnimationTreePlayer._NODE_OUTPUT, Godot.Core.AnimationTreePlayer._NODE_ANIMATION, Godot.Core.AnimationTreePlayer._NODE_BLEND2, Godot.Core.AnimationTreePlayer._NODE_TIMESCALE, Godot.Core.AnimationTreePlayer._NODE_BLEND4, Godot.Core.AnimationTreePlayer._NODE_BLEND3, Godot.Core.AnimationTreePlayer._NODE_TRANSITION, Godot.Core.AnimationTreePlayer._NODE_MIX, Godot.Core.AnimationTreePlayer._NODE_ONESHOT, Godot.Core.AnimationTreePlayer._ANIMATION_PROCESS_PHYSICS, Godot.Core.AnimationTreePlayer._ANIMATION_PROCESS_IDLE, Godot.Core.AnimationTreePlayer.add_node, Godot.Core.AnimationTreePlayer.advance, Godot.Core.AnimationTreePlayer.animation_node_get_animation, Godot.Core.AnimationTreePlayer.animation_node_get_master_animation, Godot.Core.AnimationTreePlayer.animation_node_get_position, Godot.Core.AnimationTreePlayer.animation_node_set_animation, Godot.Core.AnimationTreePlayer.animation_node_set_filter_path, Godot.Core.AnimationTreePlayer.animation_node_set_master_animation, Godot.Core.AnimationTreePlayer.are_nodes_connected, Godot.Core.AnimationTreePlayer.blend2_node_get_amount, Godot.Core.AnimationTreePlayer.blend2_node_set_amount, Godot.Core.AnimationTreePlayer.blend2_node_set_filter_path, Godot.Core.AnimationTreePlayer.blend3_node_get_amount, Godot.Core.AnimationTreePlayer.blend3_node_set_amount, Godot.Core.AnimationTreePlayer.blend4_node_get_amount, Godot.Core.AnimationTreePlayer.blend4_node_set_amount, Godot.Core.AnimationTreePlayer.connect_nodes, Godot.Core.AnimationTreePlayer.disconnect_nodes, Godot.Core.AnimationTreePlayer.get_animation_process_mode, Godot.Core.AnimationTreePlayer.get_base_path, Godot.Core.AnimationTreePlayer.get_master_player, Godot.Core.AnimationTreePlayer.get_node_list, Godot.Core.AnimationTreePlayer.is_active, Godot.Core.AnimationTreePlayer.mix_node_get_amount, Godot.Core.AnimationTreePlayer.mix_node_set_amount, Godot.Core.AnimationTreePlayer.node_exists, Godot.Core.AnimationTreePlayer.node_get_input_count, Godot.Core.AnimationTreePlayer.node_get_input_source, Godot.Core.AnimationTreePlayer.node_get_position, Godot.Core.AnimationTreePlayer.node_get_type, Godot.Core.AnimationTreePlayer.node_rename, Godot.Core.AnimationTreePlayer.node_set_position, Godot.Core.AnimationTreePlayer.oneshot_node_get_autorestart_delay, Godot.Core.AnimationTreePlayer.oneshot_node_get_autorestart_random_delay, Godot.Core.AnimationTreePlayer.oneshot_node_get_fadein_time, Godot.Core.AnimationTreePlayer.oneshot_node_get_fadeout_time, Godot.Core.AnimationTreePlayer.oneshot_node_has_autorestart, Godot.Core.AnimationTreePlayer.oneshot_node_is_active, Godot.Core.AnimationTreePlayer.oneshot_node_set_autorestart, Godot.Core.AnimationTreePlayer.oneshot_node_set_autorestart_delay, Godot.Core.AnimationTreePlayer.oneshot_node_set_autorestart_random_delay, Godot.Core.AnimationTreePlayer.oneshot_node_set_fadein_time, Godot.Core.AnimationTreePlayer.oneshot_node_set_fadeout_time, Godot.Core.AnimationTreePlayer.oneshot_node_set_filter_path, Godot.Core.AnimationTreePlayer.oneshot_node_start, Godot.Core.AnimationTreePlayer.oneshot_node_stop, Godot.Core.AnimationTreePlayer.recompute_caches, Godot.Core.AnimationTreePlayer.remove_node, Godot.Core.AnimationTreePlayer.reset, Godot.Core.AnimationTreePlayer.set_active, Godot.Core.AnimationTreePlayer.set_animation_process_mode, Godot.Core.AnimationTreePlayer.set_base_path, Godot.Core.AnimationTreePlayer.set_master_player, Godot.Core.AnimationTreePlayer.timescale_node_get_scale, Godot.Core.AnimationTreePlayer.timescale_node_set_scale, Godot.Core.AnimationTreePlayer.timeseek_node_seek, Godot.Core.AnimationTreePlayer.transition_node_delete_input, Godot.Core.AnimationTreePlayer.transition_node_get_current, Godot.Core.AnimationTreePlayer.transition_node_get_input_count, Godot.Core.AnimationTreePlayer.transition_node_get_xfade_time, Godot.Core.AnimationTreePlayer.transition_node_has_input_auto_advance, Godot.Core.AnimationTreePlayer.transition_node_set_current, Godot.Core.AnimationTreePlayer.transition_node_set_input_auto_advance, Godot.Core.AnimationTreePlayer.transition_node_set_input_count, Godot.Core.AnimationTreePlayer.transition_node_set_xfade_time) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _NODE_TIMESEEK :: Int _NODE_TIMESEEK = 8 _NODE_OUTPUT :: Int _NODE_OUTPUT = 0 _NODE_ANIMATION :: Int _NODE_ANIMATION = 1 _NODE_BLEND2 :: Int _NODE_BLEND2 = 4 _NODE_TIMESCALE :: Int _NODE_TIMESCALE = 7 _NODE_BLEND4 :: Int _NODE_BLEND4 = 6 _NODE_BLEND3 :: Int _NODE_BLEND3 = 5 _NODE_TRANSITION :: Int _NODE_TRANSITION = 9 _NODE_MIX :: Int _NODE_MIX = 3 _NODE_ONESHOT :: Int _NODE_ONESHOT = 2 _ANIMATION_PROCESS_PHYSICS :: Int _ANIMATION_PROCESS_PHYSICS = 0 _ANIMATION_PROCESS_IDLE :: Int _ANIMATION_PROCESS_IDLE = 1 instance NodeProperty AnimationTreePlayer "active" Bool 'False where nodeProperty = (is_active, wrapDroppingSetter set_active, Nothing) instance NodeProperty AnimationTreePlayer "base_path" NodePath 'False where nodeProperty = (get_base_path, wrapDroppingSetter set_base_path, Nothing) instance NodeProperty AnimationTreePlayer "master_player" NodePath 'False where nodeProperty = (get_master_player, wrapDroppingSetter set_master_player, Nothing) instance NodeProperty AnimationTreePlayer "playback_process_mode" Int 'False where nodeProperty = (get_animation_process_mode, wrapDroppingSetter set_animation_process_mode, Nothing) {-# NOINLINE bindAnimationTreePlayer_add_node #-} -- | Adds a @type@ node to the graph with name @id@. bindAnimationTreePlayer_add_node :: MethodBind bindAnimationTreePlayer_add_node = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "add_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @type@ node to the graph with name @id@. add_node :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () add_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_add_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "add_node" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.add_node {-# NOINLINE bindAnimationTreePlayer_advance #-} -- | Shifts position in the animation timeline. @delta@ is the time in seconds to shift. Events between the current frame and @delta@ are handled. bindAnimationTreePlayer_advance :: MethodBind bindAnimationTreePlayer_advance = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shifts position in the animation timeline. @delta@ is the time in seconds to shift. Events between the current frame and @delta@ are handled. advance :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> Float -> IO () advance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "advance" '[Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.advance {-# NOINLINE bindAnimationTreePlayer_animation_node_get_animation #-} -- | Returns the @AnimationPlayer@'s @Animation@ bound to the @AnimationTreePlayer@'s animation node with name @id@. bindAnimationTreePlayer_animation_node_get_animation :: MethodBind bindAnimationTreePlayer_animation_node_get_animation = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "animation_node_get_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AnimationPlayer@'s @Animation@ bound to the @AnimationTreePlayer@'s animation node with name @id@. animation_node_get_animation :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Animation animation_node_get_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_animation_node_get_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "animation_node_get_animation" '[GodotString] (IO Animation) where nodeMethod = Godot.Core.AnimationTreePlayer.animation_node_get_animation {-# NOINLINE bindAnimationTreePlayer_animation_node_get_master_animation #-} -- | Returns the name of the @master_player@'s @Animation@ bound to this animation node. bindAnimationTreePlayer_animation_node_get_master_animation :: MethodBind bindAnimationTreePlayer_animation_node_get_master_animation = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "animation_node_get_master_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the @master_player@'s @Animation@ bound to this animation node. animation_node_get_master_animation :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO GodotString animation_node_get_master_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_animation_node_get_master_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "animation_node_get_master_animation" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.AnimationTreePlayer.animation_node_get_master_animation {-# NOINLINE bindAnimationTreePlayer_animation_node_get_position #-} -- | Returns the absolute playback timestamp of the animation node with name @id@. bindAnimationTreePlayer_animation_node_get_position :: MethodBind bindAnimationTreePlayer_animation_node_get_position = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "animation_node_get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the absolute playback timestamp of the animation node with name @id@. animation_node_get_position :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float animation_node_get_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_animation_node_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "animation_node_get_position" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.animation_node_get_position {-# NOINLINE bindAnimationTreePlayer_animation_node_set_animation #-} -- | Binds a new @Animation@ from the @master_player@ to the @AnimationTreePlayer@'s animation node with name @id@. bindAnimationTreePlayer_animation_node_set_animation :: MethodBind bindAnimationTreePlayer_animation_node_set_animation = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "animation_node_set_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Binds a new @Animation@ from the @master_player@ to the @AnimationTreePlayer@'s animation node with name @id@. animation_node_set_animation :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Animation -> IO () animation_node_set_animation cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_animation_node_set_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "animation_node_set_animation" '[GodotString, Animation] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.animation_node_set_animation {-# NOINLINE bindAnimationTreePlayer_animation_node_set_filter_path #-} -- | If @enable@ is @true@, the animation node with ID @id@ turns off the track modifying the property at @path@. The modified node's children continue to animate. bindAnimationTreePlayer_animation_node_set_filter_path :: MethodBind bindAnimationTreePlayer_animation_node_set_filter_path = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "animation_node_set_filter_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @enable@ is @true@, the animation node with ID @id@ turns off the track modifying the property at @path@. The modified node's children continue to animate. animation_node_set_filter_path :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> NodePath -> Bool -> IO () animation_node_set_filter_path cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_animation_node_set_filter_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "animation_node_set_filter_path" '[GodotString, NodePath, Bool] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.animation_node_set_filter_path {-# NOINLINE bindAnimationTreePlayer_animation_node_set_master_animation #-} -- | Binds the @Animation@ named @source@ from @master_player@ to the animation node @id@. Recalculates caches. bindAnimationTreePlayer_animation_node_set_master_animation :: MethodBind bindAnimationTreePlayer_animation_node_set_master_animation = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "animation_node_set_master_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Binds the @Animation@ named @source@ from @master_player@ to the animation node @id@. Recalculates caches. animation_node_set_master_animation :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () animation_node_set_master_animation cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_animation_node_set_master_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "animation_node_set_master_animation" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.animation_node_set_master_animation {-# NOINLINE bindAnimationTreePlayer_are_nodes_connected #-} -- | Returns whether node @id@ and @dst_id@ are connected at the specified slot. bindAnimationTreePlayer_are_nodes_connected :: MethodBind bindAnimationTreePlayer_are_nodes_connected = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "are_nodes_connected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether node @id@ and @dst_id@ are connected at the specified slot. are_nodes_connected :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Int -> IO Bool are_nodes_connected cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_are_nodes_connected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "are_nodes_connected" '[GodotString, GodotString, Int] (IO Bool) where nodeMethod = Godot.Core.AnimationTreePlayer.are_nodes_connected {-# NOINLINE bindAnimationTreePlayer_blend2_node_get_amount #-} -- | Returns the blend amount of a Blend2 node given its name. bindAnimationTreePlayer_blend2_node_get_amount :: MethodBind bindAnimationTreePlayer_blend2_node_get_amount = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "blend2_node_get_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the blend amount of a Blend2 node given its name. blend2_node_get_amount :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float blend2_node_get_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_blend2_node_get_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "blend2_node_get_amount" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.blend2_node_get_amount {-# NOINLINE bindAnimationTreePlayer_blend2_node_set_amount #-} -- | Sets the blend amount of a Blend2 node given its name and value. -- A Blend2 node blends two animations (A and B) with the amount between 0 and 1. -- At 0, output is input A. Towards 1, the influence of A gets lessened, the influence of B gets raised. At 1, output is input B. bindAnimationTreePlayer_blend2_node_set_amount :: MethodBind bindAnimationTreePlayer_blend2_node_set_amount = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "blend2_node_set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the blend amount of a Blend2 node given its name and value. -- A Blend2 node blends two animations (A and B) with the amount between 0 and 1. -- At 0, output is input A. Towards 1, the influence of A gets lessened, the influence of B gets raised. At 1, output is input B. blend2_node_set_amount :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () blend2_node_set_amount cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_blend2_node_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "blend2_node_set_amount" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.blend2_node_set_amount {-# NOINLINE bindAnimationTreePlayer_blend2_node_set_filter_path #-} -- | If @enable@ is @true@, the Blend2 node with name @id@ turns off the track modifying the property at @path@. The modified node's children continue to animate. bindAnimationTreePlayer_blend2_node_set_filter_path :: MethodBind bindAnimationTreePlayer_blend2_node_set_filter_path = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "blend2_node_set_filter_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @enable@ is @true@, the Blend2 node with name @id@ turns off the track modifying the property at @path@. The modified node's children continue to animate. blend2_node_set_filter_path :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> NodePath -> Bool -> IO () blend2_node_set_filter_path cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_blend2_node_set_filter_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "blend2_node_set_filter_path" '[GodotString, NodePath, Bool] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.blend2_node_set_filter_path {-# NOINLINE bindAnimationTreePlayer_blend3_node_get_amount #-} -- | Returns the blend amount of a Blend3 node given its name. bindAnimationTreePlayer_blend3_node_get_amount :: MethodBind bindAnimationTreePlayer_blend3_node_get_amount = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "blend3_node_get_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the blend amount of a Blend3 node given its name. blend3_node_get_amount :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float blend3_node_get_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_blend3_node_get_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "blend3_node_get_amount" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.blend3_node_get_amount {-# NOINLINE bindAnimationTreePlayer_blend3_node_set_amount #-} -- | Sets the blend amount of a Blend3 node given its name and value. -- A Blend3 Node blends three animations (A, B-, B+) with the amount between -1 and 1. -- At -1, output is input B-. From -1 to 0, the influence of B- gets lessened, the influence of A gets raised and the influence of B+ is 0. At 0, output is input A. From 0 to 1, the influence of A gets lessened, the influence of B+ gets raised and the influence of B+ is 0. At 1, output is input B+. bindAnimationTreePlayer_blend3_node_set_amount :: MethodBind bindAnimationTreePlayer_blend3_node_set_amount = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "blend3_node_set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the blend amount of a Blend3 node given its name and value. -- A Blend3 Node blends three animations (A, B-, B+) with the amount between -1 and 1. -- At -1, output is input B-. From -1 to 0, the influence of B- gets lessened, the influence of A gets raised and the influence of B+ is 0. At 0, output is input A. From 0 to 1, the influence of A gets lessened, the influence of B+ gets raised and the influence of B+ is 0. At 1, output is input B+. blend3_node_set_amount :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () blend3_node_set_amount cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_blend3_node_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "blend3_node_set_amount" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.blend3_node_set_amount {-# NOINLINE bindAnimationTreePlayer_blend4_node_get_amount #-} -- | Returns the blend amount of a Blend4 node given its name. bindAnimationTreePlayer_blend4_node_get_amount :: MethodBind bindAnimationTreePlayer_blend4_node_get_amount = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "blend4_node_get_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the blend amount of a Blend4 node given its name. blend4_node_get_amount :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Vector2 blend4_node_get_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_blend4_node_get_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "blend4_node_get_amount" '[GodotString] (IO Vector2) where nodeMethod = Godot.Core.AnimationTreePlayer.blend4_node_get_amount {-# NOINLINE bindAnimationTreePlayer_blend4_node_set_amount #-} -- | Sets the blend amount of a Blend4 node given its name and value. -- A Blend4 Node blends two pairs of animations. -- The two pairs are blended like Blend2 and then added together. bindAnimationTreePlayer_blend4_node_set_amount :: MethodBind bindAnimationTreePlayer_blend4_node_set_amount = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "blend4_node_set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the blend amount of a Blend4 node given its name and value. -- A Blend4 Node blends two pairs of animations. -- The two pairs are blended like Blend2 and then added together. blend4_node_set_amount :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Vector2 -> IO () blend4_node_set_amount cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_blend4_node_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "blend4_node_set_amount" '[GodotString, Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.blend4_node_set_amount {-# NOINLINE bindAnimationTreePlayer_connect_nodes #-} -- | Connects node @id@ to @dst_id@ at the specified input slot. bindAnimationTreePlayer_connect_nodes :: MethodBind bindAnimationTreePlayer_connect_nodes = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "connect_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects node @id@ to @dst_id@ at the specified input slot. connect_nodes :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Int -> IO Int connect_nodes cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_connect_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "connect_nodes" '[GodotString, GodotString, Int] (IO Int) where nodeMethod = Godot.Core.AnimationTreePlayer.connect_nodes {-# NOINLINE bindAnimationTreePlayer_disconnect_nodes #-} -- | Disconnects nodes connected to @id@ at the specified input slot. bindAnimationTreePlayer_disconnect_nodes :: MethodBind bindAnimationTreePlayer_disconnect_nodes = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "disconnect_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disconnects nodes connected to @id@ at the specified input slot. disconnect_nodes :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () disconnect_nodes cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_disconnect_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "disconnect_nodes" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.disconnect_nodes {-# NOINLINE bindAnimationTreePlayer_get_animation_process_mode #-} -- | The thread in which to update animations. bindAnimationTreePlayer_get_animation_process_mode :: MethodBind bindAnimationTreePlayer_get_animation_process_mode = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "get_animation_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The thread in which to update animations. get_animation_process_mode :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> IO Int get_animation_process_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_get_animation_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "get_animation_process_mode" '[] (IO Int) where nodeMethod = Godot.Core.AnimationTreePlayer.get_animation_process_mode {-# NOINLINE bindAnimationTreePlayer_get_base_path #-} -- | The node from which to relatively access other nodes. -- It accesses the bones, so it should point to the same node the @AnimationPlayer@ would point its Root Node at. bindAnimationTreePlayer_get_base_path :: MethodBind bindAnimationTreePlayer_get_base_path = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "get_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node from which to relatively access other nodes. -- It accesses the bones, so it should point to the same node the @AnimationPlayer@ would point its Root Node at. get_base_path :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> IO NodePath get_base_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_get_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "get_base_path" '[] (IO NodePath) where nodeMethod = Godot.Core.AnimationTreePlayer.get_base_path {-# NOINLINE bindAnimationTreePlayer_get_master_player #-} -- | The path to the @AnimationPlayer@ from which this @AnimationTreePlayer@ binds animations to animation nodes. -- Once set, @Animation@ nodes can be added to the @AnimationTreePlayer@. bindAnimationTreePlayer_get_master_player :: MethodBind bindAnimationTreePlayer_get_master_player = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "get_master_player" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the @AnimationPlayer@ from which this @AnimationTreePlayer@ binds animations to animation nodes. -- Once set, @Animation@ nodes can be added to the @AnimationTreePlayer@. get_master_player :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> IO NodePath get_master_player cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_get_master_player (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "get_master_player" '[] (IO NodePath) where nodeMethod = Godot.Core.AnimationTreePlayer.get_master_player {-# NOINLINE bindAnimationTreePlayer_get_node_list #-} -- | Returns a @PoolStringArray@ containing the name of all nodes. bindAnimationTreePlayer_get_node_list :: MethodBind bindAnimationTreePlayer_get_node_list = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "get_node_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @PoolStringArray@ containing the name of all nodes. get_node_list :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> IO PoolStringArray get_node_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_get_node_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "get_node_list" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.AnimationTreePlayer.get_node_list {-# NOINLINE bindAnimationTreePlayer_is_active #-} -- | If @true@, the @AnimationTreePlayer@ is able to play animations. bindAnimationTreePlayer_is_active :: MethodBind bindAnimationTreePlayer_is_active = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @AnimationTreePlayer@ is able to play animations. is_active :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> IO Bool is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "is_active" '[] (IO Bool) where nodeMethod = Godot.Core.AnimationTreePlayer.is_active {-# NOINLINE bindAnimationTreePlayer_mix_node_get_amount #-} -- | Returns the mix amount of a Mix node given its name. bindAnimationTreePlayer_mix_node_get_amount :: MethodBind bindAnimationTreePlayer_mix_node_get_amount = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "mix_node_get_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the mix amount of a Mix node given its name. mix_node_get_amount :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float mix_node_get_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_mix_node_get_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "mix_node_get_amount" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.mix_node_get_amount {-# NOINLINE bindAnimationTreePlayer_mix_node_set_amount #-} -- | Sets the mix amount of a Mix node given its name and value. -- A Mix node adds input b to input a by the amount given by ratio. bindAnimationTreePlayer_mix_node_set_amount :: MethodBind bindAnimationTreePlayer_mix_node_set_amount = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "mix_node_set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the mix amount of a Mix node given its name and value. -- A Mix node adds input b to input a by the amount given by ratio. mix_node_set_amount :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () mix_node_set_amount cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_mix_node_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "mix_node_set_amount" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.mix_node_set_amount {-# NOINLINE bindAnimationTreePlayer_node_exists #-} -- | Check if a node exists (by name). bindAnimationTreePlayer_node_exists :: MethodBind bindAnimationTreePlayer_node_exists = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "node_exists" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Check if a node exists (by name). node_exists :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Bool node_exists cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_node_exists (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "node_exists" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.AnimationTreePlayer.node_exists {-# NOINLINE bindAnimationTreePlayer_node_get_input_count #-} -- | Returns the input count for a given node. Different types of nodes have different amount of inputs. bindAnimationTreePlayer_node_get_input_count :: MethodBind bindAnimationTreePlayer_node_get_input_count = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "node_get_input_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the input count for a given node. Different types of nodes have different amount of inputs. node_get_input_count :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Int node_get_input_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_node_get_input_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "node_get_input_count" '[GodotString] (IO Int) where nodeMethod = Godot.Core.AnimationTreePlayer.node_get_input_count {-# NOINLINE bindAnimationTreePlayer_node_get_input_source #-} -- | Returns the input source for a given node input. bindAnimationTreePlayer_node_get_input_source :: MethodBind bindAnimationTreePlayer_node_get_input_source = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "node_get_input_source" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the input source for a given node input. node_get_input_source :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Int -> IO GodotString node_get_input_source cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_node_get_input_source (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "node_get_input_source" '[GodotString, Int] (IO GodotString) where nodeMethod = Godot.Core.AnimationTreePlayer.node_get_input_source {-# NOINLINE bindAnimationTreePlayer_node_get_position #-} -- | Returns position of a node in the graph given its name. bindAnimationTreePlayer_node_get_position :: MethodBind bindAnimationTreePlayer_node_get_position = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "node_get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns position of a node in the graph given its name. node_get_position :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Vector2 node_get_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_node_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "node_get_position" '[GodotString] (IO Vector2) where nodeMethod = Godot.Core.AnimationTreePlayer.node_get_position {-# NOINLINE bindAnimationTreePlayer_node_get_type #-} -- | Gets the node type, will return from @enum NodeType@ enum. bindAnimationTreePlayer_node_get_type :: MethodBind bindAnimationTreePlayer_node_get_type = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "node_get_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the node type, will return from @enum NodeType@ enum. node_get_type :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Int node_get_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_node_get_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "node_get_type" '[GodotString] (IO Int) where nodeMethod = Godot.Core.AnimationTreePlayer.node_get_type {-# NOINLINE bindAnimationTreePlayer_node_rename #-} -- | Renames a node in the graph. bindAnimationTreePlayer_node_rename :: MethodBind bindAnimationTreePlayer_node_rename = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "node_rename" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Renames a node in the graph. node_rename :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int node_rename cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_node_rename (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "node_rename" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.AnimationTreePlayer.node_rename {-# NOINLINE bindAnimationTreePlayer_node_set_position #-} -- | Sets the position of a node in the graph given its name and position. bindAnimationTreePlayer_node_set_position :: MethodBind bindAnimationTreePlayer_node_set_position = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "node_set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position of a node in the graph given its name and position. node_set_position :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Vector2 -> IO () node_set_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_node_set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "node_set_position" '[GodotString, Vector2] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.node_set_position {-# NOINLINE bindAnimationTreePlayer_oneshot_node_get_autorestart_delay #-} -- | Returns the autostart delay of a OneShot node given its name. bindAnimationTreePlayer_oneshot_node_get_autorestart_delay :: MethodBind bindAnimationTreePlayer_oneshot_node_get_autorestart_delay = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_get_autorestart_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the autostart delay of a OneShot node given its name. oneshot_node_get_autorestart_delay :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float oneshot_node_get_autorestart_delay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_get_autorestart_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_get_autorestart_delay" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_get_autorestart_delay {-# NOINLINE bindAnimationTreePlayer_oneshot_node_get_autorestart_random_delay #-} -- | Returns the autostart random delay of a OneShot node given its name. bindAnimationTreePlayer_oneshot_node_get_autorestart_random_delay :: MethodBind bindAnimationTreePlayer_oneshot_node_get_autorestart_random_delay = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_get_autorestart_random_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the autostart random delay of a OneShot node given its name. oneshot_node_get_autorestart_random_delay :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float oneshot_node_get_autorestart_random_delay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_get_autorestart_random_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_get_autorestart_random_delay" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_get_autorestart_random_delay {-# NOINLINE bindAnimationTreePlayer_oneshot_node_get_fadein_time #-} -- | Returns the fade in time of a OneShot node given its name. bindAnimationTreePlayer_oneshot_node_get_fadein_time :: MethodBind bindAnimationTreePlayer_oneshot_node_get_fadein_time = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_get_fadein_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the fade in time of a OneShot node given its name. oneshot_node_get_fadein_time :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float oneshot_node_get_fadein_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_get_fadein_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_get_fadein_time" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_get_fadein_time {-# NOINLINE bindAnimationTreePlayer_oneshot_node_get_fadeout_time #-} -- | Returns the fade out time of a OneShot node given its name. bindAnimationTreePlayer_oneshot_node_get_fadeout_time :: MethodBind bindAnimationTreePlayer_oneshot_node_get_fadeout_time = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_get_fadeout_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the fade out time of a OneShot node given its name. oneshot_node_get_fadeout_time :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float oneshot_node_get_fadeout_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_get_fadeout_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_get_fadeout_time" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_get_fadeout_time {-# NOINLINE bindAnimationTreePlayer_oneshot_node_has_autorestart #-} -- | Returns whether a OneShot node will auto restart given its name. bindAnimationTreePlayer_oneshot_node_has_autorestart :: MethodBind bindAnimationTreePlayer_oneshot_node_has_autorestart = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_has_autorestart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a OneShot node will auto restart given its name. oneshot_node_has_autorestart :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Bool oneshot_node_has_autorestart cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_has_autorestart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_has_autorestart" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_has_autorestart {-# NOINLINE bindAnimationTreePlayer_oneshot_node_is_active #-} -- | Returns whether a OneShot node is active given its name. bindAnimationTreePlayer_oneshot_node_is_active :: MethodBind bindAnimationTreePlayer_oneshot_node_is_active = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a OneShot node is active given its name. oneshot_node_is_active :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Bool oneshot_node_is_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_is_active" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_is_active {-# NOINLINE bindAnimationTreePlayer_oneshot_node_set_autorestart #-} -- | Sets the autorestart property of a OneShot node given its name and value. bindAnimationTreePlayer_oneshot_node_set_autorestart :: MethodBind bindAnimationTreePlayer_oneshot_node_set_autorestart = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_set_autorestart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the autorestart property of a OneShot node given its name and value. oneshot_node_set_autorestart :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Bool -> IO () oneshot_node_set_autorestart cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_set_autorestart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_set_autorestart" '[GodotString, Bool] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_set_autorestart {-# NOINLINE bindAnimationTreePlayer_oneshot_node_set_autorestart_delay #-} -- | Sets the autorestart delay of a OneShot node given its name and value in seconds. bindAnimationTreePlayer_oneshot_node_set_autorestart_delay :: MethodBind bindAnimationTreePlayer_oneshot_node_set_autorestart_delay = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_set_autorestart_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the autorestart delay of a OneShot node given its name and value in seconds. oneshot_node_set_autorestart_delay :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () oneshot_node_set_autorestart_delay cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_set_autorestart_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_set_autorestart_delay" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_set_autorestart_delay {-# NOINLINE bindAnimationTreePlayer_oneshot_node_set_autorestart_random_delay #-} -- | Sets the autorestart random delay of a OneShot node given its name and value in seconds. bindAnimationTreePlayer_oneshot_node_set_autorestart_random_delay :: MethodBind bindAnimationTreePlayer_oneshot_node_set_autorestart_random_delay = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_set_autorestart_random_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the autorestart random delay of a OneShot node given its name and value in seconds. oneshot_node_set_autorestart_random_delay :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () oneshot_node_set_autorestart_random_delay cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_set_autorestart_random_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_set_autorestart_random_delay" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_set_autorestart_random_delay {-# NOINLINE bindAnimationTreePlayer_oneshot_node_set_fadein_time #-} -- | Sets the fade in time of a OneShot node given its name and value in seconds. bindAnimationTreePlayer_oneshot_node_set_fadein_time :: MethodBind bindAnimationTreePlayer_oneshot_node_set_fadein_time = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_set_fadein_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the fade in time of a OneShot node given its name and value in seconds. oneshot_node_set_fadein_time :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () oneshot_node_set_fadein_time cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_set_fadein_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_set_fadein_time" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_set_fadein_time {-# NOINLINE bindAnimationTreePlayer_oneshot_node_set_fadeout_time #-} -- | Sets the fade out time of a OneShot node given its name and value in seconds. bindAnimationTreePlayer_oneshot_node_set_fadeout_time :: MethodBind bindAnimationTreePlayer_oneshot_node_set_fadeout_time = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_set_fadeout_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the fade out time of a OneShot node given its name and value in seconds. oneshot_node_set_fadeout_time :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () oneshot_node_set_fadeout_time cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_set_fadeout_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_set_fadeout_time" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_set_fadeout_time {-# NOINLINE bindAnimationTreePlayer_oneshot_node_set_filter_path #-} -- | If @enable@ is @true@, the OneShot node with ID @id@ turns off the track modifying the property at @path@. The modified node's children continue to animate. bindAnimationTreePlayer_oneshot_node_set_filter_path :: MethodBind bindAnimationTreePlayer_oneshot_node_set_filter_path = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_set_filter_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @enable@ is @true@, the OneShot node with ID @id@ turns off the track modifying the property at @path@. The modified node's children continue to animate. oneshot_node_set_filter_path :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> NodePath -> Bool -> IO () oneshot_node_set_filter_path cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_set_filter_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_set_filter_path" '[GodotString, NodePath, Bool] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_set_filter_path {-# NOINLINE bindAnimationTreePlayer_oneshot_node_start #-} -- | Starts a OneShot node given its name. bindAnimationTreePlayer_oneshot_node_start :: MethodBind bindAnimationTreePlayer_oneshot_node_start = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts a OneShot node given its name. oneshot_node_start :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO () oneshot_node_start cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_start" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_start {-# NOINLINE bindAnimationTreePlayer_oneshot_node_stop #-} -- | Stops the OneShot node with name @id@. bindAnimationTreePlayer_oneshot_node_stop :: MethodBind bindAnimationTreePlayer_oneshot_node_stop = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "oneshot_node_stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the OneShot node with name @id@. oneshot_node_stop :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO () oneshot_node_stop cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_oneshot_node_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "oneshot_node_stop" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.oneshot_node_stop {-# NOINLINE bindAnimationTreePlayer_recompute_caches #-} -- | Manually recalculates the cache of track information generated from animation nodes. Needed when external sources modify the animation nodes' state. bindAnimationTreePlayer_recompute_caches :: MethodBind bindAnimationTreePlayer_recompute_caches = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "recompute_caches" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Manually recalculates the cache of track information generated from animation nodes. Needed when external sources modify the animation nodes' state. recompute_caches :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> IO () recompute_caches cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_recompute_caches (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "recompute_caches" '[] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.recompute_caches {-# NOINLINE bindAnimationTreePlayer_remove_node #-} -- | Removes the animation node with name @id@. bindAnimationTreePlayer_remove_node :: MethodBind bindAnimationTreePlayer_remove_node = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "remove_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the animation node with name @id@. remove_node :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO () remove_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_remove_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "remove_node" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.remove_node {-# NOINLINE bindAnimationTreePlayer_reset #-} -- | Resets this @AnimationTreePlayer@. bindAnimationTreePlayer_reset :: MethodBind bindAnimationTreePlayer_reset = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "reset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resets this @AnimationTreePlayer@. reset :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> IO () reset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_reset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "reset" '[] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.reset {-# NOINLINE bindAnimationTreePlayer_set_active #-} -- | If @true@, the @AnimationTreePlayer@ is able to play animations. bindAnimationTreePlayer_set_active :: MethodBind bindAnimationTreePlayer_set_active = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @AnimationTreePlayer@ is able to play animations. set_active :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> Bool -> IO () set_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "set_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.set_active {-# NOINLINE bindAnimationTreePlayer_set_animation_process_mode #-} -- | The thread in which to update animations. bindAnimationTreePlayer_set_animation_process_mode :: MethodBind bindAnimationTreePlayer_set_animation_process_mode = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "set_animation_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The thread in which to update animations. set_animation_process_mode :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> Int -> IO () set_animation_process_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_set_animation_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "set_animation_process_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.set_animation_process_mode {-# NOINLINE bindAnimationTreePlayer_set_base_path #-} -- | The node from which to relatively access other nodes. -- It accesses the bones, so it should point to the same node the @AnimationPlayer@ would point its Root Node at. bindAnimationTreePlayer_set_base_path :: MethodBind bindAnimationTreePlayer_set_base_path = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "set_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node from which to relatively access other nodes. -- It accesses the bones, so it should point to the same node the @AnimationPlayer@ would point its Root Node at. set_base_path :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> NodePath -> IO () set_base_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_set_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "set_base_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.set_base_path {-# NOINLINE bindAnimationTreePlayer_set_master_player #-} -- | The path to the @AnimationPlayer@ from which this @AnimationTreePlayer@ binds animations to animation nodes. -- Once set, @Animation@ nodes can be added to the @AnimationTreePlayer@. bindAnimationTreePlayer_set_master_player :: MethodBind bindAnimationTreePlayer_set_master_player = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "set_master_player" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the @AnimationPlayer@ from which this @AnimationTreePlayer@ binds animations to animation nodes. -- Once set, @Animation@ nodes can be added to the @AnimationTreePlayer@. set_master_player :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> NodePath -> IO () set_master_player cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_set_master_player (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "set_master_player" '[NodePath] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.set_master_player {-# NOINLINE bindAnimationTreePlayer_timescale_node_get_scale #-} -- | Returns the time scale value of the TimeScale node with name @id@. bindAnimationTreePlayer_timescale_node_get_scale :: MethodBind bindAnimationTreePlayer_timescale_node_get_scale = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "timescale_node_get_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the time scale value of the TimeScale node with name @id@. timescale_node_get_scale :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float timescale_node_get_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_timescale_node_get_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "timescale_node_get_scale" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.timescale_node_get_scale {-# NOINLINE bindAnimationTreePlayer_timescale_node_set_scale #-} -- | Sets the time scale of the TimeScale node with name @id@ to @scale@. -- The TimeScale node is used to speed @Animation@s up if the scale is above 1 or slow them down if it is below 1. -- If applied after a blend or mix, affects all input animations to that blend or mix. bindAnimationTreePlayer_timescale_node_set_scale :: MethodBind bindAnimationTreePlayer_timescale_node_set_scale = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "timescale_node_set_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the time scale of the TimeScale node with name @id@ to @scale@. -- The TimeScale node is used to speed @Animation@s up if the scale is above 1 or slow them down if it is below 1. -- If applied after a blend or mix, affects all input animations to that blend or mix. timescale_node_set_scale :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () timescale_node_set_scale cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_timescale_node_set_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "timescale_node_set_scale" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.timescale_node_set_scale {-# NOINLINE bindAnimationTreePlayer_timeseek_node_seek #-} -- | Sets the time seek value of the TimeSeek node with name @id@ to @seconds@. -- This functions as a seek in the @Animation@ or the blend or mix of @Animation@s input in it. bindAnimationTreePlayer_timeseek_node_seek :: MethodBind bindAnimationTreePlayer_timeseek_node_seek = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "timeseek_node_seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the time seek value of the TimeSeek node with name @id@ to @seconds@. -- This functions as a seek in the @Animation@ or the blend or mix of @Animation@s input in it. timeseek_node_seek :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () timeseek_node_seek cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_timeseek_node_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "timeseek_node_seek" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.timeseek_node_seek {-# NOINLINE bindAnimationTreePlayer_transition_node_delete_input #-} -- | Deletes the input at @input_idx@ for the transition node with name @id@. bindAnimationTreePlayer_transition_node_delete_input :: MethodBind bindAnimationTreePlayer_transition_node_delete_input = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_delete_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the input at @input_idx@ for the transition node with name @id@. transition_node_delete_input :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () transition_node_delete_input cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_delete_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_delete_input" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_delete_input {-# NOINLINE bindAnimationTreePlayer_transition_node_get_current #-} -- | Returns the index of the currently evaluated input for the transition node with name @id@. bindAnimationTreePlayer_transition_node_get_current :: MethodBind bindAnimationTreePlayer_transition_node_get_current = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_get_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the currently evaluated input for the transition node with name @id@. transition_node_get_current :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Int transition_node_get_current cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_get_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_get_current" '[GodotString] (IO Int) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_get_current {-# NOINLINE bindAnimationTreePlayer_transition_node_get_input_count #-} -- | Returns the number of inputs for the transition node with name @id@. You can add inputs by right-clicking on the transition node. bindAnimationTreePlayer_transition_node_get_input_count :: MethodBind bindAnimationTreePlayer_transition_node_get_input_count = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_get_input_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of inputs for the transition node with name @id@. You can add inputs by right-clicking on the transition node. transition_node_get_input_count :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Int transition_node_get_input_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_get_input_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_get_input_count" '[GodotString] (IO Int) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_get_input_count {-# NOINLINE bindAnimationTreePlayer_transition_node_get_xfade_time #-} -- | Returns the cross fade time for the transition node with name @id@. bindAnimationTreePlayer_transition_node_get_xfade_time :: MethodBind bindAnimationTreePlayer_transition_node_get_xfade_time = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_get_xfade_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cross fade time for the transition node with name @id@. transition_node_get_xfade_time :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> IO Float transition_node_get_xfade_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_get_xfade_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_get_xfade_time" '[GodotString] (IO Float) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_get_xfade_time {-# NOINLINE bindAnimationTreePlayer_transition_node_has_input_auto_advance #-} -- | Returns @true@ if the input at @input_idx@ on the transition node with name @id@ is set to automatically advance to the next input upon completion. bindAnimationTreePlayer_transition_node_has_input_auto_advance :: MethodBind bindAnimationTreePlayer_transition_node_has_input_auto_advance = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_has_input_auto_advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the input at @input_idx@ on the transition node with name @id@ is set to automatically advance to the next input upon completion. transition_node_has_input_auto_advance :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Int -> IO Bool transition_node_has_input_auto_advance cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_has_input_auto_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_has_input_auto_advance" '[GodotString, Int] (IO Bool) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_has_input_auto_advance {-# NOINLINE bindAnimationTreePlayer_transition_node_set_current #-} -- | The transition node with name @id@ sets its current input at @input_idx@. bindAnimationTreePlayer_transition_node_set_current :: MethodBind bindAnimationTreePlayer_transition_node_set_current = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_set_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The transition node with name @id@ sets its current input at @input_idx@. transition_node_set_current :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () transition_node_set_current cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_set_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_set_current" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_set_current {-# NOINLINE bindAnimationTreePlayer_transition_node_set_input_auto_advance #-} -- | The transition node with name @id@ advances to its next input automatically when the input at @input_idx@ completes. bindAnimationTreePlayer_transition_node_set_input_auto_advance :: MethodBind bindAnimationTreePlayer_transition_node_set_input_auto_advance = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_set_input_auto_advance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The transition node with name @id@ advances to its next input automatically when the input at @input_idx@ completes. transition_node_set_input_auto_advance :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Int -> Bool -> IO () transition_node_set_input_auto_advance cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_set_input_auto_advance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_set_input_auto_advance" '[GodotString, Int, Bool] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_set_input_auto_advance {-# NOINLINE bindAnimationTreePlayer_transition_node_set_input_count #-} -- | Resizes the number of inputs available for the transition node with name @id@. bindAnimationTreePlayer_transition_node_set_input_count :: MethodBind bindAnimationTreePlayer_transition_node_set_input_count = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_set_input_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resizes the number of inputs available for the transition node with name @id@. transition_node_set_input_count :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () transition_node_set_input_count cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_set_input_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_set_input_count" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_set_input_count {-# NOINLINE bindAnimationTreePlayer_transition_node_set_xfade_time #-} -- | The transition node with name @id@ sets its cross fade time to @time_sec@. bindAnimationTreePlayer_transition_node_set_xfade_time :: MethodBind bindAnimationTreePlayer_transition_node_set_xfade_time = unsafePerformIO $ withCString "AnimationTreePlayer" $ \ clsNamePtr -> withCString "transition_node_set_xfade_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The transition node with name @id@ sets its cross fade time to @time_sec@. transition_node_set_xfade_time :: (AnimationTreePlayer :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () transition_node_set_xfade_time cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAnimationTreePlayer_transition_node_set_xfade_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AnimationTreePlayer "transition_node_set_xfade_time" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.AnimationTreePlayer.transition_node_set_xfade_time ================================================ FILE: src/Godot/Core/Area.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Area (Godot.Core.Area._SPACE_OVERRIDE_REPLACE, Godot.Core.Area._SPACE_OVERRIDE_DISABLED, Godot.Core.Area._SPACE_OVERRIDE_COMBINE_REPLACE, Godot.Core.Area._SPACE_OVERRIDE_REPLACE_COMBINE, Godot.Core.Area._SPACE_OVERRIDE_COMBINE, Godot.Core.Area.sig_area_entered, Godot.Core.Area.sig_area_exited, Godot.Core.Area.sig_area_shape_entered, Godot.Core.Area.sig_area_shape_exited, Godot.Core.Area.sig_body_entered, Godot.Core.Area.sig_body_exited, Godot.Core.Area.sig_body_shape_entered, Godot.Core.Area.sig_body_shape_exited, Godot.Core.Area._area_enter_tree, Godot.Core.Area._area_exit_tree, Godot.Core.Area._area_inout, Godot.Core.Area._body_enter_tree, Godot.Core.Area._body_exit_tree, Godot.Core.Area._body_inout, Godot.Core.Area.get_angular_damp, Godot.Core.Area.get_audio_bus, Godot.Core.Area.get_collision_layer, Godot.Core.Area.get_collision_layer_bit, Godot.Core.Area.get_collision_mask, Godot.Core.Area.get_collision_mask_bit, Godot.Core.Area.get_gravity, Godot.Core.Area.get_gravity_distance_scale, Godot.Core.Area.get_gravity_vector, Godot.Core.Area.get_linear_damp, Godot.Core.Area.get_overlapping_areas, Godot.Core.Area.get_overlapping_bodies, Godot.Core.Area.get_priority, Godot.Core.Area.get_reverb_amount, Godot.Core.Area.get_reverb_bus, Godot.Core.Area.get_reverb_uniformity, Godot.Core.Area.get_space_override_mode, Godot.Core.Area.is_gravity_a_point, Godot.Core.Area.is_monitorable, Godot.Core.Area.is_monitoring, Godot.Core.Area.is_overriding_audio_bus, Godot.Core.Area.is_using_reverb_bus, Godot.Core.Area.overlaps_area, Godot.Core.Area.overlaps_body, Godot.Core.Area.set_angular_damp, Godot.Core.Area.set_audio_bus, Godot.Core.Area.set_audio_bus_override, Godot.Core.Area.set_collision_layer, Godot.Core.Area.set_collision_layer_bit, Godot.Core.Area.set_collision_mask, Godot.Core.Area.set_collision_mask_bit, Godot.Core.Area.set_gravity, Godot.Core.Area.set_gravity_distance_scale, Godot.Core.Area.set_gravity_is_point, Godot.Core.Area.set_gravity_vector, Godot.Core.Area.set_linear_damp, Godot.Core.Area.set_monitorable, Godot.Core.Area.set_monitoring, Godot.Core.Area.set_priority, Godot.Core.Area.set_reverb_amount, Godot.Core.Area.set_reverb_bus, Godot.Core.Area.set_reverb_uniformity, Godot.Core.Area.set_space_override_mode, Godot.Core.Area.set_use_reverb_bus) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CollisionObject() _SPACE_OVERRIDE_REPLACE :: Int _SPACE_OVERRIDE_REPLACE = 3 _SPACE_OVERRIDE_DISABLED :: Int _SPACE_OVERRIDE_DISABLED = 0 _SPACE_OVERRIDE_COMBINE_REPLACE :: Int _SPACE_OVERRIDE_COMBINE_REPLACE = 2 _SPACE_OVERRIDE_REPLACE_COMBINE :: Int _SPACE_OVERRIDE_REPLACE_COMBINE = 4 _SPACE_OVERRIDE_COMBINE :: Int _SPACE_OVERRIDE_COMBINE = 1 -- | Emitted when another area enters. sig_area_entered :: Godot.Internal.Dispatch.Signal Area sig_area_entered = Godot.Internal.Dispatch.Signal "area_entered" instance NodeSignal Area "area_entered" '[Area] -- | Emitted when another area exits. sig_area_exited :: Godot.Internal.Dispatch.Signal Area sig_area_exited = Godot.Internal.Dispatch.Signal "area_exited" instance NodeSignal Area "area_exited" '[Area] -- | Emitted when another area enters, reporting which areas overlapped. @shape_owner_get_owner(shape_find_owner(shape))@ returns the parent object of the owner of the @shape@. sig_area_shape_entered :: Godot.Internal.Dispatch.Signal Area sig_area_shape_entered = Godot.Internal.Dispatch.Signal "area_shape_entered" instance NodeSignal Area "area_shape_entered" '[Int, Area, Int, Int] -- | Emitted when another area exits, reporting which areas were overlapping. sig_area_shape_exited :: Godot.Internal.Dispatch.Signal Area sig_area_shape_exited = Godot.Internal.Dispatch.Signal "area_shape_exited" instance NodeSignal Area "area_shape_exited" '[Int, Area, Int, Int] -- | Emitted when a physics body enters. -- The @body@ argument can either be a @PhysicsBody@ or a @GridMap@ instance (while GridMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). sig_body_entered :: Godot.Internal.Dispatch.Signal Area sig_body_entered = Godot.Internal.Dispatch.Signal "body_entered" instance NodeSignal Area "body_entered" '[Node] -- | Emitted when a physics body exits. -- The @body@ argument can either be a @PhysicsBody@ or a @GridMap@ instance (while GridMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). sig_body_exited :: Godot.Internal.Dispatch.Signal Area sig_body_exited = Godot.Internal.Dispatch.Signal "body_exited" instance NodeSignal Area "body_exited" '[Node] -- | Emitted when a physics body enters, reporting which shapes overlapped. -- The @body@ argument can either be a @PhysicsBody@ or a @GridMap@ instance (while GridMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). sig_body_shape_entered :: Godot.Internal.Dispatch.Signal Area sig_body_shape_entered = Godot.Internal.Dispatch.Signal "body_shape_entered" instance NodeSignal Area "body_shape_entered" '[Int, Node, Int, Int] -- | Emitted when a physics body exits, reporting which shapes were overlapping. -- The @body@ argument can either be a @PhysicsBody@ or a @GridMap@ instance (while GridMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). sig_body_shape_exited :: Godot.Internal.Dispatch.Signal Area sig_body_shape_exited = Godot.Internal.Dispatch.Signal "body_shape_exited" instance NodeSignal Area "body_shape_exited" '[Int, Node, Int, Int] instance NodeProperty Area "angular_damp" Float 'False where nodeProperty = (get_angular_damp, wrapDroppingSetter set_angular_damp, Nothing) instance NodeProperty Area "audio_bus_name" GodotString 'False where nodeProperty = (get_audio_bus, wrapDroppingSetter set_audio_bus, Nothing) instance NodeProperty Area "audio_bus_override" Bool 'False where nodeProperty = (is_overriding_audio_bus, wrapDroppingSetter set_audio_bus_override, Nothing) instance NodeProperty Area "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty Area "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty Area "gravity" Float 'False where nodeProperty = (get_gravity, wrapDroppingSetter set_gravity, Nothing) instance NodeProperty Area "gravity_distance_scale" Float 'False where nodeProperty = (get_gravity_distance_scale, wrapDroppingSetter set_gravity_distance_scale, Nothing) instance NodeProperty Area "gravity_point" Bool 'False where nodeProperty = (is_gravity_a_point, wrapDroppingSetter set_gravity_is_point, Nothing) instance NodeProperty Area "gravity_vec" Vector3 'False where nodeProperty = (get_gravity_vector, wrapDroppingSetter set_gravity_vector, Nothing) instance NodeProperty Area "linear_damp" Float 'False where nodeProperty = (get_linear_damp, wrapDroppingSetter set_linear_damp, Nothing) instance NodeProperty Area "monitorable" Bool 'False where nodeProperty = (is_monitorable, wrapDroppingSetter set_monitorable, Nothing) instance NodeProperty Area "monitoring" Bool 'False where nodeProperty = (is_monitoring, wrapDroppingSetter set_monitoring, Nothing) instance NodeProperty Area "priority" Float 'False where nodeProperty = (get_priority, wrapDroppingSetter set_priority, Nothing) instance NodeProperty Area "reverb_bus_amount" Float 'False where nodeProperty = (get_reverb_amount, wrapDroppingSetter set_reverb_amount, Nothing) instance NodeProperty Area "reverb_bus_enable" Bool 'False where nodeProperty = (is_using_reverb_bus, wrapDroppingSetter set_use_reverb_bus, Nothing) instance NodeProperty Area "reverb_bus_name" GodotString 'False where nodeProperty = (get_reverb_bus, wrapDroppingSetter set_reverb_bus, Nothing) instance NodeProperty Area "reverb_bus_uniformity" Float 'False where nodeProperty = (get_reverb_uniformity, wrapDroppingSetter set_reverb_uniformity, Nothing) instance NodeProperty Area "space_override" Int 'False where nodeProperty = (get_space_override_mode, wrapDroppingSetter set_space_override_mode, Nothing) {-# NOINLINE bindArea__area_enter_tree #-} bindArea__area_enter_tree :: MethodBind bindArea__area_enter_tree = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "_area_enter_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _area_enter_tree :: (Area :< cls, Object :< cls) => cls -> Int -> IO () _area_enter_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea__area_enter_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "_area_enter_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.Area._area_enter_tree {-# NOINLINE bindArea__area_exit_tree #-} bindArea__area_exit_tree :: MethodBind bindArea__area_exit_tree = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "_area_exit_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _area_exit_tree :: (Area :< cls, Object :< cls) => cls -> Int -> IO () _area_exit_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea__area_exit_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "_area_exit_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.Area._area_exit_tree {-# NOINLINE bindArea__area_inout #-} bindArea__area_inout :: MethodBind bindArea__area_inout = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "_area_inout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _area_inout :: (Area :< cls, Object :< cls) => cls -> Int -> Rid -> Int -> Int -> Int -> IO () _area_inout cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindArea__area_inout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "_area_inout" '[Int, Rid, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.Area._area_inout {-# NOINLINE bindArea__body_enter_tree #-} bindArea__body_enter_tree :: MethodBind bindArea__body_enter_tree = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "_body_enter_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_enter_tree :: (Area :< cls, Object :< cls) => cls -> Int -> IO () _body_enter_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea__body_enter_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "_body_enter_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.Area._body_enter_tree {-# NOINLINE bindArea__body_exit_tree #-} bindArea__body_exit_tree :: MethodBind bindArea__body_exit_tree = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "_body_exit_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_exit_tree :: (Area :< cls, Object :< cls) => cls -> Int -> IO () _body_exit_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea__body_exit_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "_body_exit_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.Area._body_exit_tree {-# NOINLINE bindArea__body_inout #-} bindArea__body_inout :: MethodBind bindArea__body_inout = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "_body_inout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_inout :: (Area :< cls, Object :< cls) => cls -> Int -> Rid -> Int -> Int -> Int -> IO () _body_inout cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindArea__body_inout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "_body_inout" '[Int, Rid, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.Area._body_inout {-# NOINLINE bindArea_get_angular_damp #-} -- | The rate at which objects stop spinning in this area. Represents the angular velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). bindArea_get_angular_damp :: MethodBind bindArea_get_angular_damp = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which objects stop spinning in this area. Represents the angular velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). get_angular_damp :: (Area :< cls, Object :< cls) => cls -> IO Float get_angular_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_angular_damp" '[] (IO Float) where nodeMethod = Godot.Core.Area.get_angular_damp {-# NOINLINE bindArea_get_audio_bus #-} -- | The name of the area's audio bus. bindArea_get_audio_bus :: MethodBind bindArea_get_audio_bus = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_audio_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the area's audio bus. get_audio_bus :: (Area :< cls, Object :< cls) => cls -> IO GodotString get_audio_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_audio_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_audio_bus" '[] (IO GodotString) where nodeMethod = Godot.Core.Area.get_audio_bus {-# NOINLINE bindArea_get_collision_layer #-} -- | The area's physics layer(s). Collidable objects can exist in any of 32 different layers. A contact is detected if object A is in any of the layers that object B scans, or object B is in any layers that object A scans. See also @collision_mask@. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindArea_get_collision_layer :: MethodBind bindArea_get_collision_layer = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's physics layer(s). Collidable objects can exist in any of 32 different layers. A contact is detected if object A is in any of the layers that object B scans, or object B is in any layers that object A scans. See also @collision_mask@. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_layer :: (Area :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.Area.get_collision_layer {-# NOINLINE bindArea_get_collision_layer_bit #-} -- | Returns an individual bit on the layer mask. bindArea_get_collision_layer_bit :: MethodBind bindArea_get_collision_layer_bit = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the layer mask. get_collision_layer_bit :: (Area :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_layer_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_collision_layer_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.Area.get_collision_layer_bit {-# NOINLINE bindArea_get_collision_mask #-} -- | The physics layers this area scans to determine collision detection. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindArea_get_collision_mask :: MethodBind bindArea_get_collision_mask = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area scans to determine collision detection. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (Area :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.Area.get_collision_mask {-# NOINLINE bindArea_get_collision_mask_bit #-} -- | Returns an individual bit on the collision mask. bindArea_get_collision_mask_bit :: MethodBind bindArea_get_collision_mask_bit = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the collision mask. get_collision_mask_bit :: (Area :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.Area.get_collision_mask_bit {-# NOINLINE bindArea_get_gravity #-} -- | The area's gravity intensity (ranges from -1024 to 1024). This value multiplies the gravity vector. This is useful to alter the force of gravity without altering its direction. bindArea_get_gravity :: MethodBind bindArea_get_gravity = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's gravity intensity (ranges from -1024 to 1024). This value multiplies the gravity vector. This is useful to alter the force of gravity without altering its direction. get_gravity :: (Area :< cls, Object :< cls) => cls -> IO Float get_gravity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_gravity" '[] (IO Float) where nodeMethod = Godot.Core.Area.get_gravity {-# NOINLINE bindArea_get_gravity_distance_scale #-} -- | The falloff factor for point gravity. The greater the value, the faster gravity decreases with distance. bindArea_get_gravity_distance_scale :: MethodBind bindArea_get_gravity_distance_scale = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_gravity_distance_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The falloff factor for point gravity. The greater the value, the faster gravity decreases with distance. get_gravity_distance_scale :: (Area :< cls, Object :< cls) => cls -> IO Float get_gravity_distance_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_gravity_distance_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_gravity_distance_scale" '[] (IO Float) where nodeMethod = Godot.Core.Area.get_gravity_distance_scale {-# NOINLINE bindArea_get_gravity_vector #-} -- | The area's gravity vector (not normalized). If gravity is a point (see @gravity_point@), this will be the point of attraction. bindArea_get_gravity_vector :: MethodBind bindArea_get_gravity_vector = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_gravity_vector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's gravity vector (not normalized). If gravity is a point (see @gravity_point@), this will be the point of attraction. get_gravity_vector :: (Area :< cls, Object :< cls) => cls -> IO Vector3 get_gravity_vector cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_gravity_vector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_gravity_vector" '[] (IO Vector3) where nodeMethod = Godot.Core.Area.get_gravity_vector {-# NOINLINE bindArea_get_linear_damp #-} -- | The rate at which objects stop moving in this area. Represents the linear velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). bindArea_get_linear_damp :: MethodBind bindArea_get_linear_damp = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which objects stop moving in this area. Represents the linear velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). get_linear_damp :: (Area :< cls, Object :< cls) => cls -> IO Float get_linear_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_linear_damp" '[] (IO Float) where nodeMethod = Godot.Core.Area.get_linear_damp {-# NOINLINE bindArea_get_overlapping_areas #-} -- | Returns a list of intersecting @Area@s. For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead. bindArea_get_overlapping_areas :: MethodBind bindArea_get_overlapping_areas = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_overlapping_areas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of intersecting @Area@s. For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead. get_overlapping_areas :: (Area :< cls, Object :< cls) => cls -> IO Array get_overlapping_areas cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_overlapping_areas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_overlapping_areas" '[] (IO Array) where nodeMethod = Godot.Core.Area.get_overlapping_areas {-# NOINLINE bindArea_get_overlapping_bodies #-} -- | Returns a list of intersecting @PhysicsBody@s. For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead. bindArea_get_overlapping_bodies :: MethodBind bindArea_get_overlapping_bodies = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_overlapping_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of intersecting @PhysicsBody@s. For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead. get_overlapping_bodies :: (Area :< cls, Object :< cls) => cls -> IO Array get_overlapping_bodies cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_overlapping_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_overlapping_bodies" '[] (IO Array) where nodeMethod = Godot.Core.Area.get_overlapping_bodies {-# NOINLINE bindArea_get_priority #-} -- | The area's priority. Higher priority areas are processed first. bindArea_get_priority :: MethodBind bindArea_get_priority = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's priority. Higher priority areas are processed first. get_priority :: (Area :< cls, Object :< cls) => cls -> IO Float get_priority cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_priority" '[] (IO Float) where nodeMethod = Godot.Core.Area.get_priority {-# NOINLINE bindArea_get_reverb_amount #-} -- | The degree to which this area applies reverb to its associated audio. Ranges from @0@ to @1@ with @0.1@ precision. bindArea_get_reverb_amount :: MethodBind bindArea_get_reverb_amount = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_reverb_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The degree to which this area applies reverb to its associated audio. Ranges from @0@ to @1@ with @0.1@ precision. get_reverb_amount :: (Area :< cls, Object :< cls) => cls -> IO Float get_reverb_amount cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_reverb_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_reverb_amount" '[] (IO Float) where nodeMethod = Godot.Core.Area.get_reverb_amount {-# NOINLINE bindArea_get_reverb_bus #-} -- | The reverb bus name to use for this area's associated audio. bindArea_get_reverb_bus :: MethodBind bindArea_get_reverb_bus = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_reverb_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The reverb bus name to use for this area's associated audio. get_reverb_bus :: (Area :< cls, Object :< cls) => cls -> IO GodotString get_reverb_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_reverb_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_reverb_bus" '[] (IO GodotString) where nodeMethod = Godot.Core.Area.get_reverb_bus {-# NOINLINE bindArea_get_reverb_uniformity #-} -- | The degree to which this area's reverb is a uniform effect. Ranges from @0@ to @1@ with @0.1@ precision. bindArea_get_reverb_uniformity :: MethodBind bindArea_get_reverb_uniformity = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_reverb_uniformity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The degree to which this area's reverb is a uniform effect. Ranges from @0@ to @1@ with @0.1@ precision. get_reverb_uniformity :: (Area :< cls, Object :< cls) => cls -> IO Float get_reverb_uniformity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_reverb_uniformity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_reverb_uniformity" '[] (IO Float) where nodeMethod = Godot.Core.Area.get_reverb_uniformity {-# NOINLINE bindArea_get_space_override_mode #-} -- | Override mode for gravity and damping calculations within this area. See @enum SpaceOverride@ for possible values. bindArea_get_space_override_mode :: MethodBind bindArea_get_space_override_mode = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "get_space_override_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override mode for gravity and damping calculations within this area. See @enum SpaceOverride@ for possible values. get_space_override_mode :: (Area :< cls, Object :< cls) => cls -> IO Int get_space_override_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_get_space_override_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "get_space_override_mode" '[] (IO Int) where nodeMethod = Godot.Core.Area.get_space_override_mode {-# NOINLINE bindArea_is_gravity_a_point #-} -- | If @true@, gravity is calculated from a point (set via @gravity_vec@). See also @space_override@. bindArea_is_gravity_a_point :: MethodBind bindArea_is_gravity_a_point = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "is_gravity_a_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, gravity is calculated from a point (set via @gravity_vec@). See also @space_override@. is_gravity_a_point :: (Area :< cls, Object :< cls) => cls -> IO Bool is_gravity_a_point cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_is_gravity_a_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "is_gravity_a_point" '[] (IO Bool) where nodeMethod = Godot.Core.Area.is_gravity_a_point {-# NOINLINE bindArea_is_monitorable #-} -- | If @true@, other monitoring areas can detect this area. bindArea_is_monitorable :: MethodBind bindArea_is_monitorable = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "is_monitorable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, other monitoring areas can detect this area. is_monitorable :: (Area :< cls, Object :< cls) => cls -> IO Bool is_monitorable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_is_monitorable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "is_monitorable" '[] (IO Bool) where nodeMethod = Godot.Core.Area.is_monitorable {-# NOINLINE bindArea_is_monitoring #-} -- | If @true@, the area detects bodies or areas entering and exiting it. bindArea_is_monitoring :: MethodBind bindArea_is_monitoring = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "is_monitoring" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area detects bodies or areas entering and exiting it. is_monitoring :: (Area :< cls, Object :< cls) => cls -> IO Bool is_monitoring cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_is_monitoring (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "is_monitoring" '[] (IO Bool) where nodeMethod = Godot.Core.Area.is_monitoring {-# NOINLINE bindArea_is_overriding_audio_bus #-} -- | If @true@, the area's audio bus overrides the default audio bus. bindArea_is_overriding_audio_bus :: MethodBind bindArea_is_overriding_audio_bus = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "is_overriding_audio_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area's audio bus overrides the default audio bus. is_overriding_audio_bus :: (Area :< cls, Object :< cls) => cls -> IO Bool is_overriding_audio_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_is_overriding_audio_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "is_overriding_audio_bus" '[] (IO Bool) where nodeMethod = Godot.Core.Area.is_overriding_audio_bus {-# NOINLINE bindArea_is_using_reverb_bus #-} -- | If @true@, the area applies reverb to its associated audio. bindArea_is_using_reverb_bus :: MethodBind bindArea_is_using_reverb_bus = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "is_using_reverb_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area applies reverb to its associated audio. is_using_reverb_bus :: (Area :< cls, Object :< cls) => cls -> IO Bool is_using_reverb_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea_is_using_reverb_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "is_using_reverb_bus" '[] (IO Bool) where nodeMethod = Godot.Core.Area.is_using_reverb_bus {-# NOINLINE bindArea_overlaps_area #-} -- | If @true@, the given area overlaps the Area. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead. bindArea_overlaps_area :: MethodBind bindArea_overlaps_area = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "overlaps_area" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the given area overlaps the Area. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead. overlaps_area :: (Area :< cls, Object :< cls) => cls -> Node -> IO Bool overlaps_area cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_overlaps_area (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "overlaps_area" '[Node] (IO Bool) where nodeMethod = Godot.Core.Area.overlaps_area {-# NOINLINE bindArea_overlaps_body #-} -- | If @true@, the given physics body overlaps the Area. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead. -- The @body@ argument can either be a @PhysicsBody@ or a @GridMap@ instance (while GridMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). bindArea_overlaps_body :: MethodBind bindArea_overlaps_body = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "overlaps_body" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the given physics body overlaps the Area. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead. -- The @body@ argument can either be a @PhysicsBody@ or a @GridMap@ instance (while GridMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). overlaps_body :: (Area :< cls, Object :< cls) => cls -> Node -> IO Bool overlaps_body cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_overlaps_body (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "overlaps_body" '[Node] (IO Bool) where nodeMethod = Godot.Core.Area.overlaps_body {-# NOINLINE bindArea_set_angular_damp #-} -- | The rate at which objects stop spinning in this area. Represents the angular velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). bindArea_set_angular_damp :: MethodBind bindArea_set_angular_damp = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which objects stop spinning in this area. Represents the angular velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). set_angular_damp :: (Area :< cls, Object :< cls) => cls -> Float -> IO () set_angular_damp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_angular_damp" '[Float] (IO ()) where nodeMethod = Godot.Core.Area.set_angular_damp {-# NOINLINE bindArea_set_audio_bus #-} -- | The name of the area's audio bus. bindArea_set_audio_bus :: MethodBind bindArea_set_audio_bus = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_audio_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the area's audio bus. set_audio_bus :: (Area :< cls, Object :< cls) => cls -> GodotString -> IO () set_audio_bus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_audio_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_audio_bus" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Area.set_audio_bus {-# NOINLINE bindArea_set_audio_bus_override #-} -- | If @true@, the area's audio bus overrides the default audio bus. bindArea_set_audio_bus_override :: MethodBind bindArea_set_audio_bus_override = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_audio_bus_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area's audio bus overrides the default audio bus. set_audio_bus_override :: (Area :< cls, Object :< cls) => cls -> Bool -> IO () set_audio_bus_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_audio_bus_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_audio_bus_override" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area.set_audio_bus_override {-# NOINLINE bindArea_set_collision_layer #-} -- | The area's physics layer(s). Collidable objects can exist in any of 32 different layers. A contact is detected if object A is in any of the layers that object B scans, or object B is in any layers that object A scans. See also @collision_mask@. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindArea_set_collision_layer :: MethodBind bindArea_set_collision_layer = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's physics layer(s). Collidable objects can exist in any of 32 different layers. A contact is detected if object A is in any of the layers that object B scans, or object B is in any layers that object A scans. See also @collision_mask@. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_layer :: (Area :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.Area.set_collision_layer {-# NOINLINE bindArea_set_collision_layer_bit #-} -- | Set/clear individual bits on the layer mask. This simplifies editing this @Area@'s layers. bindArea_set_collision_layer_bit :: MethodBind bindArea_set_collision_layer_bit = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Set/clear individual bits on the layer mask. This simplifies editing this @Area@'s layers. set_collision_layer_bit :: (Area :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_layer_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_collision_layer_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Area.set_collision_layer_bit {-# NOINLINE bindArea_set_collision_mask #-} -- | The physics layers this area scans to determine collision detection. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindArea_set_collision_mask :: MethodBind bindArea_set_collision_mask = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area scans to determine collision detection. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (Area :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.Area.set_collision_mask {-# NOINLINE bindArea_set_collision_mask_bit #-} -- | Set/clear individual bits on the collision mask. This simplifies editing which @Area@ layers this @Area@ scans. bindArea_set_collision_mask_bit :: MethodBind bindArea_set_collision_mask_bit = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Set/clear individual bits on the collision mask. This simplifies editing which @Area@ layers this @Area@ scans. set_collision_mask_bit :: (Area :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Area.set_collision_mask_bit {-# NOINLINE bindArea_set_gravity #-} -- | The area's gravity intensity (ranges from -1024 to 1024). This value multiplies the gravity vector. This is useful to alter the force of gravity without altering its direction. bindArea_set_gravity :: MethodBind bindArea_set_gravity = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's gravity intensity (ranges from -1024 to 1024). This value multiplies the gravity vector. This is useful to alter the force of gravity without altering its direction. set_gravity :: (Area :< cls, Object :< cls) => cls -> Float -> IO () set_gravity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_gravity" '[Float] (IO ()) where nodeMethod = Godot.Core.Area.set_gravity {-# NOINLINE bindArea_set_gravity_distance_scale #-} -- | The falloff factor for point gravity. The greater the value, the faster gravity decreases with distance. bindArea_set_gravity_distance_scale :: MethodBind bindArea_set_gravity_distance_scale = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_gravity_distance_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The falloff factor for point gravity. The greater the value, the faster gravity decreases with distance. set_gravity_distance_scale :: (Area :< cls, Object :< cls) => cls -> Float -> IO () set_gravity_distance_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_gravity_distance_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_gravity_distance_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.Area.set_gravity_distance_scale {-# NOINLINE bindArea_set_gravity_is_point #-} -- | If @true@, gravity is calculated from a point (set via @gravity_vec@). See also @space_override@. bindArea_set_gravity_is_point :: MethodBind bindArea_set_gravity_is_point = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_gravity_is_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, gravity is calculated from a point (set via @gravity_vec@). See also @space_override@. set_gravity_is_point :: (Area :< cls, Object :< cls) => cls -> Bool -> IO () set_gravity_is_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_gravity_is_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_gravity_is_point" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area.set_gravity_is_point {-# NOINLINE bindArea_set_gravity_vector #-} -- | The area's gravity vector (not normalized). If gravity is a point (see @gravity_point@), this will be the point of attraction. bindArea_set_gravity_vector :: MethodBind bindArea_set_gravity_vector = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_gravity_vector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's gravity vector (not normalized). If gravity is a point (see @gravity_point@), this will be the point of attraction. set_gravity_vector :: (Area :< cls, Object :< cls) => cls -> Vector3 -> IO () set_gravity_vector cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_gravity_vector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_gravity_vector" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Area.set_gravity_vector {-# NOINLINE bindArea_set_linear_damp #-} -- | The rate at which objects stop moving in this area. Represents the linear velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). bindArea_set_linear_damp :: MethodBind bindArea_set_linear_damp = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which objects stop moving in this area. Represents the linear velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). set_linear_damp :: (Area :< cls, Object :< cls) => cls -> Float -> IO () set_linear_damp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_linear_damp" '[Float] (IO ()) where nodeMethod = Godot.Core.Area.set_linear_damp {-# NOINLINE bindArea_set_monitorable #-} -- | If @true@, other monitoring areas can detect this area. bindArea_set_monitorable :: MethodBind bindArea_set_monitorable = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_monitorable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, other monitoring areas can detect this area. set_monitorable :: (Area :< cls, Object :< cls) => cls -> Bool -> IO () set_monitorable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_monitorable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_monitorable" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area.set_monitorable {-# NOINLINE bindArea_set_monitoring #-} -- | If @true@, the area detects bodies or areas entering and exiting it. bindArea_set_monitoring :: MethodBind bindArea_set_monitoring = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_monitoring" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area detects bodies or areas entering and exiting it. set_monitoring :: (Area :< cls, Object :< cls) => cls -> Bool -> IO () set_monitoring cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_monitoring (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_monitoring" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area.set_monitoring {-# NOINLINE bindArea_set_priority #-} -- | The area's priority. Higher priority areas are processed first. bindArea_set_priority :: MethodBind bindArea_set_priority = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's priority. Higher priority areas are processed first. set_priority :: (Area :< cls, Object :< cls) => cls -> Float -> IO () set_priority cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_priority" '[Float] (IO ()) where nodeMethod = Godot.Core.Area.set_priority {-# NOINLINE bindArea_set_reverb_amount #-} -- | The degree to which this area applies reverb to its associated audio. Ranges from @0@ to @1@ with @0.1@ precision. bindArea_set_reverb_amount :: MethodBind bindArea_set_reverb_amount = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_reverb_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The degree to which this area applies reverb to its associated audio. Ranges from @0@ to @1@ with @0.1@ precision. set_reverb_amount :: (Area :< cls, Object :< cls) => cls -> Float -> IO () set_reverb_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_reverb_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_reverb_amount" '[Float] (IO ()) where nodeMethod = Godot.Core.Area.set_reverb_amount {-# NOINLINE bindArea_set_reverb_bus #-} -- | The reverb bus name to use for this area's associated audio. bindArea_set_reverb_bus :: MethodBind bindArea_set_reverb_bus = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_reverb_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The reverb bus name to use for this area's associated audio. set_reverb_bus :: (Area :< cls, Object :< cls) => cls -> GodotString -> IO () set_reverb_bus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_reverb_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_reverb_bus" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Area.set_reverb_bus {-# NOINLINE bindArea_set_reverb_uniformity #-} -- | The degree to which this area's reverb is a uniform effect. Ranges from @0@ to @1@ with @0.1@ precision. bindArea_set_reverb_uniformity :: MethodBind bindArea_set_reverb_uniformity = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_reverb_uniformity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The degree to which this area's reverb is a uniform effect. Ranges from @0@ to @1@ with @0.1@ precision. set_reverb_uniformity :: (Area :< cls, Object :< cls) => cls -> Float -> IO () set_reverb_uniformity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_reverb_uniformity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_reverb_uniformity" '[Float] (IO ()) where nodeMethod = Godot.Core.Area.set_reverb_uniformity {-# NOINLINE bindArea_set_space_override_mode #-} -- | Override mode for gravity and damping calculations within this area. See @enum SpaceOverride@ for possible values. bindArea_set_space_override_mode :: MethodBind bindArea_set_space_override_mode = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_space_override_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override mode for gravity and damping calculations within this area. See @enum SpaceOverride@ for possible values. set_space_override_mode :: (Area :< cls, Object :< cls) => cls -> Int -> IO () set_space_override_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_space_override_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_space_override_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Area.set_space_override_mode {-# NOINLINE bindArea_set_use_reverb_bus #-} -- | If @true@, the area applies reverb to its associated audio. bindArea_set_use_reverb_bus :: MethodBind bindArea_set_use_reverb_bus = unsafePerformIO $ withCString "Area" $ \ clsNamePtr -> withCString "set_use_reverb_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area applies reverb to its associated audio. set_use_reverb_bus :: (Area :< cls, Object :< cls) => cls -> Bool -> IO () set_use_reverb_bus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea_set_use_reverb_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area "set_use_reverb_bus" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area.set_use_reverb_bus ================================================ FILE: src/Godot/Core/Area2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Area2D (Godot.Core.Area2D._SPACE_OVERRIDE_REPLACE, Godot.Core.Area2D._SPACE_OVERRIDE_DISABLED, Godot.Core.Area2D._SPACE_OVERRIDE_COMBINE_REPLACE, Godot.Core.Area2D._SPACE_OVERRIDE_REPLACE_COMBINE, Godot.Core.Area2D._SPACE_OVERRIDE_COMBINE, Godot.Core.Area2D.sig_area_entered, Godot.Core.Area2D.sig_area_exited, Godot.Core.Area2D.sig_area_shape_entered, Godot.Core.Area2D.sig_area_shape_exited, Godot.Core.Area2D.sig_body_entered, Godot.Core.Area2D.sig_body_exited, Godot.Core.Area2D.sig_body_shape_entered, Godot.Core.Area2D.sig_body_shape_exited, Godot.Core.Area2D._area_enter_tree, Godot.Core.Area2D._area_exit_tree, Godot.Core.Area2D._area_inout, Godot.Core.Area2D._body_enter_tree, Godot.Core.Area2D._body_exit_tree, Godot.Core.Area2D._body_inout, Godot.Core.Area2D.get_angular_damp, Godot.Core.Area2D.get_audio_bus_name, Godot.Core.Area2D.get_collision_layer, Godot.Core.Area2D.get_collision_layer_bit, Godot.Core.Area2D.get_collision_mask, Godot.Core.Area2D.get_collision_mask_bit, Godot.Core.Area2D.get_gravity, Godot.Core.Area2D.get_gravity_distance_scale, Godot.Core.Area2D.get_gravity_vector, Godot.Core.Area2D.get_linear_damp, Godot.Core.Area2D.get_overlapping_areas, Godot.Core.Area2D.get_overlapping_bodies, Godot.Core.Area2D.get_priority, Godot.Core.Area2D.get_space_override_mode, Godot.Core.Area2D.is_gravity_a_point, Godot.Core.Area2D.is_monitorable, Godot.Core.Area2D.is_monitoring, Godot.Core.Area2D.is_overriding_audio_bus, Godot.Core.Area2D.overlaps_area, Godot.Core.Area2D.overlaps_body, Godot.Core.Area2D.set_angular_damp, Godot.Core.Area2D.set_audio_bus_name, Godot.Core.Area2D.set_audio_bus_override, Godot.Core.Area2D.set_collision_layer, Godot.Core.Area2D.set_collision_layer_bit, Godot.Core.Area2D.set_collision_mask, Godot.Core.Area2D.set_collision_mask_bit, Godot.Core.Area2D.set_gravity, Godot.Core.Area2D.set_gravity_distance_scale, Godot.Core.Area2D.set_gravity_is_point, Godot.Core.Area2D.set_gravity_vector, Godot.Core.Area2D.set_linear_damp, Godot.Core.Area2D.set_monitorable, Godot.Core.Area2D.set_monitoring, Godot.Core.Area2D.set_priority, Godot.Core.Area2D.set_space_override_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CollisionObject2D() _SPACE_OVERRIDE_REPLACE :: Int _SPACE_OVERRIDE_REPLACE = 3 _SPACE_OVERRIDE_DISABLED :: Int _SPACE_OVERRIDE_DISABLED = 0 _SPACE_OVERRIDE_COMBINE_REPLACE :: Int _SPACE_OVERRIDE_COMBINE_REPLACE = 2 _SPACE_OVERRIDE_REPLACE_COMBINE :: Int _SPACE_OVERRIDE_REPLACE_COMBINE = 4 _SPACE_OVERRIDE_COMBINE :: Int _SPACE_OVERRIDE_COMBINE = 1 -- | Emitted when another area enters. sig_area_entered :: Godot.Internal.Dispatch.Signal Area2D sig_area_entered = Godot.Internal.Dispatch.Signal "area_entered" instance NodeSignal Area2D "area_entered" '[Area2D] -- | Emitted when another area exits. sig_area_exited :: Godot.Internal.Dispatch.Signal Area2D sig_area_exited = Godot.Internal.Dispatch.Signal "area_exited" instance NodeSignal Area2D "area_exited" '[Area2D] -- | Emitted when another area enters, reporting which shapes overlapped. @shape_owner_get_owner(shape_find_owner(shape))@ returns the parent object of the owner of the @shape@. sig_area_shape_entered :: Godot.Internal.Dispatch.Signal Area2D sig_area_shape_entered = Godot.Internal.Dispatch.Signal "area_shape_entered" instance NodeSignal Area2D "area_shape_entered" '[Int, Area2D, Int, Int] -- | Emitted when another area exits, reporting which shapes were overlapping. sig_area_shape_exited :: Godot.Internal.Dispatch.Signal Area2D sig_area_shape_exited = Godot.Internal.Dispatch.Signal "area_shape_exited" instance NodeSignal Area2D "area_shape_exited" '[Int, Area2D, Int, Int] -- | Emitted when a physics body enters. -- The @body@ argument can either be a @PhysicsBody2D@ or a @TileMap@ instance (while TileMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). sig_body_entered :: Godot.Internal.Dispatch.Signal Area2D sig_body_entered = Godot.Internal.Dispatch.Signal "body_entered" instance NodeSignal Area2D "body_entered" '[Node] -- | Emitted when a physics body exits. -- The @body@ argument can either be a @PhysicsBody2D@ or a @TileMap@ instance (while TileMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). sig_body_exited :: Godot.Internal.Dispatch.Signal Area2D sig_body_exited = Godot.Internal.Dispatch.Signal "body_exited" instance NodeSignal Area2D "body_exited" '[Node] -- | Emitted when a physics body enters, reporting which shapes overlapped. -- The @body@ argument can either be a @PhysicsBody2D@ or a @TileMap@ instance (while TileMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). sig_body_shape_entered :: Godot.Internal.Dispatch.Signal Area2D sig_body_shape_entered = Godot.Internal.Dispatch.Signal "body_shape_entered" instance NodeSignal Area2D "body_shape_entered" '[Int, Node, Int, Int] -- | Emitted when a physics body exits, reporting which shapes were overlapping. -- The @body@ argument can either be a @PhysicsBody2D@ or a @TileMap@ instance (while TileMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). sig_body_shape_exited :: Godot.Internal.Dispatch.Signal Area2D sig_body_shape_exited = Godot.Internal.Dispatch.Signal "body_shape_exited" instance NodeSignal Area2D "body_shape_exited" '[Int, Node, Int, Int] instance NodeProperty Area2D "angular_damp" Float 'False where nodeProperty = (get_angular_damp, wrapDroppingSetter set_angular_damp, Nothing) instance NodeProperty Area2D "audio_bus_name" GodotString 'False where nodeProperty = (get_audio_bus_name, wrapDroppingSetter set_audio_bus_name, Nothing) instance NodeProperty Area2D "audio_bus_override" Bool 'False where nodeProperty = (is_overriding_audio_bus, wrapDroppingSetter set_audio_bus_override, Nothing) instance NodeProperty Area2D "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty Area2D "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty Area2D "gravity" Float 'False where nodeProperty = (get_gravity, wrapDroppingSetter set_gravity, Nothing) instance NodeProperty Area2D "gravity_distance_scale" Float 'False where nodeProperty = (get_gravity_distance_scale, wrapDroppingSetter set_gravity_distance_scale, Nothing) instance NodeProperty Area2D "gravity_point" Bool 'False where nodeProperty = (is_gravity_a_point, wrapDroppingSetter set_gravity_is_point, Nothing) instance NodeProperty Area2D "gravity_vec" Vector2 'False where nodeProperty = (get_gravity_vector, wrapDroppingSetter set_gravity_vector, Nothing) instance NodeProperty Area2D "linear_damp" Float 'False where nodeProperty = (get_linear_damp, wrapDroppingSetter set_linear_damp, Nothing) instance NodeProperty Area2D "monitorable" Bool 'False where nodeProperty = (is_monitorable, wrapDroppingSetter set_monitorable, Nothing) instance NodeProperty Area2D "monitoring" Bool 'False where nodeProperty = (is_monitoring, wrapDroppingSetter set_monitoring, Nothing) instance NodeProperty Area2D "priority" Float 'False where nodeProperty = (get_priority, wrapDroppingSetter set_priority, Nothing) instance NodeProperty Area2D "space_override" Int 'False where nodeProperty = (get_space_override_mode, wrapDroppingSetter set_space_override_mode, Nothing) {-# NOINLINE bindArea2D__area_enter_tree #-} bindArea2D__area_enter_tree :: MethodBind bindArea2D__area_enter_tree = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "_area_enter_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _area_enter_tree :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO () _area_enter_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D__area_enter_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "_area_enter_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.Area2D._area_enter_tree {-# NOINLINE bindArea2D__area_exit_tree #-} bindArea2D__area_exit_tree :: MethodBind bindArea2D__area_exit_tree = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "_area_exit_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _area_exit_tree :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO () _area_exit_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D__area_exit_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "_area_exit_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.Area2D._area_exit_tree {-# NOINLINE bindArea2D__area_inout #-} bindArea2D__area_inout :: MethodBind bindArea2D__area_inout = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "_area_inout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _area_inout :: (Area2D :< cls, Object :< cls) => cls -> Int -> Rid -> Int -> Int -> Int -> IO () _area_inout cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D__area_inout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "_area_inout" '[Int, Rid, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.Area2D._area_inout {-# NOINLINE bindArea2D__body_enter_tree #-} bindArea2D__body_enter_tree :: MethodBind bindArea2D__body_enter_tree = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "_body_enter_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_enter_tree :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO () _body_enter_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D__body_enter_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "_body_enter_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.Area2D._body_enter_tree {-# NOINLINE bindArea2D__body_exit_tree #-} bindArea2D__body_exit_tree :: MethodBind bindArea2D__body_exit_tree = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "_body_exit_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_exit_tree :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO () _body_exit_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D__body_exit_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "_body_exit_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.Area2D._body_exit_tree {-# NOINLINE bindArea2D__body_inout #-} bindArea2D__body_inout :: MethodBind bindArea2D__body_inout = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "_body_inout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_inout :: (Area2D :< cls, Object :< cls) => cls -> Int -> Rid -> Int -> Int -> Int -> IO () _body_inout cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D__body_inout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "_body_inout" '[Int, Rid, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.Area2D._body_inout {-# NOINLINE bindArea2D_get_angular_damp #-} -- | The rate at which objects stop spinning in this area. Represents the angular velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). bindArea2D_get_angular_damp :: MethodBind bindArea2D_get_angular_damp = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which objects stop spinning in this area. Represents the angular velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). get_angular_damp :: (Area2D :< cls, Object :< cls) => cls -> IO Float get_angular_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_angular_damp" '[] (IO Float) where nodeMethod = Godot.Core.Area2D.get_angular_damp {-# NOINLINE bindArea2D_get_audio_bus_name #-} -- | The name of the area's audio bus. bindArea2D_get_audio_bus_name :: MethodBind bindArea2D_get_audio_bus_name = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_audio_bus_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the area's audio bus. get_audio_bus_name :: (Area2D :< cls, Object :< cls) => cls -> IO GodotString get_audio_bus_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_audio_bus_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_audio_bus_name" '[] (IO GodotString) where nodeMethod = Godot.Core.Area2D.get_audio_bus_name {-# NOINLINE bindArea2D_get_collision_layer #-} -- | The area's physics layer(s). Collidable objects can exist in any of 32 different layers. A contact is detected if object A is in any of the layers that object B scans, or object B is in any layers that object A scans. See also @collision_mask@. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindArea2D_get_collision_layer :: MethodBind bindArea2D_get_collision_layer = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's physics layer(s). Collidable objects can exist in any of 32 different layers. A contact is detected if object A is in any of the layers that object B scans, or object B is in any layers that object A scans. See also @collision_mask@. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_layer :: (Area2D :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.Area2D.get_collision_layer {-# NOINLINE bindArea2D_get_collision_layer_bit #-} -- | Returns an individual bit on the layer mask. Describes whether other areas will collide with this one on the given layer. bindArea2D_get_collision_layer_bit :: MethodBind bindArea2D_get_collision_layer_bit = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the layer mask. Describes whether other areas will collide with this one on the given layer. get_collision_layer_bit :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_layer_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_collision_layer_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.Area2D.get_collision_layer_bit {-# NOINLINE bindArea2D_get_collision_mask #-} -- | The physics layers this area scans to determine collision detection. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindArea2D_get_collision_mask :: MethodBind bindArea2D_get_collision_mask = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area scans to determine collision detection. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (Area2D :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.Area2D.get_collision_mask {-# NOINLINE bindArea2D_get_collision_mask_bit #-} -- | Returns an individual bit on the collision mask. Describes whether this area will collide with others on the given layer. bindArea2D_get_collision_mask_bit :: MethodBind bindArea2D_get_collision_mask_bit = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the collision mask. Describes whether this area will collide with others on the given layer. get_collision_mask_bit :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.Area2D.get_collision_mask_bit {-# NOINLINE bindArea2D_get_gravity #-} -- | The area's gravity intensity (ranges from -1024 to 1024). This value multiplies the gravity vector. This is useful to alter the force of gravity without altering its direction. bindArea2D_get_gravity :: MethodBind bindArea2D_get_gravity = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's gravity intensity (ranges from -1024 to 1024). This value multiplies the gravity vector. This is useful to alter the force of gravity without altering its direction. get_gravity :: (Area2D :< cls, Object :< cls) => cls -> IO Float get_gravity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_gravity" '[] (IO Float) where nodeMethod = Godot.Core.Area2D.get_gravity {-# NOINLINE bindArea2D_get_gravity_distance_scale #-} -- | The falloff factor for point gravity. The greater the value, the faster gravity decreases with distance. bindArea2D_get_gravity_distance_scale :: MethodBind bindArea2D_get_gravity_distance_scale = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_gravity_distance_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The falloff factor for point gravity. The greater the value, the faster gravity decreases with distance. get_gravity_distance_scale :: (Area2D :< cls, Object :< cls) => cls -> IO Float get_gravity_distance_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_gravity_distance_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_gravity_distance_scale" '[] (IO Float) where nodeMethod = Godot.Core.Area2D.get_gravity_distance_scale {-# NOINLINE bindArea2D_get_gravity_vector #-} -- | The area's gravity vector (not normalized). If gravity is a point (see @gravity_point@), this will be the point of attraction. bindArea2D_get_gravity_vector :: MethodBind bindArea2D_get_gravity_vector = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_gravity_vector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's gravity vector (not normalized). If gravity is a point (see @gravity_point@), this will be the point of attraction. get_gravity_vector :: (Area2D :< cls, Object :< cls) => cls -> IO Vector2 get_gravity_vector cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_gravity_vector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_gravity_vector" '[] (IO Vector2) where nodeMethod = Godot.Core.Area2D.get_gravity_vector {-# NOINLINE bindArea2D_get_linear_damp #-} -- | The rate at which objects stop moving in this area. Represents the linear velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). bindArea2D_get_linear_damp :: MethodBind bindArea2D_get_linear_damp = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which objects stop moving in this area. Represents the linear velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). get_linear_damp :: (Area2D :< cls, Object :< cls) => cls -> IO Float get_linear_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_linear_damp" '[] (IO Float) where nodeMethod = Godot.Core.Area2D.get_linear_damp {-# NOINLINE bindArea2D_get_overlapping_areas #-} -- | Returns a list of intersecting @Area2D@s. For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead. bindArea2D_get_overlapping_areas :: MethodBind bindArea2D_get_overlapping_areas = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_overlapping_areas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of intersecting @Area2D@s. For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead. get_overlapping_areas :: (Area2D :< cls, Object :< cls) => cls -> IO Array get_overlapping_areas cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_overlapping_areas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_overlapping_areas" '[] (IO Array) where nodeMethod = Godot.Core.Area2D.get_overlapping_areas {-# NOINLINE bindArea2D_get_overlapping_bodies #-} -- | Returns a list of intersecting @PhysicsBody2D@s. For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead. bindArea2D_get_overlapping_bodies :: MethodBind bindArea2D_get_overlapping_bodies = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_overlapping_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of intersecting @PhysicsBody2D@s. For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead. get_overlapping_bodies :: (Area2D :< cls, Object :< cls) => cls -> IO Array get_overlapping_bodies cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_overlapping_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_overlapping_bodies" '[] (IO Array) where nodeMethod = Godot.Core.Area2D.get_overlapping_bodies {-# NOINLINE bindArea2D_get_priority #-} -- | The area's priority. Higher priority areas are processed first. bindArea2D_get_priority :: MethodBind bindArea2D_get_priority = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's priority. Higher priority areas are processed first. get_priority :: (Area2D :< cls, Object :< cls) => cls -> IO Float get_priority cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_priority" '[] (IO Float) where nodeMethod = Godot.Core.Area2D.get_priority {-# NOINLINE bindArea2D_get_space_override_mode #-} -- | Override mode for gravity and damping calculations within this area. See @enum SpaceOverride@ for possible values. bindArea2D_get_space_override_mode :: MethodBind bindArea2D_get_space_override_mode = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "get_space_override_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override mode for gravity and damping calculations within this area. See @enum SpaceOverride@ for possible values. get_space_override_mode :: (Area2D :< cls, Object :< cls) => cls -> IO Int get_space_override_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_get_space_override_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "get_space_override_mode" '[] (IO Int) where nodeMethod = Godot.Core.Area2D.get_space_override_mode {-# NOINLINE bindArea2D_is_gravity_a_point #-} -- | If @true@, gravity is calculated from a point (set via @gravity_vec@). See also @space_override@. bindArea2D_is_gravity_a_point :: MethodBind bindArea2D_is_gravity_a_point = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "is_gravity_a_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, gravity is calculated from a point (set via @gravity_vec@). See also @space_override@. is_gravity_a_point :: (Area2D :< cls, Object :< cls) => cls -> IO Bool is_gravity_a_point cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_is_gravity_a_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "is_gravity_a_point" '[] (IO Bool) where nodeMethod = Godot.Core.Area2D.is_gravity_a_point {-# NOINLINE bindArea2D_is_monitorable #-} -- | If @true@, other monitoring areas can detect this area. bindArea2D_is_monitorable :: MethodBind bindArea2D_is_monitorable = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "is_monitorable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, other monitoring areas can detect this area. is_monitorable :: (Area2D :< cls, Object :< cls) => cls -> IO Bool is_monitorable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_is_monitorable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "is_monitorable" '[] (IO Bool) where nodeMethod = Godot.Core.Area2D.is_monitorable {-# NOINLINE bindArea2D_is_monitoring #-} -- | If @true@, the area detects bodies or areas entering and exiting it. bindArea2D_is_monitoring :: MethodBind bindArea2D_is_monitoring = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "is_monitoring" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area detects bodies or areas entering and exiting it. is_monitoring :: (Area2D :< cls, Object :< cls) => cls -> IO Bool is_monitoring cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_is_monitoring (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "is_monitoring" '[] (IO Bool) where nodeMethod = Godot.Core.Area2D.is_monitoring {-# NOINLINE bindArea2D_is_overriding_audio_bus #-} -- | If @true@, the area's audio bus overrides the default audio bus. bindArea2D_is_overriding_audio_bus :: MethodBind bindArea2D_is_overriding_audio_bus = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "is_overriding_audio_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area's audio bus overrides the default audio bus. is_overriding_audio_bus :: (Area2D :< cls, Object :< cls) => cls -> IO Bool is_overriding_audio_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_is_overriding_audio_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "is_overriding_audio_bus" '[] (IO Bool) where nodeMethod = Godot.Core.Area2D.is_overriding_audio_bus {-# NOINLINE bindArea2D_overlaps_area #-} -- | If @true@, the given area overlaps the Area2D. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead. bindArea2D_overlaps_area :: MethodBind bindArea2D_overlaps_area = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "overlaps_area" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the given area overlaps the Area2D. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead. overlaps_area :: (Area2D :< cls, Object :< cls) => cls -> Node -> IO Bool overlaps_area cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_overlaps_area (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "overlaps_area" '[Node] (IO Bool) where nodeMethod = Godot.Core.Area2D.overlaps_area {-# NOINLINE bindArea2D_overlaps_body #-} -- | If @true@, the given physics body overlaps the Area2D. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead. -- The @body@ argument can either be a @PhysicsBody2D@ or a @TileMap@ instance (while TileMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). bindArea2D_overlaps_body :: MethodBind bindArea2D_overlaps_body = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "overlaps_body" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the given physics body overlaps the Area2D. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead. -- The @body@ argument can either be a @PhysicsBody2D@ or a @TileMap@ instance (while TileMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body). overlaps_body :: (Area2D :< cls, Object :< cls) => cls -> Node -> IO Bool overlaps_body cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_overlaps_body (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "overlaps_body" '[Node] (IO Bool) where nodeMethod = Godot.Core.Area2D.overlaps_body {-# NOINLINE bindArea2D_set_angular_damp #-} -- | The rate at which objects stop spinning in this area. Represents the angular velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). bindArea2D_set_angular_damp :: MethodBind bindArea2D_set_angular_damp = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which objects stop spinning in this area. Represents the angular velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). set_angular_damp :: (Area2D :< cls, Object :< cls) => cls -> Float -> IO () set_angular_damp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_angular_damp" '[Float] (IO ()) where nodeMethod = Godot.Core.Area2D.set_angular_damp {-# NOINLINE bindArea2D_set_audio_bus_name #-} -- | The name of the area's audio bus. bindArea2D_set_audio_bus_name :: MethodBind bindArea2D_set_audio_bus_name = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_audio_bus_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the area's audio bus. set_audio_bus_name :: (Area2D :< cls, Object :< cls) => cls -> GodotString -> IO () set_audio_bus_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_audio_bus_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_audio_bus_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Area2D.set_audio_bus_name {-# NOINLINE bindArea2D_set_audio_bus_override #-} -- | If @true@, the area's audio bus overrides the default audio bus. bindArea2D_set_audio_bus_override :: MethodBind bindArea2D_set_audio_bus_override = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_audio_bus_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area's audio bus overrides the default audio bus. set_audio_bus_override :: (Area2D :< cls, Object :< cls) => cls -> Bool -> IO () set_audio_bus_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_audio_bus_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_audio_bus_override" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area2D.set_audio_bus_override {-# NOINLINE bindArea2D_set_collision_layer #-} -- | The area's physics layer(s). Collidable objects can exist in any of 32 different layers. A contact is detected if object A is in any of the layers that object B scans, or object B is in any layers that object A scans. See also @collision_mask@. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindArea2D_set_collision_layer :: MethodBind bindArea2D_set_collision_layer = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's physics layer(s). Collidable objects can exist in any of 32 different layers. A contact is detected if object A is in any of the layers that object B scans, or object B is in any layers that object A scans. See also @collision_mask@. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_layer :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.Area2D.set_collision_layer {-# NOINLINE bindArea2D_set_collision_layer_bit #-} -- | Set/clear individual bits on the layer mask. This makes getting an area in/out of only one layer easier. bindArea2D_set_collision_layer_bit :: MethodBind bindArea2D_set_collision_layer_bit = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Set/clear individual bits on the layer mask. This makes getting an area in/out of only one layer easier. set_collision_layer_bit :: (Area2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_layer_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_collision_layer_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Area2D.set_collision_layer_bit {-# NOINLINE bindArea2D_set_collision_mask #-} -- | The physics layers this area scans to determine collision detection. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindArea2D_set_collision_mask :: MethodBind bindArea2D_set_collision_mask = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area scans to determine collision detection. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.Area2D.set_collision_mask {-# NOINLINE bindArea2D_set_collision_mask_bit #-} -- | Set/clear individual bits on the collision mask. This makes selecting the areas scanned easier. bindArea2D_set_collision_mask_bit :: MethodBind bindArea2D_set_collision_mask_bit = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Set/clear individual bits on the collision mask. This makes selecting the areas scanned easier. set_collision_mask_bit :: (Area2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Area2D.set_collision_mask_bit {-# NOINLINE bindArea2D_set_gravity #-} -- | The area's gravity intensity (ranges from -1024 to 1024). This value multiplies the gravity vector. This is useful to alter the force of gravity without altering its direction. bindArea2D_set_gravity :: MethodBind bindArea2D_set_gravity = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's gravity intensity (ranges from -1024 to 1024). This value multiplies the gravity vector. This is useful to alter the force of gravity without altering its direction. set_gravity :: (Area2D :< cls, Object :< cls) => cls -> Float -> IO () set_gravity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_gravity" '[Float] (IO ()) where nodeMethod = Godot.Core.Area2D.set_gravity {-# NOINLINE bindArea2D_set_gravity_distance_scale #-} -- | The falloff factor for point gravity. The greater the value, the faster gravity decreases with distance. bindArea2D_set_gravity_distance_scale :: MethodBind bindArea2D_set_gravity_distance_scale = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_gravity_distance_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The falloff factor for point gravity. The greater the value, the faster gravity decreases with distance. set_gravity_distance_scale :: (Area2D :< cls, Object :< cls) => cls -> Float -> IO () set_gravity_distance_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_gravity_distance_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_gravity_distance_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.Area2D.set_gravity_distance_scale {-# NOINLINE bindArea2D_set_gravity_is_point #-} -- | If @true@, gravity is calculated from a point (set via @gravity_vec@). See also @space_override@. bindArea2D_set_gravity_is_point :: MethodBind bindArea2D_set_gravity_is_point = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_gravity_is_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, gravity is calculated from a point (set via @gravity_vec@). See also @space_override@. set_gravity_is_point :: (Area2D :< cls, Object :< cls) => cls -> Bool -> IO () set_gravity_is_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_gravity_is_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_gravity_is_point" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area2D.set_gravity_is_point {-# NOINLINE bindArea2D_set_gravity_vector #-} -- | The area's gravity vector (not normalized). If gravity is a point (see @gravity_point@), this will be the point of attraction. bindArea2D_set_gravity_vector :: MethodBind bindArea2D_set_gravity_vector = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_gravity_vector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's gravity vector (not normalized). If gravity is a point (see @gravity_point@), this will be the point of attraction. set_gravity_vector :: (Area2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_gravity_vector cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_gravity_vector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_gravity_vector" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Area2D.set_gravity_vector {-# NOINLINE bindArea2D_set_linear_damp #-} -- | The rate at which objects stop moving in this area. Represents the linear velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). bindArea2D_set_linear_damp :: MethodBind bindArea2D_set_linear_damp = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which objects stop moving in this area. Represents the linear velocity lost per second. Values range from @0@ (no damping) to @1@ (full damping). set_linear_damp :: (Area2D :< cls, Object :< cls) => cls -> Float -> IO () set_linear_damp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_linear_damp" '[Float] (IO ()) where nodeMethod = Godot.Core.Area2D.set_linear_damp {-# NOINLINE bindArea2D_set_monitorable #-} -- | If @true@, other monitoring areas can detect this area. bindArea2D_set_monitorable :: MethodBind bindArea2D_set_monitorable = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_monitorable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, other monitoring areas can detect this area. set_monitorable :: (Area2D :< cls, Object :< cls) => cls -> Bool -> IO () set_monitorable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_monitorable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_monitorable" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area2D.set_monitorable {-# NOINLINE bindArea2D_set_monitoring #-} -- | If @true@, the area detects bodies or areas entering and exiting it. bindArea2D_set_monitoring :: MethodBind bindArea2D_set_monitoring = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_monitoring" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area detects bodies or areas entering and exiting it. set_monitoring :: (Area2D :< cls, Object :< cls) => cls -> Bool -> IO () set_monitoring cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_monitoring (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_monitoring" '[Bool] (IO ()) where nodeMethod = Godot.Core.Area2D.set_monitoring {-# NOINLINE bindArea2D_set_priority #-} -- | The area's priority. Higher priority areas are processed first. bindArea2D_set_priority :: MethodBind bindArea2D_set_priority = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area's priority. Higher priority areas are processed first. set_priority :: (Area2D :< cls, Object :< cls) => cls -> Float -> IO () set_priority cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_priority" '[Float] (IO ()) where nodeMethod = Godot.Core.Area2D.set_priority {-# NOINLINE bindArea2D_set_space_override_mode #-} -- | Override mode for gravity and damping calculations within this area. See @enum SpaceOverride@ for possible values. bindArea2D_set_space_override_mode :: MethodBind bindArea2D_set_space_override_mode = unsafePerformIO $ withCString "Area2D" $ \ clsNamePtr -> withCString "set_space_override_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override mode for gravity and damping calculations within this area. See @enum SpaceOverride@ for possible values. set_space_override_mode :: (Area2D :< cls, Object :< cls) => cls -> Int -> IO () set_space_override_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArea2D_set_space_override_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Area2D "set_space_override_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Area2D.set_space_override_mode ================================================ FILE: src/Godot/Core/ArrayMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ArrayMesh (Godot.Core.ArrayMesh._ARRAY_FORMAT_INDEX, Godot.Core.ArrayMesh._ARRAY_FORMAT_COLOR, Godot.Core.ArrayMesh._ARRAY_FORMAT_TEX_UV, Godot.Core.ArrayMesh._ARRAY_FORMAT_VERTEX, Godot.Core.ArrayMesh._ARRAY_MAX, Godot.Core.ArrayMesh._ARRAY_NORMAL, Godot.Core.ArrayMesh._ARRAY_FORMAT_TEX_UV2, Godot.Core.ArrayMesh._ARRAY_INDEX, Godot.Core.ArrayMesh._ARRAY_COLOR, Godot.Core.ArrayMesh._ARRAY_TEX_UV, Godot.Core.ArrayMesh._ARRAY_FORMAT_NORMAL, Godot.Core.ArrayMesh._ARRAY_TEX_UV2, Godot.Core.ArrayMesh._ARRAY_FORMAT_BONES, Godot.Core.ArrayMesh._ARRAY_WEIGHTS_SIZE, Godot.Core.ArrayMesh._ARRAY_WEIGHTS, Godot.Core.ArrayMesh._ARRAY_TANGENT, Godot.Core.ArrayMesh._ARRAY_BONES, Godot.Core.ArrayMesh._NO_INDEX_ARRAY, Godot.Core.ArrayMesh._ARRAY_VERTEX, Godot.Core.ArrayMesh._ARRAY_FORMAT_WEIGHTS, Godot.Core.ArrayMesh._ARRAY_FORMAT_TANGENT, Godot.Core.ArrayMesh.add_blend_shape, Godot.Core.ArrayMesh.add_surface_from_arrays, Godot.Core.ArrayMesh.clear_blend_shapes, Godot.Core.ArrayMesh.get_blend_shape_count, Godot.Core.ArrayMesh.get_blend_shape_mode, Godot.Core.ArrayMesh.get_blend_shape_name, Godot.Core.ArrayMesh.get_custom_aabb, Godot.Core.ArrayMesh.lightmap_unwrap, Godot.Core.ArrayMesh.regen_normalmaps, Godot.Core.ArrayMesh.set_blend_shape_mode, Godot.Core.ArrayMesh.set_custom_aabb, Godot.Core.ArrayMesh.surface_find_by_name, Godot.Core.ArrayMesh.surface_get_array_index_len, Godot.Core.ArrayMesh.surface_get_array_len, Godot.Core.ArrayMesh.surface_get_format, Godot.Core.ArrayMesh.surface_get_name, Godot.Core.ArrayMesh.surface_get_primitive_type, Godot.Core.ArrayMesh.surface_remove, Godot.Core.ArrayMesh.surface_set_name, Godot.Core.ArrayMesh.surface_update_region) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Mesh() _ARRAY_FORMAT_INDEX :: Int _ARRAY_FORMAT_INDEX = 256 _ARRAY_FORMAT_COLOR :: Int _ARRAY_FORMAT_COLOR = 8 _ARRAY_FORMAT_TEX_UV :: Int _ARRAY_FORMAT_TEX_UV = 16 _ARRAY_FORMAT_VERTEX :: Int _ARRAY_FORMAT_VERTEX = 1 _ARRAY_MAX :: Int _ARRAY_MAX = 9 _ARRAY_NORMAL :: Int _ARRAY_NORMAL = 1 _ARRAY_FORMAT_TEX_UV2 :: Int _ARRAY_FORMAT_TEX_UV2 = 32 _ARRAY_INDEX :: Int _ARRAY_INDEX = 8 _ARRAY_COLOR :: Int _ARRAY_COLOR = 3 _ARRAY_TEX_UV :: Int _ARRAY_TEX_UV = 4 _ARRAY_FORMAT_NORMAL :: Int _ARRAY_FORMAT_NORMAL = 2 _ARRAY_TEX_UV2 :: Int _ARRAY_TEX_UV2 = 5 _ARRAY_FORMAT_BONES :: Int _ARRAY_FORMAT_BONES = 64 _ARRAY_WEIGHTS_SIZE :: Int _ARRAY_WEIGHTS_SIZE = 4 _ARRAY_WEIGHTS :: Int _ARRAY_WEIGHTS = 7 _ARRAY_TANGENT :: Int _ARRAY_TANGENT = 2 _ARRAY_BONES :: Int _ARRAY_BONES = 6 _NO_INDEX_ARRAY :: Int _NO_INDEX_ARRAY = -1 _ARRAY_VERTEX :: Int _ARRAY_VERTEX = 0 _ARRAY_FORMAT_WEIGHTS :: Int _ARRAY_FORMAT_WEIGHTS = 128 _ARRAY_FORMAT_TANGENT :: Int _ARRAY_FORMAT_TANGENT = 4 instance NodeProperty ArrayMesh "blend_shape_mode" Int 'False where nodeProperty = (get_blend_shape_mode, wrapDroppingSetter set_blend_shape_mode, Nothing) instance NodeProperty ArrayMesh "custom_aabb" Aabb 'False where nodeProperty = (get_custom_aabb, wrapDroppingSetter set_custom_aabb, Nothing) {-# NOINLINE bindArrayMesh_add_blend_shape #-} -- | Adds name for a blend shape that will be added with @method add_surface_from_arrays@. Must be called before surface is added. bindArrayMesh_add_blend_shape :: MethodBind bindArrayMesh_add_blend_shape = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "add_blend_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds name for a blend shape that will be added with @method add_surface_from_arrays@. Must be called before surface is added. add_blend_shape :: (ArrayMesh :< cls, Object :< cls) => cls -> GodotString -> IO () add_blend_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_add_blend_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "add_blend_shape" '[GodotString] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.add_blend_shape {-# NOINLINE bindArrayMesh_add_surface_from_arrays #-} -- | Creates a new surface. -- Surfaces are created to be rendered using a @primitive@, which may be any of the types defined in @enum Mesh.PrimitiveType@. (As a note, when using indices, it is recommended to only use points, lines or triangles.) @method Mesh.get_surface_count@ will become the @surf_idx@ for this new surface. -- The @arrays@ argument is an array of arrays. See @enum ArrayType@ for the values used in this array. For example, @arrays@0@@ is the array of vertices. That first vertex sub-array is always required; the others are optional. Adding an index array puts this function into "index mode" where the vertex and other arrays become the sources of data and the index array defines the vertex order. All sub-arrays must have the same length as the vertex array or be empty, except for @ARRAY_INDEX@ if it is used. -- Adding an index array puts this function into "index mode" where the vertex and other arrays become the sources of data, and the index array defines the order of the vertices. bindArrayMesh_add_surface_from_arrays :: MethodBind bindArrayMesh_add_surface_from_arrays = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "add_surface_from_arrays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new surface. -- Surfaces are created to be rendered using a @primitive@, which may be any of the types defined in @enum Mesh.PrimitiveType@. (As a note, when using indices, it is recommended to only use points, lines or triangles.) @method Mesh.get_surface_count@ will become the @surf_idx@ for this new surface. -- The @arrays@ argument is an array of arrays. See @enum ArrayType@ for the values used in this array. For example, @arrays@0@@ is the array of vertices. That first vertex sub-array is always required; the others are optional. Adding an index array puts this function into "index mode" where the vertex and other arrays become the sources of data and the index array defines the vertex order. All sub-arrays must have the same length as the vertex array or be empty, except for @ARRAY_INDEX@ if it is used. -- Adding an index array puts this function into "index mode" where the vertex and other arrays become the sources of data, and the index array defines the order of the vertices. add_surface_from_arrays :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> Array -> Maybe Array -> Maybe Int -> IO () add_surface_from_arrays cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantArray V.empty arg3, maybe (VariantInt (97280)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_add_surface_from_arrays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "add_surface_from_arrays" '[Int, Array, Maybe Array, Maybe Int] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.add_surface_from_arrays {-# NOINLINE bindArrayMesh_clear_blend_shapes #-} -- | Removes all blend shapes from this @ArrayMesh@. bindArrayMesh_clear_blend_shapes :: MethodBind bindArrayMesh_clear_blend_shapes = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "clear_blend_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all blend shapes from this @ArrayMesh@. clear_blend_shapes :: (ArrayMesh :< cls, Object :< cls) => cls -> IO () clear_blend_shapes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_clear_blend_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "clear_blend_shapes" '[] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.clear_blend_shapes {-# NOINLINE bindArrayMesh_get_blend_shape_count #-} -- | Returns the number of blend shapes that the @ArrayMesh@ holds. bindArrayMesh_get_blend_shape_count :: MethodBind bindArrayMesh_get_blend_shape_count = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "get_blend_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of blend shapes that the @ArrayMesh@ holds. get_blend_shape_count :: (ArrayMesh :< cls, Object :< cls) => cls -> IO Int get_blend_shape_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_get_blend_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "get_blend_shape_count" '[] (IO Int) where nodeMethod = Godot.Core.ArrayMesh.get_blend_shape_count {-# NOINLINE bindArrayMesh_get_blend_shape_mode #-} -- | Sets the blend shape mode to one of @enum Mesh.BlendShapeMode@. bindArrayMesh_get_blend_shape_mode :: MethodBind bindArrayMesh_get_blend_shape_mode = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "get_blend_shape_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the blend shape mode to one of @enum Mesh.BlendShapeMode@. get_blend_shape_mode :: (ArrayMesh :< cls, Object :< cls) => cls -> IO Int get_blend_shape_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_get_blend_shape_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "get_blend_shape_mode" '[] (IO Int) where nodeMethod = Godot.Core.ArrayMesh.get_blend_shape_mode {-# NOINLINE bindArrayMesh_get_blend_shape_name #-} -- | Returns the name of the blend shape at this index. bindArrayMesh_get_blend_shape_name :: MethodBind bindArrayMesh_get_blend_shape_name = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "get_blend_shape_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the blend shape at this index. get_blend_shape_name :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> IO GodotString get_blend_shape_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_get_blend_shape_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "get_blend_shape_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.ArrayMesh.get_blend_shape_name {-# NOINLINE bindArrayMesh_get_custom_aabb #-} -- | Overrides the @AABB@ with one defined by user for use with frustum culling. Especially useful to avoid unexpected culling when using a shader to offset vertices. bindArrayMesh_get_custom_aabb :: MethodBind bindArrayMesh_get_custom_aabb = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "get_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the @AABB@ with one defined by user for use with frustum culling. Especially useful to avoid unexpected culling when using a shader to offset vertices. get_custom_aabb :: (ArrayMesh :< cls, Object :< cls) => cls -> IO Aabb get_custom_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_get_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "get_custom_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.ArrayMesh.get_custom_aabb {-# NOINLINE bindArrayMesh_lightmap_unwrap #-} -- | Will perform a UV unwrap on the @ArrayMesh@ to prepare the mesh for lightmapping. bindArrayMesh_lightmap_unwrap :: MethodBind bindArrayMesh_lightmap_unwrap = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "lightmap_unwrap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Will perform a UV unwrap on the @ArrayMesh@ to prepare the mesh for lightmapping. lightmap_unwrap :: (ArrayMesh :< cls, Object :< cls) => cls -> Transform -> Float -> IO Int lightmap_unwrap cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_lightmap_unwrap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "lightmap_unwrap" '[Transform, Float] (IO Int) where nodeMethod = Godot.Core.ArrayMesh.lightmap_unwrap {-# NOINLINE bindArrayMesh_regen_normalmaps #-} -- | Will regenerate normal maps for the @ArrayMesh@. bindArrayMesh_regen_normalmaps :: MethodBind bindArrayMesh_regen_normalmaps = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "regen_normalmaps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Will regenerate normal maps for the @ArrayMesh@. regen_normalmaps :: (ArrayMesh :< cls, Object :< cls) => cls -> IO () regen_normalmaps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_regen_normalmaps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "regen_normalmaps" '[] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.regen_normalmaps {-# NOINLINE bindArrayMesh_set_blend_shape_mode #-} -- | Sets the blend shape mode to one of @enum Mesh.BlendShapeMode@. bindArrayMesh_set_blend_shape_mode :: MethodBind bindArrayMesh_set_blend_shape_mode = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "set_blend_shape_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the blend shape mode to one of @enum Mesh.BlendShapeMode@. set_blend_shape_mode :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> IO () set_blend_shape_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_set_blend_shape_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "set_blend_shape_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.set_blend_shape_mode {-# NOINLINE bindArrayMesh_set_custom_aabb #-} -- | Overrides the @AABB@ with one defined by user for use with frustum culling. Especially useful to avoid unexpected culling when using a shader to offset vertices. bindArrayMesh_set_custom_aabb :: MethodBind bindArrayMesh_set_custom_aabb = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "set_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the @AABB@ with one defined by user for use with frustum culling. Especially useful to avoid unexpected culling when using a shader to offset vertices. set_custom_aabb :: (ArrayMesh :< cls, Object :< cls) => cls -> Aabb -> IO () set_custom_aabb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_set_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "set_custom_aabb" '[Aabb] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.set_custom_aabb {-# NOINLINE bindArrayMesh_surface_find_by_name #-} -- | Returns the index of the first surface with this name held within this @ArrayMesh@. If none are found, -1 is returned. bindArrayMesh_surface_find_by_name :: MethodBind bindArrayMesh_surface_find_by_name = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_find_by_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the first surface with this name held within this @ArrayMesh@. If none are found, -1 is returned. surface_find_by_name :: (ArrayMesh :< cls, Object :< cls) => cls -> GodotString -> IO Int surface_find_by_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_find_by_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_find_by_name" '[GodotString] (IO Int) where nodeMethod = Godot.Core.ArrayMesh.surface_find_by_name {-# NOINLINE bindArrayMesh_surface_get_array_index_len #-} -- | Returns the length in indices of the index array in the requested surface (see @method add_surface_from_arrays@). bindArrayMesh_surface_get_array_index_len :: MethodBind bindArrayMesh_surface_get_array_index_len = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_get_array_index_len" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the length in indices of the index array in the requested surface (see @method add_surface_from_arrays@). surface_get_array_index_len :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> IO Int surface_get_array_index_len cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_get_array_index_len (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_get_array_index_len" '[Int] (IO Int) where nodeMethod = Godot.Core.ArrayMesh.surface_get_array_index_len {-# NOINLINE bindArrayMesh_surface_get_array_len #-} -- | Returns the length in vertices of the vertex array in the requested surface (see @method add_surface_from_arrays@). bindArrayMesh_surface_get_array_len :: MethodBind bindArrayMesh_surface_get_array_len = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_get_array_len" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the length in vertices of the vertex array in the requested surface (see @method add_surface_from_arrays@). surface_get_array_len :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> IO Int surface_get_array_len cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_get_array_len (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_get_array_len" '[Int] (IO Int) where nodeMethod = Godot.Core.ArrayMesh.surface_get_array_len {-# NOINLINE bindArrayMesh_surface_get_format #-} -- | Returns the format mask of the requested surface (see @method add_surface_from_arrays@). bindArrayMesh_surface_get_format :: MethodBind bindArrayMesh_surface_get_format = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the format mask of the requested surface (see @method add_surface_from_arrays@). surface_get_format :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> IO Int surface_get_format cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_get_format" '[Int] (IO Int) where nodeMethod = Godot.Core.ArrayMesh.surface_get_format {-# NOINLINE bindArrayMesh_surface_get_name #-} -- | Gets the name assigned to this surface. bindArrayMesh_surface_get_name :: MethodBind bindArrayMesh_surface_get_name = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the name assigned to this surface. surface_get_name :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> IO GodotString surface_get_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_get_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.ArrayMesh.surface_get_name {-# NOINLINE bindArrayMesh_surface_get_primitive_type #-} -- | Returns the primitive type of the requested surface (see @method add_surface_from_arrays@). bindArrayMesh_surface_get_primitive_type :: MethodBind bindArrayMesh_surface_get_primitive_type = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_get_primitive_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the primitive type of the requested surface (see @method add_surface_from_arrays@). surface_get_primitive_type :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> IO Int surface_get_primitive_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_get_primitive_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_get_primitive_type" '[Int] (IO Int) where nodeMethod = Godot.Core.ArrayMesh.surface_get_primitive_type {-# NOINLINE bindArrayMesh_surface_remove #-} -- | Removes a surface at position @surf_idx@, shifting greater surfaces one @surf_idx@ slot down. bindArrayMesh_surface_remove :: MethodBind bindArrayMesh_surface_remove = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_remove" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a surface at position @surf_idx@, shifting greater surfaces one @surf_idx@ slot down. surface_remove :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> IO () surface_remove cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_remove (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_remove" '[Int] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.surface_remove {-# NOINLINE bindArrayMesh_surface_set_name #-} -- | Sets a name for a given surface. bindArrayMesh_surface_set_name :: MethodBind bindArrayMesh_surface_set_name = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_set_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a name for a given surface. surface_set_name :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () surface_set_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_set_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_set_name" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.surface_set_name {-# NOINLINE bindArrayMesh_surface_update_region #-} -- | Updates a specified region of mesh arrays on the GPU. -- __Warning:__ Only use if you know what you are doing. You can easily cause crashes by calling this function with improper arguments. bindArrayMesh_surface_update_region :: MethodBind bindArrayMesh_surface_update_region = unsafePerformIO $ withCString "ArrayMesh" $ \ clsNamePtr -> withCString "surface_update_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates a specified region of mesh arrays on the GPU. -- __Warning:__ Only use if you know what you are doing. You can easily cause crashes by calling this function with improper arguments. surface_update_region :: (ArrayMesh :< cls, Object :< cls) => cls -> Int -> Int -> PoolByteArray -> IO () surface_update_region cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindArrayMesh_surface_update_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ArrayMesh "surface_update_region" '[Int, Int, PoolByteArray] (IO ()) where nodeMethod = Godot.Core.ArrayMesh.surface_update_region ================================================ FILE: src/Godot/Core/AtlasTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AtlasTexture (Godot.Core.AtlasTexture.get_atlas, Godot.Core.AtlasTexture.get_margin, Godot.Core.AtlasTexture.get_region, Godot.Core.AtlasTexture.has_filter_clip, Godot.Core.AtlasTexture.set_atlas, Godot.Core.AtlasTexture.set_filter_clip, Godot.Core.AtlasTexture.set_margin, Godot.Core.AtlasTexture.set_region) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty AtlasTexture "atlas" Texture 'False where nodeProperty = (get_atlas, wrapDroppingSetter set_atlas, Nothing) instance NodeProperty AtlasTexture "filter_clip" Bool 'False where nodeProperty = (has_filter_clip, wrapDroppingSetter set_filter_clip, Nothing) instance NodeProperty AtlasTexture "margin" Rect2 'False where nodeProperty = (get_margin, wrapDroppingSetter set_margin, Nothing) instance NodeProperty AtlasTexture "region" Rect2 'False where nodeProperty = (get_region, wrapDroppingSetter set_region, Nothing) {-# NOINLINE bindAtlasTexture_get_atlas #-} -- | The texture that contains the atlas. Can be any @Texture@ subtype. bindAtlasTexture_get_atlas :: MethodBind bindAtlasTexture_get_atlas = unsafePerformIO $ withCString "AtlasTexture" $ \ clsNamePtr -> withCString "get_atlas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture that contains the atlas. Can be any @Texture@ subtype. get_atlas :: (AtlasTexture :< cls, Object :< cls) => cls -> IO Texture get_atlas cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAtlasTexture_get_atlas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AtlasTexture "get_atlas" '[] (IO Texture) where nodeMethod = Godot.Core.AtlasTexture.get_atlas {-# NOINLINE bindAtlasTexture_get_margin #-} -- | The margin around the region. The @Rect2@'s @Rect2.size@ parameter ("w" and "h" in the editor) resizes the texture so it fits within the margin. bindAtlasTexture_get_margin :: MethodBind bindAtlasTexture_get_margin = unsafePerformIO $ withCString "AtlasTexture" $ \ clsNamePtr -> withCString "get_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The margin around the region. The @Rect2@'s @Rect2.size@ parameter ("w" and "h" in the editor) resizes the texture so it fits within the margin. get_margin :: (AtlasTexture :< cls, Object :< cls) => cls -> IO Rect2 get_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAtlasTexture_get_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AtlasTexture "get_margin" '[] (IO Rect2) where nodeMethod = Godot.Core.AtlasTexture.get_margin {-# NOINLINE bindAtlasTexture_get_region #-} -- | The AtlasTexture's used region. bindAtlasTexture_get_region :: MethodBind bindAtlasTexture_get_region = unsafePerformIO $ withCString "AtlasTexture" $ \ clsNamePtr -> withCString "get_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The AtlasTexture's used region. get_region :: (AtlasTexture :< cls, Object :< cls) => cls -> IO Rect2 get_region cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAtlasTexture_get_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AtlasTexture "get_region" '[] (IO Rect2) where nodeMethod = Godot.Core.AtlasTexture.get_region {-# NOINLINE bindAtlasTexture_has_filter_clip #-} -- | If @true@, clips the area outside of the region to avoid bleeding of the surrounding texture pixels. bindAtlasTexture_has_filter_clip :: MethodBind bindAtlasTexture_has_filter_clip = unsafePerformIO $ withCString "AtlasTexture" $ \ clsNamePtr -> withCString "has_filter_clip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, clips the area outside of the region to avoid bleeding of the surrounding texture pixels. has_filter_clip :: (AtlasTexture :< cls, Object :< cls) => cls -> IO Bool has_filter_clip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAtlasTexture_has_filter_clip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AtlasTexture "has_filter_clip" '[] (IO Bool) where nodeMethod = Godot.Core.AtlasTexture.has_filter_clip {-# NOINLINE bindAtlasTexture_set_atlas #-} -- | The texture that contains the atlas. Can be any @Texture@ subtype. bindAtlasTexture_set_atlas :: MethodBind bindAtlasTexture_set_atlas = unsafePerformIO $ withCString "AtlasTexture" $ \ clsNamePtr -> withCString "set_atlas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture that contains the atlas. Can be any @Texture@ subtype. set_atlas :: (AtlasTexture :< cls, Object :< cls) => cls -> Texture -> IO () set_atlas cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAtlasTexture_set_atlas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AtlasTexture "set_atlas" '[Texture] (IO ()) where nodeMethod = Godot.Core.AtlasTexture.set_atlas {-# NOINLINE bindAtlasTexture_set_filter_clip #-} -- | If @true@, clips the area outside of the region to avoid bleeding of the surrounding texture pixels. bindAtlasTexture_set_filter_clip :: MethodBind bindAtlasTexture_set_filter_clip = unsafePerformIO $ withCString "AtlasTexture" $ \ clsNamePtr -> withCString "set_filter_clip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, clips the area outside of the region to avoid bleeding of the surrounding texture pixels. set_filter_clip :: (AtlasTexture :< cls, Object :< cls) => cls -> Bool -> IO () set_filter_clip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAtlasTexture_set_filter_clip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AtlasTexture "set_filter_clip" '[Bool] (IO ()) where nodeMethod = Godot.Core.AtlasTexture.set_filter_clip {-# NOINLINE bindAtlasTexture_set_margin #-} -- | The margin around the region. The @Rect2@'s @Rect2.size@ parameter ("w" and "h" in the editor) resizes the texture so it fits within the margin. bindAtlasTexture_set_margin :: MethodBind bindAtlasTexture_set_margin = unsafePerformIO $ withCString "AtlasTexture" $ \ clsNamePtr -> withCString "set_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The margin around the region. The @Rect2@'s @Rect2.size@ parameter ("w" and "h" in the editor) resizes the texture so it fits within the margin. set_margin :: (AtlasTexture :< cls, Object :< cls) => cls -> Rect2 -> IO () set_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAtlasTexture_set_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AtlasTexture "set_margin" '[Rect2] (IO ()) where nodeMethod = Godot.Core.AtlasTexture.set_margin {-# NOINLINE bindAtlasTexture_set_region #-} -- | The AtlasTexture's used region. bindAtlasTexture_set_region :: MethodBind bindAtlasTexture_set_region = unsafePerformIO $ withCString "AtlasTexture" $ \ clsNamePtr -> withCString "set_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The AtlasTexture's used region. set_region :: (AtlasTexture :< cls, Object :< cls) => cls -> Rect2 -> IO () set_region cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAtlasTexture_set_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AtlasTexture "set_region" '[Rect2] (IO ()) where nodeMethod = Godot.Core.AtlasTexture.set_region ================================================ FILE: src/Godot/Core/AudioBusLayout.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioBusLayout () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() ================================================ FILE: src/Godot/Core/AudioEffect.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffect () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() ================================================ FILE: src/Godot/Core/AudioEffectAmplify.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectAmplify (Godot.Core.AudioEffectAmplify.get_volume_db, Godot.Core.AudioEffectAmplify.set_volume_db) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectAmplify "volume_db" Float 'False where nodeProperty = (get_volume_db, wrapDroppingSetter set_volume_db, Nothing) {-# NOINLINE bindAudioEffectAmplify_get_volume_db #-} -- | Amount of amplification in decibels. Positive values make the sound louder, negative values make it quieter. Value can range from -80 to 24. bindAudioEffectAmplify_get_volume_db :: MethodBind bindAudioEffectAmplify_get_volume_db = unsafePerformIO $ withCString "AudioEffectAmplify" $ \ clsNamePtr -> withCString "get_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of amplification in decibels. Positive values make the sound louder, negative values make it quieter. Value can range from -80 to 24. get_volume_db :: (AudioEffectAmplify :< cls, Object :< cls) => cls -> IO Float get_volume_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectAmplify_get_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectAmplify "get_volume_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectAmplify.get_volume_db {-# NOINLINE bindAudioEffectAmplify_set_volume_db #-} -- | Amount of amplification in decibels. Positive values make the sound louder, negative values make it quieter. Value can range from -80 to 24. bindAudioEffectAmplify_set_volume_db :: MethodBind bindAudioEffectAmplify_set_volume_db = unsafePerformIO $ withCString "AudioEffectAmplify" $ \ clsNamePtr -> withCString "set_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of amplification in decibels. Positive values make the sound louder, negative values make it quieter. Value can range from -80 to 24. set_volume_db :: (AudioEffectAmplify :< cls, Object :< cls) => cls -> Float -> IO () set_volume_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectAmplify_set_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectAmplify "set_volume_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectAmplify.set_volume_db ================================================ FILE: src/Godot/Core/AudioEffectBandLimitFilter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectBandLimitFilter () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectFilter() ================================================ FILE: src/Godot/Core/AudioEffectBandPassFilter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectBandPassFilter () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectFilter() ================================================ FILE: src/Godot/Core/AudioEffectChorus.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectChorus (Godot.Core.AudioEffectChorus.get_dry, Godot.Core.AudioEffectChorus.get_voice_count, Godot.Core.AudioEffectChorus.get_voice_cutoff_hz, Godot.Core.AudioEffectChorus.get_voice_delay_ms, Godot.Core.AudioEffectChorus.get_voice_depth_ms, Godot.Core.AudioEffectChorus.get_voice_level_db, Godot.Core.AudioEffectChorus.get_voice_pan, Godot.Core.AudioEffectChorus.get_voice_rate_hz, Godot.Core.AudioEffectChorus.get_wet, Godot.Core.AudioEffectChorus.set_dry, Godot.Core.AudioEffectChorus.set_voice_count, Godot.Core.AudioEffectChorus.set_voice_cutoff_hz, Godot.Core.AudioEffectChorus.set_voice_delay_ms, Godot.Core.AudioEffectChorus.set_voice_depth_ms, Godot.Core.AudioEffectChorus.set_voice_level_db, Godot.Core.AudioEffectChorus.set_voice_pan, Godot.Core.AudioEffectChorus.set_voice_rate_hz, Godot.Core.AudioEffectChorus.set_wet) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectChorus "dry" Float 'False where nodeProperty = (get_dry, wrapDroppingSetter set_dry, Nothing) instance NodeProperty AudioEffectChorus "voice/1/cutoff_hz" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_voice_cutoff_hz, wrapIndexedSetter 0 set_voice_cutoff_hz, Nothing) instance NodeProperty AudioEffectChorus "voice/1/delay_ms" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_voice_delay_ms, wrapIndexedSetter 0 set_voice_delay_ms, Nothing) instance NodeProperty AudioEffectChorus "voice/1/depth_ms" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_voice_depth_ms, wrapIndexedSetter 0 set_voice_depth_ms, Nothing) instance NodeProperty AudioEffectChorus "voice/1/level_db" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_voice_level_db, wrapIndexedSetter 0 set_voice_level_db, Nothing) instance NodeProperty AudioEffectChorus "voice/1/pan" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_voice_pan, wrapIndexedSetter 0 set_voice_pan, Nothing) instance NodeProperty AudioEffectChorus "voice/1/rate_hz" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_voice_rate_hz, wrapIndexedSetter 0 set_voice_rate_hz, Nothing) instance NodeProperty AudioEffectChorus "voice/2/cutoff_hz" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_voice_cutoff_hz, wrapIndexedSetter 1 set_voice_cutoff_hz, Nothing) instance NodeProperty AudioEffectChorus "voice/2/delay_ms" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_voice_delay_ms, wrapIndexedSetter 1 set_voice_delay_ms, Nothing) instance NodeProperty AudioEffectChorus "voice/2/depth_ms" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_voice_depth_ms, wrapIndexedSetter 1 set_voice_depth_ms, Nothing) instance NodeProperty AudioEffectChorus "voice/2/level_db" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_voice_level_db, wrapIndexedSetter 1 set_voice_level_db, Nothing) instance NodeProperty AudioEffectChorus "voice/2/pan" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_voice_pan, wrapIndexedSetter 1 set_voice_pan, Nothing) instance NodeProperty AudioEffectChorus "voice/2/rate_hz" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_voice_rate_hz, wrapIndexedSetter 1 set_voice_rate_hz, Nothing) instance NodeProperty AudioEffectChorus "voice/3/cutoff_hz" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_voice_cutoff_hz, wrapIndexedSetter 2 set_voice_cutoff_hz, Nothing) instance NodeProperty AudioEffectChorus "voice/3/delay_ms" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_voice_delay_ms, wrapIndexedSetter 2 set_voice_delay_ms, Nothing) instance NodeProperty AudioEffectChorus "voice/3/depth_ms" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_voice_depth_ms, wrapIndexedSetter 2 set_voice_depth_ms, Nothing) instance NodeProperty AudioEffectChorus "voice/3/level_db" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_voice_level_db, wrapIndexedSetter 2 set_voice_level_db, Nothing) instance NodeProperty AudioEffectChorus "voice/3/pan" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_voice_pan, wrapIndexedSetter 2 set_voice_pan, Nothing) instance NodeProperty AudioEffectChorus "voice/3/rate_hz" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_voice_rate_hz, wrapIndexedSetter 2 set_voice_rate_hz, Nothing) instance NodeProperty AudioEffectChorus "voice/4/cutoff_hz" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_voice_cutoff_hz, wrapIndexedSetter 3 set_voice_cutoff_hz, Nothing) instance NodeProperty AudioEffectChorus "voice/4/delay_ms" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_voice_delay_ms, wrapIndexedSetter 3 set_voice_delay_ms, Nothing) instance NodeProperty AudioEffectChorus "voice/4/depth_ms" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_voice_depth_ms, wrapIndexedSetter 3 set_voice_depth_ms, Nothing) instance NodeProperty AudioEffectChorus "voice/4/level_db" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_voice_level_db, wrapIndexedSetter 3 set_voice_level_db, Nothing) instance NodeProperty AudioEffectChorus "voice/4/pan" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_voice_pan, wrapIndexedSetter 3 set_voice_pan, Nothing) instance NodeProperty AudioEffectChorus "voice/4/rate_hz" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_voice_rate_hz, wrapIndexedSetter 3 set_voice_rate_hz, Nothing) instance NodeProperty AudioEffectChorus "voice_count" Int 'False where nodeProperty = (get_voice_count, wrapDroppingSetter set_voice_count, Nothing) instance NodeProperty AudioEffectChorus "wet" Float 'False where nodeProperty = (get_wet, wrapDroppingSetter set_wet, Nothing) {-# NOINLINE bindAudioEffectChorus_get_dry #-} -- | The effect's raw signal. bindAudioEffectChorus_get_dry :: MethodBind bindAudioEffectChorus_get_dry = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_dry" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The effect's raw signal. get_dry :: (AudioEffectChorus :< cls, Object :< cls) => cls -> IO Float get_dry cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_dry (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_dry" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectChorus.get_dry {-# NOINLINE bindAudioEffectChorus_get_voice_count #-} -- | The amount of voices in the effect. bindAudioEffectChorus_get_voice_count :: MethodBind bindAudioEffectChorus_get_voice_count = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_voice_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of voices in the effect. get_voice_count :: (AudioEffectChorus :< cls, Object :< cls) => cls -> IO Int get_voice_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_voice_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_voice_count" '[] (IO Int) where nodeMethod = Godot.Core.AudioEffectChorus.get_voice_count {-# NOINLINE bindAudioEffectChorus_get_voice_cutoff_hz #-} -- | The voice's cutoff frequency. bindAudioEffectChorus_get_voice_cutoff_hz :: MethodBind bindAudioEffectChorus_get_voice_cutoff_hz = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_voice_cutoff_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's cutoff frequency. get_voice_cutoff_hz :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> IO Float get_voice_cutoff_hz cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_voice_cutoff_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_voice_cutoff_hz" '[Int] (IO Float) where nodeMethod = Godot.Core.AudioEffectChorus.get_voice_cutoff_hz {-# NOINLINE bindAudioEffectChorus_get_voice_delay_ms #-} -- | The voice's signal delay. bindAudioEffectChorus_get_voice_delay_ms :: MethodBind bindAudioEffectChorus_get_voice_delay_ms = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_voice_delay_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's signal delay. get_voice_delay_ms :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> IO Float get_voice_delay_ms cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_voice_delay_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_voice_delay_ms" '[Int] (IO Float) where nodeMethod = Godot.Core.AudioEffectChorus.get_voice_delay_ms {-# NOINLINE bindAudioEffectChorus_get_voice_depth_ms #-} -- | The voice filter's depth. bindAudioEffectChorus_get_voice_depth_ms :: MethodBind bindAudioEffectChorus_get_voice_depth_ms = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_voice_depth_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice filter's depth. get_voice_depth_ms :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> IO Float get_voice_depth_ms cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_voice_depth_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_voice_depth_ms" '[Int] (IO Float) where nodeMethod = Godot.Core.AudioEffectChorus.get_voice_depth_ms {-# NOINLINE bindAudioEffectChorus_get_voice_level_db #-} -- | The voice's volume. bindAudioEffectChorus_get_voice_level_db :: MethodBind bindAudioEffectChorus_get_voice_level_db = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_voice_level_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's volume. get_voice_level_db :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> IO Float get_voice_level_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_voice_level_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_voice_level_db" '[Int] (IO Float) where nodeMethod = Godot.Core.AudioEffectChorus.get_voice_level_db {-# NOINLINE bindAudioEffectChorus_get_voice_pan #-} -- | The voice's pan level. bindAudioEffectChorus_get_voice_pan :: MethodBind bindAudioEffectChorus_get_voice_pan = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_voice_pan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's pan level. get_voice_pan :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> IO Float get_voice_pan cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_voice_pan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_voice_pan" '[Int] (IO Float) where nodeMethod = Godot.Core.AudioEffectChorus.get_voice_pan {-# NOINLINE bindAudioEffectChorus_get_voice_rate_hz #-} -- | The voice's filter rate. bindAudioEffectChorus_get_voice_rate_hz :: MethodBind bindAudioEffectChorus_get_voice_rate_hz = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_voice_rate_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's filter rate. get_voice_rate_hz :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> IO Float get_voice_rate_hz cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_voice_rate_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_voice_rate_hz" '[Int] (IO Float) where nodeMethod = Godot.Core.AudioEffectChorus.get_voice_rate_hz {-# NOINLINE bindAudioEffectChorus_get_wet #-} -- | The effect's processed signal. bindAudioEffectChorus_get_wet :: MethodBind bindAudioEffectChorus_get_wet = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "get_wet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The effect's processed signal. get_wet :: (AudioEffectChorus :< cls, Object :< cls) => cls -> IO Float get_wet cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_get_wet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "get_wet" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectChorus.get_wet {-# NOINLINE bindAudioEffectChorus_set_dry #-} -- | The effect's raw signal. bindAudioEffectChorus_set_dry :: MethodBind bindAudioEffectChorus_set_dry = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_dry" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The effect's raw signal. set_dry :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Float -> IO () set_dry cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_dry (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_dry" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_dry {-# NOINLINE bindAudioEffectChorus_set_voice_count #-} -- | The amount of voices in the effect. bindAudioEffectChorus_set_voice_count :: MethodBind bindAudioEffectChorus_set_voice_count = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_voice_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of voices in the effect. set_voice_count :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> IO () set_voice_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_voice_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_voice_count" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_voice_count {-# NOINLINE bindAudioEffectChorus_set_voice_cutoff_hz #-} -- | The voice's cutoff frequency. bindAudioEffectChorus_set_voice_cutoff_hz :: MethodBind bindAudioEffectChorus_set_voice_cutoff_hz = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_voice_cutoff_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's cutoff frequency. set_voice_cutoff_hz :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_voice_cutoff_hz cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_voice_cutoff_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_voice_cutoff_hz" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_voice_cutoff_hz {-# NOINLINE bindAudioEffectChorus_set_voice_delay_ms #-} -- | The voice's signal delay. bindAudioEffectChorus_set_voice_delay_ms :: MethodBind bindAudioEffectChorus_set_voice_delay_ms = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_voice_delay_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's signal delay. set_voice_delay_ms :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_voice_delay_ms cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_voice_delay_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_voice_delay_ms" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_voice_delay_ms {-# NOINLINE bindAudioEffectChorus_set_voice_depth_ms #-} -- | The voice filter's depth. bindAudioEffectChorus_set_voice_depth_ms :: MethodBind bindAudioEffectChorus_set_voice_depth_ms = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_voice_depth_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice filter's depth. set_voice_depth_ms :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_voice_depth_ms cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_voice_depth_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_voice_depth_ms" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_voice_depth_ms {-# NOINLINE bindAudioEffectChorus_set_voice_level_db #-} -- | The voice's volume. bindAudioEffectChorus_set_voice_level_db :: MethodBind bindAudioEffectChorus_set_voice_level_db = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_voice_level_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's volume. set_voice_level_db :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_voice_level_db cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_voice_level_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_voice_level_db" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_voice_level_db {-# NOINLINE bindAudioEffectChorus_set_voice_pan #-} -- | The voice's pan level. bindAudioEffectChorus_set_voice_pan :: MethodBind bindAudioEffectChorus_set_voice_pan = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_voice_pan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's pan level. set_voice_pan :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_voice_pan cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_voice_pan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_voice_pan" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_voice_pan {-# NOINLINE bindAudioEffectChorus_set_voice_rate_hz #-} -- | The voice's filter rate. bindAudioEffectChorus_set_voice_rate_hz :: MethodBind bindAudioEffectChorus_set_voice_rate_hz = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_voice_rate_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The voice's filter rate. set_voice_rate_hz :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_voice_rate_hz cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_voice_rate_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_voice_rate_hz" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_voice_rate_hz {-# NOINLINE bindAudioEffectChorus_set_wet #-} -- | The effect's processed signal. bindAudioEffectChorus_set_wet :: MethodBind bindAudioEffectChorus_set_wet = unsafePerformIO $ withCString "AudioEffectChorus" $ \ clsNamePtr -> withCString "set_wet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The effect's processed signal. set_wet :: (AudioEffectChorus :< cls, Object :< cls) => cls -> Float -> IO () set_wet cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectChorus_set_wet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectChorus "set_wet" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectChorus.set_wet ================================================ FILE: src/Godot/Core/AudioEffectCompressor.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectCompressor (Godot.Core.AudioEffectCompressor.get_attack_us, Godot.Core.AudioEffectCompressor.get_gain, Godot.Core.AudioEffectCompressor.get_mix, Godot.Core.AudioEffectCompressor.get_ratio, Godot.Core.AudioEffectCompressor.get_release_ms, Godot.Core.AudioEffectCompressor.get_sidechain, Godot.Core.AudioEffectCompressor.get_threshold, Godot.Core.AudioEffectCompressor.set_attack_us, Godot.Core.AudioEffectCompressor.set_gain, Godot.Core.AudioEffectCompressor.set_mix, Godot.Core.AudioEffectCompressor.set_ratio, Godot.Core.AudioEffectCompressor.set_release_ms, Godot.Core.AudioEffectCompressor.set_sidechain, Godot.Core.AudioEffectCompressor.set_threshold) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectCompressor "attack_us" Float 'False where nodeProperty = (get_attack_us, wrapDroppingSetter set_attack_us, Nothing) instance NodeProperty AudioEffectCompressor "gain" Float 'False where nodeProperty = (get_gain, wrapDroppingSetter set_gain, Nothing) instance NodeProperty AudioEffectCompressor "mix" Float 'False where nodeProperty = (get_mix, wrapDroppingSetter set_mix, Nothing) instance NodeProperty AudioEffectCompressor "ratio" Float 'False where nodeProperty = (get_ratio, wrapDroppingSetter set_ratio, Nothing) instance NodeProperty AudioEffectCompressor "release_ms" Float 'False where nodeProperty = (get_release_ms, wrapDroppingSetter set_release_ms, Nothing) instance NodeProperty AudioEffectCompressor "sidechain" GodotString 'False where nodeProperty = (get_sidechain, wrapDroppingSetter set_sidechain, Nothing) instance NodeProperty AudioEffectCompressor "threshold" Float 'False where nodeProperty = (get_threshold, wrapDroppingSetter set_threshold, Nothing) {-# NOINLINE bindAudioEffectCompressor_get_attack_us #-} -- | Compressor's reaction time when the signal exceeds the threshold, in microseconds. Value can range from 20 to 2000. bindAudioEffectCompressor_get_attack_us :: MethodBind bindAudioEffectCompressor_get_attack_us = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "get_attack_us" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Compressor's reaction time when the signal exceeds the threshold, in microseconds. Value can range from 20 to 2000. get_attack_us :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> IO Float get_attack_us cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_get_attack_us (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "get_attack_us" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectCompressor.get_attack_us {-# NOINLINE bindAudioEffectCompressor_get_gain #-} -- | Gain applied to the output signal. bindAudioEffectCompressor_get_gain :: MethodBind bindAudioEffectCompressor_get_gain = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "get_gain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gain applied to the output signal. get_gain :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> IO Float get_gain cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_get_gain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "get_gain" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectCompressor.get_gain {-# NOINLINE bindAudioEffectCompressor_get_mix #-} -- | Balance between original signal and effect signal. Value can range from 0 (totally dry) to 1 (totally wet). bindAudioEffectCompressor_get_mix :: MethodBind bindAudioEffectCompressor_get_mix = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "get_mix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Balance between original signal and effect signal. Value can range from 0 (totally dry) to 1 (totally wet). get_mix :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> IO Float get_mix cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_get_mix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "get_mix" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectCompressor.get_mix {-# NOINLINE bindAudioEffectCompressor_get_ratio #-} -- | Amount of compression applied to the audio once it passes the threshold level. The higher the ratio, the more the loud parts of the audio will be compressed. Value can range from 1 to 48. bindAudioEffectCompressor_get_ratio :: MethodBind bindAudioEffectCompressor_get_ratio = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "get_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of compression applied to the audio once it passes the threshold level. The higher the ratio, the more the loud parts of the audio will be compressed. Value can range from 1 to 48. get_ratio :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> IO Float get_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_get_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "get_ratio" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectCompressor.get_ratio {-# NOINLINE bindAudioEffectCompressor_get_release_ms #-} -- | Compressor's delay time to stop reducing the signal after the signal level falls below the threshold, in milliseconds. Value can range from 20 to 2000. bindAudioEffectCompressor_get_release_ms :: MethodBind bindAudioEffectCompressor_get_release_ms = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "get_release_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Compressor's delay time to stop reducing the signal after the signal level falls below the threshold, in milliseconds. Value can range from 20 to 2000. get_release_ms :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> IO Float get_release_ms cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_get_release_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "get_release_ms" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectCompressor.get_release_ms {-# NOINLINE bindAudioEffectCompressor_get_sidechain #-} -- | Reduce the sound level using another audio bus for threshold detection. bindAudioEffectCompressor_get_sidechain :: MethodBind bindAudioEffectCompressor_get_sidechain = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "get_sidechain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reduce the sound level using another audio bus for threshold detection. get_sidechain :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> IO GodotString get_sidechain cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_get_sidechain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "get_sidechain" '[] (IO GodotString) where nodeMethod = Godot.Core.AudioEffectCompressor.get_sidechain {-# NOINLINE bindAudioEffectCompressor_get_threshold #-} -- | The level above which compression is applied to the audio. Value can range from -60 to 0. bindAudioEffectCompressor_get_threshold :: MethodBind bindAudioEffectCompressor_get_threshold = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "get_threshold" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The level above which compression is applied to the audio. Value can range from -60 to 0. get_threshold :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> IO Float get_threshold cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_get_threshold (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "get_threshold" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectCompressor.get_threshold {-# NOINLINE bindAudioEffectCompressor_set_attack_us #-} -- | Compressor's reaction time when the signal exceeds the threshold, in microseconds. Value can range from 20 to 2000. bindAudioEffectCompressor_set_attack_us :: MethodBind bindAudioEffectCompressor_set_attack_us = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "set_attack_us" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Compressor's reaction time when the signal exceeds the threshold, in microseconds. Value can range from 20 to 2000. set_attack_us :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> Float -> IO () set_attack_us cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_set_attack_us (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "set_attack_us" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectCompressor.set_attack_us {-# NOINLINE bindAudioEffectCompressor_set_gain #-} -- | Gain applied to the output signal. bindAudioEffectCompressor_set_gain :: MethodBind bindAudioEffectCompressor_set_gain = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "set_gain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gain applied to the output signal. set_gain :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> Float -> IO () set_gain cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_set_gain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "set_gain" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectCompressor.set_gain {-# NOINLINE bindAudioEffectCompressor_set_mix #-} -- | Balance between original signal and effect signal. Value can range from 0 (totally dry) to 1 (totally wet). bindAudioEffectCompressor_set_mix :: MethodBind bindAudioEffectCompressor_set_mix = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "set_mix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Balance between original signal and effect signal. Value can range from 0 (totally dry) to 1 (totally wet). set_mix :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> Float -> IO () set_mix cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_set_mix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "set_mix" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectCompressor.set_mix {-# NOINLINE bindAudioEffectCompressor_set_ratio #-} -- | Amount of compression applied to the audio once it passes the threshold level. The higher the ratio, the more the loud parts of the audio will be compressed. Value can range from 1 to 48. bindAudioEffectCompressor_set_ratio :: MethodBind bindAudioEffectCompressor_set_ratio = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "set_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of compression applied to the audio once it passes the threshold level. The higher the ratio, the more the loud parts of the audio will be compressed. Value can range from 1 to 48. set_ratio :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> Float -> IO () set_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_set_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "set_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectCompressor.set_ratio {-# NOINLINE bindAudioEffectCompressor_set_release_ms #-} -- | Compressor's delay time to stop reducing the signal after the signal level falls below the threshold, in milliseconds. Value can range from 20 to 2000. bindAudioEffectCompressor_set_release_ms :: MethodBind bindAudioEffectCompressor_set_release_ms = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "set_release_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Compressor's delay time to stop reducing the signal after the signal level falls below the threshold, in milliseconds. Value can range from 20 to 2000. set_release_ms :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> Float -> IO () set_release_ms cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_set_release_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "set_release_ms" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectCompressor.set_release_ms {-# NOINLINE bindAudioEffectCompressor_set_sidechain #-} -- | Reduce the sound level using another audio bus for threshold detection. bindAudioEffectCompressor_set_sidechain :: MethodBind bindAudioEffectCompressor_set_sidechain = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "set_sidechain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reduce the sound level using another audio bus for threshold detection. set_sidechain :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> GodotString -> IO () set_sidechain cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_set_sidechain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "set_sidechain" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AudioEffectCompressor.set_sidechain {-# NOINLINE bindAudioEffectCompressor_set_threshold #-} -- | The level above which compression is applied to the audio. Value can range from -60 to 0. bindAudioEffectCompressor_set_threshold :: MethodBind bindAudioEffectCompressor_set_threshold = unsafePerformIO $ withCString "AudioEffectCompressor" $ \ clsNamePtr -> withCString "set_threshold" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The level above which compression is applied to the audio. Value can range from -60 to 0. set_threshold :: (AudioEffectCompressor :< cls, Object :< cls) => cls -> Float -> IO () set_threshold cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectCompressor_set_threshold (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectCompressor "set_threshold" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectCompressor.set_threshold ================================================ FILE: src/Godot/Core/AudioEffectDelay.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectDelay (Godot.Core.AudioEffectDelay.get_dry, Godot.Core.AudioEffectDelay.get_feedback_delay_ms, Godot.Core.AudioEffectDelay.get_feedback_level_db, Godot.Core.AudioEffectDelay.get_feedback_lowpass, Godot.Core.AudioEffectDelay.get_tap1_delay_ms, Godot.Core.AudioEffectDelay.get_tap1_level_db, Godot.Core.AudioEffectDelay.get_tap1_pan, Godot.Core.AudioEffectDelay.get_tap2_delay_ms, Godot.Core.AudioEffectDelay.get_tap2_level_db, Godot.Core.AudioEffectDelay.get_tap2_pan, Godot.Core.AudioEffectDelay.is_feedback_active, Godot.Core.AudioEffectDelay.is_tap1_active, Godot.Core.AudioEffectDelay.is_tap2_active, Godot.Core.AudioEffectDelay.set_dry, Godot.Core.AudioEffectDelay.set_feedback_active, Godot.Core.AudioEffectDelay.set_feedback_delay_ms, Godot.Core.AudioEffectDelay.set_feedback_level_db, Godot.Core.AudioEffectDelay.set_feedback_lowpass, Godot.Core.AudioEffectDelay.set_tap1_active, Godot.Core.AudioEffectDelay.set_tap1_delay_ms, Godot.Core.AudioEffectDelay.set_tap1_level_db, Godot.Core.AudioEffectDelay.set_tap1_pan, Godot.Core.AudioEffectDelay.set_tap2_active, Godot.Core.AudioEffectDelay.set_tap2_delay_ms, Godot.Core.AudioEffectDelay.set_tap2_level_db, Godot.Core.AudioEffectDelay.set_tap2_pan) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectDelay "dry" Float 'False where nodeProperty = (get_dry, wrapDroppingSetter set_dry, Nothing) instance NodeProperty AudioEffectDelay "feedback/active" Bool 'False where nodeProperty = (is_feedback_active, wrapDroppingSetter set_feedback_active, Nothing) instance NodeProperty AudioEffectDelay "feedback/delay_ms" Float 'False where nodeProperty = (get_feedback_delay_ms, wrapDroppingSetter set_feedback_delay_ms, Nothing) instance NodeProperty AudioEffectDelay "feedback/level_db" Float 'False where nodeProperty = (get_feedback_level_db, wrapDroppingSetter set_feedback_level_db, Nothing) instance NodeProperty AudioEffectDelay "feedback/lowpass" Float 'False where nodeProperty = (get_feedback_lowpass, wrapDroppingSetter set_feedback_lowpass, Nothing) instance NodeProperty AudioEffectDelay "tap1/active" Bool 'False where nodeProperty = (is_tap1_active, wrapDroppingSetter set_tap1_active, Nothing) instance NodeProperty AudioEffectDelay "tap1/delay_ms" Float 'False where nodeProperty = (get_tap1_delay_ms, wrapDroppingSetter set_tap1_delay_ms, Nothing) instance NodeProperty AudioEffectDelay "tap1/level_db" Float 'False where nodeProperty = (get_tap1_level_db, wrapDroppingSetter set_tap1_level_db, Nothing) instance NodeProperty AudioEffectDelay "tap1/pan" Float 'False where nodeProperty = (get_tap1_pan, wrapDroppingSetter set_tap1_pan, Nothing) instance NodeProperty AudioEffectDelay "tap2/active" Bool 'False where nodeProperty = (is_tap2_active, wrapDroppingSetter set_tap2_active, Nothing) instance NodeProperty AudioEffectDelay "tap2/delay_ms" Float 'False where nodeProperty = (get_tap2_delay_ms, wrapDroppingSetter set_tap2_delay_ms, Nothing) instance NodeProperty AudioEffectDelay "tap2/level_db" Float 'False where nodeProperty = (get_tap2_level_db, wrapDroppingSetter set_tap2_level_db, Nothing) instance NodeProperty AudioEffectDelay "tap2/pan" Float 'False where nodeProperty = (get_tap2_pan, wrapDroppingSetter set_tap2_pan, Nothing) {-# NOINLINE bindAudioEffectDelay_get_dry #-} -- | Output percent of original sound. At 0, only delayed sounds are output. Value can range from 0 to 1. bindAudioEffectDelay_get_dry :: MethodBind bindAudioEffectDelay_get_dry = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_dry" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of original sound. At 0, only delayed sounds are output. Value can range from 0 to 1. get_dry :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_dry cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_dry (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_dry" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_dry {-# NOINLINE bindAudioEffectDelay_get_feedback_delay_ms #-} -- | Feedback delay time in milliseconds. bindAudioEffectDelay_get_feedback_delay_ms :: MethodBind bindAudioEffectDelay_get_feedback_delay_ms = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_feedback_delay_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Feedback delay time in milliseconds. get_feedback_delay_ms :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_feedback_delay_ms cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_feedback_delay_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_feedback_delay_ms" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_feedback_delay_ms {-# NOINLINE bindAudioEffectDelay_get_feedback_level_db #-} -- | Sound level for @tap1@. bindAudioEffectDelay_get_feedback_level_db :: MethodBind bindAudioEffectDelay_get_feedback_level_db = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_feedback_level_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sound level for @tap1@. get_feedback_level_db :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_feedback_level_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_feedback_level_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_feedback_level_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_feedback_level_db {-# NOINLINE bindAudioEffectDelay_get_feedback_lowpass #-} -- | Low-pass filter for feedback, in Hz. Frequencies below this value are filtered out of the source signal. bindAudioEffectDelay_get_feedback_lowpass :: MethodBind bindAudioEffectDelay_get_feedback_lowpass = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_feedback_lowpass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Low-pass filter for feedback, in Hz. Frequencies below this value are filtered out of the source signal. get_feedback_lowpass :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_feedback_lowpass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_feedback_lowpass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_feedback_lowpass" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_feedback_lowpass {-# NOINLINE bindAudioEffectDelay_get_tap1_delay_ms #-} -- | @tap1@ delay time in milliseconds. bindAudioEffectDelay_get_tap1_delay_ms :: MethodBind bindAudioEffectDelay_get_tap1_delay_ms = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_tap1_delay_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @tap1@ delay time in milliseconds. get_tap1_delay_ms :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_tap1_delay_ms cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_tap1_delay_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_tap1_delay_ms" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_tap1_delay_ms {-# NOINLINE bindAudioEffectDelay_get_tap1_level_db #-} -- | Sound level for @tap1@. bindAudioEffectDelay_get_tap1_level_db :: MethodBind bindAudioEffectDelay_get_tap1_level_db = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_tap1_level_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sound level for @tap1@. get_tap1_level_db :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_tap1_level_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_tap1_level_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_tap1_level_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_tap1_level_db {-# NOINLINE bindAudioEffectDelay_get_tap1_pan #-} -- | Pan position for @tap1@. Value can range from -1 (fully left) to 1 (fully right). bindAudioEffectDelay_get_tap1_pan :: MethodBind bindAudioEffectDelay_get_tap1_pan = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_tap1_pan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pan position for @tap1@. Value can range from -1 (fully left) to 1 (fully right). get_tap1_pan :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_tap1_pan cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_tap1_pan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_tap1_pan" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_tap1_pan {-# NOINLINE bindAudioEffectDelay_get_tap2_delay_ms #-} -- | __Tap2__ delay time in milliseconds. bindAudioEffectDelay_get_tap2_delay_ms :: MethodBind bindAudioEffectDelay_get_tap2_delay_ms = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_tap2_delay_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | __Tap2__ delay time in milliseconds. get_tap2_delay_ms :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_tap2_delay_ms cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_tap2_delay_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_tap2_delay_ms" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_tap2_delay_ms {-# NOINLINE bindAudioEffectDelay_get_tap2_level_db #-} -- | Sound level for @tap2@. bindAudioEffectDelay_get_tap2_level_db :: MethodBind bindAudioEffectDelay_get_tap2_level_db = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_tap2_level_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sound level for @tap2@. get_tap2_level_db :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_tap2_level_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_tap2_level_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_tap2_level_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_tap2_level_db {-# NOINLINE bindAudioEffectDelay_get_tap2_pan #-} -- | Pan position for @tap2@. Value can range from -1 (fully left) to 1 (fully right). bindAudioEffectDelay_get_tap2_pan :: MethodBind bindAudioEffectDelay_get_tap2_pan = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "get_tap2_pan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pan position for @tap2@. Value can range from -1 (fully left) to 1 (fully right). get_tap2_pan :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Float get_tap2_pan cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_get_tap2_pan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "get_tap2_pan" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDelay.get_tap2_pan {-# NOINLINE bindAudioEffectDelay_is_feedback_active #-} -- | If @true@, feedback is enabled. bindAudioEffectDelay_is_feedback_active :: MethodBind bindAudioEffectDelay_is_feedback_active = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "is_feedback_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, feedback is enabled. is_feedback_active :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Bool is_feedback_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_is_feedback_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "is_feedback_active" '[] (IO Bool) where nodeMethod = Godot.Core.AudioEffectDelay.is_feedback_active {-# NOINLINE bindAudioEffectDelay_is_tap1_active #-} -- | If @true@, @tap1@ will be enabled. bindAudioEffectDelay_is_tap1_active :: MethodBind bindAudioEffectDelay_is_tap1_active = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "is_tap1_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @tap1@ will be enabled. is_tap1_active :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Bool is_tap1_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_is_tap1_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "is_tap1_active" '[] (IO Bool) where nodeMethod = Godot.Core.AudioEffectDelay.is_tap1_active {-# NOINLINE bindAudioEffectDelay_is_tap2_active #-} -- | If @true@, @tap2@ will be enabled. bindAudioEffectDelay_is_tap2_active :: MethodBind bindAudioEffectDelay_is_tap2_active = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "is_tap2_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @tap2@ will be enabled. is_tap2_active :: (AudioEffectDelay :< cls, Object :< cls) => cls -> IO Bool is_tap2_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_is_tap2_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "is_tap2_active" '[] (IO Bool) where nodeMethod = Godot.Core.AudioEffectDelay.is_tap2_active {-# NOINLINE bindAudioEffectDelay_set_dry #-} -- | Output percent of original sound. At 0, only delayed sounds are output. Value can range from 0 to 1. bindAudioEffectDelay_set_dry :: MethodBind bindAudioEffectDelay_set_dry = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_dry" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of original sound. At 0, only delayed sounds are output. Value can range from 0 to 1. set_dry :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_dry cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_dry (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_dry" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_dry {-# NOINLINE bindAudioEffectDelay_set_feedback_active #-} -- | If @true@, feedback is enabled. bindAudioEffectDelay_set_feedback_active :: MethodBind bindAudioEffectDelay_set_feedback_active = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_feedback_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, feedback is enabled. set_feedback_active :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Bool -> IO () set_feedback_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_feedback_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_feedback_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_feedback_active {-# NOINLINE bindAudioEffectDelay_set_feedback_delay_ms #-} -- | Feedback delay time in milliseconds. bindAudioEffectDelay_set_feedback_delay_ms :: MethodBind bindAudioEffectDelay_set_feedback_delay_ms = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_feedback_delay_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Feedback delay time in milliseconds. set_feedback_delay_ms :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_feedback_delay_ms cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_feedback_delay_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_feedback_delay_ms" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_feedback_delay_ms {-# NOINLINE bindAudioEffectDelay_set_feedback_level_db #-} -- | Sound level for @tap1@. bindAudioEffectDelay_set_feedback_level_db :: MethodBind bindAudioEffectDelay_set_feedback_level_db = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_feedback_level_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sound level for @tap1@. set_feedback_level_db :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_feedback_level_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_feedback_level_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_feedback_level_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_feedback_level_db {-# NOINLINE bindAudioEffectDelay_set_feedback_lowpass #-} -- | Low-pass filter for feedback, in Hz. Frequencies below this value are filtered out of the source signal. bindAudioEffectDelay_set_feedback_lowpass :: MethodBind bindAudioEffectDelay_set_feedback_lowpass = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_feedback_lowpass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Low-pass filter for feedback, in Hz. Frequencies below this value are filtered out of the source signal. set_feedback_lowpass :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_feedback_lowpass cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_feedback_lowpass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_feedback_lowpass" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_feedback_lowpass {-# NOINLINE bindAudioEffectDelay_set_tap1_active #-} -- | If @true@, @tap1@ will be enabled. bindAudioEffectDelay_set_tap1_active :: MethodBind bindAudioEffectDelay_set_tap1_active = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_tap1_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @tap1@ will be enabled. set_tap1_active :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Bool -> IO () set_tap1_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_tap1_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_tap1_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_tap1_active {-# NOINLINE bindAudioEffectDelay_set_tap1_delay_ms #-} -- | @tap1@ delay time in milliseconds. bindAudioEffectDelay_set_tap1_delay_ms :: MethodBind bindAudioEffectDelay_set_tap1_delay_ms = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_tap1_delay_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @tap1@ delay time in milliseconds. set_tap1_delay_ms :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_tap1_delay_ms cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_tap1_delay_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_tap1_delay_ms" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_tap1_delay_ms {-# NOINLINE bindAudioEffectDelay_set_tap1_level_db #-} -- | Sound level for @tap1@. bindAudioEffectDelay_set_tap1_level_db :: MethodBind bindAudioEffectDelay_set_tap1_level_db = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_tap1_level_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sound level for @tap1@. set_tap1_level_db :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_tap1_level_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_tap1_level_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_tap1_level_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_tap1_level_db {-# NOINLINE bindAudioEffectDelay_set_tap1_pan #-} -- | Pan position for @tap1@. Value can range from -1 (fully left) to 1 (fully right). bindAudioEffectDelay_set_tap1_pan :: MethodBind bindAudioEffectDelay_set_tap1_pan = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_tap1_pan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pan position for @tap1@. Value can range from -1 (fully left) to 1 (fully right). set_tap1_pan :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_tap1_pan cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_tap1_pan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_tap1_pan" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_tap1_pan {-# NOINLINE bindAudioEffectDelay_set_tap2_active #-} -- | If @true@, @tap2@ will be enabled. bindAudioEffectDelay_set_tap2_active :: MethodBind bindAudioEffectDelay_set_tap2_active = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_tap2_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @tap2@ will be enabled. set_tap2_active :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Bool -> IO () set_tap2_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_tap2_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_tap2_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_tap2_active {-# NOINLINE bindAudioEffectDelay_set_tap2_delay_ms #-} -- | __Tap2__ delay time in milliseconds. bindAudioEffectDelay_set_tap2_delay_ms :: MethodBind bindAudioEffectDelay_set_tap2_delay_ms = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_tap2_delay_ms" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | __Tap2__ delay time in milliseconds. set_tap2_delay_ms :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_tap2_delay_ms cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_tap2_delay_ms (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_tap2_delay_ms" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_tap2_delay_ms {-# NOINLINE bindAudioEffectDelay_set_tap2_level_db #-} -- | Sound level for @tap2@. bindAudioEffectDelay_set_tap2_level_db :: MethodBind bindAudioEffectDelay_set_tap2_level_db = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_tap2_level_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sound level for @tap2@. set_tap2_level_db :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_tap2_level_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_tap2_level_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_tap2_level_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_tap2_level_db {-# NOINLINE bindAudioEffectDelay_set_tap2_pan #-} -- | Pan position for @tap2@. Value can range from -1 (fully left) to 1 (fully right). bindAudioEffectDelay_set_tap2_pan :: MethodBind bindAudioEffectDelay_set_tap2_pan = unsafePerformIO $ withCString "AudioEffectDelay" $ \ clsNamePtr -> withCString "set_tap2_pan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pan position for @tap2@. Value can range from -1 (fully left) to 1 (fully right). set_tap2_pan :: (AudioEffectDelay :< cls, Object :< cls) => cls -> Float -> IO () set_tap2_pan cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDelay_set_tap2_pan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDelay "set_tap2_pan" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDelay.set_tap2_pan ================================================ FILE: src/Godot/Core/AudioEffectDistortion.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectDistortion (Godot.Core.AudioEffectDistortion._MODE_CLIP, Godot.Core.AudioEffectDistortion._MODE_LOFI, Godot.Core.AudioEffectDistortion._MODE_OVERDRIVE, Godot.Core.AudioEffectDistortion._MODE_WAVESHAPE, Godot.Core.AudioEffectDistortion._MODE_ATAN, Godot.Core.AudioEffectDistortion.get_drive, Godot.Core.AudioEffectDistortion.get_keep_hf_hz, Godot.Core.AudioEffectDistortion.get_mode, Godot.Core.AudioEffectDistortion.get_post_gain, Godot.Core.AudioEffectDistortion.get_pre_gain, Godot.Core.AudioEffectDistortion.set_drive, Godot.Core.AudioEffectDistortion.set_keep_hf_hz, Godot.Core.AudioEffectDistortion.set_mode, Godot.Core.AudioEffectDistortion.set_post_gain, Godot.Core.AudioEffectDistortion.set_pre_gain) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() _MODE_CLIP :: Int _MODE_CLIP = 0 _MODE_LOFI :: Int _MODE_LOFI = 2 _MODE_OVERDRIVE :: Int _MODE_OVERDRIVE = 3 _MODE_WAVESHAPE :: Int _MODE_WAVESHAPE = 4 _MODE_ATAN :: Int _MODE_ATAN = 1 instance NodeProperty AudioEffectDistortion "drive" Float 'False where nodeProperty = (get_drive, wrapDroppingSetter set_drive, Nothing) instance NodeProperty AudioEffectDistortion "keep_hf_hz" Float 'False where nodeProperty = (get_keep_hf_hz, wrapDroppingSetter set_keep_hf_hz, Nothing) instance NodeProperty AudioEffectDistortion "mode" Int 'False where nodeProperty = (get_mode, wrapDroppingSetter set_mode, Nothing) instance NodeProperty AudioEffectDistortion "post_gain" Float 'False where nodeProperty = (get_post_gain, wrapDroppingSetter set_post_gain, Nothing) instance NodeProperty AudioEffectDistortion "pre_gain" Float 'False where nodeProperty = (get_pre_gain, wrapDroppingSetter set_pre_gain, Nothing) {-# NOINLINE bindAudioEffectDistortion_get_drive #-} -- | Distortion power. Value can range from 0 to 1. bindAudioEffectDistortion_get_drive :: MethodBind bindAudioEffectDistortion_get_drive = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "get_drive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distortion power. Value can range from 0 to 1. get_drive :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> IO Float get_drive cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_get_drive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "get_drive" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDistortion.get_drive {-# NOINLINE bindAudioEffectDistortion_get_keep_hf_hz #-} -- | High-pass filter, in Hz. Frequencies higher than this value will not be affected by the distortion. Value can range from 1 to 20000. bindAudioEffectDistortion_get_keep_hf_hz :: MethodBind bindAudioEffectDistortion_get_keep_hf_hz = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "get_keep_hf_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | High-pass filter, in Hz. Frequencies higher than this value will not be affected by the distortion. Value can range from 1 to 20000. get_keep_hf_hz :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> IO Float get_keep_hf_hz cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_get_keep_hf_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "get_keep_hf_hz" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDistortion.get_keep_hf_hz {-# NOINLINE bindAudioEffectDistortion_get_mode #-} -- | Distortion type. bindAudioEffectDistortion_get_mode :: MethodBind bindAudioEffectDistortion_get_mode = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distortion type. get_mode :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "get_mode" '[] (IO Int) where nodeMethod = Godot.Core.AudioEffectDistortion.get_mode {-# NOINLINE bindAudioEffectDistortion_get_post_gain #-} -- | Increases or decreases the volume after the effect. Value can range from -80 to 24. bindAudioEffectDistortion_get_post_gain :: MethodBind bindAudioEffectDistortion_get_post_gain = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "get_post_gain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Increases or decreases the volume after the effect. Value can range from -80 to 24. get_post_gain :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> IO Float get_post_gain cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_get_post_gain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "get_post_gain" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDistortion.get_post_gain {-# NOINLINE bindAudioEffectDistortion_get_pre_gain #-} -- | Increases or decreases the volume before the effect. Value can range from -60 to 60. bindAudioEffectDistortion_get_pre_gain :: MethodBind bindAudioEffectDistortion_get_pre_gain = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "get_pre_gain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Increases or decreases the volume before the effect. Value can range from -60 to 60. get_pre_gain :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> IO Float get_pre_gain cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_get_pre_gain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "get_pre_gain" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectDistortion.get_pre_gain {-# NOINLINE bindAudioEffectDistortion_set_drive #-} -- | Distortion power. Value can range from 0 to 1. bindAudioEffectDistortion_set_drive :: MethodBind bindAudioEffectDistortion_set_drive = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "set_drive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distortion power. Value can range from 0 to 1. set_drive :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> Float -> IO () set_drive cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_set_drive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "set_drive" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDistortion.set_drive {-# NOINLINE bindAudioEffectDistortion_set_keep_hf_hz #-} -- | High-pass filter, in Hz. Frequencies higher than this value will not be affected by the distortion. Value can range from 1 to 20000. bindAudioEffectDistortion_set_keep_hf_hz :: MethodBind bindAudioEffectDistortion_set_keep_hf_hz = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "set_keep_hf_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | High-pass filter, in Hz. Frequencies higher than this value will not be affected by the distortion. Value can range from 1 to 20000. set_keep_hf_hz :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> Float -> IO () set_keep_hf_hz cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_set_keep_hf_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "set_keep_hf_hz" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDistortion.set_keep_hf_hz {-# NOINLINE bindAudioEffectDistortion_set_mode #-} -- | Distortion type. bindAudioEffectDistortion_set_mode :: MethodBind bindAudioEffectDistortion_set_mode = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distortion type. set_mode :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioEffectDistortion.set_mode {-# NOINLINE bindAudioEffectDistortion_set_post_gain #-} -- | Increases or decreases the volume after the effect. Value can range from -80 to 24. bindAudioEffectDistortion_set_post_gain :: MethodBind bindAudioEffectDistortion_set_post_gain = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "set_post_gain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Increases or decreases the volume after the effect. Value can range from -80 to 24. set_post_gain :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> Float -> IO () set_post_gain cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_set_post_gain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "set_post_gain" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDistortion.set_post_gain {-# NOINLINE bindAudioEffectDistortion_set_pre_gain #-} -- | Increases or decreases the volume before the effect. Value can range from -60 to 60. bindAudioEffectDistortion_set_pre_gain :: MethodBind bindAudioEffectDistortion_set_pre_gain = unsafePerformIO $ withCString "AudioEffectDistortion" $ \ clsNamePtr -> withCString "set_pre_gain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Increases or decreases the volume before the effect. Value can range from -60 to 60. set_pre_gain :: (AudioEffectDistortion :< cls, Object :< cls) => cls -> Float -> IO () set_pre_gain cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectDistortion_set_pre_gain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectDistortion "set_pre_gain" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectDistortion.set_pre_gain ================================================ FILE: src/Godot/Core/AudioEffectEQ.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectEQ (Godot.Core.AudioEffectEQ.get_band_count, Godot.Core.AudioEffectEQ.get_band_gain_db, Godot.Core.AudioEffectEQ.set_band_gain_db) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() {-# NOINLINE bindAudioEffectEQ_get_band_count #-} -- | Returns the number of bands of the equalizer. bindAudioEffectEQ_get_band_count :: MethodBind bindAudioEffectEQ_get_band_count = unsafePerformIO $ withCString "AudioEffectEQ" $ \ clsNamePtr -> withCString "get_band_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of bands of the equalizer. get_band_count :: (AudioEffectEQ :< cls, Object :< cls) => cls -> IO Int get_band_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectEQ_get_band_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectEQ "get_band_count" '[] (IO Int) where nodeMethod = Godot.Core.AudioEffectEQ.get_band_count {-# NOINLINE bindAudioEffectEQ_get_band_gain_db #-} -- | Returns the band's gain at the specified index, in dB. bindAudioEffectEQ_get_band_gain_db :: MethodBind bindAudioEffectEQ_get_band_gain_db = unsafePerformIO $ withCString "AudioEffectEQ" $ \ clsNamePtr -> withCString "get_band_gain_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the band's gain at the specified index, in dB. get_band_gain_db :: (AudioEffectEQ :< cls, Object :< cls) => cls -> Int -> IO Float get_band_gain_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectEQ_get_band_gain_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectEQ "get_band_gain_db" '[Int] (IO Float) where nodeMethod = Godot.Core.AudioEffectEQ.get_band_gain_db {-# NOINLINE bindAudioEffectEQ_set_band_gain_db #-} -- | Sets band's gain at the specified index, in dB. bindAudioEffectEQ_set_band_gain_db :: MethodBind bindAudioEffectEQ_set_band_gain_db = unsafePerformIO $ withCString "AudioEffectEQ" $ \ clsNamePtr -> withCString "set_band_gain_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets band's gain at the specified index, in dB. set_band_gain_db :: (AudioEffectEQ :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_band_gain_db cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectEQ_set_band_gain_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectEQ "set_band_gain_db" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectEQ.set_band_gain_db ================================================ FILE: src/Godot/Core/AudioEffectEQ10.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectEQ10 () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectEQ() ================================================ FILE: src/Godot/Core/AudioEffectEQ21.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectEQ21 () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectEQ() ================================================ FILE: src/Godot/Core/AudioEffectEQ6.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectEQ6 () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectEQ() ================================================ FILE: src/Godot/Core/AudioEffectFilter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectFilter (Godot.Core.AudioEffectFilter._FILTER_24DB, Godot.Core.AudioEffectFilter._FILTER_12DB, Godot.Core.AudioEffectFilter._FILTER_18DB, Godot.Core.AudioEffectFilter._FILTER_6DB, Godot.Core.AudioEffectFilter.get_cutoff, Godot.Core.AudioEffectFilter.get_db, Godot.Core.AudioEffectFilter.get_gain, Godot.Core.AudioEffectFilter.get_resonance, Godot.Core.AudioEffectFilter.set_cutoff, Godot.Core.AudioEffectFilter.set_db, Godot.Core.AudioEffectFilter.set_gain, Godot.Core.AudioEffectFilter.set_resonance) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() _FILTER_24DB :: Int _FILTER_24DB = 3 _FILTER_12DB :: Int _FILTER_12DB = 1 _FILTER_18DB :: Int _FILTER_18DB = 2 _FILTER_6DB :: Int _FILTER_6DB = 0 instance NodeProperty AudioEffectFilter "cutoff_hz" Float 'False where nodeProperty = (get_cutoff, wrapDroppingSetter set_cutoff, Nothing) instance NodeProperty AudioEffectFilter "db" Int 'False where nodeProperty = (get_db, wrapDroppingSetter set_db, Nothing) instance NodeProperty AudioEffectFilter "gain" Float 'False where nodeProperty = (get_gain, wrapDroppingSetter set_gain, Nothing) instance NodeProperty AudioEffectFilter "resonance" Float 'False where nodeProperty = (get_resonance, wrapDroppingSetter set_resonance, Nothing) {-# NOINLINE bindAudioEffectFilter_get_cutoff #-} -- | Threshold frequency for the filter, in Hz. bindAudioEffectFilter_get_cutoff :: MethodBind bindAudioEffectFilter_get_cutoff = unsafePerformIO $ withCString "AudioEffectFilter" $ \ clsNamePtr -> withCString "get_cutoff" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Threshold frequency for the filter, in Hz. get_cutoff :: (AudioEffectFilter :< cls, Object :< cls) => cls -> IO Float get_cutoff cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectFilter_get_cutoff (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectFilter "get_cutoff" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectFilter.get_cutoff {-# NOINLINE bindAudioEffectFilter_get_db #-} bindAudioEffectFilter_get_db :: MethodBind bindAudioEffectFilter_get_db = unsafePerformIO $ withCString "AudioEffectFilter" $ \ clsNamePtr -> withCString "get_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_db :: (AudioEffectFilter :< cls, Object :< cls) => cls -> IO Int get_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectFilter_get_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectFilter "get_db" '[] (IO Int) where nodeMethod = Godot.Core.AudioEffectFilter.get_db {-# NOINLINE bindAudioEffectFilter_get_gain #-} -- | Gain amount of the frequencies after the filter. bindAudioEffectFilter_get_gain :: MethodBind bindAudioEffectFilter_get_gain = unsafePerformIO $ withCString "AudioEffectFilter" $ \ clsNamePtr -> withCString "get_gain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gain amount of the frequencies after the filter. get_gain :: (AudioEffectFilter :< cls, Object :< cls) => cls -> IO Float get_gain cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectFilter_get_gain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectFilter "get_gain" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectFilter.get_gain {-# NOINLINE bindAudioEffectFilter_get_resonance #-} -- | Amount of boost in the frequency range near the cutoff frequency. bindAudioEffectFilter_get_resonance :: MethodBind bindAudioEffectFilter_get_resonance = unsafePerformIO $ withCString "AudioEffectFilter" $ \ clsNamePtr -> withCString "get_resonance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of boost in the frequency range near the cutoff frequency. get_resonance :: (AudioEffectFilter :< cls, Object :< cls) => cls -> IO Float get_resonance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectFilter_get_resonance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectFilter "get_resonance" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectFilter.get_resonance {-# NOINLINE bindAudioEffectFilter_set_cutoff #-} -- | Threshold frequency for the filter, in Hz. bindAudioEffectFilter_set_cutoff :: MethodBind bindAudioEffectFilter_set_cutoff = unsafePerformIO $ withCString "AudioEffectFilter" $ \ clsNamePtr -> withCString "set_cutoff" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Threshold frequency for the filter, in Hz. set_cutoff :: (AudioEffectFilter :< cls, Object :< cls) => cls -> Float -> IO () set_cutoff cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectFilter_set_cutoff (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectFilter "set_cutoff" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectFilter.set_cutoff {-# NOINLINE bindAudioEffectFilter_set_db #-} bindAudioEffectFilter_set_db :: MethodBind bindAudioEffectFilter_set_db = unsafePerformIO $ withCString "AudioEffectFilter" $ \ clsNamePtr -> withCString "set_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_db :: (AudioEffectFilter :< cls, Object :< cls) => cls -> Int -> IO () set_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectFilter_set_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectFilter "set_db" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioEffectFilter.set_db {-# NOINLINE bindAudioEffectFilter_set_gain #-} -- | Gain amount of the frequencies after the filter. bindAudioEffectFilter_set_gain :: MethodBind bindAudioEffectFilter_set_gain = unsafePerformIO $ withCString "AudioEffectFilter" $ \ clsNamePtr -> withCString "set_gain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gain amount of the frequencies after the filter. set_gain :: (AudioEffectFilter :< cls, Object :< cls) => cls -> Float -> IO () set_gain cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectFilter_set_gain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectFilter "set_gain" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectFilter.set_gain {-# NOINLINE bindAudioEffectFilter_set_resonance #-} -- | Amount of boost in the frequency range near the cutoff frequency. bindAudioEffectFilter_set_resonance :: MethodBind bindAudioEffectFilter_set_resonance = unsafePerformIO $ withCString "AudioEffectFilter" $ \ clsNamePtr -> withCString "set_resonance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of boost in the frequency range near the cutoff frequency. set_resonance :: (AudioEffectFilter :< cls, Object :< cls) => cls -> Float -> IO () set_resonance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectFilter_set_resonance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectFilter "set_resonance" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectFilter.set_resonance ================================================ FILE: src/Godot/Core/AudioEffectHighPassFilter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectHighPassFilter () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectFilter() ================================================ FILE: src/Godot/Core/AudioEffectHighShelfFilter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectHighShelfFilter () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectFilter() ================================================ FILE: src/Godot/Core/AudioEffectInstance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectInstance () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() ================================================ FILE: src/Godot/Core/AudioEffectLimiter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectLimiter (Godot.Core.AudioEffectLimiter.get_ceiling_db, Godot.Core.AudioEffectLimiter.get_soft_clip_db, Godot.Core.AudioEffectLimiter.get_soft_clip_ratio, Godot.Core.AudioEffectLimiter.get_threshold_db, Godot.Core.AudioEffectLimiter.set_ceiling_db, Godot.Core.AudioEffectLimiter.set_soft_clip_db, Godot.Core.AudioEffectLimiter.set_soft_clip_ratio, Godot.Core.AudioEffectLimiter.set_threshold_db) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectLimiter "ceiling_db" Float 'False where nodeProperty = (get_ceiling_db, wrapDroppingSetter set_ceiling_db, Nothing) instance NodeProperty AudioEffectLimiter "soft_clip_db" Float 'False where nodeProperty = (get_soft_clip_db, wrapDroppingSetter set_soft_clip_db, Nothing) instance NodeProperty AudioEffectLimiter "soft_clip_ratio" Float 'False where nodeProperty = (get_soft_clip_ratio, wrapDroppingSetter set_soft_clip_ratio, Nothing) instance NodeProperty AudioEffectLimiter "threshold_db" Float 'False where nodeProperty = (get_threshold_db, wrapDroppingSetter set_threshold_db, Nothing) {-# NOINLINE bindAudioEffectLimiter_get_ceiling_db #-} -- | The waveform's maximum allowed value, in decibels. Value can range from -20 to -0.1. bindAudioEffectLimiter_get_ceiling_db :: MethodBind bindAudioEffectLimiter_get_ceiling_db = unsafePerformIO $ withCString "AudioEffectLimiter" $ \ clsNamePtr -> withCString "get_ceiling_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The waveform's maximum allowed value, in decibels. Value can range from -20 to -0.1. get_ceiling_db :: (AudioEffectLimiter :< cls, Object :< cls) => cls -> IO Float get_ceiling_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectLimiter_get_ceiling_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectLimiter "get_ceiling_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectLimiter.get_ceiling_db {-# NOINLINE bindAudioEffectLimiter_get_soft_clip_db #-} -- | Applies a gain to the limited waves, in decibels. Value can range from 0 to 6. bindAudioEffectLimiter_get_soft_clip_db :: MethodBind bindAudioEffectLimiter_get_soft_clip_db = unsafePerformIO $ withCString "AudioEffectLimiter" $ \ clsNamePtr -> withCString "get_soft_clip_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a gain to the limited waves, in decibels. Value can range from 0 to 6. get_soft_clip_db :: (AudioEffectLimiter :< cls, Object :< cls) => cls -> IO Float get_soft_clip_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectLimiter_get_soft_clip_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectLimiter "get_soft_clip_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectLimiter.get_soft_clip_db {-# NOINLINE bindAudioEffectLimiter_get_soft_clip_ratio #-} bindAudioEffectLimiter_get_soft_clip_ratio :: MethodBind bindAudioEffectLimiter_get_soft_clip_ratio = unsafePerformIO $ withCString "AudioEffectLimiter" $ \ clsNamePtr -> withCString "get_soft_clip_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_soft_clip_ratio :: (AudioEffectLimiter :< cls, Object :< cls) => cls -> IO Float get_soft_clip_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectLimiter_get_soft_clip_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectLimiter "get_soft_clip_ratio" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectLimiter.get_soft_clip_ratio {-# NOINLINE bindAudioEffectLimiter_get_threshold_db #-} -- | Threshold from which the limiter begins to be active, in decibels. Value can range from -30 to 0. bindAudioEffectLimiter_get_threshold_db :: MethodBind bindAudioEffectLimiter_get_threshold_db = unsafePerformIO $ withCString "AudioEffectLimiter" $ \ clsNamePtr -> withCString "get_threshold_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Threshold from which the limiter begins to be active, in decibels. Value can range from -30 to 0. get_threshold_db :: (AudioEffectLimiter :< cls, Object :< cls) => cls -> IO Float get_threshold_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectLimiter_get_threshold_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectLimiter "get_threshold_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectLimiter.get_threshold_db {-# NOINLINE bindAudioEffectLimiter_set_ceiling_db #-} -- | The waveform's maximum allowed value, in decibels. Value can range from -20 to -0.1. bindAudioEffectLimiter_set_ceiling_db :: MethodBind bindAudioEffectLimiter_set_ceiling_db = unsafePerformIO $ withCString "AudioEffectLimiter" $ \ clsNamePtr -> withCString "set_ceiling_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The waveform's maximum allowed value, in decibels. Value can range from -20 to -0.1. set_ceiling_db :: (AudioEffectLimiter :< cls, Object :< cls) => cls -> Float -> IO () set_ceiling_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectLimiter_set_ceiling_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectLimiter "set_ceiling_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectLimiter.set_ceiling_db {-# NOINLINE bindAudioEffectLimiter_set_soft_clip_db #-} -- | Applies a gain to the limited waves, in decibels. Value can range from 0 to 6. bindAudioEffectLimiter_set_soft_clip_db :: MethodBind bindAudioEffectLimiter_set_soft_clip_db = unsafePerformIO $ withCString "AudioEffectLimiter" $ \ clsNamePtr -> withCString "set_soft_clip_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a gain to the limited waves, in decibels. Value can range from 0 to 6. set_soft_clip_db :: (AudioEffectLimiter :< cls, Object :< cls) => cls -> Float -> IO () set_soft_clip_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectLimiter_set_soft_clip_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectLimiter "set_soft_clip_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectLimiter.set_soft_clip_db {-# NOINLINE bindAudioEffectLimiter_set_soft_clip_ratio #-} bindAudioEffectLimiter_set_soft_clip_ratio :: MethodBind bindAudioEffectLimiter_set_soft_clip_ratio = unsafePerformIO $ withCString "AudioEffectLimiter" $ \ clsNamePtr -> withCString "set_soft_clip_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_soft_clip_ratio :: (AudioEffectLimiter :< cls, Object :< cls) => cls -> Float -> IO () set_soft_clip_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectLimiter_set_soft_clip_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectLimiter "set_soft_clip_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectLimiter.set_soft_clip_ratio {-# NOINLINE bindAudioEffectLimiter_set_threshold_db #-} -- | Threshold from which the limiter begins to be active, in decibels. Value can range from -30 to 0. bindAudioEffectLimiter_set_threshold_db :: MethodBind bindAudioEffectLimiter_set_threshold_db = unsafePerformIO $ withCString "AudioEffectLimiter" $ \ clsNamePtr -> withCString "set_threshold_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Threshold from which the limiter begins to be active, in decibels. Value can range from -30 to 0. set_threshold_db :: (AudioEffectLimiter :< cls, Object :< cls) => cls -> Float -> IO () set_threshold_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectLimiter_set_threshold_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectLimiter "set_threshold_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectLimiter.set_threshold_db ================================================ FILE: src/Godot/Core/AudioEffectLowPassFilter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectLowPassFilter () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectFilter() ================================================ FILE: src/Godot/Core/AudioEffectLowShelfFilter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectLowShelfFilter () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectFilter() ================================================ FILE: src/Godot/Core/AudioEffectNotchFilter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectNotchFilter () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectFilter() ================================================ FILE: src/Godot/Core/AudioEffectPanner.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectPanner (Godot.Core.AudioEffectPanner.get_pan, Godot.Core.AudioEffectPanner.set_pan) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectPanner "pan" Float 'False where nodeProperty = (get_pan, wrapDroppingSetter set_pan, Nothing) {-# NOINLINE bindAudioEffectPanner_get_pan #-} -- | Pan position. Value can range from -1 (fully left) to 1 (fully right). bindAudioEffectPanner_get_pan :: MethodBind bindAudioEffectPanner_get_pan = unsafePerformIO $ withCString "AudioEffectPanner" $ \ clsNamePtr -> withCString "get_pan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pan position. Value can range from -1 (fully left) to 1 (fully right). get_pan :: (AudioEffectPanner :< cls, Object :< cls) => cls -> IO Float get_pan cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPanner_get_pan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPanner "get_pan" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectPanner.get_pan {-# NOINLINE bindAudioEffectPanner_set_pan #-} -- | Pan position. Value can range from -1 (fully left) to 1 (fully right). bindAudioEffectPanner_set_pan :: MethodBind bindAudioEffectPanner_set_pan = unsafePerformIO $ withCString "AudioEffectPanner" $ \ clsNamePtr -> withCString "set_pan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pan position. Value can range from -1 (fully left) to 1 (fully right). set_pan :: (AudioEffectPanner :< cls, Object :< cls) => cls -> Float -> IO () set_pan cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPanner_set_pan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPanner "set_pan" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectPanner.set_pan ================================================ FILE: src/Godot/Core/AudioEffectPhaser.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectPhaser (Godot.Core.AudioEffectPhaser.get_depth, Godot.Core.AudioEffectPhaser.get_feedback, Godot.Core.AudioEffectPhaser.get_range_max_hz, Godot.Core.AudioEffectPhaser.get_range_min_hz, Godot.Core.AudioEffectPhaser.get_rate_hz, Godot.Core.AudioEffectPhaser.set_depth, Godot.Core.AudioEffectPhaser.set_feedback, Godot.Core.AudioEffectPhaser.set_range_max_hz, Godot.Core.AudioEffectPhaser.set_range_min_hz, Godot.Core.AudioEffectPhaser.set_rate_hz) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectPhaser "depth" Float 'False where nodeProperty = (get_depth, wrapDroppingSetter set_depth, Nothing) instance NodeProperty AudioEffectPhaser "feedback" Float 'False where nodeProperty = (get_feedback, wrapDroppingSetter set_feedback, Nothing) instance NodeProperty AudioEffectPhaser "range_max_hz" Float 'False where nodeProperty = (get_range_max_hz, wrapDroppingSetter set_range_max_hz, Nothing) instance NodeProperty AudioEffectPhaser "range_min_hz" Float 'False where nodeProperty = (get_range_min_hz, wrapDroppingSetter set_range_min_hz, Nothing) instance NodeProperty AudioEffectPhaser "rate_hz" Float 'False where nodeProperty = (get_rate_hz, wrapDroppingSetter set_rate_hz, Nothing) {-# NOINLINE bindAudioEffectPhaser_get_depth #-} -- | Governs how high the filter frequencies sweep. Low value will primarily affect bass frequencies. High value can sweep high into the treble. Value can range from 0.1 to 4. bindAudioEffectPhaser_get_depth :: MethodBind bindAudioEffectPhaser_get_depth = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "get_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Governs how high the filter frequencies sweep. Low value will primarily affect bass frequencies. High value can sweep high into the treble. Value can range from 0.1 to 4. get_depth :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> IO Float get_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_get_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "get_depth" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectPhaser.get_depth {-# NOINLINE bindAudioEffectPhaser_get_feedback #-} -- | Output percent of modified sound. Value can range from 0.1 to 0.9. bindAudioEffectPhaser_get_feedback :: MethodBind bindAudioEffectPhaser_get_feedback = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "get_feedback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of modified sound. Value can range from 0.1 to 0.9. get_feedback :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> IO Float get_feedback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_get_feedback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "get_feedback" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectPhaser.get_feedback {-# NOINLINE bindAudioEffectPhaser_get_range_max_hz #-} -- | Determines the maximum frequency affected by the LFO modulations, in Hz. Value can range from 10 to 10000. bindAudioEffectPhaser_get_range_max_hz :: MethodBind bindAudioEffectPhaser_get_range_max_hz = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "get_range_max_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines the maximum frequency affected by the LFO modulations, in Hz. Value can range from 10 to 10000. get_range_max_hz :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> IO Float get_range_max_hz cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_get_range_max_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "get_range_max_hz" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectPhaser.get_range_max_hz {-# NOINLINE bindAudioEffectPhaser_get_range_min_hz #-} -- | Determines the minimum frequency affected by the LFO modulations, in Hz. Value can range from 10 to 10000. bindAudioEffectPhaser_get_range_min_hz :: MethodBind bindAudioEffectPhaser_get_range_min_hz = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "get_range_min_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines the minimum frequency affected by the LFO modulations, in Hz. Value can range from 10 to 10000. get_range_min_hz :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> IO Float get_range_min_hz cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_get_range_min_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "get_range_min_hz" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectPhaser.get_range_min_hz {-# NOINLINE bindAudioEffectPhaser_get_rate_hz #-} -- | Adjusts the rate in Hz at which the effect sweeps up and down across the frequency range. bindAudioEffectPhaser_get_rate_hz :: MethodBind bindAudioEffectPhaser_get_rate_hz = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "get_rate_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adjusts the rate in Hz at which the effect sweeps up and down across the frequency range. get_rate_hz :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> IO Float get_rate_hz cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_get_rate_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "get_rate_hz" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectPhaser.get_rate_hz {-# NOINLINE bindAudioEffectPhaser_set_depth #-} -- | Governs how high the filter frequencies sweep. Low value will primarily affect bass frequencies. High value can sweep high into the treble. Value can range from 0.1 to 4. bindAudioEffectPhaser_set_depth :: MethodBind bindAudioEffectPhaser_set_depth = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "set_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Governs how high the filter frequencies sweep. Low value will primarily affect bass frequencies. High value can sweep high into the treble. Value can range from 0.1 to 4. set_depth :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> Float -> IO () set_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_set_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "set_depth" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectPhaser.set_depth {-# NOINLINE bindAudioEffectPhaser_set_feedback #-} -- | Output percent of modified sound. Value can range from 0.1 to 0.9. bindAudioEffectPhaser_set_feedback :: MethodBind bindAudioEffectPhaser_set_feedback = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "set_feedback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of modified sound. Value can range from 0.1 to 0.9. set_feedback :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> Float -> IO () set_feedback cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_set_feedback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "set_feedback" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectPhaser.set_feedback {-# NOINLINE bindAudioEffectPhaser_set_range_max_hz #-} -- | Determines the maximum frequency affected by the LFO modulations, in Hz. Value can range from 10 to 10000. bindAudioEffectPhaser_set_range_max_hz :: MethodBind bindAudioEffectPhaser_set_range_max_hz = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "set_range_max_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines the maximum frequency affected by the LFO modulations, in Hz. Value can range from 10 to 10000. set_range_max_hz :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> Float -> IO () set_range_max_hz cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_set_range_max_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "set_range_max_hz" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectPhaser.set_range_max_hz {-# NOINLINE bindAudioEffectPhaser_set_range_min_hz #-} -- | Determines the minimum frequency affected by the LFO modulations, in Hz. Value can range from 10 to 10000. bindAudioEffectPhaser_set_range_min_hz :: MethodBind bindAudioEffectPhaser_set_range_min_hz = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "set_range_min_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines the minimum frequency affected by the LFO modulations, in Hz. Value can range from 10 to 10000. set_range_min_hz :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> Float -> IO () set_range_min_hz cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_set_range_min_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "set_range_min_hz" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectPhaser.set_range_min_hz {-# NOINLINE bindAudioEffectPhaser_set_rate_hz #-} -- | Adjusts the rate in Hz at which the effect sweeps up and down across the frequency range. bindAudioEffectPhaser_set_rate_hz :: MethodBind bindAudioEffectPhaser_set_rate_hz = unsafePerformIO $ withCString "AudioEffectPhaser" $ \ clsNamePtr -> withCString "set_rate_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adjusts the rate in Hz at which the effect sweeps up and down across the frequency range. set_rate_hz :: (AudioEffectPhaser :< cls, Object :< cls) => cls -> Float -> IO () set_rate_hz cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPhaser_set_rate_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPhaser "set_rate_hz" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectPhaser.set_rate_hz ================================================ FILE: src/Godot/Core/AudioEffectPitchShift.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectPitchShift (Godot.Core.AudioEffectPitchShift._FFT_SIZE_2048, Godot.Core.AudioEffectPitchShift._FFT_SIZE_4096, Godot.Core.AudioEffectPitchShift._FFT_SIZE_MAX, Godot.Core.AudioEffectPitchShift._FFT_SIZE_512, Godot.Core.AudioEffectPitchShift._FFT_SIZE_256, Godot.Core.AudioEffectPitchShift._FFT_SIZE_1024, Godot.Core.AudioEffectPitchShift.get_fft_size, Godot.Core.AudioEffectPitchShift.get_oversampling, Godot.Core.AudioEffectPitchShift.get_pitch_scale, Godot.Core.AudioEffectPitchShift.set_fft_size, Godot.Core.AudioEffectPitchShift.set_oversampling, Godot.Core.AudioEffectPitchShift.set_pitch_scale) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() _FFT_SIZE_2048 :: Int _FFT_SIZE_2048 = 3 _FFT_SIZE_4096 :: Int _FFT_SIZE_4096 = 4 _FFT_SIZE_MAX :: Int _FFT_SIZE_MAX = 5 _FFT_SIZE_512 :: Int _FFT_SIZE_512 = 1 _FFT_SIZE_256 :: Int _FFT_SIZE_256 = 0 _FFT_SIZE_1024 :: Int _FFT_SIZE_1024 = 2 instance NodeProperty AudioEffectPitchShift "fft_size" Int 'False where nodeProperty = (get_fft_size, wrapDroppingSetter set_fft_size, Nothing) instance NodeProperty AudioEffectPitchShift "oversampling" Int 'False where nodeProperty = (get_oversampling, wrapDroppingSetter set_oversampling, Nothing) instance NodeProperty AudioEffectPitchShift "pitch_scale" Float 'False where nodeProperty = (get_pitch_scale, wrapDroppingSetter set_pitch_scale, Nothing) {-# NOINLINE bindAudioEffectPitchShift_get_fft_size #-} bindAudioEffectPitchShift_get_fft_size :: MethodBind bindAudioEffectPitchShift_get_fft_size = unsafePerformIO $ withCString "AudioEffectPitchShift" $ \ clsNamePtr -> withCString "get_fft_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_fft_size :: (AudioEffectPitchShift :< cls, Object :< cls) => cls -> IO Int get_fft_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPitchShift_get_fft_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPitchShift "get_fft_size" '[] (IO Int) where nodeMethod = Godot.Core.AudioEffectPitchShift.get_fft_size {-# NOINLINE bindAudioEffectPitchShift_get_oversampling #-} bindAudioEffectPitchShift_get_oversampling :: MethodBind bindAudioEffectPitchShift_get_oversampling = unsafePerformIO $ withCString "AudioEffectPitchShift" $ \ clsNamePtr -> withCString "get_oversampling" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_oversampling :: (AudioEffectPitchShift :< cls, Object :< cls) => cls -> IO Int get_oversampling cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPitchShift_get_oversampling (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPitchShift "get_oversampling" '[] (IO Int) where nodeMethod = Godot.Core.AudioEffectPitchShift.get_oversampling {-# NOINLINE bindAudioEffectPitchShift_get_pitch_scale #-} -- | Pitch value. Can range from 0 (-1 octave) to 16 (+16 octaves). bindAudioEffectPitchShift_get_pitch_scale :: MethodBind bindAudioEffectPitchShift_get_pitch_scale = unsafePerformIO $ withCString "AudioEffectPitchShift" $ \ clsNamePtr -> withCString "get_pitch_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pitch value. Can range from 0 (-1 octave) to 16 (+16 octaves). get_pitch_scale :: (AudioEffectPitchShift :< cls, Object :< cls) => cls -> IO Float get_pitch_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPitchShift_get_pitch_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPitchShift "get_pitch_scale" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectPitchShift.get_pitch_scale {-# NOINLINE bindAudioEffectPitchShift_set_fft_size #-} bindAudioEffectPitchShift_set_fft_size :: MethodBind bindAudioEffectPitchShift_set_fft_size = unsafePerformIO $ withCString "AudioEffectPitchShift" $ \ clsNamePtr -> withCString "set_fft_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_fft_size :: (AudioEffectPitchShift :< cls, Object :< cls) => cls -> Int -> IO () set_fft_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPitchShift_set_fft_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPitchShift "set_fft_size" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioEffectPitchShift.set_fft_size {-# NOINLINE bindAudioEffectPitchShift_set_oversampling #-} bindAudioEffectPitchShift_set_oversampling :: MethodBind bindAudioEffectPitchShift_set_oversampling = unsafePerformIO $ withCString "AudioEffectPitchShift" $ \ clsNamePtr -> withCString "set_oversampling" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_oversampling :: (AudioEffectPitchShift :< cls, Object :< cls) => cls -> Int -> IO () set_oversampling cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPitchShift_set_oversampling (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPitchShift "set_oversampling" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioEffectPitchShift.set_oversampling {-# NOINLINE bindAudioEffectPitchShift_set_pitch_scale #-} -- | Pitch value. Can range from 0 (-1 octave) to 16 (+16 octaves). bindAudioEffectPitchShift_set_pitch_scale :: MethodBind bindAudioEffectPitchShift_set_pitch_scale = unsafePerformIO $ withCString "AudioEffectPitchShift" $ \ clsNamePtr -> withCString "set_pitch_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pitch value. Can range from 0 (-1 octave) to 16 (+16 octaves). set_pitch_scale :: (AudioEffectPitchShift :< cls, Object :< cls) => cls -> Float -> IO () set_pitch_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectPitchShift_set_pitch_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectPitchShift "set_pitch_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectPitchShift.set_pitch_scale ================================================ FILE: src/Godot/Core/AudioEffectRecord.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectRecord (Godot.Core.AudioEffectRecord.get_format, Godot.Core.AudioEffectRecord.get_recording, Godot.Core.AudioEffectRecord.is_recording_active, Godot.Core.AudioEffectRecord.set_format, Godot.Core.AudioEffectRecord.set_recording_active) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectRecord "format" Int 'False where nodeProperty = (get_format, wrapDroppingSetter set_format, Nothing) {-# NOINLINE bindAudioEffectRecord_get_format #-} -- | Specifies the format in which the sample will be recorded. See @enum AudioStreamSample.Format@ for available formats. bindAudioEffectRecord_get_format :: MethodBind bindAudioEffectRecord_get_format = unsafePerformIO $ withCString "AudioEffectRecord" $ \ clsNamePtr -> withCString "get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the format in which the sample will be recorded. See @enum AudioStreamSample.Format@ for available formats. get_format :: (AudioEffectRecord :< cls, Object :< cls) => cls -> IO Int get_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectRecord_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectRecord "get_format" '[] (IO Int) where nodeMethod = Godot.Core.AudioEffectRecord.get_format {-# NOINLINE bindAudioEffectRecord_get_recording #-} -- | Returns the recorded sample. bindAudioEffectRecord_get_recording :: MethodBind bindAudioEffectRecord_get_recording = unsafePerformIO $ withCString "AudioEffectRecord" $ \ clsNamePtr -> withCString "get_recording" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the recorded sample. get_recording :: (AudioEffectRecord :< cls, Object :< cls) => cls -> IO AudioStreamSample get_recording cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectRecord_get_recording (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectRecord "get_recording" '[] (IO AudioStreamSample) where nodeMethod = Godot.Core.AudioEffectRecord.get_recording {-# NOINLINE bindAudioEffectRecord_is_recording_active #-} -- | Returns whether the recording is active or not. bindAudioEffectRecord_is_recording_active :: MethodBind bindAudioEffectRecord_is_recording_active = unsafePerformIO $ withCString "AudioEffectRecord" $ \ clsNamePtr -> withCString "is_recording_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the recording is active or not. is_recording_active :: (AudioEffectRecord :< cls, Object :< cls) => cls -> IO Bool is_recording_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectRecord_is_recording_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectRecord "is_recording_active" '[] (IO Bool) where nodeMethod = Godot.Core.AudioEffectRecord.is_recording_active {-# NOINLINE bindAudioEffectRecord_set_format #-} -- | Specifies the format in which the sample will be recorded. See @enum AudioStreamSample.Format@ for available formats. bindAudioEffectRecord_set_format :: MethodBind bindAudioEffectRecord_set_format = unsafePerformIO $ withCString "AudioEffectRecord" $ \ clsNamePtr -> withCString "set_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the format in which the sample will be recorded. See @enum AudioStreamSample.Format@ for available formats. set_format :: (AudioEffectRecord :< cls, Object :< cls) => cls -> Int -> IO () set_format cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectRecord_set_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectRecord "set_format" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioEffectRecord.set_format {-# NOINLINE bindAudioEffectRecord_set_recording_active #-} -- | If @true@, the sound will be recorded. Note that restarting the recording will remove the previously recorded sample. bindAudioEffectRecord_set_recording_active :: MethodBind bindAudioEffectRecord_set_recording_active = unsafePerformIO $ withCString "AudioEffectRecord" $ \ clsNamePtr -> withCString "set_recording_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the sound will be recorded. Note that restarting the recording will remove the previously recorded sample. set_recording_active :: (AudioEffectRecord :< cls, Object :< cls) => cls -> Bool -> IO () set_recording_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectRecord_set_recording_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectRecord "set_recording_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioEffectRecord.set_recording_active ================================================ FILE: src/Godot/Core/AudioEffectReverb.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectReverb (Godot.Core.AudioEffectReverb.get_damping, Godot.Core.AudioEffectReverb.get_dry, Godot.Core.AudioEffectReverb.get_hpf, Godot.Core.AudioEffectReverb.get_predelay_feedback, Godot.Core.AudioEffectReverb.get_predelay_msec, Godot.Core.AudioEffectReverb.get_room_size, Godot.Core.AudioEffectReverb.get_spread, Godot.Core.AudioEffectReverb.get_wet, Godot.Core.AudioEffectReverb.set_damping, Godot.Core.AudioEffectReverb.set_dry, Godot.Core.AudioEffectReverb.set_hpf, Godot.Core.AudioEffectReverb.set_predelay_feedback, Godot.Core.AudioEffectReverb.set_predelay_msec, Godot.Core.AudioEffectReverb.set_room_size, Godot.Core.AudioEffectReverb.set_spread, Godot.Core.AudioEffectReverb.set_wet) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectReverb "damping" Float 'False where nodeProperty = (get_damping, wrapDroppingSetter set_damping, Nothing) instance NodeProperty AudioEffectReverb "dry" Float 'False where nodeProperty = (get_dry, wrapDroppingSetter set_dry, Nothing) instance NodeProperty AudioEffectReverb "hipass" Float 'False where nodeProperty = (get_hpf, wrapDroppingSetter set_hpf, Nothing) instance NodeProperty AudioEffectReverb "predelay_feedback" Float 'False where nodeProperty = (get_predelay_feedback, wrapDroppingSetter set_predelay_feedback, Nothing) instance NodeProperty AudioEffectReverb "predelay_msec" Float 'False where nodeProperty = (get_predelay_msec, wrapDroppingSetter set_predelay_msec, Nothing) instance NodeProperty AudioEffectReverb "room_size" Float 'False where nodeProperty = (get_room_size, wrapDroppingSetter set_room_size, Nothing) instance NodeProperty AudioEffectReverb "spread" Float 'False where nodeProperty = (get_spread, wrapDroppingSetter set_spread, Nothing) instance NodeProperty AudioEffectReverb "wet" Float 'False where nodeProperty = (get_wet, wrapDroppingSetter set_wet, Nothing) {-# NOINLINE bindAudioEffectReverb_get_damping #-} -- | Defines how reflective the imaginary room's walls are. Value can range from 0 to 1. bindAudioEffectReverb_get_damping :: MethodBind bindAudioEffectReverb_get_damping = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "get_damping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines how reflective the imaginary room's walls are. Value can range from 0 to 1. get_damping :: (AudioEffectReverb :< cls, Object :< cls) => cls -> IO Float get_damping cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_get_damping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "get_damping" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectReverb.get_damping {-# NOINLINE bindAudioEffectReverb_get_dry #-} -- | Output percent of original sound. At 0, only modified sound is outputted. Value can range from 0 to 1. bindAudioEffectReverb_get_dry :: MethodBind bindAudioEffectReverb_get_dry = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "get_dry" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of original sound. At 0, only modified sound is outputted. Value can range from 0 to 1. get_dry :: (AudioEffectReverb :< cls, Object :< cls) => cls -> IO Float get_dry cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_get_dry (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "get_dry" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectReverb.get_dry {-# NOINLINE bindAudioEffectReverb_get_hpf #-} -- | High-pass filter passes signals with a frequency higher than a certain cutoff frequency and attenuates signals with frequencies lower than the cutoff frequency. Value can range from 0 to 1. bindAudioEffectReverb_get_hpf :: MethodBind bindAudioEffectReverb_get_hpf = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "get_hpf" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | High-pass filter passes signals with a frequency higher than a certain cutoff frequency and attenuates signals with frequencies lower than the cutoff frequency. Value can range from 0 to 1. get_hpf :: (AudioEffectReverb :< cls, Object :< cls) => cls -> IO Float get_hpf cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_get_hpf (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "get_hpf" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectReverb.get_hpf {-# NOINLINE bindAudioEffectReverb_get_predelay_feedback #-} -- | Output percent of predelay. Value can range from 0 to 1. bindAudioEffectReverb_get_predelay_feedback :: MethodBind bindAudioEffectReverb_get_predelay_feedback = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "get_predelay_feedback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of predelay. Value can range from 0 to 1. get_predelay_feedback :: (AudioEffectReverb :< cls, Object :< cls) => cls -> IO Float get_predelay_feedback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_get_predelay_feedback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "get_predelay_feedback" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectReverb.get_predelay_feedback {-# NOINLINE bindAudioEffectReverb_get_predelay_msec #-} -- | Time between the original signal and the early reflections of the reverb signal, in milliseconds. bindAudioEffectReverb_get_predelay_msec :: MethodBind bindAudioEffectReverb_get_predelay_msec = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "get_predelay_msec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Time between the original signal and the early reflections of the reverb signal, in milliseconds. get_predelay_msec :: (AudioEffectReverb :< cls, Object :< cls) => cls -> IO Float get_predelay_msec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_get_predelay_msec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "get_predelay_msec" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectReverb.get_predelay_msec {-# NOINLINE bindAudioEffectReverb_get_room_size #-} -- | Dimensions of simulated room. Bigger means more echoes. Value can range from 0 to 1. bindAudioEffectReverb_get_room_size :: MethodBind bindAudioEffectReverb_get_room_size = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "get_room_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dimensions of simulated room. Bigger means more echoes. Value can range from 0 to 1. get_room_size :: (AudioEffectReverb :< cls, Object :< cls) => cls -> IO Float get_room_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_get_room_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "get_room_size" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectReverb.get_room_size {-# NOINLINE bindAudioEffectReverb_get_spread #-} -- | Widens or narrows the stereo image of the reverb tail. 1 means fully widens. Value can range from 0 to 1. bindAudioEffectReverb_get_spread :: MethodBind bindAudioEffectReverb_get_spread = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "get_spread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Widens or narrows the stereo image of the reverb tail. 1 means fully widens. Value can range from 0 to 1. get_spread :: (AudioEffectReverb :< cls, Object :< cls) => cls -> IO Float get_spread cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_get_spread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "get_spread" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectReverb.get_spread {-# NOINLINE bindAudioEffectReverb_get_wet #-} -- | Output percent of modified sound. At 0, only original sound is outputted. Value can range from 0 to 1. bindAudioEffectReverb_get_wet :: MethodBind bindAudioEffectReverb_get_wet = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "get_wet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of modified sound. At 0, only original sound is outputted. Value can range from 0 to 1. get_wet :: (AudioEffectReverb :< cls, Object :< cls) => cls -> IO Float get_wet cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_get_wet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "get_wet" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectReverb.get_wet {-# NOINLINE bindAudioEffectReverb_set_damping #-} -- | Defines how reflective the imaginary room's walls are. Value can range from 0 to 1. bindAudioEffectReverb_set_damping :: MethodBind bindAudioEffectReverb_set_damping = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "set_damping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines how reflective the imaginary room's walls are. Value can range from 0 to 1. set_damping :: (AudioEffectReverb :< cls, Object :< cls) => cls -> Float -> IO () set_damping cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_set_damping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "set_damping" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectReverb.set_damping {-# NOINLINE bindAudioEffectReverb_set_dry #-} -- | Output percent of original sound. At 0, only modified sound is outputted. Value can range from 0 to 1. bindAudioEffectReverb_set_dry :: MethodBind bindAudioEffectReverb_set_dry = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "set_dry" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of original sound. At 0, only modified sound is outputted. Value can range from 0 to 1. set_dry :: (AudioEffectReverb :< cls, Object :< cls) => cls -> Float -> IO () set_dry cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_set_dry (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "set_dry" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectReverb.set_dry {-# NOINLINE bindAudioEffectReverb_set_hpf #-} -- | High-pass filter passes signals with a frequency higher than a certain cutoff frequency and attenuates signals with frequencies lower than the cutoff frequency. Value can range from 0 to 1. bindAudioEffectReverb_set_hpf :: MethodBind bindAudioEffectReverb_set_hpf = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "set_hpf" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | High-pass filter passes signals with a frequency higher than a certain cutoff frequency and attenuates signals with frequencies lower than the cutoff frequency. Value can range from 0 to 1. set_hpf :: (AudioEffectReverb :< cls, Object :< cls) => cls -> Float -> IO () set_hpf cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_set_hpf (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "set_hpf" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectReverb.set_hpf {-# NOINLINE bindAudioEffectReverb_set_predelay_feedback #-} -- | Output percent of predelay. Value can range from 0 to 1. bindAudioEffectReverb_set_predelay_feedback :: MethodBind bindAudioEffectReverb_set_predelay_feedback = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "set_predelay_feedback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of predelay. Value can range from 0 to 1. set_predelay_feedback :: (AudioEffectReverb :< cls, Object :< cls) => cls -> Float -> IO () set_predelay_feedback cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_set_predelay_feedback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "set_predelay_feedback" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectReverb.set_predelay_feedback {-# NOINLINE bindAudioEffectReverb_set_predelay_msec #-} -- | Time between the original signal and the early reflections of the reverb signal, in milliseconds. bindAudioEffectReverb_set_predelay_msec :: MethodBind bindAudioEffectReverb_set_predelay_msec = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "set_predelay_msec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Time between the original signal and the early reflections of the reverb signal, in milliseconds. set_predelay_msec :: (AudioEffectReverb :< cls, Object :< cls) => cls -> Float -> IO () set_predelay_msec cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_set_predelay_msec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "set_predelay_msec" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectReverb.set_predelay_msec {-# NOINLINE bindAudioEffectReverb_set_room_size #-} -- | Dimensions of simulated room. Bigger means more echoes. Value can range from 0 to 1. bindAudioEffectReverb_set_room_size :: MethodBind bindAudioEffectReverb_set_room_size = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "set_room_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dimensions of simulated room. Bigger means more echoes. Value can range from 0 to 1. set_room_size :: (AudioEffectReverb :< cls, Object :< cls) => cls -> Float -> IO () set_room_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_set_room_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "set_room_size" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectReverb.set_room_size {-# NOINLINE bindAudioEffectReverb_set_spread #-} -- | Widens or narrows the stereo image of the reverb tail. 1 means fully widens. Value can range from 0 to 1. bindAudioEffectReverb_set_spread :: MethodBind bindAudioEffectReverb_set_spread = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "set_spread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Widens or narrows the stereo image of the reverb tail. 1 means fully widens. Value can range from 0 to 1. set_spread :: (AudioEffectReverb :< cls, Object :< cls) => cls -> Float -> IO () set_spread cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_set_spread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "set_spread" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectReverb.set_spread {-# NOINLINE bindAudioEffectReverb_set_wet #-} -- | Output percent of modified sound. At 0, only original sound is outputted. Value can range from 0 to 1. bindAudioEffectReverb_set_wet :: MethodBind bindAudioEffectReverb_set_wet = unsafePerformIO $ withCString "AudioEffectReverb" $ \ clsNamePtr -> withCString "set_wet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Output percent of modified sound. At 0, only original sound is outputted. Value can range from 0 to 1. set_wet :: (AudioEffectReverb :< cls, Object :< cls) => cls -> Float -> IO () set_wet cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectReverb_set_wet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectReverb "set_wet" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectReverb.set_wet ================================================ FILE: src/Godot/Core/AudioEffectSpectrumAnalyzer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectSpectrumAnalyzer (Godot.Core.AudioEffectSpectrumAnalyzer._FFT_SIZE_2048, Godot.Core.AudioEffectSpectrumAnalyzer._FFT_SIZE_4096, Godot.Core.AudioEffectSpectrumAnalyzer._FFT_SIZE_MAX, Godot.Core.AudioEffectSpectrumAnalyzer._FFT_SIZE_512, Godot.Core.AudioEffectSpectrumAnalyzer._FFT_SIZE_256, Godot.Core.AudioEffectSpectrumAnalyzer._FFT_SIZE_1024, Godot.Core.AudioEffectSpectrumAnalyzer.get_buffer_length, Godot.Core.AudioEffectSpectrumAnalyzer.get_fft_size, Godot.Core.AudioEffectSpectrumAnalyzer.get_tap_back_pos, Godot.Core.AudioEffectSpectrumAnalyzer.set_buffer_length, Godot.Core.AudioEffectSpectrumAnalyzer.set_fft_size, Godot.Core.AudioEffectSpectrumAnalyzer.set_tap_back_pos) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() _FFT_SIZE_2048 :: Int _FFT_SIZE_2048 = 3 _FFT_SIZE_4096 :: Int _FFT_SIZE_4096 = 4 _FFT_SIZE_MAX :: Int _FFT_SIZE_MAX = 5 _FFT_SIZE_512 :: Int _FFT_SIZE_512 = 1 _FFT_SIZE_256 :: Int _FFT_SIZE_256 = 0 _FFT_SIZE_1024 :: Int _FFT_SIZE_1024 = 2 instance NodeProperty AudioEffectSpectrumAnalyzer "buffer_length" Float 'False where nodeProperty = (get_buffer_length, wrapDroppingSetter set_buffer_length, Nothing) instance NodeProperty AudioEffectSpectrumAnalyzer "fft_size" Int 'False where nodeProperty = (get_fft_size, wrapDroppingSetter set_fft_size, Nothing) instance NodeProperty AudioEffectSpectrumAnalyzer "tap_back_pos" Float 'False where nodeProperty = (get_tap_back_pos, wrapDroppingSetter set_tap_back_pos, Nothing) {-# NOINLINE bindAudioEffectSpectrumAnalyzer_get_buffer_length #-} bindAudioEffectSpectrumAnalyzer_get_buffer_length :: MethodBind bindAudioEffectSpectrumAnalyzer_get_buffer_length = unsafePerformIO $ withCString "AudioEffectSpectrumAnalyzer" $ \ clsNamePtr -> withCString "get_buffer_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_buffer_length :: (AudioEffectSpectrumAnalyzer :< cls, Object :< cls) => cls -> IO Float get_buffer_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectSpectrumAnalyzer_get_buffer_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectSpectrumAnalyzer "get_buffer_length" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectSpectrumAnalyzer.get_buffer_length {-# NOINLINE bindAudioEffectSpectrumAnalyzer_get_fft_size #-} bindAudioEffectSpectrumAnalyzer_get_fft_size :: MethodBind bindAudioEffectSpectrumAnalyzer_get_fft_size = unsafePerformIO $ withCString "AudioEffectSpectrumAnalyzer" $ \ clsNamePtr -> withCString "get_fft_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_fft_size :: (AudioEffectSpectrumAnalyzer :< cls, Object :< cls) => cls -> IO Int get_fft_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectSpectrumAnalyzer_get_fft_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectSpectrumAnalyzer "get_fft_size" '[] (IO Int) where nodeMethod = Godot.Core.AudioEffectSpectrumAnalyzer.get_fft_size {-# NOINLINE bindAudioEffectSpectrumAnalyzer_get_tap_back_pos #-} bindAudioEffectSpectrumAnalyzer_get_tap_back_pos :: MethodBind bindAudioEffectSpectrumAnalyzer_get_tap_back_pos = unsafePerformIO $ withCString "AudioEffectSpectrumAnalyzer" $ \ clsNamePtr -> withCString "get_tap_back_pos" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_tap_back_pos :: (AudioEffectSpectrumAnalyzer :< cls, Object :< cls) => cls -> IO Float get_tap_back_pos cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectSpectrumAnalyzer_get_tap_back_pos (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectSpectrumAnalyzer "get_tap_back_pos" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectSpectrumAnalyzer.get_tap_back_pos {-# NOINLINE bindAudioEffectSpectrumAnalyzer_set_buffer_length #-} bindAudioEffectSpectrumAnalyzer_set_buffer_length :: MethodBind bindAudioEffectSpectrumAnalyzer_set_buffer_length = unsafePerformIO $ withCString "AudioEffectSpectrumAnalyzer" $ \ clsNamePtr -> withCString "set_buffer_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_buffer_length :: (AudioEffectSpectrumAnalyzer :< cls, Object :< cls) => cls -> Float -> IO () set_buffer_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectSpectrumAnalyzer_set_buffer_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectSpectrumAnalyzer "set_buffer_length" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectSpectrumAnalyzer.set_buffer_length {-# NOINLINE bindAudioEffectSpectrumAnalyzer_set_fft_size #-} bindAudioEffectSpectrumAnalyzer_set_fft_size :: MethodBind bindAudioEffectSpectrumAnalyzer_set_fft_size = unsafePerformIO $ withCString "AudioEffectSpectrumAnalyzer" $ \ clsNamePtr -> withCString "set_fft_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_fft_size :: (AudioEffectSpectrumAnalyzer :< cls, Object :< cls) => cls -> Int -> IO () set_fft_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectSpectrumAnalyzer_set_fft_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectSpectrumAnalyzer "set_fft_size" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioEffectSpectrumAnalyzer.set_fft_size {-# NOINLINE bindAudioEffectSpectrumAnalyzer_set_tap_back_pos #-} bindAudioEffectSpectrumAnalyzer_set_tap_back_pos :: MethodBind bindAudioEffectSpectrumAnalyzer_set_tap_back_pos = unsafePerformIO $ withCString "AudioEffectSpectrumAnalyzer" $ \ clsNamePtr -> withCString "set_tap_back_pos" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_tap_back_pos :: (AudioEffectSpectrumAnalyzer :< cls, Object :< cls) => cls -> Float -> IO () set_tap_back_pos cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectSpectrumAnalyzer_set_tap_back_pos (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectSpectrumAnalyzer "set_tap_back_pos" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectSpectrumAnalyzer.set_tap_back_pos ================================================ FILE: src/Godot/Core/AudioEffectSpectrumAnalyzerInstance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectSpectrumAnalyzerInstance (Godot.Core.AudioEffectSpectrumAnalyzerInstance._MAGNITUDE_MAX, Godot.Core.AudioEffectSpectrumAnalyzerInstance._MAGNITUDE_AVERAGE, Godot.Core.AudioEffectSpectrumAnalyzerInstance.get_magnitude_for_frequency_range) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffectInstance() _MAGNITUDE_MAX :: Int _MAGNITUDE_MAX = 1 _MAGNITUDE_AVERAGE :: Int _MAGNITUDE_AVERAGE = 0 {-# NOINLINE bindAudioEffectSpectrumAnalyzerInstance_get_magnitude_for_frequency_range #-} bindAudioEffectSpectrumAnalyzerInstance_get_magnitude_for_frequency_range :: MethodBind bindAudioEffectSpectrumAnalyzerInstance_get_magnitude_for_frequency_range = unsafePerformIO $ withCString "AudioEffectSpectrumAnalyzerInstance" $ \ clsNamePtr -> withCString "get_magnitude_for_frequency_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_magnitude_for_frequency_range :: (AudioEffectSpectrumAnalyzerInstance :< cls, Object :< cls) => cls -> Float -> Float -> Maybe Int -> IO Vector2 get_magnitude_for_frequency_range cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectSpectrumAnalyzerInstance_get_magnitude_for_frequency_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectSpectrumAnalyzerInstance "get_magnitude_for_frequency_range" '[Float, Float, Maybe Int] (IO Vector2) where nodeMethod = Godot.Core.AudioEffectSpectrumAnalyzerInstance.get_magnitude_for_frequency_range ================================================ FILE: src/Godot/Core/AudioEffectStereoEnhance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioEffectStereoEnhance (Godot.Core.AudioEffectStereoEnhance.get_pan_pullout, Godot.Core.AudioEffectStereoEnhance.get_surround, Godot.Core.AudioEffectStereoEnhance.get_time_pullout, Godot.Core.AudioEffectStereoEnhance.set_pan_pullout, Godot.Core.AudioEffectStereoEnhance.set_surround, Godot.Core.AudioEffectStereoEnhance.set_time_pullout) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioEffect() instance NodeProperty AudioEffectStereoEnhance "pan_pullout" Float 'False where nodeProperty = (get_pan_pullout, wrapDroppingSetter set_pan_pullout, Nothing) instance NodeProperty AudioEffectStereoEnhance "surround" Float 'False where nodeProperty = (get_surround, wrapDroppingSetter set_surround, Nothing) instance NodeProperty AudioEffectStereoEnhance "time_pullout_ms" Float 'False where nodeProperty = (get_time_pullout, wrapDroppingSetter set_time_pullout, Nothing) {-# NOINLINE bindAudioEffectStereoEnhance_get_pan_pullout #-} bindAudioEffectStereoEnhance_get_pan_pullout :: MethodBind bindAudioEffectStereoEnhance_get_pan_pullout = unsafePerformIO $ withCString "AudioEffectStereoEnhance" $ \ clsNamePtr -> withCString "get_pan_pullout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_pan_pullout :: (AudioEffectStereoEnhance :< cls, Object :< cls) => cls -> IO Float get_pan_pullout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectStereoEnhance_get_pan_pullout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectStereoEnhance "get_pan_pullout" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectStereoEnhance.get_pan_pullout {-# NOINLINE bindAudioEffectStereoEnhance_get_surround #-} bindAudioEffectStereoEnhance_get_surround :: MethodBind bindAudioEffectStereoEnhance_get_surround = unsafePerformIO $ withCString "AudioEffectStereoEnhance" $ \ clsNamePtr -> withCString "get_surround" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_surround :: (AudioEffectStereoEnhance :< cls, Object :< cls) => cls -> IO Float get_surround cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectStereoEnhance_get_surround (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectStereoEnhance "get_surround" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectStereoEnhance.get_surround {-# NOINLINE bindAudioEffectStereoEnhance_get_time_pullout #-} bindAudioEffectStereoEnhance_get_time_pullout :: MethodBind bindAudioEffectStereoEnhance_get_time_pullout = unsafePerformIO $ withCString "AudioEffectStereoEnhance" $ \ clsNamePtr -> withCString "get_time_pullout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_time_pullout :: (AudioEffectStereoEnhance :< cls, Object :< cls) => cls -> IO Float get_time_pullout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectStereoEnhance_get_time_pullout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectStereoEnhance "get_time_pullout" '[] (IO Float) where nodeMethod = Godot.Core.AudioEffectStereoEnhance.get_time_pullout {-# NOINLINE bindAudioEffectStereoEnhance_set_pan_pullout #-} bindAudioEffectStereoEnhance_set_pan_pullout :: MethodBind bindAudioEffectStereoEnhance_set_pan_pullout = unsafePerformIO $ withCString "AudioEffectStereoEnhance" $ \ clsNamePtr -> withCString "set_pan_pullout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_pan_pullout :: (AudioEffectStereoEnhance :< cls, Object :< cls) => cls -> Float -> IO () set_pan_pullout cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectStereoEnhance_set_pan_pullout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectStereoEnhance "set_pan_pullout" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectStereoEnhance.set_pan_pullout {-# NOINLINE bindAudioEffectStereoEnhance_set_surround #-} bindAudioEffectStereoEnhance_set_surround :: MethodBind bindAudioEffectStereoEnhance_set_surround = unsafePerformIO $ withCString "AudioEffectStereoEnhance" $ \ clsNamePtr -> withCString "set_surround" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_surround :: (AudioEffectStereoEnhance :< cls, Object :< cls) => cls -> Float -> IO () set_surround cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectStereoEnhance_set_surround (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectStereoEnhance "set_surround" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectStereoEnhance.set_surround {-# NOINLINE bindAudioEffectStereoEnhance_set_time_pullout #-} bindAudioEffectStereoEnhance_set_time_pullout :: MethodBind bindAudioEffectStereoEnhance_set_time_pullout = unsafePerformIO $ withCString "AudioEffectStereoEnhance" $ \ clsNamePtr -> withCString "set_time_pullout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_time_pullout :: (AudioEffectStereoEnhance :< cls, Object :< cls) => cls -> Float -> IO () set_time_pullout cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioEffectStereoEnhance_set_time_pullout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioEffectStereoEnhance "set_time_pullout" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioEffectStereoEnhance.set_time_pullout ================================================ FILE: src/Godot/Core/AudioServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioServer (Godot.Core.AudioServer._SPEAKER_SURROUND_71, Godot.Core.AudioServer._SPEAKER_SURROUND_31, Godot.Core.AudioServer._SPEAKER_MODE_STEREO, Godot.Core.AudioServer._SPEAKER_SURROUND_51, Godot.Core.AudioServer.sig_bus_layout_changed, Godot.Core.AudioServer.add_bus, Godot.Core.AudioServer.add_bus_effect, Godot.Core.AudioServer.capture_get_device, Godot.Core.AudioServer.capture_get_device_list, Godot.Core.AudioServer.capture_set_device, Godot.Core.AudioServer.generate_bus_layout, Godot.Core.AudioServer.get_bus_channels, Godot.Core.AudioServer.get_bus_count, Godot.Core.AudioServer.get_bus_effect, Godot.Core.AudioServer.get_bus_effect_count, Godot.Core.AudioServer.get_bus_effect_instance, Godot.Core.AudioServer.get_bus_index, Godot.Core.AudioServer.get_bus_name, Godot.Core.AudioServer.get_bus_peak_volume_left_db, Godot.Core.AudioServer.get_bus_peak_volume_right_db, Godot.Core.AudioServer.get_bus_send, Godot.Core.AudioServer.get_bus_volume_db, Godot.Core.AudioServer.get_device, Godot.Core.AudioServer.get_device_list, Godot.Core.AudioServer.get_global_rate_scale, Godot.Core.AudioServer.get_mix_rate, Godot.Core.AudioServer.get_output_latency, Godot.Core.AudioServer.get_speaker_mode, Godot.Core.AudioServer.get_time_since_last_mix, Godot.Core.AudioServer.get_time_to_next_mix, Godot.Core.AudioServer.is_bus_bypassing_effects, Godot.Core.AudioServer.is_bus_effect_enabled, Godot.Core.AudioServer.is_bus_mute, Godot.Core.AudioServer.is_bus_solo, Godot.Core.AudioServer.lock, Godot.Core.AudioServer.move_bus, Godot.Core.AudioServer.remove_bus, Godot.Core.AudioServer.remove_bus_effect, Godot.Core.AudioServer.set_bus_bypass_effects, Godot.Core.AudioServer.set_bus_count, Godot.Core.AudioServer.set_bus_effect_enabled, Godot.Core.AudioServer.set_bus_layout, Godot.Core.AudioServer.set_bus_mute, Godot.Core.AudioServer.set_bus_name, Godot.Core.AudioServer.set_bus_send, Godot.Core.AudioServer.set_bus_solo, Godot.Core.AudioServer.set_bus_volume_db, Godot.Core.AudioServer.set_device, Godot.Core.AudioServer.set_global_rate_scale, Godot.Core.AudioServer.swap_bus_effects, Godot.Core.AudioServer.unlock) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _SPEAKER_SURROUND_71 :: Int _SPEAKER_SURROUND_71 = 3 _SPEAKER_SURROUND_31 :: Int _SPEAKER_SURROUND_31 = 1 _SPEAKER_MODE_STEREO :: Int _SPEAKER_MODE_STEREO = 0 _SPEAKER_SURROUND_51 :: Int _SPEAKER_SURROUND_51 = 2 -- | Emitted when the @AudioBusLayout@ changes. sig_bus_layout_changed :: Godot.Internal.Dispatch.Signal AudioServer sig_bus_layout_changed = Godot.Internal.Dispatch.Signal "bus_layout_changed" instance NodeSignal AudioServer "bus_layout_changed" '[] instance NodeProperty AudioServer "bus_count" Int 'False where nodeProperty = (get_bus_count, wrapDroppingSetter set_bus_count, Nothing) instance NodeProperty AudioServer "device" GodotString 'False where nodeProperty = (get_device, wrapDroppingSetter set_device, Nothing) instance NodeProperty AudioServer "global_rate_scale" Float 'False where nodeProperty = (get_global_rate_scale, wrapDroppingSetter set_global_rate_scale, Nothing) {-# NOINLINE bindAudioServer_add_bus #-} -- | Adds a bus at @at_position@. bindAudioServer_add_bus :: MethodBind bindAudioServer_add_bus = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "add_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a bus at @at_position@. add_bus :: (AudioServer :< cls, Object :< cls) => cls -> Maybe Int -> IO () add_bus cls arg1 = withVariantArray [maybe (VariantInt (-1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_add_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "add_bus" '[Maybe Int] (IO ()) where nodeMethod = Godot.Core.AudioServer.add_bus {-# NOINLINE bindAudioServer_add_bus_effect #-} -- | Adds an @AudioEffect@ effect to the bus @bus_idx@ at @at_position@. bindAudioServer_add_bus_effect :: MethodBind bindAudioServer_add_bus_effect = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "add_bus_effect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an @AudioEffect@ effect to the bus @bus_idx@ at @at_position@. add_bus_effect :: (AudioServer :< cls, Object :< cls) => cls -> Int -> AudioEffect -> Maybe Int -> IO () add_bus_effect cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_add_bus_effect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "add_bus_effect" '[Int, AudioEffect, Maybe Int] (IO ()) where nodeMethod = Godot.Core.AudioServer.add_bus_effect {-# NOINLINE bindAudioServer_capture_get_device #-} -- | Name of the current device for audio input (see @method capture_get_device_list@). bindAudioServer_capture_get_device :: MethodBind bindAudioServer_capture_get_device = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "capture_get_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the current device for audio input (see @method capture_get_device_list@). capture_get_device :: (AudioServer :< cls, Object :< cls) => cls -> IO GodotString capture_get_device cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_capture_get_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "capture_get_device" '[] (IO GodotString) where nodeMethod = Godot.Core.AudioServer.capture_get_device {-# NOINLINE bindAudioServer_capture_get_device_list #-} -- | Returns the names of all audio input devices detected on the system. bindAudioServer_capture_get_device_list :: MethodBind bindAudioServer_capture_get_device_list = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "capture_get_device_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the names of all audio input devices detected on the system. capture_get_device_list :: (AudioServer :< cls, Object :< cls) => cls -> IO Array capture_get_device_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_capture_get_device_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "capture_get_device_list" '[] (IO Array) where nodeMethod = Godot.Core.AudioServer.capture_get_device_list {-# NOINLINE bindAudioServer_capture_set_device #-} -- | Sets which audio input device is used for audio capture. bindAudioServer_capture_set_device :: MethodBind bindAudioServer_capture_set_device = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "capture_set_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets which audio input device is used for audio capture. capture_set_device :: (AudioServer :< cls, Object :< cls) => cls -> GodotString -> IO () capture_set_device cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_capture_set_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "capture_set_device" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AudioServer.capture_set_device {-# NOINLINE bindAudioServer_generate_bus_layout #-} -- | Generates an @AudioBusLayout@ using the available buses and effects. bindAudioServer_generate_bus_layout :: MethodBind bindAudioServer_generate_bus_layout = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "generate_bus_layout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates an @AudioBusLayout@ using the available buses and effects. generate_bus_layout :: (AudioServer :< cls, Object :< cls) => cls -> IO AudioBusLayout generate_bus_layout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_generate_bus_layout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "generate_bus_layout" '[] (IO AudioBusLayout) where nodeMethod = Godot.Core.AudioServer.generate_bus_layout {-# NOINLINE bindAudioServer_get_bus_channels #-} -- | Returns the amount of channels of the bus at index @bus_idx@. bindAudioServer_get_bus_channels :: MethodBind bindAudioServer_get_bus_channels = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_channels" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of channels of the bus at index @bus_idx@. get_bus_channels :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO Int get_bus_channels cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_channels (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_channels" '[Int] (IO Int) where nodeMethod = Godot.Core.AudioServer.get_bus_channels {-# NOINLINE bindAudioServer_get_bus_count #-} -- | Number of available audio buses. bindAudioServer_get_bus_count :: MethodBind bindAudioServer_get_bus_count = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of available audio buses. get_bus_count :: (AudioServer :< cls, Object :< cls) => cls -> IO Int get_bus_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_count" '[] (IO Int) where nodeMethod = Godot.Core.AudioServer.get_bus_count {-# NOINLINE bindAudioServer_get_bus_effect #-} -- | Returns the @AudioEffect@ at position @effect_idx@ in bus @bus_idx@. bindAudioServer_get_bus_effect :: MethodBind bindAudioServer_get_bus_effect = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_effect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AudioEffect@ at position @effect_idx@ in bus @bus_idx@. get_bus_effect :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> IO AudioEffect get_bus_effect cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_effect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_effect" '[Int, Int] (IO AudioEffect) where nodeMethod = Godot.Core.AudioServer.get_bus_effect {-# NOINLINE bindAudioServer_get_bus_effect_count #-} -- | Returns the number of effects on the bus at @bus_idx@. bindAudioServer_get_bus_effect_count :: MethodBind bindAudioServer_get_bus_effect_count = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_effect_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of effects on the bus at @bus_idx@. get_bus_effect_count :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO Int get_bus_effect_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_effect_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_effect_count" '[Int] (IO Int) where nodeMethod = Godot.Core.AudioServer.get_bus_effect_count {-# NOINLINE bindAudioServer_get_bus_effect_instance #-} -- | Returns the @AudioEffectInstance@ assigned to the given bus and effect indices (and optionally channel). bindAudioServer_get_bus_effect_instance :: MethodBind bindAudioServer_get_bus_effect_instance = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_effect_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AudioEffectInstance@ assigned to the given bus and effect indices (and optionally channel). get_bus_effect_instance :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> Maybe Int -> IO AudioEffectInstance get_bus_effect_instance cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_effect_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_effect_instance" '[Int, Int, Maybe Int] (IO AudioEffectInstance) where nodeMethod = Godot.Core.AudioServer.get_bus_effect_instance {-# NOINLINE bindAudioServer_get_bus_index #-} -- | Returns the index of the bus with the name @bus_name@. bindAudioServer_get_bus_index :: MethodBind bindAudioServer_get_bus_index = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the bus with the name @bus_name@. get_bus_index :: (AudioServer :< cls, Object :< cls) => cls -> GodotString -> IO Int get_bus_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_index" '[GodotString] (IO Int) where nodeMethod = Godot.Core.AudioServer.get_bus_index {-# NOINLINE bindAudioServer_get_bus_name #-} -- | Returns the name of the bus with the index @bus_idx@. bindAudioServer_get_bus_name :: MethodBind bindAudioServer_get_bus_name = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the bus with the index @bus_idx@. get_bus_name :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO GodotString get_bus_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.AudioServer.get_bus_name {-# NOINLINE bindAudioServer_get_bus_peak_volume_left_db #-} -- | Returns the peak volume of the left speaker at bus index @bus_idx@ and channel index @channel@. bindAudioServer_get_bus_peak_volume_left_db :: MethodBind bindAudioServer_get_bus_peak_volume_left_db = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_peak_volume_left_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the peak volume of the left speaker at bus index @bus_idx@ and channel index @channel@. get_bus_peak_volume_left_db :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> IO Float get_bus_peak_volume_left_db cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_peak_volume_left_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_peak_volume_left_db" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.AudioServer.get_bus_peak_volume_left_db {-# NOINLINE bindAudioServer_get_bus_peak_volume_right_db #-} -- | Returns the peak volume of the right speaker at bus index @bus_idx@ and channel index @channel@. bindAudioServer_get_bus_peak_volume_right_db :: MethodBind bindAudioServer_get_bus_peak_volume_right_db = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_peak_volume_right_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the peak volume of the right speaker at bus index @bus_idx@ and channel index @channel@. get_bus_peak_volume_right_db :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> IO Float get_bus_peak_volume_right_db cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_peak_volume_right_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_peak_volume_right_db" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.AudioServer.get_bus_peak_volume_right_db {-# NOINLINE bindAudioServer_get_bus_send #-} -- | Returns the name of the bus that the bus at index @bus_idx@ sends to. bindAudioServer_get_bus_send :: MethodBind bindAudioServer_get_bus_send = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_send" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the bus that the bus at index @bus_idx@ sends to. get_bus_send :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO GodotString get_bus_send cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_send (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_send" '[Int] (IO GodotString) where nodeMethod = Godot.Core.AudioServer.get_bus_send {-# NOINLINE bindAudioServer_get_bus_volume_db #-} -- | Returns the volume of the bus at index @bus_idx@ in dB. bindAudioServer_get_bus_volume_db :: MethodBind bindAudioServer_get_bus_volume_db = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_bus_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the volume of the bus at index @bus_idx@ in dB. get_bus_volume_db :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO Float get_bus_volume_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_bus_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_bus_volume_db" '[Int] (IO Float) where nodeMethod = Godot.Core.AudioServer.get_bus_volume_db {-# NOINLINE bindAudioServer_get_device #-} -- | Name of the current device for audio output (see @method get_device_list@). bindAudioServer_get_device :: MethodBind bindAudioServer_get_device = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the current device for audio output (see @method get_device_list@). get_device :: (AudioServer :< cls, Object :< cls) => cls -> IO GodotString get_device cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_device" '[] (IO GodotString) where nodeMethod = Godot.Core.AudioServer.get_device {-# NOINLINE bindAudioServer_get_device_list #-} -- | Returns the names of all audio devices detected on the system. bindAudioServer_get_device_list :: MethodBind bindAudioServer_get_device_list = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_device_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the names of all audio devices detected on the system. get_device_list :: (AudioServer :< cls, Object :< cls) => cls -> IO Array get_device_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_device_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_device_list" '[] (IO Array) where nodeMethod = Godot.Core.AudioServer.get_device_list {-# NOINLINE bindAudioServer_get_global_rate_scale #-} -- | Scales the rate at which audio is played (i.e. setting it to @0.5@ will make the audio be played twice as fast). bindAudioServer_get_global_rate_scale :: MethodBind bindAudioServer_get_global_rate_scale = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_global_rate_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scales the rate at which audio is played (i.e. setting it to @0.5@ will make the audio be played twice as fast). get_global_rate_scale :: (AudioServer :< cls, Object :< cls) => cls -> IO Float get_global_rate_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_global_rate_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_global_rate_scale" '[] (IO Float) where nodeMethod = Godot.Core.AudioServer.get_global_rate_scale {-# NOINLINE bindAudioServer_get_mix_rate #-} -- | Returns the sample rate at the output of the @AudioServer@. bindAudioServer_get_mix_rate :: MethodBind bindAudioServer_get_mix_rate = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_mix_rate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the sample rate at the output of the @AudioServer@. get_mix_rate :: (AudioServer :< cls, Object :< cls) => cls -> IO Float get_mix_rate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_mix_rate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_mix_rate" '[] (IO Float) where nodeMethod = Godot.Core.AudioServer.get_mix_rate {-# NOINLINE bindAudioServer_get_output_latency #-} -- | Returns the audio driver's output latency. bindAudioServer_get_output_latency :: MethodBind bindAudioServer_get_output_latency = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_output_latency" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the audio driver's output latency. get_output_latency :: (AudioServer :< cls, Object :< cls) => cls -> IO Float get_output_latency cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_output_latency (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_output_latency" '[] (IO Float) where nodeMethod = Godot.Core.AudioServer.get_output_latency {-# NOINLINE bindAudioServer_get_speaker_mode #-} -- | Returns the speaker configuration. bindAudioServer_get_speaker_mode :: MethodBind bindAudioServer_get_speaker_mode = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_speaker_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the speaker configuration. get_speaker_mode :: (AudioServer :< cls, Object :< cls) => cls -> IO Int get_speaker_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_speaker_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_speaker_mode" '[] (IO Int) where nodeMethod = Godot.Core.AudioServer.get_speaker_mode {-# NOINLINE bindAudioServer_get_time_since_last_mix #-} -- | Returns the relative time since the last mix occurred. bindAudioServer_get_time_since_last_mix :: MethodBind bindAudioServer_get_time_since_last_mix = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_time_since_last_mix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the relative time since the last mix occurred. get_time_since_last_mix :: (AudioServer :< cls, Object :< cls) => cls -> IO Float get_time_since_last_mix cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_time_since_last_mix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_time_since_last_mix" '[] (IO Float) where nodeMethod = Godot.Core.AudioServer.get_time_since_last_mix {-# NOINLINE bindAudioServer_get_time_to_next_mix #-} -- | Returns the relative time until the next mix occurs. bindAudioServer_get_time_to_next_mix :: MethodBind bindAudioServer_get_time_to_next_mix = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "get_time_to_next_mix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the relative time until the next mix occurs. get_time_to_next_mix :: (AudioServer :< cls, Object :< cls) => cls -> IO Float get_time_to_next_mix cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_get_time_to_next_mix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "get_time_to_next_mix" '[] (IO Float) where nodeMethod = Godot.Core.AudioServer.get_time_to_next_mix {-# NOINLINE bindAudioServer_is_bus_bypassing_effects #-} -- | If @true@, the bus at index @bus_idx@ is bypassing effects. bindAudioServer_is_bus_bypassing_effects :: MethodBind bindAudioServer_is_bus_bypassing_effects = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "is_bus_bypassing_effects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the bus at index @bus_idx@ is bypassing effects. is_bus_bypassing_effects :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO Bool is_bus_bypassing_effects cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_is_bus_bypassing_effects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "is_bus_bypassing_effects" '[Int] (IO Bool) where nodeMethod = Godot.Core.AudioServer.is_bus_bypassing_effects {-# NOINLINE bindAudioServer_is_bus_effect_enabled #-} -- | If @true@, the effect at index @effect_idx@ on the bus at index @bus_idx@ is enabled. bindAudioServer_is_bus_effect_enabled :: MethodBind bindAudioServer_is_bus_effect_enabled = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "is_bus_effect_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the effect at index @effect_idx@ on the bus at index @bus_idx@ is enabled. is_bus_effect_enabled :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool is_bus_effect_enabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_is_bus_effect_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "is_bus_effect_enabled" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.AudioServer.is_bus_effect_enabled {-# NOINLINE bindAudioServer_is_bus_mute #-} -- | If @true@, the bus at index @bus_idx@ is muted. bindAudioServer_is_bus_mute :: MethodBind bindAudioServer_is_bus_mute = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "is_bus_mute" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the bus at index @bus_idx@ is muted. is_bus_mute :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO Bool is_bus_mute cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_is_bus_mute (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "is_bus_mute" '[Int] (IO Bool) where nodeMethod = Godot.Core.AudioServer.is_bus_mute {-# NOINLINE bindAudioServer_is_bus_solo #-} -- | If @true@, the bus at index @bus_idx@ is in solo mode. bindAudioServer_is_bus_solo :: MethodBind bindAudioServer_is_bus_solo = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "is_bus_solo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the bus at index @bus_idx@ is in solo mode. is_bus_solo :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO Bool is_bus_solo cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_is_bus_solo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "is_bus_solo" '[Int] (IO Bool) where nodeMethod = Godot.Core.AudioServer.is_bus_solo {-# NOINLINE bindAudioServer_lock #-} -- | Locks the audio driver's main loop. -- __Note:__ Remember to unlock it afterwards. bindAudioServer_lock :: MethodBind bindAudioServer_lock = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Locks the audio driver's main loop. -- __Note:__ Remember to unlock it afterwards. lock :: (AudioServer :< cls, Object :< cls) => cls -> IO () lock cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "lock" '[] (IO ()) where nodeMethod = Godot.Core.AudioServer.lock {-# NOINLINE bindAudioServer_move_bus #-} -- | Moves the bus from index @index@ to index @to_index@. bindAudioServer_move_bus :: MethodBind bindAudioServer_move_bus = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "move_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the bus from index @index@ to index @to_index@. move_bus :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> IO () move_bus cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_move_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "move_bus" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.AudioServer.move_bus {-# NOINLINE bindAudioServer_remove_bus #-} -- | Removes the bus at index @index@. bindAudioServer_remove_bus :: MethodBind bindAudioServer_remove_bus = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "remove_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the bus at index @index@. remove_bus :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO () remove_bus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_remove_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "remove_bus" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioServer.remove_bus {-# NOINLINE bindAudioServer_remove_bus_effect #-} -- | Removes the effect at index @effect_idx@ from the bus at index @bus_idx@. bindAudioServer_remove_bus_effect :: MethodBind bindAudioServer_remove_bus_effect = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "remove_bus_effect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the effect at index @effect_idx@ from the bus at index @bus_idx@. remove_bus_effect :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> IO () remove_bus_effect cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_remove_bus_effect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "remove_bus_effect" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.AudioServer.remove_bus_effect {-# NOINLINE bindAudioServer_set_bus_bypass_effects #-} -- | If @true@, the bus at index @bus_idx@ is bypassing effects. bindAudioServer_set_bus_bypass_effects :: MethodBind bindAudioServer_set_bus_bypass_effects = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_bypass_effects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the bus at index @bus_idx@ is bypassing effects. set_bus_bypass_effects :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_bus_bypass_effects cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_bypass_effects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_bypass_effects" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_bypass_effects {-# NOINLINE bindAudioServer_set_bus_count #-} -- | Number of available audio buses. bindAudioServer_set_bus_count :: MethodBind bindAudioServer_set_bus_count = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of available audio buses. set_bus_count :: (AudioServer :< cls, Object :< cls) => cls -> Int -> IO () set_bus_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_count" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_count {-# NOINLINE bindAudioServer_set_bus_effect_enabled #-} -- | If @true@, the effect at index @effect_idx@ on the bus at index @bus_idx@ is enabled. bindAudioServer_set_bus_effect_enabled :: MethodBind bindAudioServer_set_bus_effect_enabled = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_effect_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the effect at index @effect_idx@ on the bus at index @bus_idx@ is enabled. set_bus_effect_enabled :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> Bool -> IO () set_bus_effect_enabled cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_effect_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_effect_enabled" '[Int, Int, Bool] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_effect_enabled {-# NOINLINE bindAudioServer_set_bus_layout #-} -- | Overwrites the currently used @AudioBusLayout@. bindAudioServer_set_bus_layout :: MethodBind bindAudioServer_set_bus_layout = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_layout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overwrites the currently used @AudioBusLayout@. set_bus_layout :: (AudioServer :< cls, Object :< cls) => cls -> AudioBusLayout -> IO () set_bus_layout cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_layout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_layout" '[AudioBusLayout] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_layout {-# NOINLINE bindAudioServer_set_bus_mute #-} -- | If @true@, the bus at index @bus_idx@ is muted. bindAudioServer_set_bus_mute :: MethodBind bindAudioServer_set_bus_mute = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_mute" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the bus at index @bus_idx@ is muted. set_bus_mute :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_bus_mute cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_mute (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_mute" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_mute {-# NOINLINE bindAudioServer_set_bus_name #-} -- | Sets the name of the bus at index @bus_idx@ to @name@. bindAudioServer_set_bus_name :: MethodBind bindAudioServer_set_bus_name = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the name of the bus at index @bus_idx@ to @name@. set_bus_name :: (AudioServer :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_bus_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_name" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_name {-# NOINLINE bindAudioServer_set_bus_send #-} -- | Connects the output of the bus at @bus_idx@ to the bus named @send@. bindAudioServer_set_bus_send :: MethodBind bindAudioServer_set_bus_send = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_send" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects the output of the bus at @bus_idx@ to the bus named @send@. set_bus_send :: (AudioServer :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_bus_send cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_send (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_send" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_send {-# NOINLINE bindAudioServer_set_bus_solo #-} -- | If @true@, the bus at index @bus_idx@ is in solo mode. bindAudioServer_set_bus_solo :: MethodBind bindAudioServer_set_bus_solo = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_solo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the bus at index @bus_idx@ is in solo mode. set_bus_solo :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_bus_solo cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_solo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_solo" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_solo {-# NOINLINE bindAudioServer_set_bus_volume_db #-} -- | Sets the volume of the bus at index @bus_idx@ to @volume_db@. bindAudioServer_set_bus_volume_db :: MethodBind bindAudioServer_set_bus_volume_db = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_bus_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the volume of the bus at index @bus_idx@ to @volume_db@. set_bus_volume_db :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_bus_volume_db cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_bus_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_bus_volume_db" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_bus_volume_db {-# NOINLINE bindAudioServer_set_device #-} -- | Name of the current device for audio output (see @method get_device_list@). bindAudioServer_set_device :: MethodBind bindAudioServer_set_device = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the current device for audio output (see @method get_device_list@). set_device :: (AudioServer :< cls, Object :< cls) => cls -> GodotString -> IO () set_device cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_device" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_device {-# NOINLINE bindAudioServer_set_global_rate_scale #-} -- | Scales the rate at which audio is played (i.e. setting it to @0.5@ will make the audio be played twice as fast). bindAudioServer_set_global_rate_scale :: MethodBind bindAudioServer_set_global_rate_scale = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "set_global_rate_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scales the rate at which audio is played (i.e. setting it to @0.5@ will make the audio be played twice as fast). set_global_rate_scale :: (AudioServer :< cls, Object :< cls) => cls -> Float -> IO () set_global_rate_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_set_global_rate_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "set_global_rate_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioServer.set_global_rate_scale {-# NOINLINE bindAudioServer_swap_bus_effects #-} -- | Swaps the position of two effects in bus @bus_idx@. bindAudioServer_swap_bus_effects :: MethodBind bindAudioServer_swap_bus_effects = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "swap_bus_effects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Swaps the position of two effects in bus @bus_idx@. swap_bus_effects :: (AudioServer :< cls, Object :< cls) => cls -> Int -> Int -> Int -> IO () swap_bus_effects cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_swap_bus_effects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "swap_bus_effects" '[Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.AudioServer.swap_bus_effects {-# NOINLINE bindAudioServer_unlock #-} -- | Unlocks the audio driver's main loop. (After locking it, you should always unlock it.) bindAudioServer_unlock :: MethodBind bindAudioServer_unlock = unsafePerformIO $ withCString "AudioServer" $ \ clsNamePtr -> withCString "unlock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unlocks the audio driver's main loop. (After locking it, you should always unlock it.) unlock :: (AudioServer :< cls, Object :< cls) => cls -> IO () unlock cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioServer_unlock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioServer "unlock" '[] (IO ()) where nodeMethod = Godot.Core.AudioServer.unlock ================================================ FILE: src/Godot/Core/AudioStream.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStream (Godot.Core.AudioStream.get_length) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindAudioStream_get_length #-} -- | Returns the length of the audio stream in seconds. bindAudioStream_get_length :: MethodBind bindAudioStream_get_length = unsafePerformIO $ withCString "AudioStream" $ \ clsNamePtr -> withCString "get_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the length of the audio stream in seconds. get_length :: (AudioStream :< cls, Object :< cls) => cls -> IO Float get_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStream_get_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStream "get_length" '[] (IO Float) where nodeMethod = Godot.Core.AudioStream.get_length ================================================ FILE: src/Godot/Core/AudioStreamGenerator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamGenerator (Godot.Core.AudioStreamGenerator.get_buffer_length, Godot.Core.AudioStreamGenerator.get_mix_rate, Godot.Core.AudioStreamGenerator.set_buffer_length, Godot.Core.AudioStreamGenerator.set_mix_rate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioStream() instance NodeProperty AudioStreamGenerator "buffer_length" Float 'False where nodeProperty = (get_buffer_length, wrapDroppingSetter set_buffer_length, Nothing) instance NodeProperty AudioStreamGenerator "mix_rate" Float 'False where nodeProperty = (get_mix_rate, wrapDroppingSetter set_mix_rate, Nothing) {-# NOINLINE bindAudioStreamGenerator_get_buffer_length #-} bindAudioStreamGenerator_get_buffer_length :: MethodBind bindAudioStreamGenerator_get_buffer_length = unsafePerformIO $ withCString "AudioStreamGenerator" $ \ clsNamePtr -> withCString "get_buffer_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_buffer_length :: (AudioStreamGenerator :< cls, Object :< cls) => cls -> IO Float get_buffer_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGenerator_get_buffer_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGenerator "get_buffer_length" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamGenerator.get_buffer_length {-# NOINLINE bindAudioStreamGenerator_get_mix_rate #-} bindAudioStreamGenerator_get_mix_rate :: MethodBind bindAudioStreamGenerator_get_mix_rate = unsafePerformIO $ withCString "AudioStreamGenerator" $ \ clsNamePtr -> withCString "get_mix_rate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_mix_rate :: (AudioStreamGenerator :< cls, Object :< cls) => cls -> IO Float get_mix_rate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGenerator_get_mix_rate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGenerator "get_mix_rate" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamGenerator.get_mix_rate {-# NOINLINE bindAudioStreamGenerator_set_buffer_length #-} bindAudioStreamGenerator_set_buffer_length :: MethodBind bindAudioStreamGenerator_set_buffer_length = unsafePerformIO $ withCString "AudioStreamGenerator" $ \ clsNamePtr -> withCString "set_buffer_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_buffer_length :: (AudioStreamGenerator :< cls, Object :< cls) => cls -> Float -> IO () set_buffer_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGenerator_set_buffer_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGenerator "set_buffer_length" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamGenerator.set_buffer_length {-# NOINLINE bindAudioStreamGenerator_set_mix_rate #-} bindAudioStreamGenerator_set_mix_rate :: MethodBind bindAudioStreamGenerator_set_mix_rate = unsafePerformIO $ withCString "AudioStreamGenerator" $ \ clsNamePtr -> withCString "set_mix_rate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_mix_rate :: (AudioStreamGenerator :< cls, Object :< cls) => cls -> Float -> IO () set_mix_rate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGenerator_set_mix_rate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGenerator "set_mix_rate" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamGenerator.set_mix_rate ================================================ FILE: src/Godot/Core/AudioStreamGeneratorPlayback.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamGeneratorPlayback (Godot.Core.AudioStreamGeneratorPlayback.can_push_buffer, Godot.Core.AudioStreamGeneratorPlayback.clear_buffer, Godot.Core.AudioStreamGeneratorPlayback.get_frames_available, Godot.Core.AudioStreamGeneratorPlayback.get_skips, Godot.Core.AudioStreamGeneratorPlayback.push_buffer, Godot.Core.AudioStreamGeneratorPlayback.push_frame) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioStreamPlaybackResampled() {-# NOINLINE bindAudioStreamGeneratorPlayback_can_push_buffer #-} bindAudioStreamGeneratorPlayback_can_push_buffer :: MethodBind bindAudioStreamGeneratorPlayback_can_push_buffer = unsafePerformIO $ withCString "AudioStreamGeneratorPlayback" $ \ clsNamePtr -> withCString "can_push_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr can_push_buffer :: (AudioStreamGeneratorPlayback :< cls, Object :< cls) => cls -> Int -> IO Bool can_push_buffer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGeneratorPlayback_can_push_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGeneratorPlayback "can_push_buffer" '[Int] (IO Bool) where nodeMethod = Godot.Core.AudioStreamGeneratorPlayback.can_push_buffer {-# NOINLINE bindAudioStreamGeneratorPlayback_clear_buffer #-} bindAudioStreamGeneratorPlayback_clear_buffer :: MethodBind bindAudioStreamGeneratorPlayback_clear_buffer = unsafePerformIO $ withCString "AudioStreamGeneratorPlayback" $ \ clsNamePtr -> withCString "clear_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear_buffer :: (AudioStreamGeneratorPlayback :< cls, Object :< cls) => cls -> IO () clear_buffer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGeneratorPlayback_clear_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGeneratorPlayback "clear_buffer" '[] (IO ()) where nodeMethod = Godot.Core.AudioStreamGeneratorPlayback.clear_buffer {-# NOINLINE bindAudioStreamGeneratorPlayback_get_frames_available #-} bindAudioStreamGeneratorPlayback_get_frames_available :: MethodBind bindAudioStreamGeneratorPlayback_get_frames_available = unsafePerformIO $ withCString "AudioStreamGeneratorPlayback" $ \ clsNamePtr -> withCString "get_frames_available" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_frames_available :: (AudioStreamGeneratorPlayback :< cls, Object :< cls) => cls -> IO Int get_frames_available cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGeneratorPlayback_get_frames_available (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGeneratorPlayback "get_frames_available" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamGeneratorPlayback.get_frames_available {-# NOINLINE bindAudioStreamGeneratorPlayback_get_skips #-} bindAudioStreamGeneratorPlayback_get_skips :: MethodBind bindAudioStreamGeneratorPlayback_get_skips = unsafePerformIO $ withCString "AudioStreamGeneratorPlayback" $ \ clsNamePtr -> withCString "get_skips" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_skips :: (AudioStreamGeneratorPlayback :< cls, Object :< cls) => cls -> IO Int get_skips cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGeneratorPlayback_get_skips (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGeneratorPlayback "get_skips" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamGeneratorPlayback.get_skips {-# NOINLINE bindAudioStreamGeneratorPlayback_push_buffer #-} bindAudioStreamGeneratorPlayback_push_buffer :: MethodBind bindAudioStreamGeneratorPlayback_push_buffer = unsafePerformIO $ withCString "AudioStreamGeneratorPlayback" $ \ clsNamePtr -> withCString "push_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr push_buffer :: (AudioStreamGeneratorPlayback :< cls, Object :< cls) => cls -> PoolVector2Array -> IO Bool push_buffer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGeneratorPlayback_push_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGeneratorPlayback "push_buffer" '[PoolVector2Array] (IO Bool) where nodeMethod = Godot.Core.AudioStreamGeneratorPlayback.push_buffer {-# NOINLINE bindAudioStreamGeneratorPlayback_push_frame #-} bindAudioStreamGeneratorPlayback_push_frame :: MethodBind bindAudioStreamGeneratorPlayback_push_frame = unsafePerformIO $ withCString "AudioStreamGeneratorPlayback" $ \ clsNamePtr -> withCString "push_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr push_frame :: (AudioStreamGeneratorPlayback :< cls, Object :< cls) => cls -> Vector2 -> IO Bool push_frame cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamGeneratorPlayback_push_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamGeneratorPlayback "push_frame" '[Vector2] (IO Bool) where nodeMethod = Godot.Core.AudioStreamGeneratorPlayback.push_frame ================================================ FILE: src/Godot/Core/AudioStreamMicrophone.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamMicrophone () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioStream() ================================================ FILE: src/Godot/Core/AudioStreamOGGVorbis.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamOGGVorbis (Godot.Core.AudioStreamOGGVorbis.get_data, Godot.Core.AudioStreamOGGVorbis.get_loop_offset, Godot.Core.AudioStreamOGGVorbis.has_loop, Godot.Core.AudioStreamOGGVorbis.set_data, Godot.Core.AudioStreamOGGVorbis.set_loop, Godot.Core.AudioStreamOGGVorbis.set_loop_offset) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioStream() instance NodeProperty AudioStreamOGGVorbis "data" PoolByteArray 'False where nodeProperty = (get_data, wrapDroppingSetter set_data, Nothing) instance NodeProperty AudioStreamOGGVorbis "loop" Bool 'False where nodeProperty = (has_loop, wrapDroppingSetter set_loop, Nothing) instance NodeProperty AudioStreamOGGVorbis "loop_offset" Float 'False where nodeProperty = (get_loop_offset, wrapDroppingSetter set_loop_offset, Nothing) {-# NOINLINE bindAudioStreamOGGVorbis_get_data #-} bindAudioStreamOGGVorbis_get_data :: MethodBind bindAudioStreamOGGVorbis_get_data = unsafePerformIO $ withCString "AudioStreamOGGVorbis" $ \ clsNamePtr -> withCString "get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_data :: (AudioStreamOGGVorbis :< cls, Object :< cls) => cls -> IO PoolByteArray get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamOGGVorbis_get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamOGGVorbis "get_data" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.AudioStreamOGGVorbis.get_data {-# NOINLINE bindAudioStreamOGGVorbis_get_loop_offset #-} bindAudioStreamOGGVorbis_get_loop_offset :: MethodBind bindAudioStreamOGGVorbis_get_loop_offset = unsafePerformIO $ withCString "AudioStreamOGGVorbis" $ \ clsNamePtr -> withCString "get_loop_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_loop_offset :: (AudioStreamOGGVorbis :< cls, Object :< cls) => cls -> IO Float get_loop_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamOGGVorbis_get_loop_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamOGGVorbis "get_loop_offset" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamOGGVorbis.get_loop_offset {-# NOINLINE bindAudioStreamOGGVorbis_has_loop #-} bindAudioStreamOGGVorbis_has_loop :: MethodBind bindAudioStreamOGGVorbis_has_loop = unsafePerformIO $ withCString "AudioStreamOGGVorbis" $ \ clsNamePtr -> withCString "has_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_loop :: (AudioStreamOGGVorbis :< cls, Object :< cls) => cls -> IO Bool has_loop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamOGGVorbis_has_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamOGGVorbis "has_loop" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamOGGVorbis.has_loop {-# NOINLINE bindAudioStreamOGGVorbis_set_data #-} bindAudioStreamOGGVorbis_set_data :: MethodBind bindAudioStreamOGGVorbis_set_data = unsafePerformIO $ withCString "AudioStreamOGGVorbis" $ \ clsNamePtr -> withCString "set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_data :: (AudioStreamOGGVorbis :< cls, Object :< cls) => cls -> PoolByteArray -> IO () set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamOGGVorbis_set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamOGGVorbis "set_data" '[PoolByteArray] (IO ()) where nodeMethod = Godot.Core.AudioStreamOGGVorbis.set_data {-# NOINLINE bindAudioStreamOGGVorbis_set_loop #-} bindAudioStreamOGGVorbis_set_loop :: MethodBind bindAudioStreamOGGVorbis_set_loop = unsafePerformIO $ withCString "AudioStreamOGGVorbis" $ \ clsNamePtr -> withCString "set_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_loop :: (AudioStreamOGGVorbis :< cls, Object :< cls) => cls -> Bool -> IO () set_loop cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamOGGVorbis_set_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamOGGVorbis "set_loop" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamOGGVorbis.set_loop {-# NOINLINE bindAudioStreamOGGVorbis_set_loop_offset #-} bindAudioStreamOGGVorbis_set_loop_offset :: MethodBind bindAudioStreamOGGVorbis_set_loop_offset = unsafePerformIO $ withCString "AudioStreamOGGVorbis" $ \ clsNamePtr -> withCString "set_loop_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_loop_offset :: (AudioStreamOGGVorbis :< cls, Object :< cls) => cls -> Float -> IO () set_loop_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamOGGVorbis_set_loop_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamOGGVorbis "set_loop_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamOGGVorbis.set_loop_offset ================================================ FILE: src/Godot/Core/AudioStreamPlayback.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamPlayback () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() ================================================ FILE: src/Godot/Core/AudioStreamPlaybackResampled.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamPlaybackResampled () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioStreamPlayback() ================================================ FILE: src/Godot/Core/AudioStreamPlayer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamPlayer (Godot.Core.AudioStreamPlayer._MIX_TARGET_SURROUND, Godot.Core.AudioStreamPlayer._MIX_TARGET_STEREO, Godot.Core.AudioStreamPlayer._MIX_TARGET_CENTER, Godot.Core.AudioStreamPlayer.sig_finished, Godot.Core.AudioStreamPlayer._bus_layout_changed, Godot.Core.AudioStreamPlayer._is_active, Godot.Core.AudioStreamPlayer._set_playing, Godot.Core.AudioStreamPlayer.get_bus, Godot.Core.AudioStreamPlayer.get_mix_target, Godot.Core.AudioStreamPlayer.get_pitch_scale, Godot.Core.AudioStreamPlayer.get_playback_position, Godot.Core.AudioStreamPlayer.get_stream, Godot.Core.AudioStreamPlayer.get_stream_paused, Godot.Core.AudioStreamPlayer.get_stream_playback, Godot.Core.AudioStreamPlayer.get_volume_db, Godot.Core.AudioStreamPlayer.is_autoplay_enabled, Godot.Core.AudioStreamPlayer.is_playing, Godot.Core.AudioStreamPlayer.play, Godot.Core.AudioStreamPlayer.seek, Godot.Core.AudioStreamPlayer.set_autoplay, Godot.Core.AudioStreamPlayer.set_bus, Godot.Core.AudioStreamPlayer.set_mix_target, Godot.Core.AudioStreamPlayer.set_pitch_scale, Godot.Core.AudioStreamPlayer.set_stream, Godot.Core.AudioStreamPlayer.set_stream_paused, Godot.Core.AudioStreamPlayer.set_volume_db, Godot.Core.AudioStreamPlayer.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _MIX_TARGET_SURROUND :: Int _MIX_TARGET_SURROUND = 1 _MIX_TARGET_STEREO :: Int _MIX_TARGET_STEREO = 0 _MIX_TARGET_CENTER :: Int _MIX_TARGET_CENTER = 2 -- | Emitted when the audio stops playing. sig_finished :: Godot.Internal.Dispatch.Signal AudioStreamPlayer sig_finished = Godot.Internal.Dispatch.Signal "finished" instance NodeSignal AudioStreamPlayer "finished" '[] instance NodeProperty AudioStreamPlayer "autoplay" Bool 'False where nodeProperty = (is_autoplay_enabled, wrapDroppingSetter set_autoplay, Nothing) instance NodeProperty AudioStreamPlayer "bus" GodotString 'False where nodeProperty = (get_bus, wrapDroppingSetter set_bus, Nothing) instance NodeProperty AudioStreamPlayer "mix_target" Int 'False where nodeProperty = (get_mix_target, wrapDroppingSetter set_mix_target, Nothing) instance NodeProperty AudioStreamPlayer "pitch_scale" Float 'False where nodeProperty = (get_pitch_scale, wrapDroppingSetter set_pitch_scale, Nothing) instance NodeProperty AudioStreamPlayer "playing" Bool 'False where nodeProperty = (is_playing, wrapDroppingSetter _set_playing, Nothing) instance NodeProperty AudioStreamPlayer "stream" AudioStream 'False where nodeProperty = (get_stream, wrapDroppingSetter set_stream, Nothing) instance NodeProperty AudioStreamPlayer "stream_paused" Bool 'False where nodeProperty = (get_stream_paused, wrapDroppingSetter set_stream_paused, Nothing) instance NodeProperty AudioStreamPlayer "volume_db" Float 'False where nodeProperty = (get_volume_db, wrapDroppingSetter set_volume_db, Nothing) {-# NOINLINE bindAudioStreamPlayer__bus_layout_changed #-} bindAudioStreamPlayer__bus_layout_changed :: MethodBind bindAudioStreamPlayer__bus_layout_changed = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "_bus_layout_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _bus_layout_changed :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO () _bus_layout_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer__bus_layout_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "_bus_layout_changed" '[] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer._bus_layout_changed {-# NOINLINE bindAudioStreamPlayer__is_active #-} bindAudioStreamPlayer__is_active :: MethodBind bindAudioStreamPlayer__is_active = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "_is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _is_active :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO Bool _is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer__is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "_is_active" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer._is_active {-# NOINLINE bindAudioStreamPlayer__set_playing #-} -- | If @true@, audio is playing. bindAudioStreamPlayer__set_playing :: MethodBind bindAudioStreamPlayer__set_playing = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "_set_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio is playing. _set_playing :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> Bool -> IO () _set_playing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer__set_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "_set_playing" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer._set_playing {-# NOINLINE bindAudioStreamPlayer_get_bus #-} -- | Bus on which this audio is playing. bindAudioStreamPlayer_get_bus :: MethodBind bindAudioStreamPlayer_get_bus = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "get_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bus on which this audio is playing. get_bus :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO GodotString get_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_get_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "get_bus" '[] (IO GodotString) where nodeMethod = Godot.Core.AudioStreamPlayer.get_bus {-# NOINLINE bindAudioStreamPlayer_get_mix_target #-} -- | If the audio configuration has more than two speakers, this sets the target channels. See @enum MixTarget@ constants. bindAudioStreamPlayer_get_mix_target :: MethodBind bindAudioStreamPlayer_get_mix_target = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "get_mix_target" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the audio configuration has more than two speakers, this sets the target channels. See @enum MixTarget@ constants. get_mix_target :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO Int get_mix_target cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_get_mix_target (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "get_mix_target" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamPlayer.get_mix_target {-# NOINLINE bindAudioStreamPlayer_get_pitch_scale #-} -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. bindAudioStreamPlayer_get_pitch_scale :: MethodBind bindAudioStreamPlayer_get_pitch_scale = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "get_pitch_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. get_pitch_scale :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO Float get_pitch_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_get_pitch_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "get_pitch_scale" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer.get_pitch_scale {-# NOINLINE bindAudioStreamPlayer_get_playback_position #-} -- | Returns the position in the @AudioStream@ in seconds. bindAudioStreamPlayer_get_playback_position :: MethodBind bindAudioStreamPlayer_get_playback_position = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "get_playback_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position in the @AudioStream@ in seconds. get_playback_position :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO Float get_playback_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_get_playback_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "get_playback_position" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer.get_playback_position {-# NOINLINE bindAudioStreamPlayer_get_stream #-} -- | The @AudioStream@ object to be played. bindAudioStreamPlayer_get_stream :: MethodBind bindAudioStreamPlayer_get_stream = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "get_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @AudioStream@ object to be played. get_stream :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO AudioStream get_stream cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_get_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "get_stream" '[] (IO AudioStream) where nodeMethod = Godot.Core.AudioStreamPlayer.get_stream {-# NOINLINE bindAudioStreamPlayer_get_stream_paused #-} -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. bindAudioStreamPlayer_get_stream_paused :: MethodBind bindAudioStreamPlayer_get_stream_paused = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "get_stream_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. get_stream_paused :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO Bool get_stream_paused cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_get_stream_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "get_stream_paused" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer.get_stream_paused {-# NOINLINE bindAudioStreamPlayer_get_stream_playback #-} -- | Returns the @AudioStreamPlayback@ object associated with this @AudioStreamPlayer@. bindAudioStreamPlayer_get_stream_playback :: MethodBind bindAudioStreamPlayer_get_stream_playback = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "get_stream_playback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AudioStreamPlayback@ object associated with this @AudioStreamPlayer@. get_stream_playback :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO AudioStreamPlayback get_stream_playback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_get_stream_playback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "get_stream_playback" '[] (IO AudioStreamPlayback) where nodeMethod = Godot.Core.AudioStreamPlayer.get_stream_playback {-# NOINLINE bindAudioStreamPlayer_get_volume_db #-} -- | Volume of sound, in dB. bindAudioStreamPlayer_get_volume_db :: MethodBind bindAudioStreamPlayer_get_volume_db = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "get_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Volume of sound, in dB. get_volume_db :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO Float get_volume_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_get_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "get_volume_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer.get_volume_db {-# NOINLINE bindAudioStreamPlayer_is_autoplay_enabled #-} -- | If @true@, audio plays when added to scene tree. bindAudioStreamPlayer_is_autoplay_enabled :: MethodBind bindAudioStreamPlayer_is_autoplay_enabled = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "is_autoplay_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio plays when added to scene tree. is_autoplay_enabled :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO Bool is_autoplay_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_is_autoplay_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "is_autoplay_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer.is_autoplay_enabled {-# NOINLINE bindAudioStreamPlayer_is_playing #-} -- | If @true@, audio is playing. bindAudioStreamPlayer_is_playing :: MethodBind bindAudioStreamPlayer_is_playing = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio is playing. is_playing :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO Bool is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer.is_playing {-# NOINLINE bindAudioStreamPlayer_play #-} -- | Plays the audio from the given @from_position@, in seconds. bindAudioStreamPlayer_play :: MethodBind bindAudioStreamPlayer_play = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Plays the audio from the given @from_position@, in seconds. play :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> Maybe Float -> IO () play cls arg1 = withVariantArray [maybe (VariantReal (0)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "play" '[Maybe Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.play {-# NOINLINE bindAudioStreamPlayer_seek #-} -- | Sets the position from which audio will be played, in seconds. bindAudioStreamPlayer_seek :: MethodBind bindAudioStreamPlayer_seek = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position from which audio will be played, in seconds. seek :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> Float -> IO () seek cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "seek" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.seek {-# NOINLINE bindAudioStreamPlayer_set_autoplay #-} -- | If @true@, audio plays when added to scene tree. bindAudioStreamPlayer_set_autoplay :: MethodBind bindAudioStreamPlayer_set_autoplay = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "set_autoplay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio plays when added to scene tree. set_autoplay :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> Bool -> IO () set_autoplay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_set_autoplay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "set_autoplay" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.set_autoplay {-# NOINLINE bindAudioStreamPlayer_set_bus #-} -- | Bus on which this audio is playing. bindAudioStreamPlayer_set_bus :: MethodBind bindAudioStreamPlayer_set_bus = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "set_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bus on which this audio is playing. set_bus :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> GodotString -> IO () set_bus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_set_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "set_bus" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.set_bus {-# NOINLINE bindAudioStreamPlayer_set_mix_target #-} -- | If the audio configuration has more than two speakers, this sets the target channels. See @enum MixTarget@ constants. bindAudioStreamPlayer_set_mix_target :: MethodBind bindAudioStreamPlayer_set_mix_target = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "set_mix_target" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the audio configuration has more than two speakers, this sets the target channels. See @enum MixTarget@ constants. set_mix_target :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> Int -> IO () set_mix_target cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_set_mix_target (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "set_mix_target" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.set_mix_target {-# NOINLINE bindAudioStreamPlayer_set_pitch_scale #-} -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. bindAudioStreamPlayer_set_pitch_scale :: MethodBind bindAudioStreamPlayer_set_pitch_scale = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "set_pitch_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. set_pitch_scale :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> Float -> IO () set_pitch_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_set_pitch_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "set_pitch_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.set_pitch_scale {-# NOINLINE bindAudioStreamPlayer_set_stream #-} -- | The @AudioStream@ object to be played. bindAudioStreamPlayer_set_stream :: MethodBind bindAudioStreamPlayer_set_stream = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "set_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @AudioStream@ object to be played. set_stream :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> AudioStream -> IO () set_stream cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_set_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "set_stream" '[AudioStream] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.set_stream {-# NOINLINE bindAudioStreamPlayer_set_stream_paused #-} -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. bindAudioStreamPlayer_set_stream_paused :: MethodBind bindAudioStreamPlayer_set_stream_paused = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "set_stream_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. set_stream_paused :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> Bool -> IO () set_stream_paused cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_set_stream_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "set_stream_paused" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.set_stream_paused {-# NOINLINE bindAudioStreamPlayer_set_volume_db #-} -- | Volume of sound, in dB. bindAudioStreamPlayer_set_volume_db :: MethodBind bindAudioStreamPlayer_set_volume_db = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "set_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Volume of sound, in dB. set_volume_db :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> Float -> IO () set_volume_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_set_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "set_volume_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.set_volume_db {-# NOINLINE bindAudioStreamPlayer_stop #-} -- | Stops the audio. bindAudioStreamPlayer_stop :: MethodBind bindAudioStreamPlayer_stop = unsafePerformIO $ withCString "AudioStreamPlayer" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the audio. stop :: (AudioStreamPlayer :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer "stop" '[] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer.stop ================================================ FILE: src/Godot/Core/AudioStreamPlayer2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamPlayer2D (Godot.Core.AudioStreamPlayer2D.sig_finished, Godot.Core.AudioStreamPlayer2D._bus_layout_changed, Godot.Core.AudioStreamPlayer2D._is_active, Godot.Core.AudioStreamPlayer2D._set_playing, Godot.Core.AudioStreamPlayer2D.get_area_mask, Godot.Core.AudioStreamPlayer2D.get_attenuation, Godot.Core.AudioStreamPlayer2D.get_bus, Godot.Core.AudioStreamPlayer2D.get_max_distance, Godot.Core.AudioStreamPlayer2D.get_pitch_scale, Godot.Core.AudioStreamPlayer2D.get_playback_position, Godot.Core.AudioStreamPlayer2D.get_stream, Godot.Core.AudioStreamPlayer2D.get_stream_paused, Godot.Core.AudioStreamPlayer2D.get_stream_playback, Godot.Core.AudioStreamPlayer2D.get_volume_db, Godot.Core.AudioStreamPlayer2D.is_autoplay_enabled, Godot.Core.AudioStreamPlayer2D.is_playing, Godot.Core.AudioStreamPlayer2D.play, Godot.Core.AudioStreamPlayer2D.seek, Godot.Core.AudioStreamPlayer2D.set_area_mask, Godot.Core.AudioStreamPlayer2D.set_attenuation, Godot.Core.AudioStreamPlayer2D.set_autoplay, Godot.Core.AudioStreamPlayer2D.set_bus, Godot.Core.AudioStreamPlayer2D.set_max_distance, Godot.Core.AudioStreamPlayer2D.set_pitch_scale, Godot.Core.AudioStreamPlayer2D.set_stream, Godot.Core.AudioStreamPlayer2D.set_stream_paused, Godot.Core.AudioStreamPlayer2D.set_volume_db, Godot.Core.AudioStreamPlayer2D.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() -- | Emitted when the audio stops playing. sig_finished :: Godot.Internal.Dispatch.Signal AudioStreamPlayer2D sig_finished = Godot.Internal.Dispatch.Signal "finished" instance NodeSignal AudioStreamPlayer2D "finished" '[] instance NodeProperty AudioStreamPlayer2D "area_mask" Int 'False where nodeProperty = (get_area_mask, wrapDroppingSetter set_area_mask, Nothing) instance NodeProperty AudioStreamPlayer2D "attenuation" Float 'False where nodeProperty = (get_attenuation, wrapDroppingSetter set_attenuation, Nothing) instance NodeProperty AudioStreamPlayer2D "autoplay" Bool 'False where nodeProperty = (is_autoplay_enabled, wrapDroppingSetter set_autoplay, Nothing) instance NodeProperty AudioStreamPlayer2D "bus" GodotString 'False where nodeProperty = (get_bus, wrapDroppingSetter set_bus, Nothing) instance NodeProperty AudioStreamPlayer2D "max_distance" Float 'False where nodeProperty = (get_max_distance, wrapDroppingSetter set_max_distance, Nothing) instance NodeProperty AudioStreamPlayer2D "pitch_scale" Float 'False where nodeProperty = (get_pitch_scale, wrapDroppingSetter set_pitch_scale, Nothing) instance NodeProperty AudioStreamPlayer2D "playing" Bool 'False where nodeProperty = (is_playing, wrapDroppingSetter _set_playing, Nothing) instance NodeProperty AudioStreamPlayer2D "stream" AudioStream 'False where nodeProperty = (get_stream, wrapDroppingSetter set_stream, Nothing) instance NodeProperty AudioStreamPlayer2D "stream_paused" Bool 'False where nodeProperty = (get_stream_paused, wrapDroppingSetter set_stream_paused, Nothing) instance NodeProperty AudioStreamPlayer2D "volume_db" Float 'False where nodeProperty = (get_volume_db, wrapDroppingSetter set_volume_db, Nothing) {-# NOINLINE bindAudioStreamPlayer2D__bus_layout_changed #-} bindAudioStreamPlayer2D__bus_layout_changed :: MethodBind bindAudioStreamPlayer2D__bus_layout_changed = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "_bus_layout_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _bus_layout_changed :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO () _bus_layout_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D__bus_layout_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "_bus_layout_changed" '[] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D._bus_layout_changed {-# NOINLINE bindAudioStreamPlayer2D__is_active #-} bindAudioStreamPlayer2D__is_active :: MethodBind bindAudioStreamPlayer2D__is_active = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "_is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _is_active :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Bool _is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D__is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "_is_active" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer2D._is_active {-# NOINLINE bindAudioStreamPlayer2D__set_playing #-} -- | If @true@, audio is playing. bindAudioStreamPlayer2D__set_playing :: MethodBind bindAudioStreamPlayer2D__set_playing = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "_set_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio is playing. _set_playing :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Bool -> IO () _set_playing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D__set_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "_set_playing" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D._set_playing {-# NOINLINE bindAudioStreamPlayer2D_get_area_mask #-} -- | Areas in which this sound plays. bindAudioStreamPlayer2D_get_area_mask :: MethodBind bindAudioStreamPlayer2D_get_area_mask = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_area_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Areas in which this sound plays. get_area_mask :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Int get_area_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_area_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_area_mask" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_area_mask {-# NOINLINE bindAudioStreamPlayer2D_get_attenuation #-} -- | Dampens audio over distance with this as an exponent. bindAudioStreamPlayer2D_get_attenuation :: MethodBind bindAudioStreamPlayer2D_get_attenuation = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_attenuation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dampens audio over distance with this as an exponent. get_attenuation :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Float get_attenuation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_attenuation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_attenuation" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_attenuation {-# NOINLINE bindAudioStreamPlayer2D_get_bus #-} -- | Bus on which this audio is playing. bindAudioStreamPlayer2D_get_bus :: MethodBind bindAudioStreamPlayer2D_get_bus = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bus on which this audio is playing. get_bus :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO GodotString get_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_bus" '[] (IO GodotString) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_bus {-# NOINLINE bindAudioStreamPlayer2D_get_max_distance #-} -- | Maximum distance from which audio is still hearable. bindAudioStreamPlayer2D_get_max_distance :: MethodBind bindAudioStreamPlayer2D_get_max_distance = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum distance from which audio is still hearable. get_max_distance :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Float get_max_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_max_distance" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_max_distance {-# NOINLINE bindAudioStreamPlayer2D_get_pitch_scale #-} -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. bindAudioStreamPlayer2D_get_pitch_scale :: MethodBind bindAudioStreamPlayer2D_get_pitch_scale = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_pitch_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. get_pitch_scale :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Float get_pitch_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_pitch_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_pitch_scale" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_pitch_scale {-# NOINLINE bindAudioStreamPlayer2D_get_playback_position #-} -- | Returns the position in the @AudioStream@. bindAudioStreamPlayer2D_get_playback_position :: MethodBind bindAudioStreamPlayer2D_get_playback_position = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_playback_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position in the @AudioStream@. get_playback_position :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Float get_playback_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_playback_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_playback_position" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_playback_position {-# NOINLINE bindAudioStreamPlayer2D_get_stream #-} -- | The @AudioStream@ object to be played. bindAudioStreamPlayer2D_get_stream :: MethodBind bindAudioStreamPlayer2D_get_stream = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @AudioStream@ object to be played. get_stream :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO AudioStream get_stream cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_stream" '[] (IO AudioStream) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_stream {-# NOINLINE bindAudioStreamPlayer2D_get_stream_paused #-} -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. bindAudioStreamPlayer2D_get_stream_paused :: MethodBind bindAudioStreamPlayer2D_get_stream_paused = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_stream_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. get_stream_paused :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Bool get_stream_paused cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_stream_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_stream_paused" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_stream_paused {-# NOINLINE bindAudioStreamPlayer2D_get_stream_playback #-} -- | Returns the @AudioStreamPlayback@ object associated with this @AudioStreamPlayer2D@. bindAudioStreamPlayer2D_get_stream_playback :: MethodBind bindAudioStreamPlayer2D_get_stream_playback = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_stream_playback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AudioStreamPlayback@ object associated with this @AudioStreamPlayer2D@. get_stream_playback :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO AudioStreamPlayback get_stream_playback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_stream_playback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_stream_playback" '[] (IO AudioStreamPlayback) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_stream_playback {-# NOINLINE bindAudioStreamPlayer2D_get_volume_db #-} -- | Base volume without dampening. bindAudioStreamPlayer2D_get_volume_db :: MethodBind bindAudioStreamPlayer2D_get_volume_db = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "get_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Base volume without dampening. get_volume_db :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Float get_volume_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_get_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "get_volume_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer2D.get_volume_db {-# NOINLINE bindAudioStreamPlayer2D_is_autoplay_enabled #-} -- | If @true@, audio plays when added to scene tree. bindAudioStreamPlayer2D_is_autoplay_enabled :: MethodBind bindAudioStreamPlayer2D_is_autoplay_enabled = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "is_autoplay_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio plays when added to scene tree. is_autoplay_enabled :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Bool is_autoplay_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_is_autoplay_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "is_autoplay_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer2D.is_autoplay_enabled {-# NOINLINE bindAudioStreamPlayer2D_is_playing #-} -- | If @true@, audio is playing. bindAudioStreamPlayer2D_is_playing :: MethodBind bindAudioStreamPlayer2D_is_playing = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio is playing. is_playing :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO Bool is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer2D.is_playing {-# NOINLINE bindAudioStreamPlayer2D_play #-} -- | Plays the audio from the given position @from_position@, in seconds. bindAudioStreamPlayer2D_play :: MethodBind bindAudioStreamPlayer2D_play = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Plays the audio from the given position @from_position@, in seconds. play :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Maybe Float -> IO () play cls arg1 = withVariantArray [maybe (VariantReal (0)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "play" '[Maybe Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.play {-# NOINLINE bindAudioStreamPlayer2D_seek #-} -- | Sets the position from which audio will be played, in seconds. bindAudioStreamPlayer2D_seek :: MethodBind bindAudioStreamPlayer2D_seek = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position from which audio will be played, in seconds. seek :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Float -> IO () seek cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "seek" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.seek {-# NOINLINE bindAudioStreamPlayer2D_set_area_mask #-} -- | Areas in which this sound plays. bindAudioStreamPlayer2D_set_area_mask :: MethodBind bindAudioStreamPlayer2D_set_area_mask = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_area_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Areas in which this sound plays. set_area_mask :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Int -> IO () set_area_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_area_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_area_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_area_mask {-# NOINLINE bindAudioStreamPlayer2D_set_attenuation #-} -- | Dampens audio over distance with this as an exponent. bindAudioStreamPlayer2D_set_attenuation :: MethodBind bindAudioStreamPlayer2D_set_attenuation = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_attenuation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dampens audio over distance with this as an exponent. set_attenuation :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Float -> IO () set_attenuation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_attenuation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_attenuation" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_attenuation {-# NOINLINE bindAudioStreamPlayer2D_set_autoplay #-} -- | If @true@, audio plays when added to scene tree. bindAudioStreamPlayer2D_set_autoplay :: MethodBind bindAudioStreamPlayer2D_set_autoplay = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_autoplay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio plays when added to scene tree. set_autoplay :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Bool -> IO () set_autoplay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_autoplay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_autoplay" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_autoplay {-# NOINLINE bindAudioStreamPlayer2D_set_bus #-} -- | Bus on which this audio is playing. bindAudioStreamPlayer2D_set_bus :: MethodBind bindAudioStreamPlayer2D_set_bus = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bus on which this audio is playing. set_bus :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> GodotString -> IO () set_bus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_bus" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_bus {-# NOINLINE bindAudioStreamPlayer2D_set_max_distance #-} -- | Maximum distance from which audio is still hearable. bindAudioStreamPlayer2D_set_max_distance :: MethodBind bindAudioStreamPlayer2D_set_max_distance = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum distance from which audio is still hearable. set_max_distance :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Float -> IO () set_max_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_max_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_max_distance {-# NOINLINE bindAudioStreamPlayer2D_set_pitch_scale #-} -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. bindAudioStreamPlayer2D_set_pitch_scale :: MethodBind bindAudioStreamPlayer2D_set_pitch_scale = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_pitch_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. set_pitch_scale :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Float -> IO () set_pitch_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_pitch_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_pitch_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_pitch_scale {-# NOINLINE bindAudioStreamPlayer2D_set_stream #-} -- | The @AudioStream@ object to be played. bindAudioStreamPlayer2D_set_stream :: MethodBind bindAudioStreamPlayer2D_set_stream = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @AudioStream@ object to be played. set_stream :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> AudioStream -> IO () set_stream cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_stream" '[AudioStream] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_stream {-# NOINLINE bindAudioStreamPlayer2D_set_stream_paused #-} -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. bindAudioStreamPlayer2D_set_stream_paused :: MethodBind bindAudioStreamPlayer2D_set_stream_paused = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_stream_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. set_stream_paused :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Bool -> IO () set_stream_paused cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_stream_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_stream_paused" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_stream_paused {-# NOINLINE bindAudioStreamPlayer2D_set_volume_db #-} -- | Base volume without dampening. bindAudioStreamPlayer2D_set_volume_db :: MethodBind bindAudioStreamPlayer2D_set_volume_db = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "set_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Base volume without dampening. set_volume_db :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> Float -> IO () set_volume_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_set_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "set_volume_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.set_volume_db {-# NOINLINE bindAudioStreamPlayer2D_stop #-} -- | Stops the audio. bindAudioStreamPlayer2D_stop :: MethodBind bindAudioStreamPlayer2D_stop = unsafePerformIO $ withCString "AudioStreamPlayer2D" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the audio. stop :: (AudioStreamPlayer2D :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer2D_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer2D "stop" '[] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer2D.stop ================================================ FILE: src/Godot/Core/AudioStreamPlayer3D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamPlayer3D (Godot.Core.AudioStreamPlayer3D._ATTENUATION_INVERSE_SQUARE_DISTANCE, Godot.Core.AudioStreamPlayer3D._ATTENUATION_INVERSE_DISTANCE, Godot.Core.AudioStreamPlayer3D._DOPPLER_TRACKING_PHYSICS_STEP, Godot.Core.AudioStreamPlayer3D._DOPPLER_TRACKING_DISABLED, Godot.Core.AudioStreamPlayer3D._ATTENUATION_DISABLED, Godot.Core.AudioStreamPlayer3D._OUT_OF_RANGE_PAUSE, Godot.Core.AudioStreamPlayer3D._ATTENUATION_LOGARITHMIC, Godot.Core.AudioStreamPlayer3D._OUT_OF_RANGE_MIX, Godot.Core.AudioStreamPlayer3D._DOPPLER_TRACKING_IDLE_STEP, Godot.Core.AudioStreamPlayer3D.sig_finished, Godot.Core.AudioStreamPlayer3D._bus_layout_changed, Godot.Core.AudioStreamPlayer3D._is_active, Godot.Core.AudioStreamPlayer3D._set_playing, Godot.Core.AudioStreamPlayer3D.get_area_mask, Godot.Core.AudioStreamPlayer3D.get_attenuation_filter_cutoff_hz, Godot.Core.AudioStreamPlayer3D.get_attenuation_filter_db, Godot.Core.AudioStreamPlayer3D.get_attenuation_model, Godot.Core.AudioStreamPlayer3D.get_bus, Godot.Core.AudioStreamPlayer3D.get_doppler_tracking, Godot.Core.AudioStreamPlayer3D.get_emission_angle, Godot.Core.AudioStreamPlayer3D.get_emission_angle_filter_attenuation_db, Godot.Core.AudioStreamPlayer3D.get_max_db, Godot.Core.AudioStreamPlayer3D.get_max_distance, Godot.Core.AudioStreamPlayer3D.get_out_of_range_mode, Godot.Core.AudioStreamPlayer3D.get_pitch_scale, Godot.Core.AudioStreamPlayer3D.get_playback_position, Godot.Core.AudioStreamPlayer3D.get_stream, Godot.Core.AudioStreamPlayer3D.get_stream_paused, Godot.Core.AudioStreamPlayer3D.get_stream_playback, Godot.Core.AudioStreamPlayer3D.get_unit_db, Godot.Core.AudioStreamPlayer3D.get_unit_size, Godot.Core.AudioStreamPlayer3D.is_autoplay_enabled, Godot.Core.AudioStreamPlayer3D.is_emission_angle_enabled, Godot.Core.AudioStreamPlayer3D.is_playing, Godot.Core.AudioStreamPlayer3D.play, Godot.Core.AudioStreamPlayer3D.seek, Godot.Core.AudioStreamPlayer3D.set_area_mask, Godot.Core.AudioStreamPlayer3D.set_attenuation_filter_cutoff_hz, Godot.Core.AudioStreamPlayer3D.set_attenuation_filter_db, Godot.Core.AudioStreamPlayer3D.set_attenuation_model, Godot.Core.AudioStreamPlayer3D.set_autoplay, Godot.Core.AudioStreamPlayer3D.set_bus, Godot.Core.AudioStreamPlayer3D.set_doppler_tracking, Godot.Core.AudioStreamPlayer3D.set_emission_angle, Godot.Core.AudioStreamPlayer3D.set_emission_angle_enabled, Godot.Core.AudioStreamPlayer3D.set_emission_angle_filter_attenuation_db, Godot.Core.AudioStreamPlayer3D.set_max_db, Godot.Core.AudioStreamPlayer3D.set_max_distance, Godot.Core.AudioStreamPlayer3D.set_out_of_range_mode, Godot.Core.AudioStreamPlayer3D.set_pitch_scale, Godot.Core.AudioStreamPlayer3D.set_stream, Godot.Core.AudioStreamPlayer3D.set_stream_paused, Godot.Core.AudioStreamPlayer3D.set_unit_db, Godot.Core.AudioStreamPlayer3D.set_unit_size, Godot.Core.AudioStreamPlayer3D.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() _ATTENUATION_INVERSE_SQUARE_DISTANCE :: Int _ATTENUATION_INVERSE_SQUARE_DISTANCE = 1 _ATTENUATION_INVERSE_DISTANCE :: Int _ATTENUATION_INVERSE_DISTANCE = 0 _DOPPLER_TRACKING_PHYSICS_STEP :: Int _DOPPLER_TRACKING_PHYSICS_STEP = 2 _DOPPLER_TRACKING_DISABLED :: Int _DOPPLER_TRACKING_DISABLED = 0 _ATTENUATION_DISABLED :: Int _ATTENUATION_DISABLED = 3 _OUT_OF_RANGE_PAUSE :: Int _OUT_OF_RANGE_PAUSE = 1 _ATTENUATION_LOGARITHMIC :: Int _ATTENUATION_LOGARITHMIC = 2 _OUT_OF_RANGE_MIX :: Int _OUT_OF_RANGE_MIX = 0 _DOPPLER_TRACKING_IDLE_STEP :: Int _DOPPLER_TRACKING_IDLE_STEP = 1 -- | Emitted when the audio stops playing. sig_finished :: Godot.Internal.Dispatch.Signal AudioStreamPlayer3D sig_finished = Godot.Internal.Dispatch.Signal "finished" instance NodeSignal AudioStreamPlayer3D "finished" '[] instance NodeProperty AudioStreamPlayer3D "area_mask" Int 'False where nodeProperty = (get_area_mask, wrapDroppingSetter set_area_mask, Nothing) instance NodeProperty AudioStreamPlayer3D "attenuation_filter_cutoff_hz" Float 'False where nodeProperty = (get_attenuation_filter_cutoff_hz, wrapDroppingSetter set_attenuation_filter_cutoff_hz, Nothing) instance NodeProperty AudioStreamPlayer3D "attenuation_filter_db" Float 'False where nodeProperty = (get_attenuation_filter_db, wrapDroppingSetter set_attenuation_filter_db, Nothing) instance NodeProperty AudioStreamPlayer3D "attenuation_model" Int 'False where nodeProperty = (get_attenuation_model, wrapDroppingSetter set_attenuation_model, Nothing) instance NodeProperty AudioStreamPlayer3D "autoplay" Bool 'False where nodeProperty = (is_autoplay_enabled, wrapDroppingSetter set_autoplay, Nothing) instance NodeProperty AudioStreamPlayer3D "bus" GodotString 'False where nodeProperty = (get_bus, wrapDroppingSetter set_bus, Nothing) instance NodeProperty AudioStreamPlayer3D "doppler_tracking" Int 'False where nodeProperty = (get_doppler_tracking, wrapDroppingSetter set_doppler_tracking, Nothing) instance NodeProperty AudioStreamPlayer3D "emission_angle_degrees" Float 'False where nodeProperty = (get_emission_angle, wrapDroppingSetter set_emission_angle, Nothing) instance NodeProperty AudioStreamPlayer3D "emission_angle_enabled" Bool 'False where nodeProperty = (is_emission_angle_enabled, wrapDroppingSetter set_emission_angle_enabled, Nothing) instance NodeProperty AudioStreamPlayer3D "emission_angle_filter_attenuation_db" Float 'False where nodeProperty = (get_emission_angle_filter_attenuation_db, wrapDroppingSetter set_emission_angle_filter_attenuation_db, Nothing) instance NodeProperty AudioStreamPlayer3D "max_db" Float 'False where nodeProperty = (get_max_db, wrapDroppingSetter set_max_db, Nothing) instance NodeProperty AudioStreamPlayer3D "max_distance" Float 'False where nodeProperty = (get_max_distance, wrapDroppingSetter set_max_distance, Nothing) instance NodeProperty AudioStreamPlayer3D "out_of_range_mode" Int 'False where nodeProperty = (get_out_of_range_mode, wrapDroppingSetter set_out_of_range_mode, Nothing) instance NodeProperty AudioStreamPlayer3D "pitch_scale" Float 'False where nodeProperty = (get_pitch_scale, wrapDroppingSetter set_pitch_scale, Nothing) instance NodeProperty AudioStreamPlayer3D "playing" Bool 'False where nodeProperty = (is_playing, wrapDroppingSetter _set_playing, Nothing) instance NodeProperty AudioStreamPlayer3D "stream" AudioStream 'False where nodeProperty = (get_stream, wrapDroppingSetter set_stream, Nothing) instance NodeProperty AudioStreamPlayer3D "stream_paused" Bool 'False where nodeProperty = (get_stream_paused, wrapDroppingSetter set_stream_paused, Nothing) instance NodeProperty AudioStreamPlayer3D "unit_db" Float 'False where nodeProperty = (get_unit_db, wrapDroppingSetter set_unit_db, Nothing) instance NodeProperty AudioStreamPlayer3D "unit_size" Float 'False where nodeProperty = (get_unit_size, wrapDroppingSetter set_unit_size, Nothing) {-# NOINLINE bindAudioStreamPlayer3D__bus_layout_changed #-} bindAudioStreamPlayer3D__bus_layout_changed :: MethodBind bindAudioStreamPlayer3D__bus_layout_changed = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "_bus_layout_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _bus_layout_changed :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO () _bus_layout_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D__bus_layout_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "_bus_layout_changed" '[] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D._bus_layout_changed {-# NOINLINE bindAudioStreamPlayer3D__is_active #-} bindAudioStreamPlayer3D__is_active :: MethodBind bindAudioStreamPlayer3D__is_active = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "_is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _is_active :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Bool _is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D__is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "_is_active" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer3D._is_active {-# NOINLINE bindAudioStreamPlayer3D__set_playing #-} -- | If @true@, audio is playing. bindAudioStreamPlayer3D__set_playing :: MethodBind bindAudioStreamPlayer3D__set_playing = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "_set_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio is playing. _set_playing :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Bool -> IO () _set_playing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D__set_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "_set_playing" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D._set_playing {-# NOINLINE bindAudioStreamPlayer3D_get_area_mask #-} -- | Areas in which this sound plays. bindAudioStreamPlayer3D_get_area_mask :: MethodBind bindAudioStreamPlayer3D_get_area_mask = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_area_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Areas in which this sound plays. get_area_mask :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Int get_area_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_area_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_area_mask" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_area_mask {-# NOINLINE bindAudioStreamPlayer3D_get_attenuation_filter_cutoff_hz #-} -- | Dampens audio above this frequency, in Hz. bindAudioStreamPlayer3D_get_attenuation_filter_cutoff_hz :: MethodBind bindAudioStreamPlayer3D_get_attenuation_filter_cutoff_hz = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_attenuation_filter_cutoff_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dampens audio above this frequency, in Hz. get_attenuation_filter_cutoff_hz :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_attenuation_filter_cutoff_hz cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_attenuation_filter_cutoff_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_attenuation_filter_cutoff_hz" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_attenuation_filter_cutoff_hz {-# NOINLINE bindAudioStreamPlayer3D_get_attenuation_filter_db #-} -- | Amount how much the filter affects the loudness, in dB. bindAudioStreamPlayer3D_get_attenuation_filter_db :: MethodBind bindAudioStreamPlayer3D_get_attenuation_filter_db = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_attenuation_filter_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount how much the filter affects the loudness, in dB. get_attenuation_filter_db :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_attenuation_filter_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_attenuation_filter_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_attenuation_filter_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_attenuation_filter_db {-# NOINLINE bindAudioStreamPlayer3D_get_attenuation_model #-} -- | Decides if audio should get quieter with distance linearly, quadratically, logarithmically, or not be affected by distance, effectively disabling attenuation. bindAudioStreamPlayer3D_get_attenuation_model :: MethodBind bindAudioStreamPlayer3D_get_attenuation_model = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_attenuation_model" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Decides if audio should get quieter with distance linearly, quadratically, logarithmically, or not be affected by distance, effectively disabling attenuation. get_attenuation_model :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Int get_attenuation_model cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_attenuation_model (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_attenuation_model" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_attenuation_model {-# NOINLINE bindAudioStreamPlayer3D_get_bus #-} -- | Bus on which this audio is playing. bindAudioStreamPlayer3D_get_bus :: MethodBind bindAudioStreamPlayer3D_get_bus = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bus on which this audio is playing. get_bus :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO GodotString get_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_bus" '[] (IO GodotString) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_bus {-# NOINLINE bindAudioStreamPlayer3D_get_doppler_tracking #-} -- | Decides in which step the Doppler effect should be calculated. bindAudioStreamPlayer3D_get_doppler_tracking :: MethodBind bindAudioStreamPlayer3D_get_doppler_tracking = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_doppler_tracking" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Decides in which step the Doppler effect should be calculated. get_doppler_tracking :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Int get_doppler_tracking cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_doppler_tracking (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_doppler_tracking" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_doppler_tracking {-# NOINLINE bindAudioStreamPlayer3D_get_emission_angle #-} -- | The angle in which the audio reaches cameras undampened. bindAudioStreamPlayer3D_get_emission_angle :: MethodBind bindAudioStreamPlayer3D_get_emission_angle = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_emission_angle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The angle in which the audio reaches cameras undampened. get_emission_angle :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_emission_angle cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_emission_angle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_emission_angle" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_emission_angle {-# NOINLINE bindAudioStreamPlayer3D_get_emission_angle_filter_attenuation_db #-} -- | Dampens audio if camera is outside of @emission_angle_degrees@ and @emission_angle_enabled@ is set by this factor, in dB. bindAudioStreamPlayer3D_get_emission_angle_filter_attenuation_db :: MethodBind bindAudioStreamPlayer3D_get_emission_angle_filter_attenuation_db = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_emission_angle_filter_attenuation_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dampens audio if camera is outside of @emission_angle_degrees@ and @emission_angle_enabled@ is set by this factor, in dB. get_emission_angle_filter_attenuation_db :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_emission_angle_filter_attenuation_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_emission_angle_filter_attenuation_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_emission_angle_filter_attenuation_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_emission_angle_filter_attenuation_db {-# NOINLINE bindAudioStreamPlayer3D_get_max_db #-} -- | Sets the absolute maximum of the soundlevel, in dB. bindAudioStreamPlayer3D_get_max_db :: MethodBind bindAudioStreamPlayer3D_get_max_db = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_max_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the absolute maximum of the soundlevel, in dB. get_max_db :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_max_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_max_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_max_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_max_db {-# NOINLINE bindAudioStreamPlayer3D_get_max_distance #-} -- | Sets the distance from which the @out_of_range_mode@ takes effect. Has no effect if set to 0. bindAudioStreamPlayer3D_get_max_distance :: MethodBind bindAudioStreamPlayer3D_get_max_distance = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the distance from which the @out_of_range_mode@ takes effect. Has no effect if set to 0. get_max_distance :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_max_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_max_distance" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_max_distance {-# NOINLINE bindAudioStreamPlayer3D_get_out_of_range_mode #-} -- | Decides if audio should pause when source is outside of @max_distance@ range. bindAudioStreamPlayer3D_get_out_of_range_mode :: MethodBind bindAudioStreamPlayer3D_get_out_of_range_mode = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_out_of_range_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Decides if audio should pause when source is outside of @max_distance@ range. get_out_of_range_mode :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Int get_out_of_range_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_out_of_range_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_out_of_range_mode" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_out_of_range_mode {-# NOINLINE bindAudioStreamPlayer3D_get_pitch_scale #-} -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. bindAudioStreamPlayer3D_get_pitch_scale :: MethodBind bindAudioStreamPlayer3D_get_pitch_scale = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_pitch_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. get_pitch_scale :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_pitch_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_pitch_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_pitch_scale" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_pitch_scale {-# NOINLINE bindAudioStreamPlayer3D_get_playback_position #-} -- | Returns the position in the @AudioStream@. bindAudioStreamPlayer3D_get_playback_position :: MethodBind bindAudioStreamPlayer3D_get_playback_position = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_playback_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position in the @AudioStream@. get_playback_position :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_playback_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_playback_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_playback_position" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_playback_position {-# NOINLINE bindAudioStreamPlayer3D_get_stream #-} -- | The @AudioStream@ object to be played. bindAudioStreamPlayer3D_get_stream :: MethodBind bindAudioStreamPlayer3D_get_stream = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @AudioStream@ object to be played. get_stream :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO AudioStream get_stream cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_stream" '[] (IO AudioStream) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_stream {-# NOINLINE bindAudioStreamPlayer3D_get_stream_paused #-} -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. bindAudioStreamPlayer3D_get_stream_paused :: MethodBind bindAudioStreamPlayer3D_get_stream_paused = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_stream_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. get_stream_paused :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Bool get_stream_paused cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_stream_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_stream_paused" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_stream_paused {-# NOINLINE bindAudioStreamPlayer3D_get_stream_playback #-} -- | Returns the @AudioStreamPlayback@ object associated with this @AudioStreamPlayer3D@. bindAudioStreamPlayer3D_get_stream_playback :: MethodBind bindAudioStreamPlayer3D_get_stream_playback = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_stream_playback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AudioStreamPlayback@ object associated with this @AudioStreamPlayer3D@. get_stream_playback :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO AudioStreamPlayback get_stream_playback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_stream_playback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_stream_playback" '[] (IO AudioStreamPlayback) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_stream_playback {-# NOINLINE bindAudioStreamPlayer3D_get_unit_db #-} -- | Base sound level unaffected by dampening, in dB. bindAudioStreamPlayer3D_get_unit_db :: MethodBind bindAudioStreamPlayer3D_get_unit_db = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_unit_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Base sound level unaffected by dampening, in dB. get_unit_db :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_unit_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_unit_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_unit_db" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_unit_db {-# NOINLINE bindAudioStreamPlayer3D_get_unit_size #-} -- | Factor for the attenuation effect. bindAudioStreamPlayer3D_get_unit_size :: MethodBind bindAudioStreamPlayer3D_get_unit_size = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "get_unit_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Factor for the attenuation effect. get_unit_size :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Float get_unit_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_get_unit_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "get_unit_size" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamPlayer3D.get_unit_size {-# NOINLINE bindAudioStreamPlayer3D_is_autoplay_enabled #-} -- | If @true@, audio plays when added to scene tree. bindAudioStreamPlayer3D_is_autoplay_enabled :: MethodBind bindAudioStreamPlayer3D_is_autoplay_enabled = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "is_autoplay_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio plays when added to scene tree. is_autoplay_enabled :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Bool is_autoplay_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_is_autoplay_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "is_autoplay_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer3D.is_autoplay_enabled {-# NOINLINE bindAudioStreamPlayer3D_is_emission_angle_enabled #-} -- | If @true@, the audio should be dampened according to the direction of the sound. bindAudioStreamPlayer3D_is_emission_angle_enabled :: MethodBind bindAudioStreamPlayer3D_is_emission_angle_enabled = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "is_emission_angle_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the audio should be dampened according to the direction of the sound. is_emission_angle_enabled :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Bool is_emission_angle_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_is_emission_angle_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "is_emission_angle_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer3D.is_emission_angle_enabled {-# NOINLINE bindAudioStreamPlayer3D_is_playing #-} -- | If @true@, audio is playing. bindAudioStreamPlayer3D_is_playing :: MethodBind bindAudioStreamPlayer3D_is_playing = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio is playing. is_playing :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO Bool is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamPlayer3D.is_playing {-# NOINLINE bindAudioStreamPlayer3D_play #-} -- | Plays the audio from the given position @from_position@, in seconds. bindAudioStreamPlayer3D_play :: MethodBind bindAudioStreamPlayer3D_play = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Plays the audio from the given position @from_position@, in seconds. play :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Maybe Float -> IO () play cls arg1 = withVariantArray [maybe (VariantReal (0)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "play" '[Maybe Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.play {-# NOINLINE bindAudioStreamPlayer3D_seek #-} -- | Sets the position from which audio will be played, in seconds. bindAudioStreamPlayer3D_seek :: MethodBind bindAudioStreamPlayer3D_seek = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position from which audio will be played, in seconds. seek :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () seek cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "seek" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.seek {-# NOINLINE bindAudioStreamPlayer3D_set_area_mask #-} -- | Areas in which this sound plays. bindAudioStreamPlayer3D_set_area_mask :: MethodBind bindAudioStreamPlayer3D_set_area_mask = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_area_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Areas in which this sound plays. set_area_mask :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Int -> IO () set_area_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_area_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_area_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_area_mask {-# NOINLINE bindAudioStreamPlayer3D_set_attenuation_filter_cutoff_hz #-} -- | Dampens audio above this frequency, in Hz. bindAudioStreamPlayer3D_set_attenuation_filter_cutoff_hz :: MethodBind bindAudioStreamPlayer3D_set_attenuation_filter_cutoff_hz = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_attenuation_filter_cutoff_hz" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dampens audio above this frequency, in Hz. set_attenuation_filter_cutoff_hz :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_attenuation_filter_cutoff_hz cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_attenuation_filter_cutoff_hz (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_attenuation_filter_cutoff_hz" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_attenuation_filter_cutoff_hz {-# NOINLINE bindAudioStreamPlayer3D_set_attenuation_filter_db #-} -- | Amount how much the filter affects the loudness, in dB. bindAudioStreamPlayer3D_set_attenuation_filter_db :: MethodBind bindAudioStreamPlayer3D_set_attenuation_filter_db = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_attenuation_filter_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount how much the filter affects the loudness, in dB. set_attenuation_filter_db :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_attenuation_filter_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_attenuation_filter_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_attenuation_filter_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_attenuation_filter_db {-# NOINLINE bindAudioStreamPlayer3D_set_attenuation_model #-} -- | Decides if audio should get quieter with distance linearly, quadratically, logarithmically, or not be affected by distance, effectively disabling attenuation. bindAudioStreamPlayer3D_set_attenuation_model :: MethodBind bindAudioStreamPlayer3D_set_attenuation_model = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_attenuation_model" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Decides if audio should get quieter with distance linearly, quadratically, logarithmically, or not be affected by distance, effectively disabling attenuation. set_attenuation_model :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Int -> IO () set_attenuation_model cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_attenuation_model (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_attenuation_model" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_attenuation_model {-# NOINLINE bindAudioStreamPlayer3D_set_autoplay #-} -- | If @true@, audio plays when added to scene tree. bindAudioStreamPlayer3D_set_autoplay :: MethodBind bindAudioStreamPlayer3D_set_autoplay = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_autoplay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio plays when added to scene tree. set_autoplay :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Bool -> IO () set_autoplay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_autoplay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_autoplay" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_autoplay {-# NOINLINE bindAudioStreamPlayer3D_set_bus #-} -- | Bus on which this audio is playing. bindAudioStreamPlayer3D_set_bus :: MethodBind bindAudioStreamPlayer3D_set_bus = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bus on which this audio is playing. set_bus :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> GodotString -> IO () set_bus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_bus" '[GodotString] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_bus {-# NOINLINE bindAudioStreamPlayer3D_set_doppler_tracking #-} -- | Decides in which step the Doppler effect should be calculated. bindAudioStreamPlayer3D_set_doppler_tracking :: MethodBind bindAudioStreamPlayer3D_set_doppler_tracking = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_doppler_tracking" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Decides in which step the Doppler effect should be calculated. set_doppler_tracking :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Int -> IO () set_doppler_tracking cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_doppler_tracking (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_doppler_tracking" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_doppler_tracking {-# NOINLINE bindAudioStreamPlayer3D_set_emission_angle #-} -- | The angle in which the audio reaches cameras undampened. bindAudioStreamPlayer3D_set_emission_angle :: MethodBind bindAudioStreamPlayer3D_set_emission_angle = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_emission_angle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The angle in which the audio reaches cameras undampened. set_emission_angle :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_emission_angle cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_emission_angle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_emission_angle" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_emission_angle {-# NOINLINE bindAudioStreamPlayer3D_set_emission_angle_enabled #-} -- | If @true@, the audio should be dampened according to the direction of the sound. bindAudioStreamPlayer3D_set_emission_angle_enabled :: MethodBind bindAudioStreamPlayer3D_set_emission_angle_enabled = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_emission_angle_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the audio should be dampened according to the direction of the sound. set_emission_angle_enabled :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Bool -> IO () set_emission_angle_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_emission_angle_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_emission_angle_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_emission_angle_enabled {-# NOINLINE bindAudioStreamPlayer3D_set_emission_angle_filter_attenuation_db #-} -- | Dampens audio if camera is outside of @emission_angle_degrees@ and @emission_angle_enabled@ is set by this factor, in dB. bindAudioStreamPlayer3D_set_emission_angle_filter_attenuation_db :: MethodBind bindAudioStreamPlayer3D_set_emission_angle_filter_attenuation_db = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_emission_angle_filter_attenuation_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dampens audio if camera is outside of @emission_angle_degrees@ and @emission_angle_enabled@ is set by this factor, in dB. set_emission_angle_filter_attenuation_db :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_emission_angle_filter_attenuation_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_emission_angle_filter_attenuation_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_emission_angle_filter_attenuation_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_emission_angle_filter_attenuation_db {-# NOINLINE bindAudioStreamPlayer3D_set_max_db #-} -- | Sets the absolute maximum of the soundlevel, in dB. bindAudioStreamPlayer3D_set_max_db :: MethodBind bindAudioStreamPlayer3D_set_max_db = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_max_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the absolute maximum of the soundlevel, in dB. set_max_db :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_max_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_max_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_max_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_max_db {-# NOINLINE bindAudioStreamPlayer3D_set_max_distance #-} -- | Sets the distance from which the @out_of_range_mode@ takes effect. Has no effect if set to 0. bindAudioStreamPlayer3D_set_max_distance :: MethodBind bindAudioStreamPlayer3D_set_max_distance = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the distance from which the @out_of_range_mode@ takes effect. Has no effect if set to 0. set_max_distance :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_max_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_max_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_max_distance {-# NOINLINE bindAudioStreamPlayer3D_set_out_of_range_mode #-} -- | Decides if audio should pause when source is outside of @max_distance@ range. bindAudioStreamPlayer3D_set_out_of_range_mode :: MethodBind bindAudioStreamPlayer3D_set_out_of_range_mode = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_out_of_range_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Decides if audio should pause when source is outside of @max_distance@ range. set_out_of_range_mode :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Int -> IO () set_out_of_range_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_out_of_range_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_out_of_range_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_out_of_range_mode {-# NOINLINE bindAudioStreamPlayer3D_set_pitch_scale #-} -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. bindAudioStreamPlayer3D_set_pitch_scale :: MethodBind bindAudioStreamPlayer3D_set_pitch_scale = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_pitch_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. set_pitch_scale :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_pitch_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_pitch_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_pitch_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_pitch_scale {-# NOINLINE bindAudioStreamPlayer3D_set_stream #-} -- | The @AudioStream@ object to be played. bindAudioStreamPlayer3D_set_stream :: MethodBind bindAudioStreamPlayer3D_set_stream = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @AudioStream@ object to be played. set_stream :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> AudioStream -> IO () set_stream cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_stream" '[AudioStream] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_stream {-# NOINLINE bindAudioStreamPlayer3D_set_stream_paused #-} -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. bindAudioStreamPlayer3D_set_stream_paused :: MethodBind bindAudioStreamPlayer3D_set_stream_paused = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_stream_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the playback is paused. You can resume it by setting @stream_paused@ to @false@. set_stream_paused :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Bool -> IO () set_stream_paused cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_stream_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_stream_paused" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_stream_paused {-# NOINLINE bindAudioStreamPlayer3D_set_unit_db #-} -- | Base sound level unaffected by dampening, in dB. bindAudioStreamPlayer3D_set_unit_db :: MethodBind bindAudioStreamPlayer3D_set_unit_db = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_unit_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Base sound level unaffected by dampening, in dB. set_unit_db :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_unit_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_unit_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_unit_db" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_unit_db {-# NOINLINE bindAudioStreamPlayer3D_set_unit_size #-} -- | Factor for the attenuation effect. bindAudioStreamPlayer3D_set_unit_size :: MethodBind bindAudioStreamPlayer3D_set_unit_size = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "set_unit_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Factor for the attenuation effect. set_unit_size :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> Float -> IO () set_unit_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_set_unit_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "set_unit_size" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.set_unit_size {-# NOINLINE bindAudioStreamPlayer3D_stop #-} -- | Stops the audio. bindAudioStreamPlayer3D_stop :: MethodBind bindAudioStreamPlayer3D_stop = unsafePerformIO $ withCString "AudioStreamPlayer3D" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the audio. stop :: (AudioStreamPlayer3D :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamPlayer3D_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamPlayer3D "stop" '[] (IO ()) where nodeMethod = Godot.Core.AudioStreamPlayer3D.stop ================================================ FILE: src/Godot/Core/AudioStreamRandomPitch.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamRandomPitch (Godot.Core.AudioStreamRandomPitch.get_audio_stream, Godot.Core.AudioStreamRandomPitch.get_random_pitch, Godot.Core.AudioStreamRandomPitch.set_audio_stream, Godot.Core.AudioStreamRandomPitch.set_random_pitch) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioStream() instance NodeProperty AudioStreamRandomPitch "audio_stream" AudioStream 'False where nodeProperty = (get_audio_stream, wrapDroppingSetter set_audio_stream, Nothing) instance NodeProperty AudioStreamRandomPitch "random_pitch" Float 'False where nodeProperty = (get_random_pitch, wrapDroppingSetter set_random_pitch, Nothing) {-# NOINLINE bindAudioStreamRandomPitch_get_audio_stream #-} -- | The current @AudioStream@. bindAudioStreamRandomPitch_get_audio_stream :: MethodBind bindAudioStreamRandomPitch_get_audio_stream = unsafePerformIO $ withCString "AudioStreamRandomPitch" $ \ clsNamePtr -> withCString "get_audio_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current @AudioStream@. get_audio_stream :: (AudioStreamRandomPitch :< cls, Object :< cls) => cls -> IO AudioStream get_audio_stream cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamRandomPitch_get_audio_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamRandomPitch "get_audio_stream" '[] (IO AudioStream) where nodeMethod = Godot.Core.AudioStreamRandomPitch.get_audio_stream {-# NOINLINE bindAudioStreamRandomPitch_get_random_pitch #-} -- | The intensity of random pitch variation. bindAudioStreamRandomPitch_get_random_pitch :: MethodBind bindAudioStreamRandomPitch_get_random_pitch = unsafePerformIO $ withCString "AudioStreamRandomPitch" $ \ clsNamePtr -> withCString "get_random_pitch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The intensity of random pitch variation. get_random_pitch :: (AudioStreamRandomPitch :< cls, Object :< cls) => cls -> IO Float get_random_pitch cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamRandomPitch_get_random_pitch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamRandomPitch "get_random_pitch" '[] (IO Float) where nodeMethod = Godot.Core.AudioStreamRandomPitch.get_random_pitch {-# NOINLINE bindAudioStreamRandomPitch_set_audio_stream #-} -- | The current @AudioStream@. bindAudioStreamRandomPitch_set_audio_stream :: MethodBind bindAudioStreamRandomPitch_set_audio_stream = unsafePerformIO $ withCString "AudioStreamRandomPitch" $ \ clsNamePtr -> withCString "set_audio_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current @AudioStream@. set_audio_stream :: (AudioStreamRandomPitch :< cls, Object :< cls) => cls -> AudioStream -> IO () set_audio_stream cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamRandomPitch_set_audio_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamRandomPitch "set_audio_stream" '[AudioStream] (IO ()) where nodeMethod = Godot.Core.AudioStreamRandomPitch.set_audio_stream {-# NOINLINE bindAudioStreamRandomPitch_set_random_pitch #-} -- | The intensity of random pitch variation. bindAudioStreamRandomPitch_set_random_pitch :: MethodBind bindAudioStreamRandomPitch_set_random_pitch = unsafePerformIO $ withCString "AudioStreamRandomPitch" $ \ clsNamePtr -> withCString "set_random_pitch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The intensity of random pitch variation. set_random_pitch :: (AudioStreamRandomPitch :< cls, Object :< cls) => cls -> Float -> IO () set_random_pitch cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamRandomPitch_set_random_pitch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamRandomPitch "set_random_pitch" '[Float] (IO ()) where nodeMethod = Godot.Core.AudioStreamRandomPitch.set_random_pitch ================================================ FILE: src/Godot/Core/AudioStreamSample.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.AudioStreamSample (Godot.Core.AudioStreamSample._FORMAT_8_BITS, Godot.Core.AudioStreamSample._LOOP_PING_PONG, Godot.Core.AudioStreamSample._LOOP_BACKWARD, Godot.Core.AudioStreamSample._LOOP_DISABLED, Godot.Core.AudioStreamSample._FORMAT_IMA_ADPCM, Godot.Core.AudioStreamSample._LOOP_FORWARD, Godot.Core.AudioStreamSample._FORMAT_16_BITS, Godot.Core.AudioStreamSample.get_data, Godot.Core.AudioStreamSample.get_format, Godot.Core.AudioStreamSample.get_loop_begin, Godot.Core.AudioStreamSample.get_loop_end, Godot.Core.AudioStreamSample.get_loop_mode, Godot.Core.AudioStreamSample.get_mix_rate, Godot.Core.AudioStreamSample.is_stereo, Godot.Core.AudioStreamSample.save_to_wav, Godot.Core.AudioStreamSample.set_data, Godot.Core.AudioStreamSample.set_format, Godot.Core.AudioStreamSample.set_loop_begin, Godot.Core.AudioStreamSample.set_loop_end, Godot.Core.AudioStreamSample.set_loop_mode, Godot.Core.AudioStreamSample.set_mix_rate, Godot.Core.AudioStreamSample.set_stereo) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AudioStream() _FORMAT_8_BITS :: Int _FORMAT_8_BITS = 0 _LOOP_PING_PONG :: Int _LOOP_PING_PONG = 2 _LOOP_BACKWARD :: Int _LOOP_BACKWARD = 3 _LOOP_DISABLED :: Int _LOOP_DISABLED = 0 _FORMAT_IMA_ADPCM :: Int _FORMAT_IMA_ADPCM = 2 _LOOP_FORWARD :: Int _LOOP_FORWARD = 1 _FORMAT_16_BITS :: Int _FORMAT_16_BITS = 1 instance NodeProperty AudioStreamSample "data" PoolByteArray 'False where nodeProperty = (get_data, wrapDroppingSetter set_data, Nothing) instance NodeProperty AudioStreamSample "format" Int 'False where nodeProperty = (get_format, wrapDroppingSetter set_format, Nothing) instance NodeProperty AudioStreamSample "loop_begin" Int 'False where nodeProperty = (get_loop_begin, wrapDroppingSetter set_loop_begin, Nothing) instance NodeProperty AudioStreamSample "loop_end" Int 'False where nodeProperty = (get_loop_end, wrapDroppingSetter set_loop_end, Nothing) instance NodeProperty AudioStreamSample "loop_mode" Int 'False where nodeProperty = (get_loop_mode, wrapDroppingSetter set_loop_mode, Nothing) instance NodeProperty AudioStreamSample "mix_rate" Int 'False where nodeProperty = (get_mix_rate, wrapDroppingSetter set_mix_rate, Nothing) instance NodeProperty AudioStreamSample "stereo" Bool 'False where nodeProperty = (is_stereo, wrapDroppingSetter set_stereo, Nothing) {-# NOINLINE bindAudioStreamSample_get_data #-} -- | Contains the audio data in bytes. -- __Note:__ This property expects signed PCM8 data. To convert unsigned PCM8 to signed PCM8, subtract 128 from each byte. bindAudioStreamSample_get_data :: MethodBind bindAudioStreamSample_get_data = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Contains the audio data in bytes. -- __Note:__ This property expects signed PCM8 data. To convert unsigned PCM8 to signed PCM8, subtract 128 from each byte. get_data :: (AudioStreamSample :< cls, Object :< cls) => cls -> IO PoolByteArray get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "get_data" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.AudioStreamSample.get_data {-# NOINLINE bindAudioStreamSample_get_format #-} -- | Audio format. See @enum Format@ constants for values. bindAudioStreamSample_get_format :: MethodBind bindAudioStreamSample_get_format = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Audio format. See @enum Format@ constants for values. get_format :: (AudioStreamSample :< cls, Object :< cls) => cls -> IO Int get_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "get_format" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamSample.get_format {-# NOINLINE bindAudioStreamSample_get_loop_begin #-} -- | The loop start point (in number of samples, relative to the beginning of the sample). This information will be imported automatically from the WAV file if present. bindAudioStreamSample_get_loop_begin :: MethodBind bindAudioStreamSample_get_loop_begin = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "get_loop_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The loop start point (in number of samples, relative to the beginning of the sample). This information will be imported automatically from the WAV file if present. get_loop_begin :: (AudioStreamSample :< cls, Object :< cls) => cls -> IO Int get_loop_begin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_get_loop_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "get_loop_begin" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamSample.get_loop_begin {-# NOINLINE bindAudioStreamSample_get_loop_end #-} -- | The loop end point (in number of samples, relative to the beginning of the sample). This information will be imported automatically from the WAV file if present. bindAudioStreamSample_get_loop_end :: MethodBind bindAudioStreamSample_get_loop_end = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "get_loop_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The loop end point (in number of samples, relative to the beginning of the sample). This information will be imported automatically from the WAV file if present. get_loop_end :: (AudioStreamSample :< cls, Object :< cls) => cls -> IO Int get_loop_end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_get_loop_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "get_loop_end" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamSample.get_loop_end {-# NOINLINE bindAudioStreamSample_get_loop_mode #-} -- | The loop mode. This information will be imported automatically from the WAV file if present. See @enum LoopMode@ constants for values. bindAudioStreamSample_get_loop_mode :: MethodBind bindAudioStreamSample_get_loop_mode = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "get_loop_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The loop mode. This information will be imported automatically from the WAV file if present. See @enum LoopMode@ constants for values. get_loop_mode :: (AudioStreamSample :< cls, Object :< cls) => cls -> IO Int get_loop_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_get_loop_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "get_loop_mode" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamSample.get_loop_mode {-# NOINLINE bindAudioStreamSample_get_mix_rate #-} -- | The sample rate for mixing this audio. bindAudioStreamSample_get_mix_rate :: MethodBind bindAudioStreamSample_get_mix_rate = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "get_mix_rate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sample rate for mixing this audio. get_mix_rate :: (AudioStreamSample :< cls, Object :< cls) => cls -> IO Int get_mix_rate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_get_mix_rate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "get_mix_rate" '[] (IO Int) where nodeMethod = Godot.Core.AudioStreamSample.get_mix_rate {-# NOINLINE bindAudioStreamSample_is_stereo #-} -- | If @true@, audio is stereo. bindAudioStreamSample_is_stereo :: MethodBind bindAudioStreamSample_is_stereo = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "is_stereo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio is stereo. is_stereo :: (AudioStreamSample :< cls, Object :< cls) => cls -> IO Bool is_stereo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_is_stereo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "is_stereo" '[] (IO Bool) where nodeMethod = Godot.Core.AudioStreamSample.is_stereo {-# NOINLINE bindAudioStreamSample_save_to_wav #-} -- | Saves the AudioStreamSample as a WAV file to @path@. Samples with IMA ADPCM format can't be saved. -- __Note:__ A @.wav@ extension is automatically appended to @path@ if it is missing. bindAudioStreamSample_save_to_wav :: MethodBind bindAudioStreamSample_save_to_wav = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "save_to_wav" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the AudioStreamSample as a WAV file to @path@. Samples with IMA ADPCM format can't be saved. -- __Note:__ A @.wav@ extension is automatically appended to @path@ if it is missing. save_to_wav :: (AudioStreamSample :< cls, Object :< cls) => cls -> GodotString -> IO Int save_to_wav cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_save_to_wav (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "save_to_wav" '[GodotString] (IO Int) where nodeMethod = Godot.Core.AudioStreamSample.save_to_wav {-# NOINLINE bindAudioStreamSample_set_data #-} -- | Contains the audio data in bytes. -- __Note:__ This property expects signed PCM8 data. To convert unsigned PCM8 to signed PCM8, subtract 128 from each byte. bindAudioStreamSample_set_data :: MethodBind bindAudioStreamSample_set_data = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Contains the audio data in bytes. -- __Note:__ This property expects signed PCM8 data. To convert unsigned PCM8 to signed PCM8, subtract 128 from each byte. set_data :: (AudioStreamSample :< cls, Object :< cls) => cls -> PoolByteArray -> IO () set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "set_data" '[PoolByteArray] (IO ()) where nodeMethod = Godot.Core.AudioStreamSample.set_data {-# NOINLINE bindAudioStreamSample_set_format #-} -- | Audio format. See @enum Format@ constants for values. bindAudioStreamSample_set_format :: MethodBind bindAudioStreamSample_set_format = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "set_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Audio format. See @enum Format@ constants for values. set_format :: (AudioStreamSample :< cls, Object :< cls) => cls -> Int -> IO () set_format cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_set_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "set_format" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamSample.set_format {-# NOINLINE bindAudioStreamSample_set_loop_begin #-} -- | The loop start point (in number of samples, relative to the beginning of the sample). This information will be imported automatically from the WAV file if present. bindAudioStreamSample_set_loop_begin :: MethodBind bindAudioStreamSample_set_loop_begin = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "set_loop_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The loop start point (in number of samples, relative to the beginning of the sample). This information will be imported automatically from the WAV file if present. set_loop_begin :: (AudioStreamSample :< cls, Object :< cls) => cls -> Int -> IO () set_loop_begin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_set_loop_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "set_loop_begin" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamSample.set_loop_begin {-# NOINLINE bindAudioStreamSample_set_loop_end #-} -- | The loop end point (in number of samples, relative to the beginning of the sample). This information will be imported automatically from the WAV file if present. bindAudioStreamSample_set_loop_end :: MethodBind bindAudioStreamSample_set_loop_end = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "set_loop_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The loop end point (in number of samples, relative to the beginning of the sample). This information will be imported automatically from the WAV file if present. set_loop_end :: (AudioStreamSample :< cls, Object :< cls) => cls -> Int -> IO () set_loop_end cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_set_loop_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "set_loop_end" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamSample.set_loop_end {-# NOINLINE bindAudioStreamSample_set_loop_mode #-} -- | The loop mode. This information will be imported automatically from the WAV file if present. See @enum LoopMode@ constants for values. bindAudioStreamSample_set_loop_mode :: MethodBind bindAudioStreamSample_set_loop_mode = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "set_loop_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The loop mode. This information will be imported automatically from the WAV file if present. See @enum LoopMode@ constants for values. set_loop_mode :: (AudioStreamSample :< cls, Object :< cls) => cls -> Int -> IO () set_loop_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_set_loop_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "set_loop_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamSample.set_loop_mode {-# NOINLINE bindAudioStreamSample_set_mix_rate #-} -- | The sample rate for mixing this audio. bindAudioStreamSample_set_mix_rate :: MethodBind bindAudioStreamSample_set_mix_rate = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "set_mix_rate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sample rate for mixing this audio. set_mix_rate :: (AudioStreamSample :< cls, Object :< cls) => cls -> Int -> IO () set_mix_rate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_set_mix_rate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "set_mix_rate" '[Int] (IO ()) where nodeMethod = Godot.Core.AudioStreamSample.set_mix_rate {-# NOINLINE bindAudioStreamSample_set_stereo #-} -- | If @true@, audio is stereo. bindAudioStreamSample_set_stereo :: MethodBind bindAudioStreamSample_set_stereo = unsafePerformIO $ withCString "AudioStreamSample" $ \ clsNamePtr -> withCString "set_stereo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, audio is stereo. set_stereo :: (AudioStreamSample :< cls, Object :< cls) => cls -> Bool -> IO () set_stereo cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindAudioStreamSample_set_stereo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod AudioStreamSample "set_stereo" '[Bool] (IO ()) where nodeMethod = Godot.Core.AudioStreamSample.set_stereo ================================================ FILE: src/Godot/Core/BackBufferCopy.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BackBufferCopy (Godot.Core.BackBufferCopy._COPY_MODE_VIEWPORT, Godot.Core.BackBufferCopy._COPY_MODE_RECT, Godot.Core.BackBufferCopy._COPY_MODE_DISABLED, Godot.Core.BackBufferCopy.get_copy_mode, Godot.Core.BackBufferCopy.get_rect, Godot.Core.BackBufferCopy.set_copy_mode, Godot.Core.BackBufferCopy.set_rect) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _COPY_MODE_VIEWPORT :: Int _COPY_MODE_VIEWPORT = 2 _COPY_MODE_RECT :: Int _COPY_MODE_RECT = 1 _COPY_MODE_DISABLED :: Int _COPY_MODE_DISABLED = 0 instance NodeProperty BackBufferCopy "copy_mode" Int 'False where nodeProperty = (get_copy_mode, wrapDroppingSetter set_copy_mode, Nothing) instance NodeProperty BackBufferCopy "rect" Rect2 'False where nodeProperty = (get_rect, wrapDroppingSetter set_rect, Nothing) {-# NOINLINE bindBackBufferCopy_get_copy_mode #-} -- | Buffer mode. See @enum CopyMode@ constants. bindBackBufferCopy_get_copy_mode :: MethodBind bindBackBufferCopy_get_copy_mode = unsafePerformIO $ withCString "BackBufferCopy" $ \ clsNamePtr -> withCString "get_copy_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Buffer mode. See @enum CopyMode@ constants. get_copy_mode :: (BackBufferCopy :< cls, Object :< cls) => cls -> IO Int get_copy_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBackBufferCopy_get_copy_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BackBufferCopy "get_copy_mode" '[] (IO Int) where nodeMethod = Godot.Core.BackBufferCopy.get_copy_mode {-# NOINLINE bindBackBufferCopy_get_rect #-} -- | The area covered by the BackBufferCopy. Only used if @copy_mode@ is @COPY_MODE_RECT@. bindBackBufferCopy_get_rect :: MethodBind bindBackBufferCopy_get_rect = unsafePerformIO $ withCString "BackBufferCopy" $ \ clsNamePtr -> withCString "get_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area covered by the BackBufferCopy. Only used if @copy_mode@ is @COPY_MODE_RECT@. get_rect :: (BackBufferCopy :< cls, Object :< cls) => cls -> IO Rect2 get_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBackBufferCopy_get_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BackBufferCopy "get_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.BackBufferCopy.get_rect {-# NOINLINE bindBackBufferCopy_set_copy_mode #-} -- | Buffer mode. See @enum CopyMode@ constants. bindBackBufferCopy_set_copy_mode :: MethodBind bindBackBufferCopy_set_copy_mode = unsafePerformIO $ withCString "BackBufferCopy" $ \ clsNamePtr -> withCString "set_copy_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Buffer mode. See @enum CopyMode@ constants. set_copy_mode :: (BackBufferCopy :< cls, Object :< cls) => cls -> Int -> IO () set_copy_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBackBufferCopy_set_copy_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BackBufferCopy "set_copy_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.BackBufferCopy.set_copy_mode {-# NOINLINE bindBackBufferCopy_set_rect #-} -- | The area covered by the BackBufferCopy. Only used if @copy_mode@ is @COPY_MODE_RECT@. bindBackBufferCopy_set_rect :: MethodBind bindBackBufferCopy_set_rect = unsafePerformIO $ withCString "BackBufferCopy" $ \ clsNamePtr -> withCString "set_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The area covered by the BackBufferCopy. Only used if @copy_mode@ is @COPY_MODE_RECT@. set_rect :: (BackBufferCopy :< cls, Object :< cls) => cls -> Rect2 -> IO () set_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBackBufferCopy_set_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BackBufferCopy "set_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.BackBufferCopy.set_rect ================================================ FILE: src/Godot/Core/BakedLightmap.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BakedLightmap (Godot.Core.BakedLightmap._BAKE_QUALITY_LOW, Godot.Core.BakedLightmap._BAKE_QUALITY_MEDIUM, Godot.Core.BakedLightmap._BAKE_ERROR_CANT_CREATE_IMAGE, Godot.Core.BakedLightmap._BAKE_ERROR_NO_MESHES, Godot.Core.BakedLightmap._BAKE_ERROR_OK, Godot.Core.BakedLightmap._BAKE_MODE_CONE_TRACE, Godot.Core.BakedLightmap._BAKE_MODE_RAY_TRACE, Godot.Core.BakedLightmap._BAKE_ERROR_NO_SAVE_PATH, Godot.Core.BakedLightmap._BAKE_ERROR_USER_ABORTED, Godot.Core.BakedLightmap._BAKE_QUALITY_HIGH, Godot.Core.BakedLightmap.bake, Godot.Core.BakedLightmap.debug_bake, Godot.Core.BakedLightmap.get_bake_cell_size, Godot.Core.BakedLightmap.get_bake_default_texels_per_unit, Godot.Core.BakedLightmap.get_bake_mode, Godot.Core.BakedLightmap.get_bake_quality, Godot.Core.BakedLightmap.get_capture_cell_size, Godot.Core.BakedLightmap.get_energy, Godot.Core.BakedLightmap.get_extents, Godot.Core.BakedLightmap.get_image_path, Godot.Core.BakedLightmap.get_light_data, Godot.Core.BakedLightmap.get_propagation, Godot.Core.BakedLightmap.is_hdr, Godot.Core.BakedLightmap.set_bake_cell_size, Godot.Core.BakedLightmap.set_bake_default_texels_per_unit, Godot.Core.BakedLightmap.set_bake_mode, Godot.Core.BakedLightmap.set_bake_quality, Godot.Core.BakedLightmap.set_capture_cell_size, Godot.Core.BakedLightmap.set_energy, Godot.Core.BakedLightmap.set_extents, Godot.Core.BakedLightmap.set_hdr, Godot.Core.BakedLightmap.set_image_path, Godot.Core.BakedLightmap.set_light_data, Godot.Core.BakedLightmap.set_propagation) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualInstance() _BAKE_QUALITY_LOW :: Int _BAKE_QUALITY_LOW = 0 _BAKE_QUALITY_MEDIUM :: Int _BAKE_QUALITY_MEDIUM = 1 _BAKE_ERROR_CANT_CREATE_IMAGE :: Int _BAKE_ERROR_CANT_CREATE_IMAGE = 3 _BAKE_ERROR_NO_MESHES :: Int _BAKE_ERROR_NO_MESHES = 2 _BAKE_ERROR_OK :: Int _BAKE_ERROR_OK = 0 _BAKE_MODE_CONE_TRACE :: Int _BAKE_MODE_CONE_TRACE = 0 _BAKE_MODE_RAY_TRACE :: Int _BAKE_MODE_RAY_TRACE = 1 _BAKE_ERROR_NO_SAVE_PATH :: Int _BAKE_ERROR_NO_SAVE_PATH = 1 _BAKE_ERROR_USER_ABORTED :: Int _BAKE_ERROR_USER_ABORTED = 4 _BAKE_QUALITY_HIGH :: Int _BAKE_QUALITY_HIGH = 2 instance NodeProperty BakedLightmap "bake_cell_size" Float 'False where nodeProperty = (get_bake_cell_size, wrapDroppingSetter set_bake_cell_size, Nothing) instance NodeProperty BakedLightmap "bake_default_texels_per_unit" Float 'False where nodeProperty = (get_bake_default_texels_per_unit, wrapDroppingSetter set_bake_default_texels_per_unit, Nothing) instance NodeProperty BakedLightmap "bake_energy" Float 'False where nodeProperty = (get_energy, wrapDroppingSetter set_energy, Nothing) instance NodeProperty BakedLightmap "bake_extents" Vector3 'False where nodeProperty = (get_extents, wrapDroppingSetter set_extents, Nothing) instance NodeProperty BakedLightmap "bake_hdr" Bool 'False where nodeProperty = (is_hdr, wrapDroppingSetter set_hdr, Nothing) instance NodeProperty BakedLightmap "bake_mode" Int 'False where nodeProperty = (get_bake_mode, wrapDroppingSetter set_bake_mode, Nothing) instance NodeProperty BakedLightmap "bake_propagation" Float 'False where nodeProperty = (get_propagation, wrapDroppingSetter set_propagation, Nothing) instance NodeProperty BakedLightmap "bake_quality" Int 'False where nodeProperty = (get_bake_quality, wrapDroppingSetter set_bake_quality, Nothing) instance NodeProperty BakedLightmap "capture_cell_size" Float 'False where nodeProperty = (get_capture_cell_size, wrapDroppingSetter set_capture_cell_size, Nothing) instance NodeProperty BakedLightmap "image_path" GodotString 'False where nodeProperty = (get_image_path, wrapDroppingSetter set_image_path, Nothing) instance NodeProperty BakedLightmap "light_data" BakedLightmapData 'False where nodeProperty = (get_light_data, wrapDroppingSetter set_light_data, Nothing) {-# NOINLINE bindBakedLightmap_bake #-} -- | Bakes the lightmaps within the currently edited scene. Returns a @enum BakeError@ to signify if the bake was successful, or if unsuccessful, how the bake failed. bindBakedLightmap_bake :: MethodBind bindBakedLightmap_bake = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "bake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bakes the lightmaps within the currently edited scene. Returns a @enum BakeError@ to signify if the bake was successful, or if unsuccessful, how the bake failed. bake :: (BakedLightmap :< cls, Object :< cls) => cls -> Maybe Node -> Maybe Bool -> IO Int bake cls arg1 arg2 = withVariantArray [maybe VariantNil toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_bake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "bake" '[Maybe Node, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.BakedLightmap.bake {-# NOINLINE bindBakedLightmap_debug_bake #-} -- | Executes a dry run bake of lightmaps within the currently edited scene. bindBakedLightmap_debug_bake :: MethodBind bindBakedLightmap_debug_bake = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "debug_bake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Executes a dry run bake of lightmaps within the currently edited scene. debug_bake :: (BakedLightmap :< cls, Object :< cls) => cls -> IO () debug_bake cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_debug_bake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "debug_bake" '[] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.debug_bake {-# NOINLINE bindBakedLightmap_get_bake_cell_size #-} -- | Grid subdivision size for lightmapper calculation. The default value will work for most cases. Increase for better lighting on small details or if your scene is very large. bindBakedLightmap_get_bake_cell_size :: MethodBind bindBakedLightmap_get_bake_cell_size = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_bake_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Grid subdivision size for lightmapper calculation. The default value will work for most cases. Increase for better lighting on small details or if your scene is very large. get_bake_cell_size :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Float get_bake_cell_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_bake_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_bake_cell_size" '[] (IO Float) where nodeMethod = Godot.Core.BakedLightmap.get_bake_cell_size {-# NOINLINE bindBakedLightmap_get_bake_default_texels_per_unit #-} -- | If a @Mesh.lightmap_size_hint@ isn't specified, the lightmap baker will dynamically set the lightmap size using this value. This value is measured in texels per world unit. The maximum lightmap texture size is 4096x4096. bindBakedLightmap_get_bake_default_texels_per_unit :: MethodBind bindBakedLightmap_get_bake_default_texels_per_unit = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_bake_default_texels_per_unit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If a @Mesh.lightmap_size_hint@ isn't specified, the lightmap baker will dynamically set the lightmap size using this value. This value is measured in texels per world unit. The maximum lightmap texture size is 4096x4096. get_bake_default_texels_per_unit :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Float get_bake_default_texels_per_unit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_bake_default_texels_per_unit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_bake_default_texels_per_unit" '[] (IO Float) where nodeMethod = Godot.Core.BakedLightmap.get_bake_default_texels_per_unit {-# NOINLINE bindBakedLightmap_get_bake_mode #-} -- | Lightmapping mode. See @enum BakeMode@. bindBakedLightmap_get_bake_mode :: MethodBind bindBakedLightmap_get_bake_mode = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_bake_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Lightmapping mode. See @enum BakeMode@. get_bake_mode :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Int get_bake_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_bake_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_bake_mode" '[] (IO Int) where nodeMethod = Godot.Core.BakedLightmap.get_bake_mode {-# NOINLINE bindBakedLightmap_get_bake_quality #-} -- | Three quality modes are available. Higher quality requires more rendering time. See @enum BakeQuality@. bindBakedLightmap_get_bake_quality :: MethodBind bindBakedLightmap_get_bake_quality = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_bake_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Three quality modes are available. Higher quality requires more rendering time. See @enum BakeQuality@. get_bake_quality :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Int get_bake_quality cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_bake_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_bake_quality" '[] (IO Int) where nodeMethod = Godot.Core.BakedLightmap.get_bake_quality {-# NOINLINE bindBakedLightmap_get_capture_cell_size #-} -- | Grid size used for real-time capture information on dynamic objects. Cannot be larger than @bake_cell_size@. bindBakedLightmap_get_capture_cell_size :: MethodBind bindBakedLightmap_get_capture_cell_size = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_capture_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Grid size used for real-time capture information on dynamic objects. Cannot be larger than @bake_cell_size@. get_capture_cell_size :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Float get_capture_cell_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_capture_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_capture_cell_size" '[] (IO Float) where nodeMethod = Godot.Core.BakedLightmap.get_capture_cell_size {-# NOINLINE bindBakedLightmap_get_energy #-} -- | Multiplies the light sources' intensity by this value. For instance, if the value is set to 2, lights will be twice as bright. If the value is set to 0.5, lights will be half as bright. bindBakedLightmap_get_energy :: MethodBind bindBakedLightmap_get_energy = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the light sources' intensity by this value. For instance, if the value is set to 2, lights will be twice as bright. If the value is set to 0.5, lights will be half as bright. get_energy :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Float get_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_energy" '[] (IO Float) where nodeMethod = Godot.Core.BakedLightmap.get_energy {-# NOINLINE bindBakedLightmap_get_extents #-} -- | The size of the affected area. bindBakedLightmap_get_extents :: MethodBind bindBakedLightmap_get_extents = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the affected area. get_extents :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Vector3 get_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_extents" '[] (IO Vector3) where nodeMethod = Godot.Core.BakedLightmap.get_extents {-# NOINLINE bindBakedLightmap_get_image_path #-} -- | The location where lightmaps will be saved. bindBakedLightmap_get_image_path :: MethodBind bindBakedLightmap_get_image_path = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_image_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The location where lightmaps will be saved. get_image_path :: (BakedLightmap :< cls, Object :< cls) => cls -> IO GodotString get_image_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_image_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_image_path" '[] (IO GodotString) where nodeMethod = Godot.Core.BakedLightmap.get_image_path {-# NOINLINE bindBakedLightmap_get_light_data #-} -- | The calculated light data. bindBakedLightmap_get_light_data :: MethodBind bindBakedLightmap_get_light_data = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_light_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The calculated light data. get_light_data :: (BakedLightmap :< cls, Object :< cls) => cls -> IO BakedLightmapData get_light_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_light_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_light_data" '[] (IO BakedLightmapData) where nodeMethod = Godot.Core.BakedLightmap.get_light_data {-# NOINLINE bindBakedLightmap_get_propagation #-} -- | Defines how far the light will travel before it is no longer effective. The higher the number, the farther the light will travel. For instance, if the value is set to 2, the light will go twice as far. If the value is set to 0.5, the light will only go half as far. bindBakedLightmap_get_propagation :: MethodBind bindBakedLightmap_get_propagation = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "get_propagation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines how far the light will travel before it is no longer effective. The higher the number, the farther the light will travel. For instance, if the value is set to 2, the light will go twice as far. If the value is set to 0.5, the light will only go half as far. get_propagation :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Float get_propagation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_get_propagation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "get_propagation" '[] (IO Float) where nodeMethod = Godot.Core.BakedLightmap.get_propagation {-# NOINLINE bindBakedLightmap_is_hdr #-} -- | If @true@, the lightmap can capture light values greater than @1.0@. Turning this off will result in a smaller file size. bindBakedLightmap_is_hdr :: MethodBind bindBakedLightmap_is_hdr = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "is_hdr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the lightmap can capture light values greater than @1.0@. Turning this off will result in a smaller file size. is_hdr :: (BakedLightmap :< cls, Object :< cls) => cls -> IO Bool is_hdr cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_is_hdr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "is_hdr" '[] (IO Bool) where nodeMethod = Godot.Core.BakedLightmap.is_hdr {-# NOINLINE bindBakedLightmap_set_bake_cell_size #-} -- | Grid subdivision size for lightmapper calculation. The default value will work for most cases. Increase for better lighting on small details or if your scene is very large. bindBakedLightmap_set_bake_cell_size :: MethodBind bindBakedLightmap_set_bake_cell_size = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_bake_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Grid subdivision size for lightmapper calculation. The default value will work for most cases. Increase for better lighting on small details or if your scene is very large. set_bake_cell_size :: (BakedLightmap :< cls, Object :< cls) => cls -> Float -> IO () set_bake_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_bake_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_bake_cell_size" '[Float] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_bake_cell_size {-# NOINLINE bindBakedLightmap_set_bake_default_texels_per_unit #-} -- | If a @Mesh.lightmap_size_hint@ isn't specified, the lightmap baker will dynamically set the lightmap size using this value. This value is measured in texels per world unit. The maximum lightmap texture size is 4096x4096. bindBakedLightmap_set_bake_default_texels_per_unit :: MethodBind bindBakedLightmap_set_bake_default_texels_per_unit = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_bake_default_texels_per_unit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If a @Mesh.lightmap_size_hint@ isn't specified, the lightmap baker will dynamically set the lightmap size using this value. This value is measured in texels per world unit. The maximum lightmap texture size is 4096x4096. set_bake_default_texels_per_unit :: (BakedLightmap :< cls, Object :< cls) => cls -> Float -> IO () set_bake_default_texels_per_unit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_bake_default_texels_per_unit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_bake_default_texels_per_unit" '[Float] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_bake_default_texels_per_unit {-# NOINLINE bindBakedLightmap_set_bake_mode #-} -- | Lightmapping mode. See @enum BakeMode@. bindBakedLightmap_set_bake_mode :: MethodBind bindBakedLightmap_set_bake_mode = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_bake_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Lightmapping mode. See @enum BakeMode@. set_bake_mode :: (BakedLightmap :< cls, Object :< cls) => cls -> Int -> IO () set_bake_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_bake_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_bake_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_bake_mode {-# NOINLINE bindBakedLightmap_set_bake_quality #-} -- | Three quality modes are available. Higher quality requires more rendering time. See @enum BakeQuality@. bindBakedLightmap_set_bake_quality :: MethodBind bindBakedLightmap_set_bake_quality = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_bake_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Three quality modes are available. Higher quality requires more rendering time. See @enum BakeQuality@. set_bake_quality :: (BakedLightmap :< cls, Object :< cls) => cls -> Int -> IO () set_bake_quality cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_bake_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_bake_quality" '[Int] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_bake_quality {-# NOINLINE bindBakedLightmap_set_capture_cell_size #-} -- | Grid size used for real-time capture information on dynamic objects. Cannot be larger than @bake_cell_size@. bindBakedLightmap_set_capture_cell_size :: MethodBind bindBakedLightmap_set_capture_cell_size = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_capture_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Grid size used for real-time capture information on dynamic objects. Cannot be larger than @bake_cell_size@. set_capture_cell_size :: (BakedLightmap :< cls, Object :< cls) => cls -> Float -> IO () set_capture_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_capture_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_capture_cell_size" '[Float] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_capture_cell_size {-# NOINLINE bindBakedLightmap_set_energy #-} -- | Multiplies the light sources' intensity by this value. For instance, if the value is set to 2, lights will be twice as bright. If the value is set to 0.5, lights will be half as bright. bindBakedLightmap_set_energy :: MethodBind bindBakedLightmap_set_energy = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the light sources' intensity by this value. For instance, if the value is set to 2, lights will be twice as bright. If the value is set to 0.5, lights will be half as bright. set_energy :: (BakedLightmap :< cls, Object :< cls) => cls -> Float -> IO () set_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_energy {-# NOINLINE bindBakedLightmap_set_extents #-} -- | The size of the affected area. bindBakedLightmap_set_extents :: MethodBind bindBakedLightmap_set_extents = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the affected area. set_extents :: (BakedLightmap :< cls, Object :< cls) => cls -> Vector3 -> IO () set_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_extents" '[Vector3] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_extents {-# NOINLINE bindBakedLightmap_set_hdr #-} -- | If @true@, the lightmap can capture light values greater than @1.0@. Turning this off will result in a smaller file size. bindBakedLightmap_set_hdr :: MethodBind bindBakedLightmap_set_hdr = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_hdr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the lightmap can capture light values greater than @1.0@. Turning this off will result in a smaller file size. set_hdr :: (BakedLightmap :< cls, Object :< cls) => cls -> Bool -> IO () set_hdr cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_hdr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_hdr" '[Bool] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_hdr {-# NOINLINE bindBakedLightmap_set_image_path #-} -- | The location where lightmaps will be saved. bindBakedLightmap_set_image_path :: MethodBind bindBakedLightmap_set_image_path = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_image_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The location where lightmaps will be saved. set_image_path :: (BakedLightmap :< cls, Object :< cls) => cls -> GodotString -> IO () set_image_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_image_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_image_path" '[GodotString] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_image_path {-# NOINLINE bindBakedLightmap_set_light_data #-} -- | The calculated light data. bindBakedLightmap_set_light_data :: MethodBind bindBakedLightmap_set_light_data = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_light_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The calculated light data. set_light_data :: (BakedLightmap :< cls, Object :< cls) => cls -> BakedLightmapData -> IO () set_light_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_light_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_light_data" '[BakedLightmapData] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_light_data {-# NOINLINE bindBakedLightmap_set_propagation #-} -- | Defines how far the light will travel before it is no longer effective. The higher the number, the farther the light will travel. For instance, if the value is set to 2, the light will go twice as far. If the value is set to 0.5, the light will only go half as far. bindBakedLightmap_set_propagation :: MethodBind bindBakedLightmap_set_propagation = unsafePerformIO $ withCString "BakedLightmap" $ \ clsNamePtr -> withCString "set_propagation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines how far the light will travel before it is no longer effective. The higher the number, the farther the light will travel. For instance, if the value is set to 2, the light will go twice as far. If the value is set to 0.5, the light will only go half as far. set_propagation :: (BakedLightmap :< cls, Object :< cls) => cls -> Float -> IO () set_propagation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmap_set_propagation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmap "set_propagation" '[Float] (IO ()) where nodeMethod = Godot.Core.BakedLightmap.set_propagation ================================================ FILE: src/Godot/Core/BakedLightmapData.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BakedLightmapData (Godot.Core.BakedLightmapData._get_user_data, Godot.Core.BakedLightmapData._set_user_data, Godot.Core.BakedLightmapData.add_user, Godot.Core.BakedLightmapData.clear_users, Godot.Core.BakedLightmapData.get_bounds, Godot.Core.BakedLightmapData.get_cell_space_transform, Godot.Core.BakedLightmapData.get_cell_subdiv, Godot.Core.BakedLightmapData.get_energy, Godot.Core.BakedLightmapData.get_octree, Godot.Core.BakedLightmapData.get_user_count, Godot.Core.BakedLightmapData.get_user_lightmap, Godot.Core.BakedLightmapData.get_user_path, Godot.Core.BakedLightmapData.set_bounds, Godot.Core.BakedLightmapData.set_cell_space_transform, Godot.Core.BakedLightmapData.set_cell_subdiv, Godot.Core.BakedLightmapData.set_energy, Godot.Core.BakedLightmapData.set_octree) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty BakedLightmapData "bounds" Aabb 'False where nodeProperty = (get_bounds, wrapDroppingSetter set_bounds, Nothing) instance NodeProperty BakedLightmapData "cell_space_transform" Transform 'False where nodeProperty = (get_cell_space_transform, wrapDroppingSetter set_cell_space_transform, Nothing) instance NodeProperty BakedLightmapData "cell_subdiv" Int 'False where nodeProperty = (get_cell_subdiv, wrapDroppingSetter set_cell_subdiv, Nothing) instance NodeProperty BakedLightmapData "energy" Float 'False where nodeProperty = (get_energy, wrapDroppingSetter set_energy, Nothing) instance NodeProperty BakedLightmapData "octree" PoolByteArray 'False where nodeProperty = (get_octree, wrapDroppingSetter set_octree, Nothing) instance NodeProperty BakedLightmapData "user_data" Array 'False where nodeProperty = (_get_user_data, wrapDroppingSetter _set_user_data, Nothing) {-# NOINLINE bindBakedLightmapData__get_user_data #-} bindBakedLightmapData__get_user_data :: MethodBind bindBakedLightmapData__get_user_data = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "_get_user_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_user_data :: (BakedLightmapData :< cls, Object :< cls) => cls -> IO Array _get_user_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData__get_user_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "_get_user_data" '[] (IO Array) where nodeMethod = Godot.Core.BakedLightmapData._get_user_data {-# NOINLINE bindBakedLightmapData__set_user_data #-} bindBakedLightmapData__set_user_data :: MethodBind bindBakedLightmapData__set_user_data = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "_set_user_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_user_data :: (BakedLightmapData :< cls, Object :< cls) => cls -> Array -> IO () _set_user_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData__set_user_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "_set_user_data" '[Array] (IO ()) where nodeMethod = Godot.Core.BakedLightmapData._set_user_data {-# NOINLINE bindBakedLightmapData_add_user #-} bindBakedLightmapData_add_user :: MethodBind bindBakedLightmapData_add_user = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "add_user" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_user :: (BakedLightmapData :< cls, Object :< cls) => cls -> NodePath -> Texture -> Int -> IO () add_user cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_add_user (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "add_user" '[NodePath, Texture, Int] (IO ()) where nodeMethod = Godot.Core.BakedLightmapData.add_user {-# NOINLINE bindBakedLightmapData_clear_users #-} bindBakedLightmapData_clear_users :: MethodBind bindBakedLightmapData_clear_users = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "clear_users" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear_users :: (BakedLightmapData :< cls, Object :< cls) => cls -> IO () clear_users cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_clear_users (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "clear_users" '[] (IO ()) where nodeMethod = Godot.Core.BakedLightmapData.clear_users {-# NOINLINE bindBakedLightmapData_get_bounds #-} bindBakedLightmapData_get_bounds :: MethodBind bindBakedLightmapData_get_bounds = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "get_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bounds :: (BakedLightmapData :< cls, Object :< cls) => cls -> IO Aabb get_bounds cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_get_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "get_bounds" '[] (IO Aabb) where nodeMethod = Godot.Core.BakedLightmapData.get_bounds {-# NOINLINE bindBakedLightmapData_get_cell_space_transform #-} bindBakedLightmapData_get_cell_space_transform :: MethodBind bindBakedLightmapData_get_cell_space_transform = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "get_cell_space_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_space_transform :: (BakedLightmapData :< cls, Object :< cls) => cls -> IO Transform get_cell_space_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_get_cell_space_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "get_cell_space_transform" '[] (IO Transform) where nodeMethod = Godot.Core.BakedLightmapData.get_cell_space_transform {-# NOINLINE bindBakedLightmapData_get_cell_subdiv #-} bindBakedLightmapData_get_cell_subdiv :: MethodBind bindBakedLightmapData_get_cell_subdiv = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "get_cell_subdiv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_subdiv :: (BakedLightmapData :< cls, Object :< cls) => cls -> IO Int get_cell_subdiv cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_get_cell_subdiv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "get_cell_subdiv" '[] (IO Int) where nodeMethod = Godot.Core.BakedLightmapData.get_cell_subdiv {-# NOINLINE bindBakedLightmapData_get_energy #-} bindBakedLightmapData_get_energy :: MethodBind bindBakedLightmapData_get_energy = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "get_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_energy :: (BakedLightmapData :< cls, Object :< cls) => cls -> IO Float get_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_get_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "get_energy" '[] (IO Float) where nodeMethod = Godot.Core.BakedLightmapData.get_energy {-# NOINLINE bindBakedLightmapData_get_octree #-} bindBakedLightmapData_get_octree :: MethodBind bindBakedLightmapData_get_octree = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "get_octree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_octree :: (BakedLightmapData :< cls, Object :< cls) => cls -> IO PoolByteArray get_octree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_get_octree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "get_octree" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.BakedLightmapData.get_octree {-# NOINLINE bindBakedLightmapData_get_user_count #-} bindBakedLightmapData_get_user_count :: MethodBind bindBakedLightmapData_get_user_count = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "get_user_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_user_count :: (BakedLightmapData :< cls, Object :< cls) => cls -> IO Int get_user_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_get_user_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "get_user_count" '[] (IO Int) where nodeMethod = Godot.Core.BakedLightmapData.get_user_count {-# NOINLINE bindBakedLightmapData_get_user_lightmap #-} bindBakedLightmapData_get_user_lightmap :: MethodBind bindBakedLightmapData_get_user_lightmap = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "get_user_lightmap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_user_lightmap :: (BakedLightmapData :< cls, Object :< cls) => cls -> Int -> IO Texture get_user_lightmap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_get_user_lightmap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "get_user_lightmap" '[Int] (IO Texture) where nodeMethod = Godot.Core.BakedLightmapData.get_user_lightmap {-# NOINLINE bindBakedLightmapData_get_user_path #-} bindBakedLightmapData_get_user_path :: MethodBind bindBakedLightmapData_get_user_path = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "get_user_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_user_path :: (BakedLightmapData :< cls, Object :< cls) => cls -> Int -> IO NodePath get_user_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_get_user_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "get_user_path" '[Int] (IO NodePath) where nodeMethod = Godot.Core.BakedLightmapData.get_user_path {-# NOINLINE bindBakedLightmapData_set_bounds #-} bindBakedLightmapData_set_bounds :: MethodBind bindBakedLightmapData_set_bounds = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "set_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bounds :: (BakedLightmapData :< cls, Object :< cls) => cls -> Aabb -> IO () set_bounds cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_set_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "set_bounds" '[Aabb] (IO ()) where nodeMethod = Godot.Core.BakedLightmapData.set_bounds {-# NOINLINE bindBakedLightmapData_set_cell_space_transform #-} bindBakedLightmapData_set_cell_space_transform :: MethodBind bindBakedLightmapData_set_cell_space_transform = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "set_cell_space_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_space_transform :: (BakedLightmapData :< cls, Object :< cls) => cls -> Transform -> IO () set_cell_space_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_set_cell_space_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "set_cell_space_transform" '[Transform] (IO ()) where nodeMethod = Godot.Core.BakedLightmapData.set_cell_space_transform {-# NOINLINE bindBakedLightmapData_set_cell_subdiv #-} bindBakedLightmapData_set_cell_subdiv :: MethodBind bindBakedLightmapData_set_cell_subdiv = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "set_cell_subdiv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_subdiv :: (BakedLightmapData :< cls, Object :< cls) => cls -> Int -> IO () set_cell_subdiv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_set_cell_subdiv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "set_cell_subdiv" '[Int] (IO ()) where nodeMethod = Godot.Core.BakedLightmapData.set_cell_subdiv {-# NOINLINE bindBakedLightmapData_set_energy #-} bindBakedLightmapData_set_energy :: MethodBind bindBakedLightmapData_set_energy = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "set_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_energy :: (BakedLightmapData :< cls, Object :< cls) => cls -> Float -> IO () set_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_set_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "set_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.BakedLightmapData.set_energy {-# NOINLINE bindBakedLightmapData_set_octree #-} bindBakedLightmapData_set_octree :: MethodBind bindBakedLightmapData_set_octree = unsafePerformIO $ withCString "BakedLightmapData" $ \ clsNamePtr -> withCString "set_octree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_octree :: (BakedLightmapData :< cls, Object :< cls) => cls -> PoolByteArray -> IO () set_octree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBakedLightmapData_set_octree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BakedLightmapData "set_octree" '[PoolByteArray] (IO ()) where nodeMethod = Godot.Core.BakedLightmapData.set_octree ================================================ FILE: src/Godot/Core/BaseButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BaseButton (Godot.Core.BaseButton._DRAW_NORMAL, Godot.Core.BaseButton._DRAW_DISABLED, Godot.Core.BaseButton._ACTION_MODE_BUTTON_RELEASE, Godot.Core.BaseButton._DRAW_HOVER_PRESSED, Godot.Core.BaseButton._ACTION_MODE_BUTTON_PRESS, Godot.Core.BaseButton._DRAW_PRESSED, Godot.Core.BaseButton._DRAW_HOVER, Godot.Core.BaseButton.sig_button_down, Godot.Core.BaseButton.sig_button_up, Godot.Core.BaseButton.sig_pressed, Godot.Core.BaseButton.sig_toggled, Godot.Core.BaseButton._gui_input, Godot.Core.BaseButton._pressed, Godot.Core.BaseButton._toggled, Godot.Core.BaseButton._unhandled_input, Godot.Core.BaseButton.get_action_mode, Godot.Core.BaseButton.get_button_group, Godot.Core.BaseButton.get_button_mask, Godot.Core.BaseButton.get_draw_mode, Godot.Core.BaseButton.get_enabled_focus_mode, Godot.Core.BaseButton.get_shortcut, Godot.Core.BaseButton.is_disabled, Godot.Core.BaseButton.is_hovered, Godot.Core.BaseButton.is_keep_pressed_outside, Godot.Core.BaseButton.is_pressed, Godot.Core.BaseButton.is_shortcut_in_tooltip_enabled, Godot.Core.BaseButton.is_toggle_mode, Godot.Core.BaseButton.set_action_mode, Godot.Core.BaseButton.set_button_group, Godot.Core.BaseButton.set_button_mask, Godot.Core.BaseButton.set_disabled, Godot.Core.BaseButton.set_enabled_focus_mode, Godot.Core.BaseButton.set_keep_pressed_outside, Godot.Core.BaseButton.set_pressed, Godot.Core.BaseButton.set_shortcut, Godot.Core.BaseButton.set_shortcut_in_tooltip, Godot.Core.BaseButton.set_toggle_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _DRAW_NORMAL :: Int _DRAW_NORMAL = 0 _DRAW_DISABLED :: Int _DRAW_DISABLED = 3 _ACTION_MODE_BUTTON_RELEASE :: Int _ACTION_MODE_BUTTON_RELEASE = 1 _DRAW_HOVER_PRESSED :: Int _DRAW_HOVER_PRESSED = 4 _ACTION_MODE_BUTTON_PRESS :: Int _ACTION_MODE_BUTTON_PRESS = 0 _DRAW_PRESSED :: Int _DRAW_PRESSED = 1 _DRAW_HOVER :: Int _DRAW_HOVER = 2 -- | Emitted when the button starts being held down. sig_button_down :: Godot.Internal.Dispatch.Signal BaseButton sig_button_down = Godot.Internal.Dispatch.Signal "button_down" instance NodeSignal BaseButton "button_down" '[] -- | Emitted when the button stops being held down. sig_button_up :: Godot.Internal.Dispatch.Signal BaseButton sig_button_up = Godot.Internal.Dispatch.Signal "button_up" instance NodeSignal BaseButton "button_up" '[] -- | Emitted when the button is toggled or pressed. This is on @signal button_down@ if @action_mode@ is @ACTION_MODE_BUTTON_PRESS@ and on @signal button_up@ otherwise. -- If you need to know the button's pressed state (and @toggle_mode@ is active), use @signal toggled@ instead. sig_pressed :: Godot.Internal.Dispatch.Signal BaseButton sig_pressed = Godot.Internal.Dispatch.Signal "pressed" instance NodeSignal BaseButton "pressed" '[] -- | Emitted when the button was just toggled between pressed and normal states (only if @toggle_mode@ is active). The new state is contained in the @button_pressed@ argument. sig_toggled :: Godot.Internal.Dispatch.Signal BaseButton sig_toggled = Godot.Internal.Dispatch.Signal "toggled" instance NodeSignal BaseButton "toggled" '[Bool] instance NodeProperty BaseButton "action_mode" Int 'False where nodeProperty = (get_action_mode, wrapDroppingSetter set_action_mode, Nothing) instance NodeProperty BaseButton "button_mask" Int 'False where nodeProperty = (get_button_mask, wrapDroppingSetter set_button_mask, Nothing) instance NodeProperty BaseButton "disabled" Bool 'False where nodeProperty = (is_disabled, wrapDroppingSetter set_disabled, Nothing) instance NodeProperty BaseButton "enabled_focus_mode" Int 'False where nodeProperty = (get_enabled_focus_mode, wrapDroppingSetter set_enabled_focus_mode, Nothing) instance NodeProperty BaseButton "group" ButtonGroup 'False where nodeProperty = (get_button_group, wrapDroppingSetter set_button_group, Nothing) instance NodeProperty BaseButton "keep_pressed_outside" Bool 'False where nodeProperty = (is_keep_pressed_outside, wrapDroppingSetter set_keep_pressed_outside, Nothing) instance NodeProperty BaseButton "pressed" Bool 'False where nodeProperty = (is_pressed, wrapDroppingSetter set_pressed, Nothing) instance NodeProperty BaseButton "shortcut" ShortCut 'False where nodeProperty = (get_shortcut, wrapDroppingSetter set_shortcut, Nothing) instance NodeProperty BaseButton "shortcut_in_tooltip" Bool 'False where nodeProperty = (is_shortcut_in_tooltip_enabled, wrapDroppingSetter set_shortcut_in_tooltip, Nothing) instance NodeProperty BaseButton "toggle_mode" Bool 'False where nodeProperty = (is_toggle_mode, wrapDroppingSetter set_toggle_mode, Nothing) {-# NOINLINE bindBaseButton__gui_input #-} bindBaseButton__gui_input :: MethodBind bindBaseButton__gui_input = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (BaseButton :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.BaseButton._gui_input {-# NOINLINE bindBaseButton__pressed #-} -- | Called when the button is pressed. If you need to know the button's pressed state (and @toggle_mode@ is active), use @method _toggled@ instead. bindBaseButton__pressed :: MethodBind bindBaseButton__pressed = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when the button is pressed. If you need to know the button's pressed state (and @toggle_mode@ is active), use @method _toggled@ instead. _pressed :: (BaseButton :< cls, Object :< cls) => cls -> IO () _pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton__pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "_pressed" '[] (IO ()) where nodeMethod = Godot.Core.BaseButton._pressed {-# NOINLINE bindBaseButton__toggled #-} -- | Called when the button is toggled (only if @toggle_mode@ is active). bindBaseButton__toggled :: MethodBind bindBaseButton__toggled = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "_toggled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when the button is toggled (only if @toggle_mode@ is active). _toggled :: (BaseButton :< cls, Object :< cls) => cls -> Bool -> IO () _toggled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton__toggled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "_toggled" '[Bool] (IO ()) where nodeMethod = Godot.Core.BaseButton._toggled {-# NOINLINE bindBaseButton__unhandled_input #-} bindBaseButton__unhandled_input :: MethodBind bindBaseButton__unhandled_input = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _unhandled_input :: (BaseButton :< cls, Object :< cls) => cls -> InputEvent -> IO () _unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton__unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "_unhandled_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.BaseButton._unhandled_input {-# NOINLINE bindBaseButton_get_action_mode #-} -- | Determines when the button is considered clicked, one of the @enum ActionMode@ constants. bindBaseButton_get_action_mode :: MethodBind bindBaseButton_get_action_mode = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "get_action_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines when the button is considered clicked, one of the @enum ActionMode@ constants. get_action_mode :: (BaseButton :< cls, Object :< cls) => cls -> IO Int get_action_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_get_action_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "get_action_mode" '[] (IO Int) where nodeMethod = Godot.Core.BaseButton.get_action_mode {-# NOINLINE bindBaseButton_get_button_group #-} -- | @ButtonGroup@ associated to the button. bindBaseButton_get_button_group :: MethodBind bindBaseButton_get_button_group = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "get_button_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @ButtonGroup@ associated to the button. get_button_group :: (BaseButton :< cls, Object :< cls) => cls -> IO ButtonGroup get_button_group cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_get_button_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "get_button_group" '[] (IO ButtonGroup) where nodeMethod = Godot.Core.BaseButton.get_button_group {-# NOINLINE bindBaseButton_get_button_mask #-} -- | Binary mask to choose which mouse buttons this button will respond to. -- To allow both left-click and right-click, use @BUTTON_MASK_LEFT | BUTTON_MASK_RIGHT@. bindBaseButton_get_button_mask :: MethodBind bindBaseButton_get_button_mask = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "get_button_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Binary mask to choose which mouse buttons this button will respond to. -- To allow both left-click and right-click, use @BUTTON_MASK_LEFT | BUTTON_MASK_RIGHT@. get_button_mask :: (BaseButton :< cls, Object :< cls) => cls -> IO Int get_button_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_get_button_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "get_button_mask" '[] (IO Int) where nodeMethod = Godot.Core.BaseButton.get_button_mask {-# NOINLINE bindBaseButton_get_draw_mode #-} -- | Returns the visual state used to draw the button. This is useful mainly when implementing your own draw code by either overriding _draw() or connecting to "draw" signal. The visual state of the button is defined by the @enum DrawMode@ enum. bindBaseButton_get_draw_mode :: MethodBind bindBaseButton_get_draw_mode = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "get_draw_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the visual state used to draw the button. This is useful mainly when implementing your own draw code by either overriding _draw() or connecting to "draw" signal. The visual state of the button is defined by the @enum DrawMode@ enum. get_draw_mode :: (BaseButton :< cls, Object :< cls) => cls -> IO Int get_draw_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_get_draw_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "get_draw_mode" '[] (IO Int) where nodeMethod = Godot.Core.BaseButton.get_draw_mode {-# NOINLINE bindBaseButton_get_enabled_focus_mode #-} -- | Focus access mode to use when switching between enabled/disabled (see @Control.focus_mode@ and @disabled@). bindBaseButton_get_enabled_focus_mode :: MethodBind bindBaseButton_get_enabled_focus_mode = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "get_enabled_focus_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Focus access mode to use when switching between enabled/disabled (see @Control.focus_mode@ and @disabled@). get_enabled_focus_mode :: (BaseButton :< cls, Object :< cls) => cls -> IO Int get_enabled_focus_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_get_enabled_focus_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "get_enabled_focus_mode" '[] (IO Int) where nodeMethod = Godot.Core.BaseButton.get_enabled_focus_mode {-# NOINLINE bindBaseButton_get_shortcut #-} -- | @ShortCut@ associated to the button. bindBaseButton_get_shortcut :: MethodBind bindBaseButton_get_shortcut = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "get_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @ShortCut@ associated to the button. get_shortcut :: (BaseButton :< cls, Object :< cls) => cls -> IO ShortCut get_shortcut cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_get_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "get_shortcut" '[] (IO ShortCut) where nodeMethod = Godot.Core.BaseButton.get_shortcut {-# NOINLINE bindBaseButton_is_disabled #-} -- | If @true@, the button is in disabled state and can't be clicked or toggled. bindBaseButton_is_disabled :: MethodBind bindBaseButton_is_disabled = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "is_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button is in disabled state and can't be clicked or toggled. is_disabled :: (BaseButton :< cls, Object :< cls) => cls -> IO Bool is_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_is_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "is_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.BaseButton.is_disabled {-# NOINLINE bindBaseButton_is_hovered #-} -- | Returns @true@ if the mouse has entered the button and has not left it yet. bindBaseButton_is_hovered :: MethodBind bindBaseButton_is_hovered = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "is_hovered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the mouse has entered the button and has not left it yet. is_hovered :: (BaseButton :< cls, Object :< cls) => cls -> IO Bool is_hovered cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_is_hovered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "is_hovered" '[] (IO Bool) where nodeMethod = Godot.Core.BaseButton.is_hovered {-# NOINLINE bindBaseButton_is_keep_pressed_outside #-} -- | If @true@, the button stays pressed when moving the cursor outside the button while pressing it. -- __Note:__ This property only affects the button's visual appearance. Signals will be emitted at the same moment regardless of this property's value. bindBaseButton_is_keep_pressed_outside :: MethodBind bindBaseButton_is_keep_pressed_outside = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "is_keep_pressed_outside" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button stays pressed when moving the cursor outside the button while pressing it. -- __Note:__ This property only affects the button's visual appearance. Signals will be emitted at the same moment regardless of this property's value. is_keep_pressed_outside :: (BaseButton :< cls, Object :< cls) => cls -> IO Bool is_keep_pressed_outside cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_is_keep_pressed_outside (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "is_keep_pressed_outside" '[] (IO Bool) where nodeMethod = Godot.Core.BaseButton.is_keep_pressed_outside {-# NOINLINE bindBaseButton_is_pressed #-} -- | If @true@, the button's state is pressed. Means the button is pressed down or toggled (if @toggle_mode@ is active). bindBaseButton_is_pressed :: MethodBind bindBaseButton_is_pressed = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "is_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button's state is pressed. Means the button is pressed down or toggled (if @toggle_mode@ is active). is_pressed :: (BaseButton :< cls, Object :< cls) => cls -> IO Bool is_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_is_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "is_pressed" '[] (IO Bool) where nodeMethod = Godot.Core.BaseButton.is_pressed {-# NOINLINE bindBaseButton_is_shortcut_in_tooltip_enabled #-} -- | If @true@, the button will add information about its shortcut in the tooltip. bindBaseButton_is_shortcut_in_tooltip_enabled :: MethodBind bindBaseButton_is_shortcut_in_tooltip_enabled = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "is_shortcut_in_tooltip_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button will add information about its shortcut in the tooltip. is_shortcut_in_tooltip_enabled :: (BaseButton :< cls, Object :< cls) => cls -> IO Bool is_shortcut_in_tooltip_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_is_shortcut_in_tooltip_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "is_shortcut_in_tooltip_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.BaseButton.is_shortcut_in_tooltip_enabled {-# NOINLINE bindBaseButton_is_toggle_mode #-} -- | If @true@, the button is in toggle mode. Makes the button flip state between pressed and unpressed each time its area is clicked. bindBaseButton_is_toggle_mode :: MethodBind bindBaseButton_is_toggle_mode = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "is_toggle_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button is in toggle mode. Makes the button flip state between pressed and unpressed each time its area is clicked. is_toggle_mode :: (BaseButton :< cls, Object :< cls) => cls -> IO Bool is_toggle_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_is_toggle_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "is_toggle_mode" '[] (IO Bool) where nodeMethod = Godot.Core.BaseButton.is_toggle_mode {-# NOINLINE bindBaseButton_set_action_mode #-} -- | Determines when the button is considered clicked, one of the @enum ActionMode@ constants. bindBaseButton_set_action_mode :: MethodBind bindBaseButton_set_action_mode = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_action_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines when the button is considered clicked, one of the @enum ActionMode@ constants. set_action_mode :: (BaseButton :< cls, Object :< cls) => cls -> Int -> IO () set_action_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_action_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_action_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_action_mode {-# NOINLINE bindBaseButton_set_button_group #-} -- | @ButtonGroup@ associated to the button. bindBaseButton_set_button_group :: MethodBind bindBaseButton_set_button_group = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_button_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @ButtonGroup@ associated to the button. set_button_group :: (BaseButton :< cls, Object :< cls) => cls -> ButtonGroup -> IO () set_button_group cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_button_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_button_group" '[ButtonGroup] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_button_group {-# NOINLINE bindBaseButton_set_button_mask #-} -- | Binary mask to choose which mouse buttons this button will respond to. -- To allow both left-click and right-click, use @BUTTON_MASK_LEFT | BUTTON_MASK_RIGHT@. bindBaseButton_set_button_mask :: MethodBind bindBaseButton_set_button_mask = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_button_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Binary mask to choose which mouse buttons this button will respond to. -- To allow both left-click and right-click, use @BUTTON_MASK_LEFT | BUTTON_MASK_RIGHT@. set_button_mask :: (BaseButton :< cls, Object :< cls) => cls -> Int -> IO () set_button_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_button_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_button_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_button_mask {-# NOINLINE bindBaseButton_set_disabled #-} -- | If @true@, the button is in disabled state and can't be clicked or toggled. bindBaseButton_set_disabled :: MethodBind bindBaseButton_set_disabled = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button is in disabled state and can't be clicked or toggled. set_disabled :: (BaseButton :< cls, Object :< cls) => cls -> Bool -> IO () set_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_disabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_disabled {-# NOINLINE bindBaseButton_set_enabled_focus_mode #-} -- | Focus access mode to use when switching between enabled/disabled (see @Control.focus_mode@ and @disabled@). bindBaseButton_set_enabled_focus_mode :: MethodBind bindBaseButton_set_enabled_focus_mode = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_enabled_focus_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Focus access mode to use when switching between enabled/disabled (see @Control.focus_mode@ and @disabled@). set_enabled_focus_mode :: (BaseButton :< cls, Object :< cls) => cls -> Int -> IO () set_enabled_focus_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_enabled_focus_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_enabled_focus_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_enabled_focus_mode {-# NOINLINE bindBaseButton_set_keep_pressed_outside #-} -- | If @true@, the button stays pressed when moving the cursor outside the button while pressing it. -- __Note:__ This property only affects the button's visual appearance. Signals will be emitted at the same moment regardless of this property's value. bindBaseButton_set_keep_pressed_outside :: MethodBind bindBaseButton_set_keep_pressed_outside = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_keep_pressed_outside" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button stays pressed when moving the cursor outside the button while pressing it. -- __Note:__ This property only affects the button's visual appearance. Signals will be emitted at the same moment regardless of this property's value. set_keep_pressed_outside :: (BaseButton :< cls, Object :< cls) => cls -> Bool -> IO () set_keep_pressed_outside cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_keep_pressed_outside (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_keep_pressed_outside" '[Bool] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_keep_pressed_outside {-# NOINLINE bindBaseButton_set_pressed #-} -- | If @true@, the button's state is pressed. Means the button is pressed down or toggled (if @toggle_mode@ is active). bindBaseButton_set_pressed :: MethodBind bindBaseButton_set_pressed = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button's state is pressed. Means the button is pressed down or toggled (if @toggle_mode@ is active). set_pressed :: (BaseButton :< cls, Object :< cls) => cls -> Bool -> IO () set_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_pressed" '[Bool] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_pressed {-# NOINLINE bindBaseButton_set_shortcut #-} -- | @ShortCut@ associated to the button. bindBaseButton_set_shortcut :: MethodBind bindBaseButton_set_shortcut = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @ShortCut@ associated to the button. set_shortcut :: (BaseButton :< cls, Object :< cls) => cls -> ShortCut -> IO () set_shortcut cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_shortcut" '[ShortCut] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_shortcut {-# NOINLINE bindBaseButton_set_shortcut_in_tooltip #-} -- | If @true@, the button will add information about its shortcut in the tooltip. bindBaseButton_set_shortcut_in_tooltip :: MethodBind bindBaseButton_set_shortcut_in_tooltip = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_shortcut_in_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button will add information about its shortcut in the tooltip. set_shortcut_in_tooltip :: (BaseButton :< cls, Object :< cls) => cls -> Bool -> IO () set_shortcut_in_tooltip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_shortcut_in_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_shortcut_in_tooltip" '[Bool] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_shortcut_in_tooltip {-# NOINLINE bindBaseButton_set_toggle_mode #-} -- | If @true@, the button is in toggle mode. Makes the button flip state between pressed and unpressed each time its area is clicked. bindBaseButton_set_toggle_mode :: MethodBind bindBaseButton_set_toggle_mode = unsafePerformIO $ withCString "BaseButton" $ \ clsNamePtr -> withCString "set_toggle_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button is in toggle mode. Makes the button flip state between pressed and unpressed each time its area is clicked. set_toggle_mode :: (BaseButton :< cls, Object :< cls) => cls -> Bool -> IO () set_toggle_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBaseButton_set_toggle_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BaseButton "set_toggle_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.BaseButton.set_toggle_mode ================================================ FILE: src/Godot/Core/BitMap.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BitMap (Godot.Core.BitMap._get_data, Godot.Core.BitMap._set_data, Godot.Core.BitMap.create, Godot.Core.BitMap.create_from_image_alpha, Godot.Core.BitMap.get_bit, Godot.Core.BitMap.get_size, Godot.Core.BitMap.get_true_bit_count, Godot.Core.BitMap.grow_mask, Godot.Core.BitMap.opaque_to_polygons, Godot.Core.BitMap.set_bit, Godot.Core.BitMap.set_bit_rect) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty BitMap "data" Dictionary 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) {-# NOINLINE bindBitMap__get_data #-} bindBitMap__get_data :: MethodBind bindBitMap__get_data = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_data :: (BitMap :< cls, Object :< cls) => cls -> IO Dictionary _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "_get_data" '[] (IO Dictionary) where nodeMethod = Godot.Core.BitMap._get_data {-# NOINLINE bindBitMap__set_data #-} bindBitMap__set_data :: MethodBind bindBitMap__set_data = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_data :: (BitMap :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "_set_data" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.BitMap._set_data {-# NOINLINE bindBitMap_create #-} -- | Creates a bitmap with the specified size, filled with @false@. bindBitMap_create :: MethodBind bindBitMap_create = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a bitmap with the specified size, filled with @false@. create :: (BitMap :< cls, Object :< cls) => cls -> Vector2 -> IO () create cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "create" '[Vector2] (IO ()) where nodeMethod = Godot.Core.BitMap.create {-# NOINLINE bindBitMap_create_from_image_alpha #-} -- | Creates a bitmap that matches the given image dimensions, every element of the bitmap is set to @false@ if the alpha value of the image at that position is equal to @threshold@ or less, and @true@ in other case. bindBitMap_create_from_image_alpha :: MethodBind bindBitMap_create_from_image_alpha = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "create_from_image_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a bitmap that matches the given image dimensions, every element of the bitmap is set to @false@ if the alpha value of the image at that position is equal to @threshold@ or less, and @true@ in other case. create_from_image_alpha :: (BitMap :< cls, Object :< cls) => cls -> Image -> Maybe Float -> IO () create_from_image_alpha cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantReal (0.1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_create_from_image_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "create_from_image_alpha" '[Image, Maybe Float] (IO ()) where nodeMethod = Godot.Core.BitMap.create_from_image_alpha {-# NOINLINE bindBitMap_get_bit #-} -- | Returns bitmap's value at the specified position. bindBitMap_get_bit :: MethodBind bindBitMap_get_bit = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "get_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns bitmap's value at the specified position. get_bit :: (BitMap :< cls, Object :< cls) => cls -> Vector2 -> IO Bool get_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_get_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "get_bit" '[Vector2] (IO Bool) where nodeMethod = Godot.Core.BitMap.get_bit {-# NOINLINE bindBitMap_get_size #-} -- | Returns bitmap's dimensions. bindBitMap_get_size :: MethodBind bindBitMap_get_size = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns bitmap's dimensions. get_size :: (BitMap :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.BitMap.get_size {-# NOINLINE bindBitMap_get_true_bit_count #-} -- | Returns the amount of bitmap elements that are set to @true@. bindBitMap_get_true_bit_count :: MethodBind bindBitMap_get_true_bit_count = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "get_true_bit_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of bitmap elements that are set to @true@. get_true_bit_count :: (BitMap :< cls, Object :< cls) => cls -> IO Int get_true_bit_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_get_true_bit_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "get_true_bit_count" '[] (IO Int) where nodeMethod = Godot.Core.BitMap.get_true_bit_count {-# NOINLINE bindBitMap_grow_mask #-} -- | Applies morphological dilation to the bitmap. The first argument is the dilation amount, Rect2 is the area where the dilation will be applied. bindBitMap_grow_mask :: MethodBind bindBitMap_grow_mask = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "grow_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies morphological dilation to the bitmap. The first argument is the dilation amount, Rect2 is the area where the dilation will be applied. grow_mask :: (BitMap :< cls, Object :< cls) => cls -> Int -> Rect2 -> IO () grow_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_grow_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "grow_mask" '[Int, Rect2] (IO ()) where nodeMethod = Godot.Core.BitMap.grow_mask {-# NOINLINE bindBitMap_opaque_to_polygons #-} bindBitMap_opaque_to_polygons :: MethodBind bindBitMap_opaque_to_polygons = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "opaque_to_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr opaque_to_polygons :: (BitMap :< cls, Object :< cls) => cls -> Rect2 -> Maybe Float -> IO Array opaque_to_polygons cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantReal (2)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_opaque_to_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "opaque_to_polygons" '[Rect2, Maybe Float] (IO Array) where nodeMethod = Godot.Core.BitMap.opaque_to_polygons {-# NOINLINE bindBitMap_set_bit #-} -- | Sets the bitmap's element at the specified position, to the specified value. bindBitMap_set_bit :: MethodBind bindBitMap_set_bit = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "set_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the bitmap's element at the specified position, to the specified value. set_bit :: (BitMap :< cls, Object :< cls) => cls -> Vector2 -> Bool -> IO () set_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_set_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "set_bit" '[Vector2, Bool] (IO ()) where nodeMethod = Godot.Core.BitMap.set_bit {-# NOINLINE bindBitMap_set_bit_rect #-} -- | Sets a rectangular portion of the bitmap to the specified value. bindBitMap_set_bit_rect :: MethodBind bindBitMap_set_bit_rect = unsafePerformIO $ withCString "BitMap" $ \ clsNamePtr -> withCString "set_bit_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a rectangular portion of the bitmap to the specified value. set_bit_rect :: (BitMap :< cls, Object :< cls) => cls -> Rect2 -> Bool -> IO () set_bit_rect cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindBitMap_set_bit_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitMap "set_bit_rect" '[Rect2, Bool] (IO ()) where nodeMethod = Godot.Core.BitMap.set_bit_rect ================================================ FILE: src/Godot/Core/BitmapFont.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BitmapFont (Godot.Core.BitmapFont.get_ascent, Godot.Core.BitmapFont.is_distance_field_hint, Godot.Core.BitmapFont.get_height, Godot.Core.BitmapFont._get_chars, Godot.Core.BitmapFont._get_kernings, Godot.Core.BitmapFont._get_textures, Godot.Core.BitmapFont._set_chars, Godot.Core.BitmapFont._set_kernings, Godot.Core.BitmapFont._set_textures, Godot.Core.BitmapFont.add_char, Godot.Core.BitmapFont.add_kerning_pair, Godot.Core.BitmapFont.add_texture, Godot.Core.BitmapFont.clear, Godot.Core.BitmapFont.create_from_fnt, Godot.Core.BitmapFont.get_char_size, Godot.Core.BitmapFont.get_fallback, Godot.Core.BitmapFont.get_kerning_pair, Godot.Core.BitmapFont.get_texture, Godot.Core.BitmapFont.get_texture_count, Godot.Core.BitmapFont.set_ascent, Godot.Core.BitmapFont.set_distance_field_hint, Godot.Core.BitmapFont.set_fallback, Godot.Core.BitmapFont.set_height) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Font() {-# NOINLINE bindBitmapFont_get_ascent #-} -- | Ascent (number of pixels above the baseline). bindBitmapFont_get_ascent :: MethodBind bindBitmapFont_get_ascent = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "get_ascent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Ascent (number of pixels above the baseline). get_ascent :: (BitmapFont :< cls, Object :< cls) => cls -> IO Float get_ascent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_get_ascent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "get_ascent" '[] (IO Float) where nodeMethod = Godot.Core.BitmapFont.get_ascent instance NodeProperty BitmapFont "ascent" Float 'False where nodeProperty = (get_ascent, wrapDroppingSetter set_ascent, Nothing) instance NodeProperty BitmapFont "chars" PoolIntArray 'False where nodeProperty = (_get_chars, wrapDroppingSetter _set_chars, Nothing) {-# NOINLINE bindBitmapFont_is_distance_field_hint #-} -- | If @true@, distance field hint is enabled. bindBitmapFont_is_distance_field_hint :: MethodBind bindBitmapFont_is_distance_field_hint = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "is_distance_field_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, distance field hint is enabled. is_distance_field_hint :: (BitmapFont :< cls, Object :< cls) => cls -> IO Bool is_distance_field_hint cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_is_distance_field_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "is_distance_field_hint" '[] (IO Bool) where nodeMethod = Godot.Core.BitmapFont.is_distance_field_hint instance NodeProperty BitmapFont "distance_field" Bool 'False where nodeProperty = (is_distance_field_hint, wrapDroppingSetter set_distance_field_hint, Nothing) instance NodeProperty BitmapFont "fallback" BitmapFont 'False where nodeProperty = (get_fallback, wrapDroppingSetter set_fallback, Nothing) {-# NOINLINE bindBitmapFont_get_height #-} -- | Total font height (ascent plus descent) in pixels. bindBitmapFont_get_height :: MethodBind bindBitmapFont_get_height = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Total font height (ascent plus descent) in pixels. get_height :: (BitmapFont :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "get_height" '[] (IO Float) where nodeMethod = Godot.Core.BitmapFont.get_height instance NodeProperty BitmapFont "height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty BitmapFont "kernings" PoolIntArray 'False where nodeProperty = (_get_kernings, wrapDroppingSetter _set_kernings, Nothing) instance NodeProperty BitmapFont "textures" Array 'False where nodeProperty = (_get_textures, wrapDroppingSetter _set_textures, Nothing) {-# NOINLINE bindBitmapFont__get_chars #-} bindBitmapFont__get_chars :: MethodBind bindBitmapFont__get_chars = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "_get_chars" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_chars :: (BitmapFont :< cls, Object :< cls) => cls -> IO PoolIntArray _get_chars cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont__get_chars (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "_get_chars" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.BitmapFont._get_chars {-# NOINLINE bindBitmapFont__get_kernings #-} bindBitmapFont__get_kernings :: MethodBind bindBitmapFont__get_kernings = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "_get_kernings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_kernings :: (BitmapFont :< cls, Object :< cls) => cls -> IO PoolIntArray _get_kernings cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont__get_kernings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "_get_kernings" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.BitmapFont._get_kernings {-# NOINLINE bindBitmapFont__get_textures #-} bindBitmapFont__get_textures :: MethodBind bindBitmapFont__get_textures = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "_get_textures" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_textures :: (BitmapFont :< cls, Object :< cls) => cls -> IO Array _get_textures cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont__get_textures (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "_get_textures" '[] (IO Array) where nodeMethod = Godot.Core.BitmapFont._get_textures {-# NOINLINE bindBitmapFont__set_chars #-} bindBitmapFont__set_chars :: MethodBind bindBitmapFont__set_chars = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "_set_chars" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_chars :: (BitmapFont :< cls, Object :< cls) => cls -> PoolIntArray -> IO () _set_chars cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont__set_chars (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "_set_chars" '[PoolIntArray] (IO ()) where nodeMethod = Godot.Core.BitmapFont._set_chars {-# NOINLINE bindBitmapFont__set_kernings #-} bindBitmapFont__set_kernings :: MethodBind bindBitmapFont__set_kernings = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "_set_kernings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_kernings :: (BitmapFont :< cls, Object :< cls) => cls -> PoolIntArray -> IO () _set_kernings cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont__set_kernings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "_set_kernings" '[PoolIntArray] (IO ()) where nodeMethod = Godot.Core.BitmapFont._set_kernings {-# NOINLINE bindBitmapFont__set_textures #-} bindBitmapFont__set_textures :: MethodBind bindBitmapFont__set_textures = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "_set_textures" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_textures :: (BitmapFont :< cls, Object :< cls) => cls -> Array -> IO () _set_textures cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont__set_textures (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "_set_textures" '[Array] (IO ()) where nodeMethod = Godot.Core.BitmapFont._set_textures {-# NOINLINE bindBitmapFont_add_char #-} -- | Adds a character to the font, where @character@ is the Unicode value, @texture@ is the texture index, @rect@ is the region in the texture (in pixels!), @align@ is the (optional) alignment for the character and @advance@ is the (optional) advance. bindBitmapFont_add_char :: MethodBind bindBitmapFont_add_char = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "add_char" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a character to the font, where @character@ is the Unicode value, @texture@ is the texture index, @rect@ is the region in the texture (in pixels!), @align@ is the (optional) alignment for the character and @advance@ is the (optional) advance. add_char :: (BitmapFont :< cls, Object :< cls) => cls -> Int -> Int -> Rect2 -> Maybe Vector2 -> Maybe Float -> IO () add_char cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantVector2 (V2 0 0) arg4, maybe (VariantReal (-1)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_add_char (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "add_char" '[Int, Int, Rect2, Maybe Vector2, Maybe Float] (IO ()) where nodeMethod = Godot.Core.BitmapFont.add_char {-# NOINLINE bindBitmapFont_add_kerning_pair #-} -- | Adds a kerning pair to the @BitmapFont@ as a difference. Kerning pairs are special cases where a typeface advance is determined by the next character. bindBitmapFont_add_kerning_pair :: MethodBind bindBitmapFont_add_kerning_pair = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "add_kerning_pair" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a kerning pair to the @BitmapFont@ as a difference. Kerning pairs are special cases where a typeface advance is determined by the next character. add_kerning_pair :: (BitmapFont :< cls, Object :< cls) => cls -> Int -> Int -> Int -> IO () add_kerning_pair cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_add_kerning_pair (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "add_kerning_pair" '[Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.BitmapFont.add_kerning_pair {-# NOINLINE bindBitmapFont_add_texture #-} -- | Adds a texture to the @BitmapFont@. bindBitmapFont_add_texture :: MethodBind bindBitmapFont_add_texture = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "add_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a texture to the @BitmapFont@. add_texture :: (BitmapFont :< cls, Object :< cls) => cls -> Texture -> IO () add_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_add_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "add_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.BitmapFont.add_texture {-# NOINLINE bindBitmapFont_clear #-} -- | Clears all the font data and settings. bindBitmapFont_clear :: MethodBind bindBitmapFont_clear = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all the font data and settings. clear :: (BitmapFont :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "clear" '[] (IO ()) where nodeMethod = Godot.Core.BitmapFont.clear {-# NOINLINE bindBitmapFont_create_from_fnt #-} -- | Creates a BitmapFont from the @*.fnt@ file at @path@. bindBitmapFont_create_from_fnt :: MethodBind bindBitmapFont_create_from_fnt = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "create_from_fnt" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a BitmapFont from the @*.fnt@ file at @path@. create_from_fnt :: (BitmapFont :< cls, Object :< cls) => cls -> GodotString -> IO Int create_from_fnt cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_create_from_fnt (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "create_from_fnt" '[GodotString] (IO Int) where nodeMethod = Godot.Core.BitmapFont.create_from_fnt {-# NOINLINE bindBitmapFont_get_char_size #-} bindBitmapFont_get_char_size :: MethodBind bindBitmapFont_get_char_size = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "get_char_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_char_size :: (BitmapFont :< cls, Object :< cls) => cls -> Int -> Maybe Int -> IO Vector2 get_char_size cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_get_char_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "get_char_size" '[Int, Maybe Int] (IO Vector2) where nodeMethod = Godot.Core.BitmapFont.get_char_size {-# NOINLINE bindBitmapFont_get_fallback #-} -- | The fallback font. bindBitmapFont_get_fallback :: MethodBind bindBitmapFont_get_fallback = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "get_fallback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fallback font. get_fallback :: (BitmapFont :< cls, Object :< cls) => cls -> IO BitmapFont get_fallback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_get_fallback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "get_fallback" '[] (IO BitmapFont) where nodeMethod = Godot.Core.BitmapFont.get_fallback {-# NOINLINE bindBitmapFont_get_kerning_pair #-} -- | Returns a kerning pair as a difference. bindBitmapFont_get_kerning_pair :: MethodBind bindBitmapFont_get_kerning_pair = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "get_kerning_pair" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a kerning pair as a difference. get_kerning_pair :: (BitmapFont :< cls, Object :< cls) => cls -> Int -> Int -> IO Int get_kerning_pair cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_get_kerning_pair (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "get_kerning_pair" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.BitmapFont.get_kerning_pair {-# NOINLINE bindBitmapFont_get_texture #-} -- | Returns the font atlas texture at index @idx@. bindBitmapFont_get_texture :: MethodBind bindBitmapFont_get_texture = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the font atlas texture at index @idx@. get_texture :: (BitmapFont :< cls, Object :< cls) => cls -> Int -> IO Texture get_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "get_texture" '[Int] (IO Texture) where nodeMethod = Godot.Core.BitmapFont.get_texture {-# NOINLINE bindBitmapFont_get_texture_count #-} -- | Returns the number of textures in the BitmapFont atlas. bindBitmapFont_get_texture_count :: MethodBind bindBitmapFont_get_texture_count = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "get_texture_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of textures in the BitmapFont atlas. get_texture_count :: (BitmapFont :< cls, Object :< cls) => cls -> IO Int get_texture_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_get_texture_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "get_texture_count" '[] (IO Int) where nodeMethod = Godot.Core.BitmapFont.get_texture_count {-# NOINLINE bindBitmapFont_set_ascent #-} -- | Ascent (number of pixels above the baseline). bindBitmapFont_set_ascent :: MethodBind bindBitmapFont_set_ascent = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "set_ascent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Ascent (number of pixels above the baseline). set_ascent :: (BitmapFont :< cls, Object :< cls) => cls -> Float -> IO () set_ascent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_set_ascent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "set_ascent" '[Float] (IO ()) where nodeMethod = Godot.Core.BitmapFont.set_ascent {-# NOINLINE bindBitmapFont_set_distance_field_hint #-} -- | If @true@, distance field hint is enabled. bindBitmapFont_set_distance_field_hint :: MethodBind bindBitmapFont_set_distance_field_hint = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "set_distance_field_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, distance field hint is enabled. set_distance_field_hint :: (BitmapFont :< cls, Object :< cls) => cls -> Bool -> IO () set_distance_field_hint cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_set_distance_field_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "set_distance_field_hint" '[Bool] (IO ()) where nodeMethod = Godot.Core.BitmapFont.set_distance_field_hint {-# NOINLINE bindBitmapFont_set_fallback #-} -- | The fallback font. bindBitmapFont_set_fallback :: MethodBind bindBitmapFont_set_fallback = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "set_fallback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fallback font. set_fallback :: (BitmapFont :< cls, Object :< cls) => cls -> BitmapFont -> IO () set_fallback cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_set_fallback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "set_fallback" '[BitmapFont] (IO ()) where nodeMethod = Godot.Core.BitmapFont.set_fallback {-# NOINLINE bindBitmapFont_set_height #-} -- | Total font height (ascent plus descent) in pixels. bindBitmapFont_set_height :: MethodBind bindBitmapFont_set_height = unsafePerformIO $ withCString "BitmapFont" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Total font height (ascent plus descent) in pixels. set_height :: (BitmapFont :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBitmapFont_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BitmapFont "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.BitmapFont.set_height ================================================ FILE: src/Godot/Core/Bone2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Bone2D (Godot.Core.Bone2D.apply_rest, Godot.Core.Bone2D.get_default_length, Godot.Core.Bone2D.get_index_in_skeleton, Godot.Core.Bone2D.get_rest, Godot.Core.Bone2D.get_skeleton_rest, Godot.Core.Bone2D.set_default_length, Godot.Core.Bone2D.set_rest) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty Bone2D "default_length" Float 'False where nodeProperty = (get_default_length, wrapDroppingSetter set_default_length, Nothing) instance NodeProperty Bone2D "rest" Transform2d 'False where nodeProperty = (get_rest, wrapDroppingSetter set_rest, Nothing) {-# NOINLINE bindBone2D_apply_rest #-} -- | Stores the node's current transforms in @rest@. bindBone2D_apply_rest :: MethodBind bindBone2D_apply_rest = unsafePerformIO $ withCString "Bone2D" $ \ clsNamePtr -> withCString "apply_rest" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores the node's current transforms in @rest@. apply_rest :: (Bone2D :< cls, Object :< cls) => cls -> IO () apply_rest cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBone2D_apply_rest (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Bone2D "apply_rest" '[] (IO ()) where nodeMethod = Godot.Core.Bone2D.apply_rest {-# NOINLINE bindBone2D_get_default_length #-} -- | Length of the bone's representation drawn in the editor's viewport in pixels. bindBone2D_get_default_length :: MethodBind bindBone2D_get_default_length = unsafePerformIO $ withCString "Bone2D" $ \ clsNamePtr -> withCString "get_default_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Length of the bone's representation drawn in the editor's viewport in pixels. get_default_length :: (Bone2D :< cls, Object :< cls) => cls -> IO Float get_default_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBone2D_get_default_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Bone2D "get_default_length" '[] (IO Float) where nodeMethod = Godot.Core.Bone2D.get_default_length {-# NOINLINE bindBone2D_get_index_in_skeleton #-} -- | Returns the node's index as part of the entire skeleton. See @Skeleton2D@. bindBone2D_get_index_in_skeleton :: MethodBind bindBone2D_get_index_in_skeleton = unsafePerformIO $ withCString "Bone2D" $ \ clsNamePtr -> withCString "get_index_in_skeleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the node's index as part of the entire skeleton. See @Skeleton2D@. get_index_in_skeleton :: (Bone2D :< cls, Object :< cls) => cls -> IO Int get_index_in_skeleton cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBone2D_get_index_in_skeleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Bone2D "get_index_in_skeleton" '[] (IO Int) where nodeMethod = Godot.Core.Bone2D.get_index_in_skeleton {-# NOINLINE bindBone2D_get_rest #-} -- | Rest transform of the bone. You can reset the node's transforms to this value using @method apply_rest@. bindBone2D_get_rest :: MethodBind bindBone2D_get_rest = unsafePerformIO $ withCString "Bone2D" $ \ clsNamePtr -> withCString "get_rest" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rest transform of the bone. You can reset the node's transforms to this value using @method apply_rest@. get_rest :: (Bone2D :< cls, Object :< cls) => cls -> IO Transform2d get_rest cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBone2D_get_rest (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Bone2D "get_rest" '[] (IO Transform2d) where nodeMethod = Godot.Core.Bone2D.get_rest {-# NOINLINE bindBone2D_get_skeleton_rest #-} -- | Returns the node's @rest@ @Transform2D@ if it doesn't have a parent, or its rest pose relative to its parent. bindBone2D_get_skeleton_rest :: MethodBind bindBone2D_get_skeleton_rest = unsafePerformIO $ withCString "Bone2D" $ \ clsNamePtr -> withCString "get_skeleton_rest" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the node's @rest@ @Transform2D@ if it doesn't have a parent, or its rest pose relative to its parent. get_skeleton_rest :: (Bone2D :< cls, Object :< cls) => cls -> IO Transform2d get_skeleton_rest cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBone2D_get_skeleton_rest (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Bone2D "get_skeleton_rest" '[] (IO Transform2d) where nodeMethod = Godot.Core.Bone2D.get_skeleton_rest {-# NOINLINE bindBone2D_set_default_length #-} -- | Length of the bone's representation drawn in the editor's viewport in pixels. bindBone2D_set_default_length :: MethodBind bindBone2D_set_default_length = unsafePerformIO $ withCString "Bone2D" $ \ clsNamePtr -> withCString "set_default_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Length of the bone's representation drawn in the editor's viewport in pixels. set_default_length :: (Bone2D :< cls, Object :< cls) => cls -> Float -> IO () set_default_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBone2D_set_default_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Bone2D "set_default_length" '[Float] (IO ()) where nodeMethod = Godot.Core.Bone2D.set_default_length {-# NOINLINE bindBone2D_set_rest #-} -- | Rest transform of the bone. You can reset the node's transforms to this value using @method apply_rest@. bindBone2D_set_rest :: MethodBind bindBone2D_set_rest = unsafePerformIO $ withCString "Bone2D" $ \ clsNamePtr -> withCString "set_rest" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rest transform of the bone. You can reset the node's transforms to this value using @method apply_rest@. set_rest :: (Bone2D :< cls, Object :< cls) => cls -> Transform2d -> IO () set_rest cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBone2D_set_rest (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Bone2D "set_rest" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.Bone2D.set_rest ================================================ FILE: src/Godot/Core/BoneAttachment.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BoneAttachment (Godot.Core.BoneAttachment.get_bone_name, Godot.Core.BoneAttachment.set_bone_name) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty BoneAttachment "bone_name" GodotString 'False where nodeProperty = (get_bone_name, wrapDroppingSetter set_bone_name, Nothing) {-# NOINLINE bindBoneAttachment_get_bone_name #-} -- | The name of the attached bone. bindBoneAttachment_get_bone_name :: MethodBind bindBoneAttachment_get_bone_name = unsafePerformIO $ withCString "BoneAttachment" $ \ clsNamePtr -> withCString "get_bone_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the attached bone. get_bone_name :: (BoneAttachment :< cls, Object :< cls) => cls -> IO GodotString get_bone_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBoneAttachment_get_bone_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BoneAttachment "get_bone_name" '[] (IO GodotString) where nodeMethod = Godot.Core.BoneAttachment.get_bone_name {-# NOINLINE bindBoneAttachment_set_bone_name #-} -- | The name of the attached bone. bindBoneAttachment_set_bone_name :: MethodBind bindBoneAttachment_set_bone_name = unsafePerformIO $ withCString "BoneAttachment" $ \ clsNamePtr -> withCString "set_bone_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the attached bone. set_bone_name :: (BoneAttachment :< cls, Object :< cls) => cls -> GodotString -> IO () set_bone_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBoneAttachment_set_bone_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BoneAttachment "set_bone_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.BoneAttachment.set_bone_name ================================================ FILE: src/Godot/Core/BoxContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BoxContainer (Godot.Core.BoxContainer._ALIGN_END, Godot.Core.BoxContainer._ALIGN_BEGIN, Godot.Core.BoxContainer._ALIGN_CENTER, Godot.Core.BoxContainer.add_spacer, Godot.Core.BoxContainer.get_alignment, Godot.Core.BoxContainer.set_alignment) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() _ALIGN_END :: Int _ALIGN_END = 2 _ALIGN_BEGIN :: Int _ALIGN_BEGIN = 0 _ALIGN_CENTER :: Int _ALIGN_CENTER = 1 instance NodeProperty BoxContainer "alignment" Int 'False where nodeProperty = (get_alignment, wrapDroppingSetter set_alignment, Nothing) {-# NOINLINE bindBoxContainer_add_spacer #-} -- | Adds a control to the box as a spacer. If @true@, @begin@ will insert the spacer control in front of other children. bindBoxContainer_add_spacer :: MethodBind bindBoxContainer_add_spacer = unsafePerformIO $ withCString "BoxContainer" $ \ clsNamePtr -> withCString "add_spacer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a control to the box as a spacer. If @true@, @begin@ will insert the spacer control in front of other children. add_spacer :: (BoxContainer :< cls, Object :< cls) => cls -> Bool -> IO () add_spacer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBoxContainer_add_spacer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BoxContainer "add_spacer" '[Bool] (IO ()) where nodeMethod = Godot.Core.BoxContainer.add_spacer {-# NOINLINE bindBoxContainer_get_alignment #-} -- | The alignment of the container's children (must be one of @ALIGN_BEGIN@, @ALIGN_CENTER@ or @ALIGN_END@). bindBoxContainer_get_alignment :: MethodBind bindBoxContainer_get_alignment = unsafePerformIO $ withCString "BoxContainer" $ \ clsNamePtr -> withCString "get_alignment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The alignment of the container's children (must be one of @ALIGN_BEGIN@, @ALIGN_CENTER@ or @ALIGN_END@). get_alignment :: (BoxContainer :< cls, Object :< cls) => cls -> IO Int get_alignment cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBoxContainer_get_alignment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BoxContainer "get_alignment" '[] (IO Int) where nodeMethod = Godot.Core.BoxContainer.get_alignment {-# NOINLINE bindBoxContainer_set_alignment #-} -- | The alignment of the container's children (must be one of @ALIGN_BEGIN@, @ALIGN_CENTER@ or @ALIGN_END@). bindBoxContainer_set_alignment :: MethodBind bindBoxContainer_set_alignment = unsafePerformIO $ withCString "BoxContainer" $ \ clsNamePtr -> withCString "set_alignment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The alignment of the container's children (must be one of @ALIGN_BEGIN@, @ALIGN_CENTER@ or @ALIGN_END@). set_alignment :: (BoxContainer :< cls, Object :< cls) => cls -> Int -> IO () set_alignment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBoxContainer_set_alignment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BoxContainer "set_alignment" '[Int] (IO ()) where nodeMethod = Godot.Core.BoxContainer.set_alignment ================================================ FILE: src/Godot/Core/BoxShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BoxShape (Godot.Core.BoxShape.get_extents, Godot.Core.BoxShape.set_extents) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty BoxShape "extents" Vector3 'False where nodeProperty = (get_extents, wrapDroppingSetter set_extents, Nothing) {-# NOINLINE bindBoxShape_get_extents #-} -- | The box's half extents. The width, height and depth of this shape is twice the half extents. bindBoxShape_get_extents :: MethodBind bindBoxShape_get_extents = unsafePerformIO $ withCString "BoxShape" $ \ clsNamePtr -> withCString "get_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The box's half extents. The width, height and depth of this shape is twice the half extents. get_extents :: (BoxShape :< cls, Object :< cls) => cls -> IO Vector3 get_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindBoxShape_get_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BoxShape "get_extents" '[] (IO Vector3) where nodeMethod = Godot.Core.BoxShape.get_extents {-# NOINLINE bindBoxShape_set_extents #-} -- | The box's half extents. The width, height and depth of this shape is twice the half extents. bindBoxShape_set_extents :: MethodBind bindBoxShape_set_extents = unsafePerformIO $ withCString "BoxShape" $ \ clsNamePtr -> withCString "set_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The box's half extents. The width, height and depth of this shape is twice the half extents. set_extents :: (BoxShape :< cls, Object :< cls) => cls -> Vector3 -> IO () set_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindBoxShape_set_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod BoxShape "set_extents" '[Vector3] (IO ()) where nodeMethod = Godot.Core.BoxShape.set_extents ================================================ FILE: src/Godot/Core/BulletPhysicsDirectBodyState.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BulletPhysicsDirectBodyState () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsDirectBodyState() ================================================ FILE: src/Godot/Core/BulletPhysicsServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.BulletPhysicsServer () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsServer() ================================================ FILE: src/Godot/Core/Button.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Button (Godot.Core.Button._ALIGN_RIGHT, Godot.Core.Button._ALIGN_LEFT, Godot.Core.Button._ALIGN_CENTER, Godot.Core.Button.get_button_icon, Godot.Core.Button.get_clip_text, Godot.Core.Button.get_text, Godot.Core.Button.get_text_align, Godot.Core.Button.is_expand_icon, Godot.Core.Button.is_flat, Godot.Core.Button.set_button_icon, Godot.Core.Button.set_clip_text, Godot.Core.Button.set_expand_icon, Godot.Core.Button.set_flat, Godot.Core.Button.set_text, Godot.Core.Button.set_text_align) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.BaseButton() _ALIGN_RIGHT :: Int _ALIGN_RIGHT = 2 _ALIGN_LEFT :: Int _ALIGN_LEFT = 0 _ALIGN_CENTER :: Int _ALIGN_CENTER = 1 instance NodeProperty Button "align" Int 'False where nodeProperty = (get_text_align, wrapDroppingSetter set_text_align, Nothing) instance NodeProperty Button "clip_text" Bool 'False where nodeProperty = (get_clip_text, wrapDroppingSetter set_clip_text, Nothing) instance NodeProperty Button "expand_icon" Bool 'False where nodeProperty = (is_expand_icon, wrapDroppingSetter set_expand_icon, Nothing) instance NodeProperty Button "flat" Bool 'False where nodeProperty = (is_flat, wrapDroppingSetter set_flat, Nothing) instance NodeProperty Button "icon" Texture 'False where nodeProperty = (get_button_icon, wrapDroppingSetter set_button_icon, Nothing) instance NodeProperty Button "text" GodotString 'False where nodeProperty = (get_text, wrapDroppingSetter set_text, Nothing) {-# NOINLINE bindButton_get_button_icon #-} -- | Button's icon, if text is present the icon will be placed before the text. bindButton_get_button_icon :: MethodBind bindButton_get_button_icon = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "get_button_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Button's icon, if text is present the icon will be placed before the text. get_button_icon :: (Button :< cls, Object :< cls) => cls -> IO Texture get_button_icon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindButton_get_button_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "get_button_icon" '[] (IO Texture) where nodeMethod = Godot.Core.Button.get_button_icon {-# NOINLINE bindButton_get_clip_text #-} -- | When this property is enabled, text that is too large to fit the button is clipped, when disabled the Button will always be wide enough to hold the text. bindButton_get_clip_text :: MethodBind bindButton_get_clip_text = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "get_clip_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When this property is enabled, text that is too large to fit the button is clipped, when disabled the Button will always be wide enough to hold the text. get_clip_text :: (Button :< cls, Object :< cls) => cls -> IO Bool get_clip_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindButton_get_clip_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "get_clip_text" '[] (IO Bool) where nodeMethod = Godot.Core.Button.get_clip_text {-# NOINLINE bindButton_get_text #-} -- | The button's text that will be displayed inside the button's area. bindButton_get_text :: MethodBind bindButton_get_text = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's text that will be displayed inside the button's area. get_text :: (Button :< cls, Object :< cls) => cls -> IO GodotString get_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindButton_get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "get_text" '[] (IO GodotString) where nodeMethod = Godot.Core.Button.get_text {-# NOINLINE bindButton_get_text_align #-} -- | Text alignment policy for the button's text, use one of the @enum TextAlign@ constants. bindButton_get_text_align :: MethodBind bindButton_get_text_align = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "get_text_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Text alignment policy for the button's text, use one of the @enum TextAlign@ constants. get_text_align :: (Button :< cls, Object :< cls) => cls -> IO Int get_text_align cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindButton_get_text_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "get_text_align" '[] (IO Int) where nodeMethod = Godot.Core.Button.get_text_align {-# NOINLINE bindButton_is_expand_icon #-} -- | When enabled, the button's icon will expand/shrink to fit the button's size while keeping its aspect. bindButton_is_expand_icon :: MethodBind bindButton_is_expand_icon = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "is_expand_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When enabled, the button's icon will expand/shrink to fit the button's size while keeping its aspect. is_expand_icon :: (Button :< cls, Object :< cls) => cls -> IO Bool is_expand_icon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindButton_is_expand_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "is_expand_icon" '[] (IO Bool) where nodeMethod = Godot.Core.Button.is_expand_icon {-# NOINLINE bindButton_is_flat #-} -- | Flat buttons don't display decoration. bindButton_is_flat :: MethodBind bindButton_is_flat = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "is_flat" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Flat buttons don't display decoration. is_flat :: (Button :< cls, Object :< cls) => cls -> IO Bool is_flat cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindButton_is_flat (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "is_flat" '[] (IO Bool) where nodeMethod = Godot.Core.Button.is_flat {-# NOINLINE bindButton_set_button_icon #-} -- | Button's icon, if text is present the icon will be placed before the text. bindButton_set_button_icon :: MethodBind bindButton_set_button_icon = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "set_button_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Button's icon, if text is present the icon will be placed before the text. set_button_icon :: (Button :< cls, Object :< cls) => cls -> Texture -> IO () set_button_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindButton_set_button_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "set_button_icon" '[Texture] (IO ()) where nodeMethod = Godot.Core.Button.set_button_icon {-# NOINLINE bindButton_set_clip_text #-} -- | When this property is enabled, text that is too large to fit the button is clipped, when disabled the Button will always be wide enough to hold the text. bindButton_set_clip_text :: MethodBind bindButton_set_clip_text = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "set_clip_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When this property is enabled, text that is too large to fit the button is clipped, when disabled the Button will always be wide enough to hold the text. set_clip_text :: (Button :< cls, Object :< cls) => cls -> Bool -> IO () set_clip_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindButton_set_clip_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "set_clip_text" '[Bool] (IO ()) where nodeMethod = Godot.Core.Button.set_clip_text {-# NOINLINE bindButton_set_expand_icon #-} -- | When enabled, the button's icon will expand/shrink to fit the button's size while keeping its aspect. bindButton_set_expand_icon :: MethodBind bindButton_set_expand_icon = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "set_expand_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When enabled, the button's icon will expand/shrink to fit the button's size while keeping its aspect. set_expand_icon :: (Button :< cls, Object :< cls) => cls -> Bool -> IO () set_expand_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindButton_set_expand_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "set_expand_icon" '[Bool] (IO ()) where nodeMethod = Godot.Core.Button.set_expand_icon {-# NOINLINE bindButton_set_flat #-} -- | Flat buttons don't display decoration. bindButton_set_flat :: MethodBind bindButton_set_flat = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "set_flat" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Flat buttons don't display decoration. set_flat :: (Button :< cls, Object :< cls) => cls -> Bool -> IO () set_flat cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindButton_set_flat (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "set_flat" '[Bool] (IO ()) where nodeMethod = Godot.Core.Button.set_flat {-# NOINLINE bindButton_set_text #-} -- | The button's text that will be displayed inside the button's area. bindButton_set_text :: MethodBind bindButton_set_text = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "set_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's text that will be displayed inside the button's area. set_text :: (Button :< cls, Object :< cls) => cls -> GodotString -> IO () set_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindButton_set_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "set_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Button.set_text {-# NOINLINE bindButton_set_text_align #-} -- | Text alignment policy for the button's text, use one of the @enum TextAlign@ constants. bindButton_set_text_align :: MethodBind bindButton_set_text_align = unsafePerformIO $ withCString "Button" $ \ clsNamePtr -> withCString "set_text_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Text alignment policy for the button's text, use one of the @enum TextAlign@ constants. set_text_align :: (Button :< cls, Object :< cls) => cls -> Int -> IO () set_text_align cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindButton_set_text_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Button "set_text_align" '[Int] (IO ()) where nodeMethod = Godot.Core.Button.set_text_align ================================================ FILE: src/Godot/Core/ButtonGroup.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ButtonGroup (Godot.Core.ButtonGroup.get_buttons, Godot.Core.ButtonGroup.get_pressed_button) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindButtonGroup_get_buttons #-} -- | Returns an @Array@ of @Button@s who have this as their @ButtonGroup@ (see @BaseButton.group@). bindButtonGroup_get_buttons :: MethodBind bindButtonGroup_get_buttons = unsafePerformIO $ withCString "ButtonGroup" $ \ clsNamePtr -> withCString "get_buttons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ of @Button@s who have this as their @ButtonGroup@ (see @BaseButton.group@). get_buttons :: (ButtonGroup :< cls, Object :< cls) => cls -> IO Array get_buttons cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindButtonGroup_get_buttons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ButtonGroup "get_buttons" '[] (IO Array) where nodeMethod = Godot.Core.ButtonGroup.get_buttons {-# NOINLINE bindButtonGroup_get_pressed_button #-} -- | Returns the current pressed button. bindButtonGroup_get_pressed_button :: MethodBind bindButtonGroup_get_pressed_button = unsafePerformIO $ withCString "ButtonGroup" $ \ clsNamePtr -> withCString "get_pressed_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current pressed button. get_pressed_button :: (ButtonGroup :< cls, Object :< cls) => cls -> IO BaseButton get_pressed_button cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindButtonGroup_get_pressed_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ButtonGroup "get_pressed_button" '[] (IO BaseButton) where nodeMethod = Godot.Core.ButtonGroup.get_pressed_button ================================================ FILE: src/Godot/Core/CPUParticles.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CPUParticles (Godot.Core.CPUParticles._FLAG_ALIGN_Y_TO_VELOCITY, Godot.Core.CPUParticles._PARAM_RADIAL_ACCEL, Godot.Core.CPUParticles._FLAG_ROTATE_Y, Godot.Core.CPUParticles._EMISSION_SHAPE_SPHERE, Godot.Core.CPUParticles._FLAG_DISABLE_Z, Godot.Core.CPUParticles._PARAM_ANGULAR_VELOCITY, Godot.Core.CPUParticles._EMISSION_SHAPE_MAX, Godot.Core.CPUParticles._PARAM_TANGENTIAL_ACCEL, Godot.Core.CPUParticles._PARAM_ANIM_SPEED, Godot.Core.CPUParticles._EMISSION_SHAPE_BOX, Godot.Core.CPUParticles._EMISSION_SHAPE_POINTS, Godot.Core.CPUParticles._PARAM_MAX, Godot.Core.CPUParticles._PARAM_INITIAL_LINEAR_VELOCITY, Godot.Core.CPUParticles._FLAG_MAX, Godot.Core.CPUParticles._PARAM_LINEAR_ACCEL, Godot.Core.CPUParticles._EMISSION_SHAPE_DIRECTED_POINTS, Godot.Core.CPUParticles._EMISSION_SHAPE_POINT, Godot.Core.CPUParticles._PARAM_ORBIT_VELOCITY, Godot.Core.CPUParticles._DRAW_ORDER_LIFETIME, Godot.Core.CPUParticles._PARAM_SCALE, Godot.Core.CPUParticles._DRAW_ORDER_INDEX, Godot.Core.CPUParticles._PARAM_DAMPING, Godot.Core.CPUParticles._PARAM_HUE_VARIATION, Godot.Core.CPUParticles._PARAM_ANIM_OFFSET, Godot.Core.CPUParticles._PARAM_ANGLE, Godot.Core.CPUParticles._DRAW_ORDER_VIEW_DEPTH, Godot.Core.CPUParticles._update_render_thread, Godot.Core.CPUParticles.convert_from_particles, Godot.Core.CPUParticles.get_amount, Godot.Core.CPUParticles.get_color, Godot.Core.CPUParticles.get_color_ramp, Godot.Core.CPUParticles.get_direction, Godot.Core.CPUParticles.get_draw_order, Godot.Core.CPUParticles.get_emission_box_extents, Godot.Core.CPUParticles.get_emission_colors, Godot.Core.CPUParticles.get_emission_normals, Godot.Core.CPUParticles.get_emission_points, Godot.Core.CPUParticles.get_emission_shape, Godot.Core.CPUParticles.get_emission_sphere_radius, Godot.Core.CPUParticles.get_explosiveness_ratio, Godot.Core.CPUParticles.get_fixed_fps, Godot.Core.CPUParticles.get_flatness, Godot.Core.CPUParticles.get_fractional_delta, Godot.Core.CPUParticles.get_gravity, Godot.Core.CPUParticles.get_lifetime, Godot.Core.CPUParticles.get_lifetime_randomness, Godot.Core.CPUParticles.get_mesh, Godot.Core.CPUParticles.get_one_shot, Godot.Core.CPUParticles.get_param, Godot.Core.CPUParticles.get_param_curve, Godot.Core.CPUParticles.get_param_randomness, Godot.Core.CPUParticles.get_particle_flag, Godot.Core.CPUParticles.get_pre_process_time, Godot.Core.CPUParticles.get_randomness_ratio, Godot.Core.CPUParticles.get_speed_scale, Godot.Core.CPUParticles.get_spread, Godot.Core.CPUParticles.get_use_local_coordinates, Godot.Core.CPUParticles.is_emitting, Godot.Core.CPUParticles.restart, Godot.Core.CPUParticles.set_amount, Godot.Core.CPUParticles.set_color, Godot.Core.CPUParticles.set_color_ramp, Godot.Core.CPUParticles.set_direction, Godot.Core.CPUParticles.set_draw_order, Godot.Core.CPUParticles.set_emission_box_extents, Godot.Core.CPUParticles.set_emission_colors, Godot.Core.CPUParticles.set_emission_normals, Godot.Core.CPUParticles.set_emission_points, Godot.Core.CPUParticles.set_emission_shape, Godot.Core.CPUParticles.set_emission_sphere_radius, Godot.Core.CPUParticles.set_emitting, Godot.Core.CPUParticles.set_explosiveness_ratio, Godot.Core.CPUParticles.set_fixed_fps, Godot.Core.CPUParticles.set_flatness, Godot.Core.CPUParticles.set_fractional_delta, Godot.Core.CPUParticles.set_gravity, Godot.Core.CPUParticles.set_lifetime, Godot.Core.CPUParticles.set_lifetime_randomness, Godot.Core.CPUParticles.set_mesh, Godot.Core.CPUParticles.set_one_shot, Godot.Core.CPUParticles.set_param, Godot.Core.CPUParticles.set_param_curve, Godot.Core.CPUParticles.set_param_randomness, Godot.Core.CPUParticles.set_particle_flag, Godot.Core.CPUParticles.set_pre_process_time, Godot.Core.CPUParticles.set_randomness_ratio, Godot.Core.CPUParticles.set_speed_scale, Godot.Core.CPUParticles.set_spread, Godot.Core.CPUParticles.set_use_local_coordinates) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.GeometryInstance() _FLAG_ALIGN_Y_TO_VELOCITY :: Int _FLAG_ALIGN_Y_TO_VELOCITY = 0 _PARAM_RADIAL_ACCEL :: Int _PARAM_RADIAL_ACCEL = 4 _FLAG_ROTATE_Y :: Int _FLAG_ROTATE_Y = 1 _EMISSION_SHAPE_SPHERE :: Int _EMISSION_SHAPE_SPHERE = 1 _FLAG_DISABLE_Z :: Int _FLAG_DISABLE_Z = 2 _PARAM_ANGULAR_VELOCITY :: Int _PARAM_ANGULAR_VELOCITY = 1 _EMISSION_SHAPE_MAX :: Int _EMISSION_SHAPE_MAX = 5 _PARAM_TANGENTIAL_ACCEL :: Int _PARAM_TANGENTIAL_ACCEL = 5 _PARAM_ANIM_SPEED :: Int _PARAM_ANIM_SPEED = 10 _EMISSION_SHAPE_BOX :: Int _EMISSION_SHAPE_BOX = 2 _EMISSION_SHAPE_POINTS :: Int _EMISSION_SHAPE_POINTS = 3 _PARAM_MAX :: Int _PARAM_MAX = 12 _PARAM_INITIAL_LINEAR_VELOCITY :: Int _PARAM_INITIAL_LINEAR_VELOCITY = 0 _FLAG_MAX :: Int _FLAG_MAX = 3 _PARAM_LINEAR_ACCEL :: Int _PARAM_LINEAR_ACCEL = 3 _EMISSION_SHAPE_DIRECTED_POINTS :: Int _EMISSION_SHAPE_DIRECTED_POINTS = 4 _EMISSION_SHAPE_POINT :: Int _EMISSION_SHAPE_POINT = 0 _PARAM_ORBIT_VELOCITY :: Int _PARAM_ORBIT_VELOCITY = 2 _DRAW_ORDER_LIFETIME :: Int _DRAW_ORDER_LIFETIME = 1 _PARAM_SCALE :: Int _PARAM_SCALE = 8 _DRAW_ORDER_INDEX :: Int _DRAW_ORDER_INDEX = 0 _PARAM_DAMPING :: Int _PARAM_DAMPING = 6 _PARAM_HUE_VARIATION :: Int _PARAM_HUE_VARIATION = 9 _PARAM_ANIM_OFFSET :: Int _PARAM_ANIM_OFFSET = 11 _PARAM_ANGLE :: Int _PARAM_ANGLE = 7 _DRAW_ORDER_VIEW_DEPTH :: Int _DRAW_ORDER_VIEW_DEPTH = 2 instance NodeProperty CPUParticles "amount" Int 'False where nodeProperty = (get_amount, wrapDroppingSetter set_amount, Nothing) instance NodeProperty CPUParticles "angle" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param, wrapIndexedSetter 7 set_param, Nothing) instance NodeProperty CPUParticles "angle_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 7 get_param_curve, wrapIndexedSetter 7 set_param_curve, Nothing) instance NodeProperty CPUParticles "angle_random" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param_randomness, wrapIndexedSetter 7 set_param_randomness, Nothing) instance NodeProperty CPUParticles "angular_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param, wrapIndexedSetter 1 set_param, Nothing) instance NodeProperty CPUParticles "angular_velocity_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 1 get_param_curve, wrapIndexedSetter 1 set_param_curve, Nothing) instance NodeProperty CPUParticles "angular_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param_randomness, wrapIndexedSetter 1 set_param_randomness, Nothing) instance NodeProperty CPUParticles "anim_offset" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_param, wrapIndexedSetter 11 set_param, Nothing) instance NodeProperty CPUParticles "anim_offset_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 11 get_param_curve, wrapIndexedSetter 11 set_param_curve, Nothing) instance NodeProperty CPUParticles "anim_offset_random" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_param_randomness, wrapIndexedSetter 11 set_param_randomness, Nothing) instance NodeProperty CPUParticles "anim_speed" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_param, wrapIndexedSetter 10 set_param, Nothing) instance NodeProperty CPUParticles "anim_speed_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 10 get_param_curve, wrapIndexedSetter 10 set_param_curve, Nothing) instance NodeProperty CPUParticles "anim_speed_random" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_param_randomness, wrapIndexedSetter 10 set_param_randomness, Nothing) instance NodeProperty CPUParticles "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) instance NodeProperty CPUParticles "color_ramp" Gradient 'False where nodeProperty = (get_color_ramp, wrapDroppingSetter set_color_ramp, Nothing) instance NodeProperty CPUParticles "damping" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param, wrapIndexedSetter 6 set_param, Nothing) instance NodeProperty CPUParticles "damping_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 6 get_param_curve, wrapIndexedSetter 6 set_param_curve, Nothing) instance NodeProperty CPUParticles "damping_random" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param_randomness, wrapIndexedSetter 6 set_param_randomness, Nothing) instance NodeProperty CPUParticles "direction" Vector3 'False where nodeProperty = (get_direction, wrapDroppingSetter set_direction, Nothing) instance NodeProperty CPUParticles "draw_order" Int 'False where nodeProperty = (get_draw_order, wrapDroppingSetter set_draw_order, Nothing) instance NodeProperty CPUParticles "emission_box_extents" Vector3 'False where nodeProperty = (get_emission_box_extents, wrapDroppingSetter set_emission_box_extents, Nothing) instance NodeProperty CPUParticles "emission_colors" PoolColorArray 'False where nodeProperty = (get_emission_colors, wrapDroppingSetter set_emission_colors, Nothing) instance NodeProperty CPUParticles "emission_normals" PoolVector3Array 'False where nodeProperty = (get_emission_normals, wrapDroppingSetter set_emission_normals, Nothing) instance NodeProperty CPUParticles "emission_points" PoolVector3Array 'False where nodeProperty = (get_emission_points, wrapDroppingSetter set_emission_points, Nothing) instance NodeProperty CPUParticles "emission_shape" Int 'False where nodeProperty = (get_emission_shape, wrapDroppingSetter set_emission_shape, Nothing) instance NodeProperty CPUParticles "emission_sphere_radius" Float 'False where nodeProperty = (get_emission_sphere_radius, wrapDroppingSetter set_emission_sphere_radius, Nothing) instance NodeProperty CPUParticles "emitting" Bool 'False where nodeProperty = (is_emitting, wrapDroppingSetter set_emitting, Nothing) instance NodeProperty CPUParticles "explosiveness" Float 'False where nodeProperty = (get_explosiveness_ratio, wrapDroppingSetter set_explosiveness_ratio, Nothing) instance NodeProperty CPUParticles "fixed_fps" Int 'False where nodeProperty = (get_fixed_fps, wrapDroppingSetter set_fixed_fps, Nothing) instance NodeProperty CPUParticles "flag_align_y" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_particle_flag, wrapIndexedSetter 0 set_particle_flag, Nothing) instance NodeProperty CPUParticles "flag_disable_z" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_particle_flag, wrapIndexedSetter 2 set_particle_flag, Nothing) instance NodeProperty CPUParticles "flag_rotate_y" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_particle_flag, wrapIndexedSetter 1 set_particle_flag, Nothing) instance NodeProperty CPUParticles "flatness" Float 'False where nodeProperty = (get_flatness, wrapDroppingSetter set_flatness, Nothing) instance NodeProperty CPUParticles "fract_delta" Bool 'False where nodeProperty = (get_fractional_delta, wrapDroppingSetter set_fractional_delta, Nothing) instance NodeProperty CPUParticles "gravity" Vector3 'False where nodeProperty = (get_gravity, wrapDroppingSetter set_gravity, Nothing) instance NodeProperty CPUParticles "hue_variation" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param, wrapIndexedSetter 9 set_param, Nothing) instance NodeProperty CPUParticles "hue_variation_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 9 get_param_curve, wrapIndexedSetter 9 set_param_curve, Nothing) instance NodeProperty CPUParticles "hue_variation_random" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param_randomness, wrapIndexedSetter 9 set_param_randomness, Nothing) instance NodeProperty CPUParticles "initial_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param, wrapIndexedSetter 0 set_param, Nothing) instance NodeProperty CPUParticles "initial_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param_randomness, wrapIndexedSetter 0 set_param_randomness, Nothing) instance NodeProperty CPUParticles "lifetime" Float 'False where nodeProperty = (get_lifetime, wrapDroppingSetter set_lifetime, Nothing) instance NodeProperty CPUParticles "lifetime_randomness" Float 'False where nodeProperty = (get_lifetime_randomness, wrapDroppingSetter set_lifetime_randomness, Nothing) instance NodeProperty CPUParticles "linear_accel" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param, wrapIndexedSetter 3 set_param, Nothing) instance NodeProperty CPUParticles "linear_accel_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 3 get_param_curve, wrapIndexedSetter 3 set_param_curve, Nothing) instance NodeProperty CPUParticles "linear_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param_randomness, wrapIndexedSetter 3 set_param_randomness, Nothing) instance NodeProperty CPUParticles "local_coords" Bool 'False where nodeProperty = (get_use_local_coordinates, wrapDroppingSetter set_use_local_coordinates, Nothing) instance NodeProperty CPUParticles "mesh" Mesh 'False where nodeProperty = (get_mesh, wrapDroppingSetter set_mesh, Nothing) instance NodeProperty CPUParticles "one_shot" Bool 'False where nodeProperty = (get_one_shot, wrapDroppingSetter set_one_shot, Nothing) instance NodeProperty CPUParticles "orbit_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param, wrapIndexedSetter 2 set_param, Nothing) instance NodeProperty CPUParticles "orbit_velocity_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 2 get_param_curve, wrapIndexedSetter 2 set_param_curve, Nothing) instance NodeProperty CPUParticles "orbit_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param_randomness, wrapIndexedSetter 2 set_param_randomness, Nothing) instance NodeProperty CPUParticles "preprocess" Float 'False where nodeProperty = (get_pre_process_time, wrapDroppingSetter set_pre_process_time, Nothing) instance NodeProperty CPUParticles "radial_accel" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param, wrapIndexedSetter 4 set_param, Nothing) instance NodeProperty CPUParticles "radial_accel_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 4 get_param_curve, wrapIndexedSetter 4 set_param_curve, Nothing) instance NodeProperty CPUParticles "radial_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param_randomness, wrapIndexedSetter 4 set_param_randomness, Nothing) instance NodeProperty CPUParticles "randomness" Float 'False where nodeProperty = (get_randomness_ratio, wrapDroppingSetter set_randomness_ratio, Nothing) instance NodeProperty CPUParticles "scale_amount" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param, wrapIndexedSetter 8 set_param, Nothing) instance NodeProperty CPUParticles "scale_amount_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 8 get_param_curve, wrapIndexedSetter 8 set_param_curve, Nothing) instance NodeProperty CPUParticles "scale_amount_random" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param_randomness, wrapIndexedSetter 8 set_param_randomness, Nothing) instance NodeProperty CPUParticles "speed_scale" Float 'False where nodeProperty = (get_speed_scale, wrapDroppingSetter set_speed_scale, Nothing) instance NodeProperty CPUParticles "spread" Float 'False where nodeProperty = (get_spread, wrapDroppingSetter set_spread, Nothing) instance NodeProperty CPUParticles "tangential_accel" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param, wrapIndexedSetter 5 set_param, Nothing) instance NodeProperty CPUParticles "tangential_accel_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 5 get_param_curve, wrapIndexedSetter 5 set_param_curve, Nothing) instance NodeProperty CPUParticles "tangential_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param_randomness, wrapIndexedSetter 5 set_param_randomness, Nothing) {-# NOINLINE bindCPUParticles__update_render_thread #-} bindCPUParticles__update_render_thread :: MethodBind bindCPUParticles__update_render_thread = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "_update_render_thread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_render_thread :: (CPUParticles :< cls, Object :< cls) => cls -> IO () _update_render_thread cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles__update_render_thread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "_update_render_thread" '[] (IO ()) where nodeMethod = Godot.Core.CPUParticles._update_render_thread {-# NOINLINE bindCPUParticles_convert_from_particles #-} -- | Sets this node's properties to match a given @Particles@ node with an assigned @ParticlesMaterial@. bindCPUParticles_convert_from_particles :: MethodBind bindCPUParticles_convert_from_particles = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "convert_from_particles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets this node's properties to match a given @Particles@ node with an assigned @ParticlesMaterial@. convert_from_particles :: (CPUParticles :< cls, Object :< cls) => cls -> Node -> IO () convert_from_particles cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_convert_from_particles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "convert_from_particles" '[Node] (IO ()) where nodeMethod = Godot.Core.CPUParticles.convert_from_particles {-# NOINLINE bindCPUParticles_get_amount #-} -- | Number of particles emitted in one emission cycle. bindCPUParticles_get_amount :: MethodBind bindCPUParticles_get_amount = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of particles emitted in one emission cycle. get_amount :: (CPUParticles :< cls, Object :< cls) => cls -> IO Int get_amount cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_amount" '[] (IO Int) where nodeMethod = Godot.Core.CPUParticles.get_amount {-# NOINLINE bindCPUParticles_get_color #-} -- | Unused for 3D particles. bindCPUParticles_get_color :: MethodBind bindCPUParticles_get_color = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unused for 3D particles. get_color :: (CPUParticles :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_color" '[] (IO Color) where nodeMethod = Godot.Core.CPUParticles.get_color {-# NOINLINE bindCPUParticles_get_color_ramp #-} -- | Unused for 3D particles. bindCPUParticles_get_color_ramp :: MethodBind bindCPUParticles_get_color_ramp = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_color_ramp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unused for 3D particles. get_color_ramp :: (CPUParticles :< cls, Object :< cls) => cls -> IO Gradient get_color_ramp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_color_ramp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_color_ramp" '[] (IO Gradient) where nodeMethod = Godot.Core.CPUParticles.get_color_ramp {-# NOINLINE bindCPUParticles_get_direction #-} -- | Unit vector specifying the particles' emission direction. bindCPUParticles_get_direction :: MethodBind bindCPUParticles_get_direction = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unit vector specifying the particles' emission direction. get_direction :: (CPUParticles :< cls, Object :< cls) => cls -> IO Vector3 get_direction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_direction" '[] (IO Vector3) where nodeMethod = Godot.Core.CPUParticles.get_direction {-# NOINLINE bindCPUParticles_get_draw_order #-} -- | Particle draw order. Uses @enum DrawOrder@ values. bindCPUParticles_get_draw_order :: MethodBind bindCPUParticles_get_draw_order = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle draw order. Uses @enum DrawOrder@ values. get_draw_order :: (CPUParticles :< cls, Object :< cls) => cls -> IO Int get_draw_order cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_draw_order" '[] (IO Int) where nodeMethod = Godot.Core.CPUParticles.get_draw_order {-# NOINLINE bindCPUParticles_get_emission_box_extents #-} -- | The rectangle's extents if @emission_shape@ is set to @EMISSION_SHAPE_BOX@. bindCPUParticles_get_emission_box_extents :: MethodBind bindCPUParticles_get_emission_box_extents = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_emission_box_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rectangle's extents if @emission_shape@ is set to @EMISSION_SHAPE_BOX@. get_emission_box_extents :: (CPUParticles :< cls, Object :< cls) => cls -> IO Vector3 get_emission_box_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_emission_box_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_emission_box_extents" '[] (IO Vector3) where nodeMethod = Godot.Core.CPUParticles.get_emission_box_extents {-# NOINLINE bindCPUParticles_get_emission_colors #-} -- | Sets the @Color@s to modulate particles by when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles_get_emission_colors :: MethodBind bindCPUParticles_get_emission_colors = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_emission_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Color@s to modulate particles by when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. get_emission_colors :: (CPUParticles :< cls, Object :< cls) => cls -> IO PoolColorArray get_emission_colors cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_emission_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_emission_colors" '[] (IO PoolColorArray) where nodeMethod = Godot.Core.CPUParticles.get_emission_colors {-# NOINLINE bindCPUParticles_get_emission_normals #-} -- | Sets the direction the particles will be emitted in when using @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles_get_emission_normals :: MethodBind bindCPUParticles_get_emission_normals = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_emission_normals" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the direction the particles will be emitted in when using @EMISSION_SHAPE_DIRECTED_POINTS@. get_emission_normals :: (CPUParticles :< cls, Object :< cls) => cls -> IO PoolVector3Array get_emission_normals cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_emission_normals (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_emission_normals" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.CPUParticles.get_emission_normals {-# NOINLINE bindCPUParticles_get_emission_points #-} -- | Sets the initial positions to spawn particles when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles_get_emission_points :: MethodBind bindCPUParticles_get_emission_points = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_emission_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the initial positions to spawn particles when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. get_emission_points :: (CPUParticles :< cls, Object :< cls) => cls -> IO PoolVector3Array get_emission_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_emission_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_emission_points" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.CPUParticles.get_emission_points {-# NOINLINE bindCPUParticles_get_emission_shape #-} -- | Particles will be emitted inside this region. See @enum EmissionShape@ for possible values. bindCPUParticles_get_emission_shape :: MethodBind bindCPUParticles_get_emission_shape = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_emission_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particles will be emitted inside this region. See @enum EmissionShape@ for possible values. get_emission_shape :: (CPUParticles :< cls, Object :< cls) => cls -> IO Int get_emission_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_emission_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_emission_shape" '[] (IO Int) where nodeMethod = Godot.Core.CPUParticles.get_emission_shape {-# NOINLINE bindCPUParticles_get_emission_sphere_radius #-} -- | The sphere's radius if @enum EmissionShape@ is set to @EMISSION_SHAPE_SPHERE@. bindCPUParticles_get_emission_sphere_radius :: MethodBind bindCPUParticles_get_emission_sphere_radius = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_emission_sphere_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sphere's radius if @enum EmissionShape@ is set to @EMISSION_SHAPE_SPHERE@. get_emission_sphere_radius :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_emission_sphere_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_emission_sphere_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_emission_sphere_radius" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_emission_sphere_radius {-# NOINLINE bindCPUParticles_get_explosiveness_ratio #-} -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. bindCPUParticles_get_explosiveness_ratio :: MethodBind bindCPUParticles_get_explosiveness_ratio = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. get_explosiveness_ratio :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_explosiveness_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_explosiveness_ratio" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_explosiveness_ratio {-# NOINLINE bindCPUParticles_get_fixed_fps #-} -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the particle system itself. bindCPUParticles_get_fixed_fps :: MethodBind bindCPUParticles_get_fixed_fps = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the particle system itself. get_fixed_fps :: (CPUParticles :< cls, Object :< cls) => cls -> IO Int get_fixed_fps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_fixed_fps" '[] (IO Int) where nodeMethod = Godot.Core.CPUParticles.get_fixed_fps {-# NOINLINE bindCPUParticles_get_flatness #-} -- | Amount of @spread@ in Y/Z plane. A value of @1@ restricts particles to X/Z plane. bindCPUParticles_get_flatness :: MethodBind bindCPUParticles_get_flatness = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_flatness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of @spread@ in Y/Z plane. A value of @1@ restricts particles to X/Z plane. get_flatness :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_flatness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_flatness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_flatness" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_flatness {-# NOINLINE bindCPUParticles_get_fractional_delta #-} -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. bindCPUParticles_get_fractional_delta :: MethodBind bindCPUParticles_get_fractional_delta = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. get_fractional_delta :: (CPUParticles :< cls, Object :< cls) => cls -> IO Bool get_fractional_delta cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_fractional_delta" '[] (IO Bool) where nodeMethod = Godot.Core.CPUParticles.get_fractional_delta {-# NOINLINE bindCPUParticles_get_gravity #-} -- | Gravity applied to every particle. bindCPUParticles_get_gravity :: MethodBind bindCPUParticles_get_gravity = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gravity applied to every particle. get_gravity :: (CPUParticles :< cls, Object :< cls) => cls -> IO Vector3 get_gravity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_gravity" '[] (IO Vector3) where nodeMethod = Godot.Core.CPUParticles.get_gravity {-# NOINLINE bindCPUParticles_get_lifetime #-} -- | Amount of time each particle will exist. bindCPUParticles_get_lifetime :: MethodBind bindCPUParticles_get_lifetime = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time each particle will exist. get_lifetime :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_lifetime cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_lifetime" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_lifetime {-# NOINLINE bindCPUParticles_get_lifetime_randomness #-} -- | Particle lifetime randomness ratio. bindCPUParticles_get_lifetime_randomness :: MethodBind bindCPUParticles_get_lifetime_randomness = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_lifetime_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle lifetime randomness ratio. get_lifetime_randomness :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_lifetime_randomness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_lifetime_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_lifetime_randomness" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_lifetime_randomness {-# NOINLINE bindCPUParticles_get_mesh #-} -- | The @Mesh@ used for each particle. If @null@, particles will be spheres. bindCPUParticles_get_mesh :: MethodBind bindCPUParticles_get_mesh = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Mesh@ used for each particle. If @null@, particles will be spheres. get_mesh :: (CPUParticles :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.CPUParticles.get_mesh {-# NOINLINE bindCPUParticles_get_one_shot #-} -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. bindCPUParticles_get_one_shot :: MethodBind bindCPUParticles_get_one_shot = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. get_one_shot :: (CPUParticles :< cls, Object :< cls) => cls -> IO Bool get_one_shot cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_one_shot" '[] (IO Bool) where nodeMethod = Godot.Core.CPUParticles.get_one_shot {-# NOINLINE bindCPUParticles_get_param #-} -- | Returns the base value of the parameter specified by @enum Parameter@. bindCPUParticles_get_param :: MethodBind bindCPUParticles_get_param = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the base value of the parameter specified by @enum Parameter@. get_param :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_param {-# NOINLINE bindCPUParticles_get_param_curve #-} -- | Returns the @Curve@ of the parameter specified by @enum Parameter@. bindCPUParticles_get_param_curve :: MethodBind bindCPUParticles_get_param_curve = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_param_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Curve@ of the parameter specified by @enum Parameter@. get_param_curve :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> IO Curve get_param_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_param_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_param_curve" '[Int] (IO Curve) where nodeMethod = Godot.Core.CPUParticles.get_param_curve {-# NOINLINE bindCPUParticles_get_param_randomness #-} -- | Returns the randomness factor of the parameter specified by @enum Parameter@. bindCPUParticles_get_param_randomness :: MethodBind bindCPUParticles_get_param_randomness = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_param_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the randomness factor of the parameter specified by @enum Parameter@. get_param_randomness :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> IO Float get_param_randomness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_param_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_param_randomness" '[Int] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_param_randomness {-# NOINLINE bindCPUParticles_get_particle_flag #-} -- | Returns the enabled state of the given flag (see @enum Flags@ for options). bindCPUParticles_get_particle_flag :: MethodBind bindCPUParticles_get_particle_flag = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_particle_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the enabled state of the given flag (see @enum Flags@ for options). get_particle_flag :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> IO Bool get_particle_flag cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_particle_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_particle_flag" '[Int] (IO Bool) where nodeMethod = Godot.Core.CPUParticles.get_particle_flag {-# NOINLINE bindCPUParticles_get_pre_process_time #-} -- | Particle system starts as if it had already run for this many seconds. bindCPUParticles_get_pre_process_time :: MethodBind bindCPUParticles_get_pre_process_time = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system starts as if it had already run for this many seconds. get_pre_process_time :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_pre_process_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_pre_process_time" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_pre_process_time {-# NOINLINE bindCPUParticles_get_randomness_ratio #-} -- | Emission lifetime randomness ratio. bindCPUParticles_get_randomness_ratio :: MethodBind bindCPUParticles_get_randomness_ratio = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emission lifetime randomness ratio. get_randomness_ratio :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_randomness_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_randomness_ratio" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_randomness_ratio {-# NOINLINE bindCPUParticles_get_speed_scale #-} -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. bindCPUParticles_get_speed_scale :: MethodBind bindCPUParticles_get_speed_scale = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. get_speed_scale :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_speed_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_speed_scale" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_speed_scale {-# NOINLINE bindCPUParticles_get_spread #-} -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. Applied to X/Z plane and Y/Z planes. bindCPUParticles_get_spread :: MethodBind bindCPUParticles_get_spread = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_spread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. Applied to X/Z plane and Y/Z planes. get_spread :: (CPUParticles :< cls, Object :< cls) => cls -> IO Float get_spread cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_spread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_spread" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles.get_spread {-# NOINLINE bindCPUParticles_get_use_local_coordinates #-} -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. bindCPUParticles_get_use_local_coordinates :: MethodBind bindCPUParticles_get_use_local_coordinates = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "get_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. get_use_local_coordinates :: (CPUParticles :< cls, Object :< cls) => cls -> IO Bool get_use_local_coordinates cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_get_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "get_use_local_coordinates" '[] (IO Bool) where nodeMethod = Godot.Core.CPUParticles.get_use_local_coordinates {-# NOINLINE bindCPUParticles_is_emitting #-} -- | If @true@, particles are being emitted. bindCPUParticles_is_emitting :: MethodBind bindCPUParticles_is_emitting = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "is_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles are being emitted. is_emitting :: (CPUParticles :< cls, Object :< cls) => cls -> IO Bool is_emitting cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_is_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "is_emitting" '[] (IO Bool) where nodeMethod = Godot.Core.CPUParticles.is_emitting {-# NOINLINE bindCPUParticles_restart #-} -- | Restarts the particle emitter. bindCPUParticles_restart :: MethodBind bindCPUParticles_restart = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "restart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Restarts the particle emitter. restart :: (CPUParticles :< cls, Object :< cls) => cls -> IO () restart cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_restart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "restart" '[] (IO ()) where nodeMethod = Godot.Core.CPUParticles.restart {-# NOINLINE bindCPUParticles_set_amount #-} -- | Number of particles emitted in one emission cycle. bindCPUParticles_set_amount :: MethodBind bindCPUParticles_set_amount = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of particles emitted in one emission cycle. set_amount :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> IO () set_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_amount" '[Int] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_amount {-# NOINLINE bindCPUParticles_set_color #-} -- | Unused for 3D particles. bindCPUParticles_set_color :: MethodBind bindCPUParticles_set_color = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unused for 3D particles. set_color :: (CPUParticles :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_color {-# NOINLINE bindCPUParticles_set_color_ramp #-} -- | Unused for 3D particles. bindCPUParticles_set_color_ramp :: MethodBind bindCPUParticles_set_color_ramp = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_color_ramp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unused for 3D particles. set_color_ramp :: (CPUParticles :< cls, Object :< cls) => cls -> Gradient -> IO () set_color_ramp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_color_ramp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_color_ramp" '[Gradient] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_color_ramp {-# NOINLINE bindCPUParticles_set_direction #-} -- | Unit vector specifying the particles' emission direction. bindCPUParticles_set_direction :: MethodBind bindCPUParticles_set_direction = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unit vector specifying the particles' emission direction. set_direction :: (CPUParticles :< cls, Object :< cls) => cls -> Vector3 -> IO () set_direction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_direction" '[Vector3] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_direction {-# NOINLINE bindCPUParticles_set_draw_order #-} -- | Particle draw order. Uses @enum DrawOrder@ values. bindCPUParticles_set_draw_order :: MethodBind bindCPUParticles_set_draw_order = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle draw order. Uses @enum DrawOrder@ values. set_draw_order :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> IO () set_draw_order cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_draw_order" '[Int] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_draw_order {-# NOINLINE bindCPUParticles_set_emission_box_extents #-} -- | The rectangle's extents if @emission_shape@ is set to @EMISSION_SHAPE_BOX@. bindCPUParticles_set_emission_box_extents :: MethodBind bindCPUParticles_set_emission_box_extents = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_emission_box_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rectangle's extents if @emission_shape@ is set to @EMISSION_SHAPE_BOX@. set_emission_box_extents :: (CPUParticles :< cls, Object :< cls) => cls -> Vector3 -> IO () set_emission_box_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_emission_box_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_emission_box_extents" '[Vector3] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_emission_box_extents {-# NOINLINE bindCPUParticles_set_emission_colors #-} -- | Sets the @Color@s to modulate particles by when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles_set_emission_colors :: MethodBind bindCPUParticles_set_emission_colors = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_emission_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Color@s to modulate particles by when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. set_emission_colors :: (CPUParticles :< cls, Object :< cls) => cls -> PoolColorArray -> IO () set_emission_colors cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_emission_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_emission_colors" '[PoolColorArray] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_emission_colors {-# NOINLINE bindCPUParticles_set_emission_normals #-} -- | Sets the direction the particles will be emitted in when using @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles_set_emission_normals :: MethodBind bindCPUParticles_set_emission_normals = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_emission_normals" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the direction the particles will be emitted in when using @EMISSION_SHAPE_DIRECTED_POINTS@. set_emission_normals :: (CPUParticles :< cls, Object :< cls) => cls -> PoolVector3Array -> IO () set_emission_normals cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_emission_normals (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_emission_normals" '[PoolVector3Array] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_emission_normals {-# NOINLINE bindCPUParticles_set_emission_points #-} -- | Sets the initial positions to spawn particles when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles_set_emission_points :: MethodBind bindCPUParticles_set_emission_points = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_emission_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the initial positions to spawn particles when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. set_emission_points :: (CPUParticles :< cls, Object :< cls) => cls -> PoolVector3Array -> IO () set_emission_points cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_emission_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_emission_points" '[PoolVector3Array] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_emission_points {-# NOINLINE bindCPUParticles_set_emission_shape #-} -- | Particles will be emitted inside this region. See @enum EmissionShape@ for possible values. bindCPUParticles_set_emission_shape :: MethodBind bindCPUParticles_set_emission_shape = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_emission_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particles will be emitted inside this region. See @enum EmissionShape@ for possible values. set_emission_shape :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> IO () set_emission_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_emission_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_emission_shape" '[Int] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_emission_shape {-# NOINLINE bindCPUParticles_set_emission_sphere_radius #-} -- | The sphere's radius if @enum EmissionShape@ is set to @EMISSION_SHAPE_SPHERE@. bindCPUParticles_set_emission_sphere_radius :: MethodBind bindCPUParticles_set_emission_sphere_radius = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_emission_sphere_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sphere's radius if @enum EmissionShape@ is set to @EMISSION_SHAPE_SPHERE@. set_emission_sphere_radius :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_emission_sphere_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_emission_sphere_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_emission_sphere_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_emission_sphere_radius {-# NOINLINE bindCPUParticles_set_emitting #-} -- | If @true@, particles are being emitted. bindCPUParticles_set_emitting :: MethodBind bindCPUParticles_set_emitting = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles are being emitted. set_emitting :: (CPUParticles :< cls, Object :< cls) => cls -> Bool -> IO () set_emitting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_emitting" '[Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_emitting {-# NOINLINE bindCPUParticles_set_explosiveness_ratio #-} -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. bindCPUParticles_set_explosiveness_ratio :: MethodBind bindCPUParticles_set_explosiveness_ratio = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. set_explosiveness_ratio :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_explosiveness_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_explosiveness_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_explosiveness_ratio {-# NOINLINE bindCPUParticles_set_fixed_fps #-} -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the particle system itself. bindCPUParticles_set_fixed_fps :: MethodBind bindCPUParticles_set_fixed_fps = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the particle system itself. set_fixed_fps :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> IO () set_fixed_fps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_fixed_fps" '[Int] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_fixed_fps {-# NOINLINE bindCPUParticles_set_flatness #-} -- | Amount of @spread@ in Y/Z plane. A value of @1@ restricts particles to X/Z plane. bindCPUParticles_set_flatness :: MethodBind bindCPUParticles_set_flatness = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_flatness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of @spread@ in Y/Z plane. A value of @1@ restricts particles to X/Z plane. set_flatness :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_flatness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_flatness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_flatness" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_flatness {-# NOINLINE bindCPUParticles_set_fractional_delta #-} -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. bindCPUParticles_set_fractional_delta :: MethodBind bindCPUParticles_set_fractional_delta = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. set_fractional_delta :: (CPUParticles :< cls, Object :< cls) => cls -> Bool -> IO () set_fractional_delta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_fractional_delta" '[Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_fractional_delta {-# NOINLINE bindCPUParticles_set_gravity #-} -- | Gravity applied to every particle. bindCPUParticles_set_gravity :: MethodBind bindCPUParticles_set_gravity = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gravity applied to every particle. set_gravity :: (CPUParticles :< cls, Object :< cls) => cls -> Vector3 -> IO () set_gravity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_gravity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_gravity {-# NOINLINE bindCPUParticles_set_lifetime #-} -- | Amount of time each particle will exist. bindCPUParticles_set_lifetime :: MethodBind bindCPUParticles_set_lifetime = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time each particle will exist. set_lifetime :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_lifetime cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_lifetime" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_lifetime {-# NOINLINE bindCPUParticles_set_lifetime_randomness #-} -- | Particle lifetime randomness ratio. bindCPUParticles_set_lifetime_randomness :: MethodBind bindCPUParticles_set_lifetime_randomness = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_lifetime_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle lifetime randomness ratio. set_lifetime_randomness :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_lifetime_randomness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_lifetime_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_lifetime_randomness" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_lifetime_randomness {-# NOINLINE bindCPUParticles_set_mesh #-} -- | The @Mesh@ used for each particle. If @null@, particles will be spheres. bindCPUParticles_set_mesh :: MethodBind bindCPUParticles_set_mesh = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Mesh@ used for each particle. If @null@, particles will be spheres. set_mesh :: (CPUParticles :< cls, Object :< cls) => cls -> Mesh -> IO () set_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_mesh" '[Mesh] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_mesh {-# NOINLINE bindCPUParticles_set_one_shot #-} -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. bindCPUParticles_set_one_shot :: MethodBind bindCPUParticles_set_one_shot = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. set_one_shot :: (CPUParticles :< cls, Object :< cls) => cls -> Bool -> IO () set_one_shot cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_one_shot" '[Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_one_shot {-# NOINLINE bindCPUParticles_set_param #-} -- | Sets the base value of the parameter specified by @enum Parameter@. bindCPUParticles_set_param :: MethodBind bindCPUParticles_set_param = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the base value of the parameter specified by @enum Parameter@. set_param :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_param {-# NOINLINE bindCPUParticles_set_param_curve #-} -- | Sets the @Curve@ of the parameter specified by @enum Parameter@. bindCPUParticles_set_param_curve :: MethodBind bindCPUParticles_set_param_curve = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_param_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Curve@ of the parameter specified by @enum Parameter@. set_param_curve :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> Curve -> IO () set_param_curve cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_param_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_param_curve" '[Int, Curve] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_param_curve {-# NOINLINE bindCPUParticles_set_param_randomness #-} -- | Sets the randomness factor of the parameter specified by @enum Parameter@. bindCPUParticles_set_param_randomness :: MethodBind bindCPUParticles_set_param_randomness = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_param_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the randomness factor of the parameter specified by @enum Parameter@. set_param_randomness :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param_randomness cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_param_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_param_randomness" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_param_randomness {-# NOINLINE bindCPUParticles_set_particle_flag #-} -- | Enables or disables the given flag (see @enum Flags@ for options). bindCPUParticles_set_particle_flag :: MethodBind bindCPUParticles_set_particle_flag = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_particle_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables the given flag (see @enum Flags@ for options). set_particle_flag :: (CPUParticles :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_particle_flag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_particle_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_particle_flag" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_particle_flag {-# NOINLINE bindCPUParticles_set_pre_process_time #-} -- | Particle system starts as if it had already run for this many seconds. bindCPUParticles_set_pre_process_time :: MethodBind bindCPUParticles_set_pre_process_time = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system starts as if it had already run for this many seconds. set_pre_process_time :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_pre_process_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_pre_process_time" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_pre_process_time {-# NOINLINE bindCPUParticles_set_randomness_ratio #-} -- | Emission lifetime randomness ratio. bindCPUParticles_set_randomness_ratio :: MethodBind bindCPUParticles_set_randomness_ratio = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emission lifetime randomness ratio. set_randomness_ratio :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_randomness_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_randomness_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_randomness_ratio {-# NOINLINE bindCPUParticles_set_speed_scale #-} -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. bindCPUParticles_set_speed_scale :: MethodBind bindCPUParticles_set_speed_scale = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. set_speed_scale :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_speed_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_speed_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_speed_scale {-# NOINLINE bindCPUParticles_set_spread #-} -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. Applied to X/Z plane and Y/Z planes. bindCPUParticles_set_spread :: MethodBind bindCPUParticles_set_spread = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_spread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. Applied to X/Z plane and Y/Z planes. set_spread :: (CPUParticles :< cls, Object :< cls) => cls -> Float -> IO () set_spread cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_spread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_spread" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_spread {-# NOINLINE bindCPUParticles_set_use_local_coordinates #-} -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. bindCPUParticles_set_use_local_coordinates :: MethodBind bindCPUParticles_set_use_local_coordinates = unsafePerformIO $ withCString "CPUParticles" $ \ clsNamePtr -> withCString "set_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. set_use_local_coordinates :: (CPUParticles :< cls, Object :< cls) => cls -> Bool -> IO () set_use_local_coordinates cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles_set_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles "set_use_local_coordinates" '[Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles.set_use_local_coordinates ================================================ FILE: src/Godot/Core/CPUParticles2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CPUParticles2D (Godot.Core.CPUParticles2D._FLAG_ALIGN_Y_TO_VELOCITY, Godot.Core.CPUParticles2D._PARAM_RADIAL_ACCEL, Godot.Core.CPUParticles2D._FLAG_ROTATE_Y, Godot.Core.CPUParticles2D._EMISSION_SHAPE_SPHERE, Godot.Core.CPUParticles2D._FLAG_DISABLE_Z, Godot.Core.CPUParticles2D._PARAM_ANGULAR_VELOCITY, Godot.Core.CPUParticles2D._EMISSION_SHAPE_MAX, Godot.Core.CPUParticles2D._PARAM_TANGENTIAL_ACCEL, Godot.Core.CPUParticles2D._PARAM_ANIM_SPEED, Godot.Core.CPUParticles2D._EMISSION_SHAPE_POINTS, Godot.Core.CPUParticles2D._PARAM_MAX, Godot.Core.CPUParticles2D._PARAM_INITIAL_LINEAR_VELOCITY, Godot.Core.CPUParticles2D._FLAG_MAX, Godot.Core.CPUParticles2D._EMISSION_SHAPE_RECTANGLE, Godot.Core.CPUParticles2D._PARAM_LINEAR_ACCEL, Godot.Core.CPUParticles2D._EMISSION_SHAPE_DIRECTED_POINTS, Godot.Core.CPUParticles2D._EMISSION_SHAPE_POINT, Godot.Core.CPUParticles2D._PARAM_ORBIT_VELOCITY, Godot.Core.CPUParticles2D._DRAW_ORDER_LIFETIME, Godot.Core.CPUParticles2D._PARAM_SCALE, Godot.Core.CPUParticles2D._DRAW_ORDER_INDEX, Godot.Core.CPUParticles2D._PARAM_DAMPING, Godot.Core.CPUParticles2D._PARAM_HUE_VARIATION, Godot.Core.CPUParticles2D._PARAM_ANIM_OFFSET, Godot.Core.CPUParticles2D._PARAM_ANGLE, Godot.Core.CPUParticles2D._update_render_thread, Godot.Core.CPUParticles2D.convert_from_particles, Godot.Core.CPUParticles2D.get_amount, Godot.Core.CPUParticles2D.get_color, Godot.Core.CPUParticles2D.get_color_ramp, Godot.Core.CPUParticles2D.get_direction, Godot.Core.CPUParticles2D.get_draw_order, Godot.Core.CPUParticles2D.get_emission_colors, Godot.Core.CPUParticles2D.get_emission_normals, Godot.Core.CPUParticles2D.get_emission_points, Godot.Core.CPUParticles2D.get_emission_rect_extents, Godot.Core.CPUParticles2D.get_emission_shape, Godot.Core.CPUParticles2D.get_emission_sphere_radius, Godot.Core.CPUParticles2D.get_explosiveness_ratio, Godot.Core.CPUParticles2D.get_fixed_fps, Godot.Core.CPUParticles2D.get_fractional_delta, Godot.Core.CPUParticles2D.get_gravity, Godot.Core.CPUParticles2D.get_lifetime, Godot.Core.CPUParticles2D.get_lifetime_randomness, Godot.Core.CPUParticles2D.get_normalmap, Godot.Core.CPUParticles2D.get_one_shot, Godot.Core.CPUParticles2D.get_param, Godot.Core.CPUParticles2D.get_param_curve, Godot.Core.CPUParticles2D.get_param_randomness, Godot.Core.CPUParticles2D.get_particle_flag, Godot.Core.CPUParticles2D.get_pre_process_time, Godot.Core.CPUParticles2D.get_randomness_ratio, Godot.Core.CPUParticles2D.get_speed_scale, Godot.Core.CPUParticles2D.get_spread, Godot.Core.CPUParticles2D.get_texture, Godot.Core.CPUParticles2D.get_use_local_coordinates, Godot.Core.CPUParticles2D.is_emitting, Godot.Core.CPUParticles2D.restart, Godot.Core.CPUParticles2D.set_amount, Godot.Core.CPUParticles2D.set_color, Godot.Core.CPUParticles2D.set_color_ramp, Godot.Core.CPUParticles2D.set_direction, Godot.Core.CPUParticles2D.set_draw_order, Godot.Core.CPUParticles2D.set_emission_colors, Godot.Core.CPUParticles2D.set_emission_normals, Godot.Core.CPUParticles2D.set_emission_points, Godot.Core.CPUParticles2D.set_emission_rect_extents, Godot.Core.CPUParticles2D.set_emission_shape, Godot.Core.CPUParticles2D.set_emission_sphere_radius, Godot.Core.CPUParticles2D.set_emitting, Godot.Core.CPUParticles2D.set_explosiveness_ratio, Godot.Core.CPUParticles2D.set_fixed_fps, Godot.Core.CPUParticles2D.set_fractional_delta, Godot.Core.CPUParticles2D.set_gravity, Godot.Core.CPUParticles2D.set_lifetime, Godot.Core.CPUParticles2D.set_lifetime_randomness, Godot.Core.CPUParticles2D.set_normalmap, Godot.Core.CPUParticles2D.set_one_shot, Godot.Core.CPUParticles2D.set_param, Godot.Core.CPUParticles2D.set_param_curve, Godot.Core.CPUParticles2D.set_param_randomness, Godot.Core.CPUParticles2D.set_particle_flag, Godot.Core.CPUParticles2D.set_pre_process_time, Godot.Core.CPUParticles2D.set_randomness_ratio, Godot.Core.CPUParticles2D.set_speed_scale, Godot.Core.CPUParticles2D.set_spread, Godot.Core.CPUParticles2D.set_texture, Godot.Core.CPUParticles2D.set_use_local_coordinates) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _FLAG_ALIGN_Y_TO_VELOCITY :: Int _FLAG_ALIGN_Y_TO_VELOCITY = 0 _PARAM_RADIAL_ACCEL :: Int _PARAM_RADIAL_ACCEL = 4 _FLAG_ROTATE_Y :: Int _FLAG_ROTATE_Y = 1 _EMISSION_SHAPE_SPHERE :: Int _EMISSION_SHAPE_SPHERE = 1 _FLAG_DISABLE_Z :: Int _FLAG_DISABLE_Z = 2 _PARAM_ANGULAR_VELOCITY :: Int _PARAM_ANGULAR_VELOCITY = 1 _EMISSION_SHAPE_MAX :: Int _EMISSION_SHAPE_MAX = 5 _PARAM_TANGENTIAL_ACCEL :: Int _PARAM_TANGENTIAL_ACCEL = 5 _PARAM_ANIM_SPEED :: Int _PARAM_ANIM_SPEED = 10 _EMISSION_SHAPE_POINTS :: Int _EMISSION_SHAPE_POINTS = 3 _PARAM_MAX :: Int _PARAM_MAX = 12 _PARAM_INITIAL_LINEAR_VELOCITY :: Int _PARAM_INITIAL_LINEAR_VELOCITY = 0 _FLAG_MAX :: Int _FLAG_MAX = 3 _EMISSION_SHAPE_RECTANGLE :: Int _EMISSION_SHAPE_RECTANGLE = 2 _PARAM_LINEAR_ACCEL :: Int _PARAM_LINEAR_ACCEL = 3 _EMISSION_SHAPE_DIRECTED_POINTS :: Int _EMISSION_SHAPE_DIRECTED_POINTS = 4 _EMISSION_SHAPE_POINT :: Int _EMISSION_SHAPE_POINT = 0 _PARAM_ORBIT_VELOCITY :: Int _PARAM_ORBIT_VELOCITY = 2 _DRAW_ORDER_LIFETIME :: Int _DRAW_ORDER_LIFETIME = 1 _PARAM_SCALE :: Int _PARAM_SCALE = 8 _DRAW_ORDER_INDEX :: Int _DRAW_ORDER_INDEX = 0 _PARAM_DAMPING :: Int _PARAM_DAMPING = 6 _PARAM_HUE_VARIATION :: Int _PARAM_HUE_VARIATION = 9 _PARAM_ANIM_OFFSET :: Int _PARAM_ANIM_OFFSET = 11 _PARAM_ANGLE :: Int _PARAM_ANGLE = 7 instance NodeProperty CPUParticles2D "amount" Int 'False where nodeProperty = (get_amount, wrapDroppingSetter set_amount, Nothing) instance NodeProperty CPUParticles2D "angle" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param, wrapIndexedSetter 7 set_param, Nothing) instance NodeProperty CPUParticles2D "angle_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 7 get_param_curve, wrapIndexedSetter 7 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "angle_random" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param_randomness, wrapIndexedSetter 7 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "angular_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param, wrapIndexedSetter 1 set_param, Nothing) instance NodeProperty CPUParticles2D "angular_velocity_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 1 get_param_curve, wrapIndexedSetter 1 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "angular_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param_randomness, wrapIndexedSetter 1 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "anim_offset" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_param, wrapIndexedSetter 11 set_param, Nothing) instance NodeProperty CPUParticles2D "anim_offset_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 11 get_param_curve, wrapIndexedSetter 11 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "anim_offset_random" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_param_randomness, wrapIndexedSetter 11 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "anim_speed" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_param, wrapIndexedSetter 10 set_param, Nothing) instance NodeProperty CPUParticles2D "anim_speed_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 10 get_param_curve, wrapIndexedSetter 10 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "anim_speed_random" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_param_randomness, wrapIndexedSetter 10 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) instance NodeProperty CPUParticles2D "color_ramp" Gradient 'False where nodeProperty = (get_color_ramp, wrapDroppingSetter set_color_ramp, Nothing) instance NodeProperty CPUParticles2D "damping" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param, wrapIndexedSetter 6 set_param, Nothing) instance NodeProperty CPUParticles2D "damping_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 6 get_param_curve, wrapIndexedSetter 6 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "damping_random" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param_randomness, wrapIndexedSetter 6 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "direction" Vector2 'False where nodeProperty = (get_direction, wrapDroppingSetter set_direction, Nothing) instance NodeProperty CPUParticles2D "draw_order" Int 'False where nodeProperty = (get_draw_order, wrapDroppingSetter set_draw_order, Nothing) instance NodeProperty CPUParticles2D "emission_colors" PoolColorArray 'False where nodeProperty = (get_emission_colors, wrapDroppingSetter set_emission_colors, Nothing) instance NodeProperty CPUParticles2D "emission_normals" PoolVector2Array 'False where nodeProperty = (get_emission_normals, wrapDroppingSetter set_emission_normals, Nothing) instance NodeProperty CPUParticles2D "emission_points" PoolVector2Array 'False where nodeProperty = (get_emission_points, wrapDroppingSetter set_emission_points, Nothing) instance NodeProperty CPUParticles2D "emission_rect_extents" Vector2 'False where nodeProperty = (get_emission_rect_extents, wrapDroppingSetter set_emission_rect_extents, Nothing) instance NodeProperty CPUParticles2D "emission_shape" Int 'False where nodeProperty = (get_emission_shape, wrapDroppingSetter set_emission_shape, Nothing) instance NodeProperty CPUParticles2D "emission_sphere_radius" Float 'False where nodeProperty = (get_emission_sphere_radius, wrapDroppingSetter set_emission_sphere_radius, Nothing) instance NodeProperty CPUParticles2D "emitting" Bool 'False where nodeProperty = (is_emitting, wrapDroppingSetter set_emitting, Nothing) instance NodeProperty CPUParticles2D "explosiveness" Float 'False where nodeProperty = (get_explosiveness_ratio, wrapDroppingSetter set_explosiveness_ratio, Nothing) instance NodeProperty CPUParticles2D "fixed_fps" Int 'False where nodeProperty = (get_fixed_fps, wrapDroppingSetter set_fixed_fps, Nothing) instance NodeProperty CPUParticles2D "flag_align_y" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_particle_flag, wrapIndexedSetter 0 set_particle_flag, Nothing) instance NodeProperty CPUParticles2D "fract_delta" Bool 'False where nodeProperty = (get_fractional_delta, wrapDroppingSetter set_fractional_delta, Nothing) instance NodeProperty CPUParticles2D "gravity" Vector2 'False where nodeProperty = (get_gravity, wrapDroppingSetter set_gravity, Nothing) instance NodeProperty CPUParticles2D "hue_variation" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param, wrapIndexedSetter 9 set_param, Nothing) instance NodeProperty CPUParticles2D "hue_variation_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 9 get_param_curve, wrapIndexedSetter 9 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "hue_variation_random" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param_randomness, wrapIndexedSetter 9 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "initial_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param, wrapIndexedSetter 0 set_param, Nothing) instance NodeProperty CPUParticles2D "initial_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param_randomness, wrapIndexedSetter 0 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "lifetime" Float 'False where nodeProperty = (get_lifetime, wrapDroppingSetter set_lifetime, Nothing) instance NodeProperty CPUParticles2D "lifetime_randomness" Float 'False where nodeProperty = (get_lifetime_randomness, wrapDroppingSetter set_lifetime_randomness, Nothing) instance NodeProperty CPUParticles2D "linear_accel" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param, wrapIndexedSetter 3 set_param, Nothing) instance NodeProperty CPUParticles2D "linear_accel_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 3 get_param_curve, wrapIndexedSetter 3 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "linear_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param_randomness, wrapIndexedSetter 3 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "local_coords" Bool 'False where nodeProperty = (get_use_local_coordinates, wrapDroppingSetter set_use_local_coordinates, Nothing) instance NodeProperty CPUParticles2D "normalmap" Texture 'False where nodeProperty = (get_normalmap, wrapDroppingSetter set_normalmap, Nothing) instance NodeProperty CPUParticles2D "one_shot" Bool 'False where nodeProperty = (get_one_shot, wrapDroppingSetter set_one_shot, Nothing) instance NodeProperty CPUParticles2D "orbit_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param, wrapIndexedSetter 2 set_param, Nothing) instance NodeProperty CPUParticles2D "orbit_velocity_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 2 get_param_curve, wrapIndexedSetter 2 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "orbit_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param_randomness, wrapIndexedSetter 2 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "preprocess" Float 'False where nodeProperty = (get_pre_process_time, wrapDroppingSetter set_pre_process_time, Nothing) instance NodeProperty CPUParticles2D "radial_accel" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param, wrapIndexedSetter 4 set_param, Nothing) instance NodeProperty CPUParticles2D "radial_accel_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 4 get_param_curve, wrapIndexedSetter 4 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "radial_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param_randomness, wrapIndexedSetter 4 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "randomness" Float 'False where nodeProperty = (get_randomness_ratio, wrapDroppingSetter set_randomness_ratio, Nothing) instance NodeProperty CPUParticles2D "scale_amount" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param, wrapIndexedSetter 8 set_param, Nothing) instance NodeProperty CPUParticles2D "scale_amount_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 8 get_param_curve, wrapIndexedSetter 8 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "scale_amount_random" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param_randomness, wrapIndexedSetter 8 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "speed_scale" Float 'False where nodeProperty = (get_speed_scale, wrapDroppingSetter set_speed_scale, Nothing) instance NodeProperty CPUParticles2D "spread" Float 'False where nodeProperty = (get_spread, wrapDroppingSetter set_spread, Nothing) instance NodeProperty CPUParticles2D "tangential_accel" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param, wrapIndexedSetter 5 set_param, Nothing) instance NodeProperty CPUParticles2D "tangential_accel_curve" Curve 'False where nodeProperty = (wrapIndexedGetter 5 get_param_curve, wrapIndexedSetter 5 set_param_curve, Nothing) instance NodeProperty CPUParticles2D "tangential_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param_randomness, wrapIndexedSetter 5 set_param_randomness, Nothing) instance NodeProperty CPUParticles2D "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) {-# NOINLINE bindCPUParticles2D__update_render_thread #-} bindCPUParticles2D__update_render_thread :: MethodBind bindCPUParticles2D__update_render_thread = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "_update_render_thread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_render_thread :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO () _update_render_thread cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D__update_render_thread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "_update_render_thread" '[] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D._update_render_thread {-# NOINLINE bindCPUParticles2D_convert_from_particles #-} -- | Sets this node's properties to match a given @Particles2D@ node with an assigned @ParticlesMaterial@. bindCPUParticles2D_convert_from_particles :: MethodBind bindCPUParticles2D_convert_from_particles = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "convert_from_particles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets this node's properties to match a given @Particles2D@ node with an assigned @ParticlesMaterial@. convert_from_particles :: (CPUParticles2D :< cls, Object :< cls) => cls -> Node -> IO () convert_from_particles cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_convert_from_particles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "convert_from_particles" '[Node] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.convert_from_particles {-# NOINLINE bindCPUParticles2D_get_amount #-} -- | Number of particles emitted in one emission cycle. bindCPUParticles2D_get_amount :: MethodBind bindCPUParticles2D_get_amount = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of particles emitted in one emission cycle. get_amount :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Int get_amount cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_amount" '[] (IO Int) where nodeMethod = Godot.Core.CPUParticles2D.get_amount {-# NOINLINE bindCPUParticles2D_get_color #-} -- | Each particle's initial color. If @texture@ is defined, it will be multiplied by this color. bindCPUParticles2D_get_color :: MethodBind bindCPUParticles2D_get_color = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial color. If @texture@ is defined, it will be multiplied by this color. get_color :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_color" '[] (IO Color) where nodeMethod = Godot.Core.CPUParticles2D.get_color {-# NOINLINE bindCPUParticles2D_get_color_ramp #-} -- | Each particle's color will vary along this @Gradient@. bindCPUParticles2D_get_color_ramp :: MethodBind bindCPUParticles2D_get_color_ramp = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_color_ramp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's color will vary along this @Gradient@. get_color_ramp :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Gradient get_color_ramp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_color_ramp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_color_ramp" '[] (IO Gradient) where nodeMethod = Godot.Core.CPUParticles2D.get_color_ramp {-# NOINLINE bindCPUParticles2D_get_direction #-} -- | Unit vector specifying the particles' emission direction. bindCPUParticles2D_get_direction :: MethodBind bindCPUParticles2D_get_direction = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unit vector specifying the particles' emission direction. get_direction :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Vector2 get_direction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_direction" '[] (IO Vector2) where nodeMethod = Godot.Core.CPUParticles2D.get_direction {-# NOINLINE bindCPUParticles2D_get_draw_order #-} -- | Particle draw order. Uses @enum DrawOrder@ values. bindCPUParticles2D_get_draw_order :: MethodBind bindCPUParticles2D_get_draw_order = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle draw order. Uses @enum DrawOrder@ values. get_draw_order :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Int get_draw_order cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_draw_order" '[] (IO Int) where nodeMethod = Godot.Core.CPUParticles2D.get_draw_order {-# NOINLINE bindCPUParticles2D_get_emission_colors #-} -- | Sets the @Color@s to modulate particles by when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles2D_get_emission_colors :: MethodBind bindCPUParticles2D_get_emission_colors = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_emission_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Color@s to modulate particles by when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. get_emission_colors :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO PoolColorArray get_emission_colors cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_emission_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_emission_colors" '[] (IO PoolColorArray) where nodeMethod = Godot.Core.CPUParticles2D.get_emission_colors {-# NOINLINE bindCPUParticles2D_get_emission_normals #-} -- | Sets the direction the particles will be emitted in when using @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles2D_get_emission_normals :: MethodBind bindCPUParticles2D_get_emission_normals = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_emission_normals" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the direction the particles will be emitted in when using @EMISSION_SHAPE_DIRECTED_POINTS@. get_emission_normals :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_emission_normals cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_emission_normals (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_emission_normals" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.CPUParticles2D.get_emission_normals {-# NOINLINE bindCPUParticles2D_get_emission_points #-} -- | Sets the initial positions to spawn particles when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles2D_get_emission_points :: MethodBind bindCPUParticles2D_get_emission_points = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_emission_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the initial positions to spawn particles when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. get_emission_points :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_emission_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_emission_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_emission_points" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.CPUParticles2D.get_emission_points {-# NOINLINE bindCPUParticles2D_get_emission_rect_extents #-} -- | The rectangle's extents if @emission_shape@ is set to @EMISSION_SHAPE_RECTANGLE@. bindCPUParticles2D_get_emission_rect_extents :: MethodBind bindCPUParticles2D_get_emission_rect_extents = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_emission_rect_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rectangle's extents if @emission_shape@ is set to @EMISSION_SHAPE_RECTANGLE@. get_emission_rect_extents :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Vector2 get_emission_rect_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_emission_rect_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_emission_rect_extents" '[] (IO Vector2) where nodeMethod = Godot.Core.CPUParticles2D.get_emission_rect_extents {-# NOINLINE bindCPUParticles2D_get_emission_shape #-} -- | Particles will be emitted inside this region. See @enum EmissionShape@ for possible values. bindCPUParticles2D_get_emission_shape :: MethodBind bindCPUParticles2D_get_emission_shape = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_emission_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particles will be emitted inside this region. See @enum EmissionShape@ for possible values. get_emission_shape :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Int get_emission_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_emission_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_emission_shape" '[] (IO Int) where nodeMethod = Godot.Core.CPUParticles2D.get_emission_shape {-# NOINLINE bindCPUParticles2D_get_emission_sphere_radius #-} -- | The sphere's radius if @emission_shape@ is set to @EMISSION_SHAPE_SPHERE@. bindCPUParticles2D_get_emission_sphere_radius :: MethodBind bindCPUParticles2D_get_emission_sphere_radius = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_emission_sphere_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sphere's radius if @emission_shape@ is set to @EMISSION_SHAPE_SPHERE@. get_emission_sphere_radius :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Float get_emission_sphere_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_emission_sphere_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_emission_sphere_radius" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_emission_sphere_radius {-# NOINLINE bindCPUParticles2D_get_explosiveness_ratio #-} -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. bindCPUParticles2D_get_explosiveness_ratio :: MethodBind bindCPUParticles2D_get_explosiveness_ratio = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. get_explosiveness_ratio :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Float get_explosiveness_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_explosiveness_ratio" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_explosiveness_ratio {-# NOINLINE bindCPUParticles2D_get_fixed_fps #-} -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. bindCPUParticles2D_get_fixed_fps :: MethodBind bindCPUParticles2D_get_fixed_fps = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. get_fixed_fps :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Int get_fixed_fps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_fixed_fps" '[] (IO Int) where nodeMethod = Godot.Core.CPUParticles2D.get_fixed_fps {-# NOINLINE bindCPUParticles2D_get_fractional_delta #-} -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. bindCPUParticles2D_get_fractional_delta :: MethodBind bindCPUParticles2D_get_fractional_delta = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. get_fractional_delta :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Bool get_fractional_delta cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_fractional_delta" '[] (IO Bool) where nodeMethod = Godot.Core.CPUParticles2D.get_fractional_delta {-# NOINLINE bindCPUParticles2D_get_gravity #-} -- | Gravity applied to every particle. bindCPUParticles2D_get_gravity :: MethodBind bindCPUParticles2D_get_gravity = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gravity applied to every particle. get_gravity :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Vector2 get_gravity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_gravity" '[] (IO Vector2) where nodeMethod = Godot.Core.CPUParticles2D.get_gravity {-# NOINLINE bindCPUParticles2D_get_lifetime #-} -- | Amount of time each particle will exist. bindCPUParticles2D_get_lifetime :: MethodBind bindCPUParticles2D_get_lifetime = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time each particle will exist. get_lifetime :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Float get_lifetime cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_lifetime" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_lifetime {-# NOINLINE bindCPUParticles2D_get_lifetime_randomness #-} -- | Particle lifetime randomness ratio. bindCPUParticles2D_get_lifetime_randomness :: MethodBind bindCPUParticles2D_get_lifetime_randomness = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_lifetime_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle lifetime randomness ratio. get_lifetime_randomness :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Float get_lifetime_randomness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_lifetime_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_lifetime_randomness" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_lifetime_randomness {-# NOINLINE bindCPUParticles2D_get_normalmap #-} -- | Normal map to be used for the @texture@ property. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindCPUParticles2D_get_normalmap :: MethodBind bindCPUParticles2D_get_normalmap = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_normalmap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Normal map to be used for the @texture@ property. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. get_normalmap :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Texture get_normalmap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_normalmap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_normalmap" '[] (IO Texture) where nodeMethod = Godot.Core.CPUParticles2D.get_normalmap {-# NOINLINE bindCPUParticles2D_get_one_shot #-} -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. bindCPUParticles2D_get_one_shot :: MethodBind bindCPUParticles2D_get_one_shot = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. get_one_shot :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Bool get_one_shot cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_one_shot" '[] (IO Bool) where nodeMethod = Godot.Core.CPUParticles2D.get_one_shot {-# NOINLINE bindCPUParticles2D_get_param #-} -- | Returns the base value of the parameter specified by @enum Parameter@. bindCPUParticles2D_get_param :: MethodBind bindCPUParticles2D_get_param = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the base value of the parameter specified by @enum Parameter@. get_param :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_param {-# NOINLINE bindCPUParticles2D_get_param_curve #-} -- | Returns the @Curve@ of the parameter specified by @enum Parameter@. bindCPUParticles2D_get_param_curve :: MethodBind bindCPUParticles2D_get_param_curve = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_param_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Curve@ of the parameter specified by @enum Parameter@. get_param_curve :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> IO Curve get_param_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_param_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_param_curve" '[Int] (IO Curve) where nodeMethod = Godot.Core.CPUParticles2D.get_param_curve {-# NOINLINE bindCPUParticles2D_get_param_randomness #-} -- | Returns the randomness factor of the parameter specified by @enum Parameter@. bindCPUParticles2D_get_param_randomness :: MethodBind bindCPUParticles2D_get_param_randomness = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_param_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the randomness factor of the parameter specified by @enum Parameter@. get_param_randomness :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> IO Float get_param_randomness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_param_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_param_randomness" '[Int] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_param_randomness {-# NOINLINE bindCPUParticles2D_get_particle_flag #-} -- | Returns the enabled state of the given flag (see @enum Flags@ for options). bindCPUParticles2D_get_particle_flag :: MethodBind bindCPUParticles2D_get_particle_flag = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_particle_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the enabled state of the given flag (see @enum Flags@ for options). get_particle_flag :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> IO Bool get_particle_flag cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_particle_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_particle_flag" '[Int] (IO Bool) where nodeMethod = Godot.Core.CPUParticles2D.get_particle_flag {-# NOINLINE bindCPUParticles2D_get_pre_process_time #-} -- | Particle system starts as if it had already run for this many seconds. bindCPUParticles2D_get_pre_process_time :: MethodBind bindCPUParticles2D_get_pre_process_time = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system starts as if it had already run for this many seconds. get_pre_process_time :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Float get_pre_process_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_pre_process_time" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_pre_process_time {-# NOINLINE bindCPUParticles2D_get_randomness_ratio #-} -- | Emission lifetime randomness ratio. bindCPUParticles2D_get_randomness_ratio :: MethodBind bindCPUParticles2D_get_randomness_ratio = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emission lifetime randomness ratio. get_randomness_ratio :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Float get_randomness_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_randomness_ratio" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_randomness_ratio {-# NOINLINE bindCPUParticles2D_get_speed_scale #-} -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. bindCPUParticles2D_get_speed_scale :: MethodBind bindCPUParticles2D_get_speed_scale = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. get_speed_scale :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Float get_speed_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_speed_scale" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_speed_scale {-# NOINLINE bindCPUParticles2D_get_spread #-} -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. bindCPUParticles2D_get_spread :: MethodBind bindCPUParticles2D_get_spread = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_spread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. get_spread :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Float get_spread cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_spread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_spread" '[] (IO Float) where nodeMethod = Godot.Core.CPUParticles2D.get_spread {-# NOINLINE bindCPUParticles2D_get_texture #-} -- | Particle texture. If @null@, particles will be squares. bindCPUParticles2D_get_texture :: MethodBind bindCPUParticles2D_get_texture = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle texture. If @null@, particles will be squares. get_texture :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.CPUParticles2D.get_texture {-# NOINLINE bindCPUParticles2D_get_use_local_coordinates #-} -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. bindCPUParticles2D_get_use_local_coordinates :: MethodBind bindCPUParticles2D_get_use_local_coordinates = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "get_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. get_use_local_coordinates :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Bool get_use_local_coordinates cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_get_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "get_use_local_coordinates" '[] (IO Bool) where nodeMethod = Godot.Core.CPUParticles2D.get_use_local_coordinates {-# NOINLINE bindCPUParticles2D_is_emitting #-} -- | If @true@, particles are being emitted. bindCPUParticles2D_is_emitting :: MethodBind bindCPUParticles2D_is_emitting = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "is_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles are being emitted. is_emitting :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO Bool is_emitting cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_is_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "is_emitting" '[] (IO Bool) where nodeMethod = Godot.Core.CPUParticles2D.is_emitting {-# NOINLINE bindCPUParticles2D_restart #-} -- | Restarts the particle emitter. bindCPUParticles2D_restart :: MethodBind bindCPUParticles2D_restart = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "restart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Restarts the particle emitter. restart :: (CPUParticles2D :< cls, Object :< cls) => cls -> IO () restart cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_restart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "restart" '[] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.restart {-# NOINLINE bindCPUParticles2D_set_amount #-} -- | Number of particles emitted in one emission cycle. bindCPUParticles2D_set_amount :: MethodBind bindCPUParticles2D_set_amount = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of particles emitted in one emission cycle. set_amount :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> IO () set_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_amount" '[Int] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_amount {-# NOINLINE bindCPUParticles2D_set_color #-} -- | Each particle's initial color. If @texture@ is defined, it will be multiplied by this color. bindCPUParticles2D_set_color :: MethodBind bindCPUParticles2D_set_color = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial color. If @texture@ is defined, it will be multiplied by this color. set_color :: (CPUParticles2D :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_color {-# NOINLINE bindCPUParticles2D_set_color_ramp #-} -- | Each particle's color will vary along this @Gradient@. bindCPUParticles2D_set_color_ramp :: MethodBind bindCPUParticles2D_set_color_ramp = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_color_ramp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's color will vary along this @Gradient@. set_color_ramp :: (CPUParticles2D :< cls, Object :< cls) => cls -> Gradient -> IO () set_color_ramp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_color_ramp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_color_ramp" '[Gradient] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_color_ramp {-# NOINLINE bindCPUParticles2D_set_direction #-} -- | Unit vector specifying the particles' emission direction. bindCPUParticles2D_set_direction :: MethodBind bindCPUParticles2D_set_direction = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unit vector specifying the particles' emission direction. set_direction :: (CPUParticles2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_direction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_direction" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_direction {-# NOINLINE bindCPUParticles2D_set_draw_order #-} -- | Particle draw order. Uses @enum DrawOrder@ values. bindCPUParticles2D_set_draw_order :: MethodBind bindCPUParticles2D_set_draw_order = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle draw order. Uses @enum DrawOrder@ values. set_draw_order :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> IO () set_draw_order cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_draw_order" '[Int] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_draw_order {-# NOINLINE bindCPUParticles2D_set_emission_colors #-} -- | Sets the @Color@s to modulate particles by when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles2D_set_emission_colors :: MethodBind bindCPUParticles2D_set_emission_colors = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_emission_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Color@s to modulate particles by when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. set_emission_colors :: (CPUParticles2D :< cls, Object :< cls) => cls -> PoolColorArray -> IO () set_emission_colors cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_emission_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_emission_colors" '[PoolColorArray] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_emission_colors {-# NOINLINE bindCPUParticles2D_set_emission_normals #-} -- | Sets the direction the particles will be emitted in when using @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles2D_set_emission_normals :: MethodBind bindCPUParticles2D_set_emission_normals = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_emission_normals" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the direction the particles will be emitted in when using @EMISSION_SHAPE_DIRECTED_POINTS@. set_emission_normals :: (CPUParticles2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_emission_normals cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_emission_normals (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_emission_normals" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_emission_normals {-# NOINLINE bindCPUParticles2D_set_emission_points #-} -- | Sets the initial positions to spawn particles when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindCPUParticles2D_set_emission_points :: MethodBind bindCPUParticles2D_set_emission_points = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_emission_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the initial positions to spawn particles when using @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. set_emission_points :: (CPUParticles2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_emission_points cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_emission_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_emission_points" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_emission_points {-# NOINLINE bindCPUParticles2D_set_emission_rect_extents #-} -- | The rectangle's extents if @emission_shape@ is set to @EMISSION_SHAPE_RECTANGLE@. bindCPUParticles2D_set_emission_rect_extents :: MethodBind bindCPUParticles2D_set_emission_rect_extents = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_emission_rect_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rectangle's extents if @emission_shape@ is set to @EMISSION_SHAPE_RECTANGLE@. set_emission_rect_extents :: (CPUParticles2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_emission_rect_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_emission_rect_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_emission_rect_extents" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_emission_rect_extents {-# NOINLINE bindCPUParticles2D_set_emission_shape #-} -- | Particles will be emitted inside this region. See @enum EmissionShape@ for possible values. bindCPUParticles2D_set_emission_shape :: MethodBind bindCPUParticles2D_set_emission_shape = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_emission_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particles will be emitted inside this region. See @enum EmissionShape@ for possible values. set_emission_shape :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> IO () set_emission_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_emission_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_emission_shape" '[Int] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_emission_shape {-# NOINLINE bindCPUParticles2D_set_emission_sphere_radius #-} -- | The sphere's radius if @emission_shape@ is set to @EMISSION_SHAPE_SPHERE@. bindCPUParticles2D_set_emission_sphere_radius :: MethodBind bindCPUParticles2D_set_emission_sphere_radius = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_emission_sphere_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sphere's radius if @emission_shape@ is set to @EMISSION_SHAPE_SPHERE@. set_emission_sphere_radius :: (CPUParticles2D :< cls, Object :< cls) => cls -> Float -> IO () set_emission_sphere_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_emission_sphere_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_emission_sphere_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_emission_sphere_radius {-# NOINLINE bindCPUParticles2D_set_emitting #-} -- | If @true@, particles are being emitted. bindCPUParticles2D_set_emitting :: MethodBind bindCPUParticles2D_set_emitting = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles are being emitted. set_emitting :: (CPUParticles2D :< cls, Object :< cls) => cls -> Bool -> IO () set_emitting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_emitting" '[Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_emitting {-# NOINLINE bindCPUParticles2D_set_explosiveness_ratio #-} -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. bindCPUParticles2D_set_explosiveness_ratio :: MethodBind bindCPUParticles2D_set_explosiveness_ratio = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. set_explosiveness_ratio :: (CPUParticles2D :< cls, Object :< cls) => cls -> Float -> IO () set_explosiveness_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_explosiveness_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_explosiveness_ratio {-# NOINLINE bindCPUParticles2D_set_fixed_fps #-} -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. bindCPUParticles2D_set_fixed_fps :: MethodBind bindCPUParticles2D_set_fixed_fps = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. set_fixed_fps :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> IO () set_fixed_fps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_fixed_fps" '[Int] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_fixed_fps {-# NOINLINE bindCPUParticles2D_set_fractional_delta #-} -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. bindCPUParticles2D_set_fractional_delta :: MethodBind bindCPUParticles2D_set_fractional_delta = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. set_fractional_delta :: (CPUParticles2D :< cls, Object :< cls) => cls -> Bool -> IO () set_fractional_delta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_fractional_delta" '[Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_fractional_delta {-# NOINLINE bindCPUParticles2D_set_gravity #-} -- | Gravity applied to every particle. bindCPUParticles2D_set_gravity :: MethodBind bindCPUParticles2D_set_gravity = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gravity applied to every particle. set_gravity :: (CPUParticles2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_gravity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_gravity" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_gravity {-# NOINLINE bindCPUParticles2D_set_lifetime #-} -- | Amount of time each particle will exist. bindCPUParticles2D_set_lifetime :: MethodBind bindCPUParticles2D_set_lifetime = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time each particle will exist. set_lifetime :: (CPUParticles2D :< cls, Object :< cls) => cls -> Float -> IO () set_lifetime cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_lifetime" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_lifetime {-# NOINLINE bindCPUParticles2D_set_lifetime_randomness #-} -- | Particle lifetime randomness ratio. bindCPUParticles2D_set_lifetime_randomness :: MethodBind bindCPUParticles2D_set_lifetime_randomness = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_lifetime_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle lifetime randomness ratio. set_lifetime_randomness :: (CPUParticles2D :< cls, Object :< cls) => cls -> Float -> IO () set_lifetime_randomness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_lifetime_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_lifetime_randomness" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_lifetime_randomness {-# NOINLINE bindCPUParticles2D_set_normalmap #-} -- | Normal map to be used for the @texture@ property. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindCPUParticles2D_set_normalmap :: MethodBind bindCPUParticles2D_set_normalmap = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_normalmap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Normal map to be used for the @texture@ property. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. set_normalmap :: (CPUParticles2D :< cls, Object :< cls) => cls -> Texture -> IO () set_normalmap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_normalmap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_normalmap" '[Texture] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_normalmap {-# NOINLINE bindCPUParticles2D_set_one_shot #-} -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. bindCPUParticles2D_set_one_shot :: MethodBind bindCPUParticles2D_set_one_shot = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. set_one_shot :: (CPUParticles2D :< cls, Object :< cls) => cls -> Bool -> IO () set_one_shot cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_one_shot" '[Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_one_shot {-# NOINLINE bindCPUParticles2D_set_param #-} -- | Sets the base value of the parameter specified by @enum Parameter@. bindCPUParticles2D_set_param :: MethodBind bindCPUParticles2D_set_param = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the base value of the parameter specified by @enum Parameter@. set_param :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_param {-# NOINLINE bindCPUParticles2D_set_param_curve #-} -- | Sets the @Curve@ of the parameter specified by @enum Parameter@. bindCPUParticles2D_set_param_curve :: MethodBind bindCPUParticles2D_set_param_curve = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_param_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Curve@ of the parameter specified by @enum Parameter@. set_param_curve :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> Curve -> IO () set_param_curve cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_param_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_param_curve" '[Int, Curve] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_param_curve {-# NOINLINE bindCPUParticles2D_set_param_randomness #-} -- | Sets the randomness factor of the parameter specified by @enum Parameter@. bindCPUParticles2D_set_param_randomness :: MethodBind bindCPUParticles2D_set_param_randomness = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_param_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the randomness factor of the parameter specified by @enum Parameter@. set_param_randomness :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param_randomness cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_param_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_param_randomness" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_param_randomness {-# NOINLINE bindCPUParticles2D_set_particle_flag #-} -- | Enables or disables the given flag (see @enum Flags@ for options). bindCPUParticles2D_set_particle_flag :: MethodBind bindCPUParticles2D_set_particle_flag = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_particle_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables the given flag (see @enum Flags@ for options). set_particle_flag :: (CPUParticles2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_particle_flag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_particle_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_particle_flag" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_particle_flag {-# NOINLINE bindCPUParticles2D_set_pre_process_time #-} -- | Particle system starts as if it had already run for this many seconds. bindCPUParticles2D_set_pre_process_time :: MethodBind bindCPUParticles2D_set_pre_process_time = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system starts as if it had already run for this many seconds. set_pre_process_time :: (CPUParticles2D :< cls, Object :< cls) => cls -> Float -> IO () set_pre_process_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_pre_process_time" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_pre_process_time {-# NOINLINE bindCPUParticles2D_set_randomness_ratio #-} -- | Emission lifetime randomness ratio. bindCPUParticles2D_set_randomness_ratio :: MethodBind bindCPUParticles2D_set_randomness_ratio = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emission lifetime randomness ratio. set_randomness_ratio :: (CPUParticles2D :< cls, Object :< cls) => cls -> Float -> IO () set_randomness_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_randomness_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_randomness_ratio {-# NOINLINE bindCPUParticles2D_set_speed_scale #-} -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. bindCPUParticles2D_set_speed_scale :: MethodBind bindCPUParticles2D_set_speed_scale = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. set_speed_scale :: (CPUParticles2D :< cls, Object :< cls) => cls -> Float -> IO () set_speed_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_speed_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_speed_scale {-# NOINLINE bindCPUParticles2D_set_spread #-} -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. bindCPUParticles2D_set_spread :: MethodBind bindCPUParticles2D_set_spread = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_spread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. set_spread :: (CPUParticles2D :< cls, Object :< cls) => cls -> Float -> IO () set_spread cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_spread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_spread" '[Float] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_spread {-# NOINLINE bindCPUParticles2D_set_texture #-} -- | Particle texture. If @null@, particles will be squares. bindCPUParticles2D_set_texture :: MethodBind bindCPUParticles2D_set_texture = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle texture. If @null@, particles will be squares. set_texture :: (CPUParticles2D :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_texture {-# NOINLINE bindCPUParticles2D_set_use_local_coordinates #-} -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. bindCPUParticles2D_set_use_local_coordinates :: MethodBind bindCPUParticles2D_set_use_local_coordinates = unsafePerformIO $ withCString "CPUParticles2D" $ \ clsNamePtr -> withCString "set_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. set_use_local_coordinates :: (CPUParticles2D :< cls, Object :< cls) => cls -> Bool -> IO () set_use_local_coordinates cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCPUParticles2D_set_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CPUParticles2D "set_use_local_coordinates" '[Bool] (IO ()) where nodeMethod = Godot.Core.CPUParticles2D.set_use_local_coordinates ================================================ FILE: src/Godot/Core/CSGBox.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGBox (Godot.Core.CSGBox.get_depth, Godot.Core.CSGBox.get_height, Godot.Core.CSGBox.get_material, Godot.Core.CSGBox.get_width, Godot.Core.CSGBox.set_depth, Godot.Core.CSGBox.set_height, Godot.Core.CSGBox.set_material, Godot.Core.CSGBox.set_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CSGPrimitive() instance NodeProperty CSGBox "depth" Float 'False where nodeProperty = (get_depth, wrapDroppingSetter set_depth, Nothing) instance NodeProperty CSGBox "height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty CSGBox "material" Material 'False where nodeProperty = (get_material, wrapDroppingSetter set_material, Nothing) instance NodeProperty CSGBox "width" Float 'False where nodeProperty = (get_width, wrapDroppingSetter set_width, Nothing) {-# NOINLINE bindCSGBox_get_depth #-} bindCSGBox_get_depth :: MethodBind bindCSGBox_get_depth = unsafePerformIO $ withCString "CSGBox" $ \ clsNamePtr -> withCString "get_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_depth :: (CSGBox :< cls, Object :< cls) => cls -> IO Float get_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGBox_get_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGBox "get_depth" '[] (IO Float) where nodeMethod = Godot.Core.CSGBox.get_depth {-# NOINLINE bindCSGBox_get_height #-} bindCSGBox_get_height :: MethodBind bindCSGBox_get_height = unsafePerformIO $ withCString "CSGBox" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_height :: (CSGBox :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGBox_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGBox "get_height" '[] (IO Float) where nodeMethod = Godot.Core.CSGBox.get_height {-# NOINLINE bindCSGBox_get_material #-} bindCSGBox_get_material :: MethodBind bindCSGBox_get_material = unsafePerformIO $ withCString "CSGBox" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_material :: (CSGBox :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGBox_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGBox "get_material" '[] (IO Material) where nodeMethod = Godot.Core.CSGBox.get_material {-# NOINLINE bindCSGBox_get_width #-} bindCSGBox_get_width :: MethodBind bindCSGBox_get_width = unsafePerformIO $ withCString "CSGBox" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_width :: (CSGBox :< cls, Object :< cls) => cls -> IO Float get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGBox_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGBox "get_width" '[] (IO Float) where nodeMethod = Godot.Core.CSGBox.get_width {-# NOINLINE bindCSGBox_set_depth #-} bindCSGBox_set_depth :: MethodBind bindCSGBox_set_depth = unsafePerformIO $ withCString "CSGBox" $ \ clsNamePtr -> withCString "set_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_depth :: (CSGBox :< cls, Object :< cls) => cls -> Float -> IO () set_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGBox_set_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGBox "set_depth" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGBox.set_depth {-# NOINLINE bindCSGBox_set_height #-} bindCSGBox_set_height :: MethodBind bindCSGBox_set_height = unsafePerformIO $ withCString "CSGBox" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_height :: (CSGBox :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGBox_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGBox "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGBox.set_height {-# NOINLINE bindCSGBox_set_material #-} bindCSGBox_set_material :: MethodBind bindCSGBox_set_material = unsafePerformIO $ withCString "CSGBox" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_material :: (CSGBox :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGBox_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGBox "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.CSGBox.set_material {-# NOINLINE bindCSGBox_set_width #-} bindCSGBox_set_width :: MethodBind bindCSGBox_set_width = unsafePerformIO $ withCString "CSGBox" $ \ clsNamePtr -> withCString "set_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_width :: (CSGBox :< cls, Object :< cls) => cls -> Float -> IO () set_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGBox_set_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGBox "set_width" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGBox.set_width ================================================ FILE: src/Godot/Core/CSGCombiner.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGCombiner () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CSGShape() ================================================ FILE: src/Godot/Core/CSGCylinder.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGCylinder (Godot.Core.CSGCylinder.get_height, Godot.Core.CSGCylinder.get_material, Godot.Core.CSGCylinder.get_radius, Godot.Core.CSGCylinder.get_sides, Godot.Core.CSGCylinder.get_smooth_faces, Godot.Core.CSGCylinder.is_cone, Godot.Core.CSGCylinder.set_cone, Godot.Core.CSGCylinder.set_height, Godot.Core.CSGCylinder.set_material, Godot.Core.CSGCylinder.set_radius, Godot.Core.CSGCylinder.set_sides, Godot.Core.CSGCylinder.set_smooth_faces) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CSGPrimitive() instance NodeProperty CSGCylinder "cone" Bool 'False where nodeProperty = (is_cone, wrapDroppingSetter set_cone, Nothing) instance NodeProperty CSGCylinder "height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty CSGCylinder "material" Material 'False where nodeProperty = (get_material, wrapDroppingSetter set_material, Nothing) instance NodeProperty CSGCylinder "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) instance NodeProperty CSGCylinder "sides" Int 'False where nodeProperty = (get_sides, wrapDroppingSetter set_sides, Nothing) instance NodeProperty CSGCylinder "smooth_faces" Bool 'False where nodeProperty = (get_smooth_faces, wrapDroppingSetter set_smooth_faces, Nothing) {-# NOINLINE bindCSGCylinder_get_height #-} bindCSGCylinder_get_height :: MethodBind bindCSGCylinder_get_height = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_height :: (CSGCylinder :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "get_height" '[] (IO Float) where nodeMethod = Godot.Core.CSGCylinder.get_height {-# NOINLINE bindCSGCylinder_get_material #-} bindCSGCylinder_get_material :: MethodBind bindCSGCylinder_get_material = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_material :: (CSGCylinder :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "get_material" '[] (IO Material) where nodeMethod = Godot.Core.CSGCylinder.get_material {-# NOINLINE bindCSGCylinder_get_radius #-} bindCSGCylinder_get_radius :: MethodBind bindCSGCylinder_get_radius = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_radius :: (CSGCylinder :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.CSGCylinder.get_radius {-# NOINLINE bindCSGCylinder_get_sides #-} bindCSGCylinder_get_sides :: MethodBind bindCSGCylinder_get_sides = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "get_sides" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_sides :: (CSGCylinder :< cls, Object :< cls) => cls -> IO Int get_sides cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_get_sides (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "get_sides" '[] (IO Int) where nodeMethod = Godot.Core.CSGCylinder.get_sides {-# NOINLINE bindCSGCylinder_get_smooth_faces #-} bindCSGCylinder_get_smooth_faces :: MethodBind bindCSGCylinder_get_smooth_faces = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "get_smooth_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_smooth_faces :: (CSGCylinder :< cls, Object :< cls) => cls -> IO Bool get_smooth_faces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_get_smooth_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "get_smooth_faces" '[] (IO Bool) where nodeMethod = Godot.Core.CSGCylinder.get_smooth_faces {-# NOINLINE bindCSGCylinder_is_cone #-} bindCSGCylinder_is_cone :: MethodBind bindCSGCylinder_is_cone = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "is_cone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_cone :: (CSGCylinder :< cls, Object :< cls) => cls -> IO Bool is_cone cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_is_cone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "is_cone" '[] (IO Bool) where nodeMethod = Godot.Core.CSGCylinder.is_cone {-# NOINLINE bindCSGCylinder_set_cone #-} bindCSGCylinder_set_cone :: MethodBind bindCSGCylinder_set_cone = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "set_cone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cone :: (CSGCylinder :< cls, Object :< cls) => cls -> Bool -> IO () set_cone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_set_cone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "set_cone" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGCylinder.set_cone {-# NOINLINE bindCSGCylinder_set_height #-} bindCSGCylinder_set_height :: MethodBind bindCSGCylinder_set_height = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_height :: (CSGCylinder :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGCylinder.set_height {-# NOINLINE bindCSGCylinder_set_material #-} bindCSGCylinder_set_material :: MethodBind bindCSGCylinder_set_material = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_material :: (CSGCylinder :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.CSGCylinder.set_material {-# NOINLINE bindCSGCylinder_set_radius #-} bindCSGCylinder_set_radius :: MethodBind bindCSGCylinder_set_radius = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_radius :: (CSGCylinder :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGCylinder.set_radius {-# NOINLINE bindCSGCylinder_set_sides #-} bindCSGCylinder_set_sides :: MethodBind bindCSGCylinder_set_sides = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "set_sides" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_sides :: (CSGCylinder :< cls, Object :< cls) => cls -> Int -> IO () set_sides cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_set_sides (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "set_sides" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGCylinder.set_sides {-# NOINLINE bindCSGCylinder_set_smooth_faces #-} bindCSGCylinder_set_smooth_faces :: MethodBind bindCSGCylinder_set_smooth_faces = unsafePerformIO $ withCString "CSGCylinder" $ \ clsNamePtr -> withCString "set_smooth_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_smooth_faces :: (CSGCylinder :< cls, Object :< cls) => cls -> Bool -> IO () set_smooth_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGCylinder_set_smooth_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGCylinder "set_smooth_faces" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGCylinder.set_smooth_faces ================================================ FILE: src/Godot/Core/CSGMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGMesh (Godot.Core.CSGMesh._mesh_changed, Godot.Core.CSGMesh.get_material, Godot.Core.CSGMesh.get_mesh, Godot.Core.CSGMesh.set_material, Godot.Core.CSGMesh.set_mesh) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CSGPrimitive() instance NodeProperty CSGMesh "material" Material 'False where nodeProperty = (get_material, wrapDroppingSetter set_material, Nothing) instance NodeProperty CSGMesh "mesh" Mesh 'False where nodeProperty = (get_mesh, wrapDroppingSetter set_mesh, Nothing) {-# NOINLINE bindCSGMesh__mesh_changed #-} bindCSGMesh__mesh_changed :: MethodBind bindCSGMesh__mesh_changed = unsafePerformIO $ withCString "CSGMesh" $ \ clsNamePtr -> withCString "_mesh_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _mesh_changed :: (CSGMesh :< cls, Object :< cls) => cls -> IO () _mesh_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGMesh__mesh_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGMesh "_mesh_changed" '[] (IO ()) where nodeMethod = Godot.Core.CSGMesh._mesh_changed {-# NOINLINE bindCSGMesh_get_material #-} bindCSGMesh_get_material :: MethodBind bindCSGMesh_get_material = unsafePerformIO $ withCString "CSGMesh" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_material :: (CSGMesh :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGMesh_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGMesh "get_material" '[] (IO Material) where nodeMethod = Godot.Core.CSGMesh.get_material {-# NOINLINE bindCSGMesh_get_mesh #-} bindCSGMesh_get_mesh :: MethodBind bindCSGMesh_get_mesh = unsafePerformIO $ withCString "CSGMesh" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_mesh :: (CSGMesh :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGMesh_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGMesh "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.CSGMesh.get_mesh {-# NOINLINE bindCSGMesh_set_material #-} bindCSGMesh_set_material :: MethodBind bindCSGMesh_set_material = unsafePerformIO $ withCString "CSGMesh" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_material :: (CSGMesh :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGMesh_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGMesh "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.CSGMesh.set_material {-# NOINLINE bindCSGMesh_set_mesh #-} bindCSGMesh_set_mesh :: MethodBind bindCSGMesh_set_mesh = unsafePerformIO $ withCString "CSGMesh" $ \ clsNamePtr -> withCString "set_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_mesh :: (CSGMesh :< cls, Object :< cls) => cls -> Mesh -> IO () set_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGMesh_set_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGMesh "set_mesh" '[Mesh] (IO ()) where nodeMethod = Godot.Core.CSGMesh.set_mesh ================================================ FILE: src/Godot/Core/CSGPolygon.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGPolygon (Godot.Core.CSGPolygon._MODE_PATH, Godot.Core.CSGPolygon._PATH_ROTATION_PATH, Godot.Core.CSGPolygon._PATH_ROTATION_PATH_FOLLOW, Godot.Core.CSGPolygon._PATH_ROTATION_POLYGON, Godot.Core.CSGPolygon._MODE_SPIN, Godot.Core.CSGPolygon._MODE_DEPTH, Godot.Core.CSGPolygon._has_editable_3d_polygon_no_depth, Godot.Core.CSGPolygon._is_editable_3d_polygon, Godot.Core.CSGPolygon._path_changed, Godot.Core.CSGPolygon._path_exited, Godot.Core.CSGPolygon.get_depth, Godot.Core.CSGPolygon.get_material, Godot.Core.CSGPolygon.get_mode, Godot.Core.CSGPolygon.get_path_interval, Godot.Core.CSGPolygon.get_path_node, Godot.Core.CSGPolygon.get_path_rotation, Godot.Core.CSGPolygon.get_polygon, Godot.Core.CSGPolygon.get_smooth_faces, Godot.Core.CSGPolygon.get_spin_degrees, Godot.Core.CSGPolygon.get_spin_sides, Godot.Core.CSGPolygon.is_path_continuous_u, Godot.Core.CSGPolygon.is_path_joined, Godot.Core.CSGPolygon.is_path_local, Godot.Core.CSGPolygon.set_depth, Godot.Core.CSGPolygon.set_material, Godot.Core.CSGPolygon.set_mode, Godot.Core.CSGPolygon.set_path_continuous_u, Godot.Core.CSGPolygon.set_path_interval, Godot.Core.CSGPolygon.set_path_joined, Godot.Core.CSGPolygon.set_path_local, Godot.Core.CSGPolygon.set_path_node, Godot.Core.CSGPolygon.set_path_rotation, Godot.Core.CSGPolygon.set_polygon, Godot.Core.CSGPolygon.set_smooth_faces, Godot.Core.CSGPolygon.set_spin_degrees, Godot.Core.CSGPolygon.set_spin_sides) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CSGPrimitive() _MODE_PATH :: Int _MODE_PATH = 2 _PATH_ROTATION_PATH :: Int _PATH_ROTATION_PATH = 1 _PATH_ROTATION_PATH_FOLLOW :: Int _PATH_ROTATION_PATH_FOLLOW = 2 _PATH_ROTATION_POLYGON :: Int _PATH_ROTATION_POLYGON = 0 _MODE_SPIN :: Int _MODE_SPIN = 1 _MODE_DEPTH :: Int _MODE_DEPTH = 0 instance NodeProperty CSGPolygon "depth" Float 'False where nodeProperty = (get_depth, wrapDroppingSetter set_depth, Nothing) instance NodeProperty CSGPolygon "material" Material 'False where nodeProperty = (get_material, wrapDroppingSetter set_material, Nothing) instance NodeProperty CSGPolygon "mode" Int 'False where nodeProperty = (get_mode, wrapDroppingSetter set_mode, Nothing) instance NodeProperty CSGPolygon "path_continuous_u" Bool 'False where nodeProperty = (is_path_continuous_u, wrapDroppingSetter set_path_continuous_u, Nothing) instance NodeProperty CSGPolygon "path_interval" Float 'False where nodeProperty = (get_path_interval, wrapDroppingSetter set_path_interval, Nothing) instance NodeProperty CSGPolygon "path_joined" Bool 'False where nodeProperty = (is_path_joined, wrapDroppingSetter set_path_joined, Nothing) instance NodeProperty CSGPolygon "path_local" Bool 'False where nodeProperty = (is_path_local, wrapDroppingSetter set_path_local, Nothing) instance NodeProperty CSGPolygon "path_node" NodePath 'False where nodeProperty = (get_path_node, wrapDroppingSetter set_path_node, Nothing) instance NodeProperty CSGPolygon "path_rotation" Int 'False where nodeProperty = (get_path_rotation, wrapDroppingSetter set_path_rotation, Nothing) instance NodeProperty CSGPolygon "polygon" PoolVector2Array 'False where nodeProperty = (get_polygon, wrapDroppingSetter set_polygon, Nothing) instance NodeProperty CSGPolygon "smooth_faces" Bool 'False where nodeProperty = (get_smooth_faces, wrapDroppingSetter set_smooth_faces, Nothing) instance NodeProperty CSGPolygon "spin_degrees" Float 'False where nodeProperty = (get_spin_degrees, wrapDroppingSetter set_spin_degrees, Nothing) instance NodeProperty CSGPolygon "spin_sides" Int 'False where nodeProperty = (get_spin_sides, wrapDroppingSetter set_spin_sides, Nothing) {-# NOINLINE bindCSGPolygon__has_editable_3d_polygon_no_depth #-} bindCSGPolygon__has_editable_3d_polygon_no_depth :: MethodBind bindCSGPolygon__has_editable_3d_polygon_no_depth = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "_has_editable_3d_polygon_no_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _has_editable_3d_polygon_no_depth :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Bool _has_editable_3d_polygon_no_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon__has_editable_3d_polygon_no_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "_has_editable_3d_polygon_no_depth" '[] (IO Bool) where nodeMethod = Godot.Core.CSGPolygon._has_editable_3d_polygon_no_depth {-# NOINLINE bindCSGPolygon__is_editable_3d_polygon #-} bindCSGPolygon__is_editable_3d_polygon :: MethodBind bindCSGPolygon__is_editable_3d_polygon = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "_is_editable_3d_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _is_editable_3d_polygon :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Bool _is_editable_3d_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon__is_editable_3d_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "_is_editable_3d_polygon" '[] (IO Bool) where nodeMethod = Godot.Core.CSGPolygon._is_editable_3d_polygon {-# NOINLINE bindCSGPolygon__path_changed #-} bindCSGPolygon__path_changed :: MethodBind bindCSGPolygon__path_changed = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "_path_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _path_changed :: (CSGPolygon :< cls, Object :< cls) => cls -> IO () _path_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon__path_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "_path_changed" '[] (IO ()) where nodeMethod = Godot.Core.CSGPolygon._path_changed {-# NOINLINE bindCSGPolygon__path_exited #-} bindCSGPolygon__path_exited :: MethodBind bindCSGPolygon__path_exited = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "_path_exited" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _path_exited :: (CSGPolygon :< cls, Object :< cls) => cls -> IO () _path_exited cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon__path_exited (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "_path_exited" '[] (IO ()) where nodeMethod = Godot.Core.CSGPolygon._path_exited {-# NOINLINE bindCSGPolygon_get_depth #-} bindCSGPolygon_get_depth :: MethodBind bindCSGPolygon_get_depth = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_depth :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Float get_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_depth" '[] (IO Float) where nodeMethod = Godot.Core.CSGPolygon.get_depth {-# NOINLINE bindCSGPolygon_get_material #-} bindCSGPolygon_get_material :: MethodBind bindCSGPolygon_get_material = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_material :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_material" '[] (IO Material) where nodeMethod = Godot.Core.CSGPolygon.get_material {-# NOINLINE bindCSGPolygon_get_mode #-} bindCSGPolygon_get_mode :: MethodBind bindCSGPolygon_get_mode = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_mode :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_mode" '[] (IO Int) where nodeMethod = Godot.Core.CSGPolygon.get_mode {-# NOINLINE bindCSGPolygon_get_path_interval #-} bindCSGPolygon_get_path_interval :: MethodBind bindCSGPolygon_get_path_interval = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_path_interval" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_path_interval :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Float get_path_interval cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_path_interval (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_path_interval" '[] (IO Float) where nodeMethod = Godot.Core.CSGPolygon.get_path_interval {-# NOINLINE bindCSGPolygon_get_path_node #-} bindCSGPolygon_get_path_node :: MethodBind bindCSGPolygon_get_path_node = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_path_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_path_node :: (CSGPolygon :< cls, Object :< cls) => cls -> IO NodePath get_path_node cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_path_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_path_node" '[] (IO NodePath) where nodeMethod = Godot.Core.CSGPolygon.get_path_node {-# NOINLINE bindCSGPolygon_get_path_rotation #-} bindCSGPolygon_get_path_rotation :: MethodBind bindCSGPolygon_get_path_rotation = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_path_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_path_rotation :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Int get_path_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_path_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_path_rotation" '[] (IO Int) where nodeMethod = Godot.Core.CSGPolygon.get_path_rotation {-# NOINLINE bindCSGPolygon_get_polygon #-} bindCSGPolygon_get_polygon :: MethodBind bindCSGPolygon_get_polygon = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_polygon :: (CSGPolygon :< cls, Object :< cls) => cls -> IO PoolVector2Array get_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_polygon" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.CSGPolygon.get_polygon {-# NOINLINE bindCSGPolygon_get_smooth_faces #-} bindCSGPolygon_get_smooth_faces :: MethodBind bindCSGPolygon_get_smooth_faces = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_smooth_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_smooth_faces :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Bool get_smooth_faces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_smooth_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_smooth_faces" '[] (IO Bool) where nodeMethod = Godot.Core.CSGPolygon.get_smooth_faces {-# NOINLINE bindCSGPolygon_get_spin_degrees #-} bindCSGPolygon_get_spin_degrees :: MethodBind bindCSGPolygon_get_spin_degrees = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_spin_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_spin_degrees :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Float get_spin_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_spin_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_spin_degrees" '[] (IO Float) where nodeMethod = Godot.Core.CSGPolygon.get_spin_degrees {-# NOINLINE bindCSGPolygon_get_spin_sides #-} bindCSGPolygon_get_spin_sides :: MethodBind bindCSGPolygon_get_spin_sides = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "get_spin_sides" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_spin_sides :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Int get_spin_sides cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_get_spin_sides (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "get_spin_sides" '[] (IO Int) where nodeMethod = Godot.Core.CSGPolygon.get_spin_sides {-# NOINLINE bindCSGPolygon_is_path_continuous_u #-} bindCSGPolygon_is_path_continuous_u :: MethodBind bindCSGPolygon_is_path_continuous_u = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "is_path_continuous_u" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_path_continuous_u :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Bool is_path_continuous_u cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_is_path_continuous_u (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "is_path_continuous_u" '[] (IO Bool) where nodeMethod = Godot.Core.CSGPolygon.is_path_continuous_u {-# NOINLINE bindCSGPolygon_is_path_joined #-} bindCSGPolygon_is_path_joined :: MethodBind bindCSGPolygon_is_path_joined = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "is_path_joined" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_path_joined :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Bool is_path_joined cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_is_path_joined (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "is_path_joined" '[] (IO Bool) where nodeMethod = Godot.Core.CSGPolygon.is_path_joined {-# NOINLINE bindCSGPolygon_is_path_local #-} bindCSGPolygon_is_path_local :: MethodBind bindCSGPolygon_is_path_local = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "is_path_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_path_local :: (CSGPolygon :< cls, Object :< cls) => cls -> IO Bool is_path_local cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_is_path_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "is_path_local" '[] (IO Bool) where nodeMethod = Godot.Core.CSGPolygon.is_path_local {-# NOINLINE bindCSGPolygon_set_depth #-} bindCSGPolygon_set_depth :: MethodBind bindCSGPolygon_set_depth = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_depth :: (CSGPolygon :< cls, Object :< cls) => cls -> Float -> IO () set_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_depth" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_depth {-# NOINLINE bindCSGPolygon_set_material #-} bindCSGPolygon_set_material :: MethodBind bindCSGPolygon_set_material = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_material :: (CSGPolygon :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_material {-# NOINLINE bindCSGPolygon_set_mode #-} bindCSGPolygon_set_mode :: MethodBind bindCSGPolygon_set_mode = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_mode :: (CSGPolygon :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_mode {-# NOINLINE bindCSGPolygon_set_path_continuous_u #-} bindCSGPolygon_set_path_continuous_u :: MethodBind bindCSGPolygon_set_path_continuous_u = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_path_continuous_u" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_path_continuous_u :: (CSGPolygon :< cls, Object :< cls) => cls -> Bool -> IO () set_path_continuous_u cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_path_continuous_u (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_path_continuous_u" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_path_continuous_u {-# NOINLINE bindCSGPolygon_set_path_interval #-} bindCSGPolygon_set_path_interval :: MethodBind bindCSGPolygon_set_path_interval = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_path_interval" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_path_interval :: (CSGPolygon :< cls, Object :< cls) => cls -> Float -> IO () set_path_interval cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_path_interval (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_path_interval" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_path_interval {-# NOINLINE bindCSGPolygon_set_path_joined #-} bindCSGPolygon_set_path_joined :: MethodBind bindCSGPolygon_set_path_joined = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_path_joined" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_path_joined :: (CSGPolygon :< cls, Object :< cls) => cls -> Bool -> IO () set_path_joined cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_path_joined (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_path_joined" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_path_joined {-# NOINLINE bindCSGPolygon_set_path_local #-} bindCSGPolygon_set_path_local :: MethodBind bindCSGPolygon_set_path_local = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_path_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_path_local :: (CSGPolygon :< cls, Object :< cls) => cls -> Bool -> IO () set_path_local cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_path_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_path_local" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_path_local {-# NOINLINE bindCSGPolygon_set_path_node #-} bindCSGPolygon_set_path_node :: MethodBind bindCSGPolygon_set_path_node = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_path_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_path_node :: (CSGPolygon :< cls, Object :< cls) => cls -> NodePath -> IO () set_path_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_path_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_path_node" '[NodePath] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_path_node {-# NOINLINE bindCSGPolygon_set_path_rotation #-} bindCSGPolygon_set_path_rotation :: MethodBind bindCSGPolygon_set_path_rotation = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_path_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_path_rotation :: (CSGPolygon :< cls, Object :< cls) => cls -> Int -> IO () set_path_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_path_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_path_rotation" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_path_rotation {-# NOINLINE bindCSGPolygon_set_polygon #-} bindCSGPolygon_set_polygon :: MethodBind bindCSGPolygon_set_polygon = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_polygon :: (CSGPolygon :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_polygon" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_polygon {-# NOINLINE bindCSGPolygon_set_smooth_faces #-} bindCSGPolygon_set_smooth_faces :: MethodBind bindCSGPolygon_set_smooth_faces = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_smooth_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_smooth_faces :: (CSGPolygon :< cls, Object :< cls) => cls -> Bool -> IO () set_smooth_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_smooth_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_smooth_faces" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_smooth_faces {-# NOINLINE bindCSGPolygon_set_spin_degrees #-} bindCSGPolygon_set_spin_degrees :: MethodBind bindCSGPolygon_set_spin_degrees = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_spin_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_spin_degrees :: (CSGPolygon :< cls, Object :< cls) => cls -> Float -> IO () set_spin_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_spin_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_spin_degrees" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_spin_degrees {-# NOINLINE bindCSGPolygon_set_spin_sides #-} bindCSGPolygon_set_spin_sides :: MethodBind bindCSGPolygon_set_spin_sides = unsafePerformIO $ withCString "CSGPolygon" $ \ clsNamePtr -> withCString "set_spin_sides" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_spin_sides :: (CSGPolygon :< cls, Object :< cls) => cls -> Int -> IO () set_spin_sides cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPolygon_set_spin_sides (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPolygon "set_spin_sides" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGPolygon.set_spin_sides ================================================ FILE: src/Godot/Core/CSGPrimitive.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGPrimitive (Godot.Core.CSGPrimitive.is_inverting_faces, Godot.Core.CSGPrimitive.set_invert_faces) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CSGShape() instance NodeProperty CSGPrimitive "invert_faces" Bool 'False where nodeProperty = (is_inverting_faces, wrapDroppingSetter set_invert_faces, Nothing) {-# NOINLINE bindCSGPrimitive_is_inverting_faces #-} bindCSGPrimitive_is_inverting_faces :: MethodBind bindCSGPrimitive_is_inverting_faces = unsafePerformIO $ withCString "CSGPrimitive" $ \ clsNamePtr -> withCString "is_inverting_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_inverting_faces :: (CSGPrimitive :< cls, Object :< cls) => cls -> IO Bool is_inverting_faces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPrimitive_is_inverting_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPrimitive "is_inverting_faces" '[] (IO Bool) where nodeMethod = Godot.Core.CSGPrimitive.is_inverting_faces {-# NOINLINE bindCSGPrimitive_set_invert_faces #-} bindCSGPrimitive_set_invert_faces :: MethodBind bindCSGPrimitive_set_invert_faces = unsafePerformIO $ withCString "CSGPrimitive" $ \ clsNamePtr -> withCString "set_invert_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_invert_faces :: (CSGPrimitive :< cls, Object :< cls) => cls -> Bool -> IO () set_invert_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGPrimitive_set_invert_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGPrimitive "set_invert_faces" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGPrimitive.set_invert_faces ================================================ FILE: src/Godot/Core/CSGShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGShape (Godot.Core.CSGShape._OPERATION_SUBTRACTION, Godot.Core.CSGShape._OPERATION_UNION, Godot.Core.CSGShape._OPERATION_INTERSECTION, Godot.Core.CSGShape._update_shape, Godot.Core.CSGShape.get_collision_layer, Godot.Core.CSGShape.get_collision_layer_bit, Godot.Core.CSGShape.get_collision_mask, Godot.Core.CSGShape.get_collision_mask_bit, Godot.Core.CSGShape.get_meshes, Godot.Core.CSGShape.get_operation, Godot.Core.CSGShape.get_snap, Godot.Core.CSGShape.is_calculating_tangents, Godot.Core.CSGShape.is_root_shape, Godot.Core.CSGShape.is_using_collision, Godot.Core.CSGShape.set_calculate_tangents, Godot.Core.CSGShape.set_collision_layer, Godot.Core.CSGShape.set_collision_layer_bit, Godot.Core.CSGShape.set_collision_mask, Godot.Core.CSGShape.set_collision_mask_bit, Godot.Core.CSGShape.set_operation, Godot.Core.CSGShape.set_snap, Godot.Core.CSGShape.set_use_collision) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.GeometryInstance() _OPERATION_SUBTRACTION :: Int _OPERATION_SUBTRACTION = 2 _OPERATION_UNION :: Int _OPERATION_UNION = 0 _OPERATION_INTERSECTION :: Int _OPERATION_INTERSECTION = 1 instance NodeProperty CSGShape "calculate_tangents" Bool 'False where nodeProperty = (is_calculating_tangents, wrapDroppingSetter set_calculate_tangents, Nothing) instance NodeProperty CSGShape "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty CSGShape "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty CSGShape "operation" Int 'False where nodeProperty = (get_operation, wrapDroppingSetter set_operation, Nothing) instance NodeProperty CSGShape "snap" Float 'False where nodeProperty = (get_snap, wrapDroppingSetter set_snap, Nothing) instance NodeProperty CSGShape "use_collision" Bool 'False where nodeProperty = (is_using_collision, wrapDroppingSetter set_use_collision, Nothing) {-# NOINLINE bindCSGShape__update_shape #-} bindCSGShape__update_shape :: MethodBind bindCSGShape__update_shape = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "_update_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_shape :: (CSGShape :< cls, Object :< cls) => cls -> IO () _update_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape__update_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "_update_shape" '[] (IO ()) where nodeMethod = Godot.Core.CSGShape._update_shape {-# NOINLINE bindCSGShape_get_collision_layer #-} bindCSGShape_get_collision_layer :: MethodBind bindCSGShape_get_collision_layer = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_layer :: (CSGShape :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.CSGShape.get_collision_layer {-# NOINLINE bindCSGShape_get_collision_layer_bit #-} bindCSGShape_get_collision_layer_bit :: MethodBind bindCSGShape_get_collision_layer_bit = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "get_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_layer_bit :: (CSGShape :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_layer_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_get_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "get_collision_layer_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.CSGShape.get_collision_layer_bit {-# NOINLINE bindCSGShape_get_collision_mask #-} bindCSGShape_get_collision_mask :: MethodBind bindCSGShape_get_collision_mask = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_mask :: (CSGShape :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.CSGShape.get_collision_mask {-# NOINLINE bindCSGShape_get_collision_mask_bit #-} bindCSGShape_get_collision_mask_bit :: MethodBind bindCSGShape_get_collision_mask_bit = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_mask_bit :: (CSGShape :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.CSGShape.get_collision_mask_bit {-# NOINLINE bindCSGShape_get_meshes #-} bindCSGShape_get_meshes :: MethodBind bindCSGShape_get_meshes = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "get_meshes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_meshes :: (CSGShape :< cls, Object :< cls) => cls -> IO Array get_meshes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_get_meshes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "get_meshes" '[] (IO Array) where nodeMethod = Godot.Core.CSGShape.get_meshes {-# NOINLINE bindCSGShape_get_operation #-} bindCSGShape_get_operation :: MethodBind bindCSGShape_get_operation = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "get_operation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_operation :: (CSGShape :< cls, Object :< cls) => cls -> IO Int get_operation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_get_operation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "get_operation" '[] (IO Int) where nodeMethod = Godot.Core.CSGShape.get_operation {-# NOINLINE bindCSGShape_get_snap #-} bindCSGShape_get_snap :: MethodBind bindCSGShape_get_snap = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "get_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_snap :: (CSGShape :< cls, Object :< cls) => cls -> IO Float get_snap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_get_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "get_snap" '[] (IO Float) where nodeMethod = Godot.Core.CSGShape.get_snap {-# NOINLINE bindCSGShape_is_calculating_tangents #-} bindCSGShape_is_calculating_tangents :: MethodBind bindCSGShape_is_calculating_tangents = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "is_calculating_tangents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_calculating_tangents :: (CSGShape :< cls, Object :< cls) => cls -> IO Bool is_calculating_tangents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_is_calculating_tangents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "is_calculating_tangents" '[] (IO Bool) where nodeMethod = Godot.Core.CSGShape.is_calculating_tangents {-# NOINLINE bindCSGShape_is_root_shape #-} bindCSGShape_is_root_shape :: MethodBind bindCSGShape_is_root_shape = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "is_root_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_root_shape :: (CSGShape :< cls, Object :< cls) => cls -> IO Bool is_root_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_is_root_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "is_root_shape" '[] (IO Bool) where nodeMethod = Godot.Core.CSGShape.is_root_shape {-# NOINLINE bindCSGShape_is_using_collision #-} bindCSGShape_is_using_collision :: MethodBind bindCSGShape_is_using_collision = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "is_using_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_using_collision :: (CSGShape :< cls, Object :< cls) => cls -> IO Bool is_using_collision cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_is_using_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "is_using_collision" '[] (IO Bool) where nodeMethod = Godot.Core.CSGShape.is_using_collision {-# NOINLINE bindCSGShape_set_calculate_tangents #-} bindCSGShape_set_calculate_tangents :: MethodBind bindCSGShape_set_calculate_tangents = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "set_calculate_tangents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_calculate_tangents :: (CSGShape :< cls, Object :< cls) => cls -> Bool -> IO () set_calculate_tangents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_set_calculate_tangents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "set_calculate_tangents" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGShape.set_calculate_tangents {-# NOINLINE bindCSGShape_set_collision_layer #-} bindCSGShape_set_collision_layer :: MethodBind bindCSGShape_set_collision_layer = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_layer :: (CSGShape :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGShape.set_collision_layer {-# NOINLINE bindCSGShape_set_collision_layer_bit #-} bindCSGShape_set_collision_layer_bit :: MethodBind bindCSGShape_set_collision_layer_bit = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "set_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_layer_bit :: (CSGShape :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_layer_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_set_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "set_collision_layer_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.CSGShape.set_collision_layer_bit {-# NOINLINE bindCSGShape_set_collision_mask #-} bindCSGShape_set_collision_mask :: MethodBind bindCSGShape_set_collision_mask = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_mask :: (CSGShape :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGShape.set_collision_mask {-# NOINLINE bindCSGShape_set_collision_mask_bit #-} bindCSGShape_set_collision_mask_bit :: MethodBind bindCSGShape_set_collision_mask_bit = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_mask_bit :: (CSGShape :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.CSGShape.set_collision_mask_bit {-# NOINLINE bindCSGShape_set_operation #-} bindCSGShape_set_operation :: MethodBind bindCSGShape_set_operation = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "set_operation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_operation :: (CSGShape :< cls, Object :< cls) => cls -> Int -> IO () set_operation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_set_operation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "set_operation" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGShape.set_operation {-# NOINLINE bindCSGShape_set_snap #-} bindCSGShape_set_snap :: MethodBind bindCSGShape_set_snap = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "set_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_snap :: (CSGShape :< cls, Object :< cls) => cls -> Float -> IO () set_snap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_set_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "set_snap" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGShape.set_snap {-# NOINLINE bindCSGShape_set_use_collision #-} bindCSGShape_set_use_collision :: MethodBind bindCSGShape_set_use_collision = unsafePerformIO $ withCString "CSGShape" $ \ clsNamePtr -> withCString "set_use_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_use_collision :: (CSGShape :< cls, Object :< cls) => cls -> Bool -> IO () set_use_collision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGShape_set_use_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGShape "set_use_collision" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGShape.set_use_collision ================================================ FILE: src/Godot/Core/CSGSphere.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGSphere (Godot.Core.CSGSphere.get_material, Godot.Core.CSGSphere.get_radial_segments, Godot.Core.CSGSphere.get_radius, Godot.Core.CSGSphere.get_rings, Godot.Core.CSGSphere.get_smooth_faces, Godot.Core.CSGSphere.set_material, Godot.Core.CSGSphere.set_radial_segments, Godot.Core.CSGSphere.set_radius, Godot.Core.CSGSphere.set_rings, Godot.Core.CSGSphere.set_smooth_faces) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CSGPrimitive() instance NodeProperty CSGSphere "material" Material 'False where nodeProperty = (get_material, wrapDroppingSetter set_material, Nothing) instance NodeProperty CSGSphere "radial_segments" Int 'False where nodeProperty = (get_radial_segments, wrapDroppingSetter set_radial_segments, Nothing) instance NodeProperty CSGSphere "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) instance NodeProperty CSGSphere "rings" Int 'False where nodeProperty = (get_rings, wrapDroppingSetter set_rings, Nothing) instance NodeProperty CSGSphere "smooth_faces" Bool 'False where nodeProperty = (get_smooth_faces, wrapDroppingSetter set_smooth_faces, Nothing) {-# NOINLINE bindCSGSphere_get_material #-} bindCSGSphere_get_material :: MethodBind bindCSGSphere_get_material = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_material :: (CSGSphere :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "get_material" '[] (IO Material) where nodeMethod = Godot.Core.CSGSphere.get_material {-# NOINLINE bindCSGSphere_get_radial_segments #-} bindCSGSphere_get_radial_segments :: MethodBind bindCSGSphere_get_radial_segments = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "get_radial_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_radial_segments :: (CSGSphere :< cls, Object :< cls) => cls -> IO Int get_radial_segments cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_get_radial_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "get_radial_segments" '[] (IO Int) where nodeMethod = Godot.Core.CSGSphere.get_radial_segments {-# NOINLINE bindCSGSphere_get_radius #-} bindCSGSphere_get_radius :: MethodBind bindCSGSphere_get_radius = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_radius :: (CSGSphere :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.CSGSphere.get_radius {-# NOINLINE bindCSGSphere_get_rings #-} bindCSGSphere_get_rings :: MethodBind bindCSGSphere_get_rings = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "get_rings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_rings :: (CSGSphere :< cls, Object :< cls) => cls -> IO Int get_rings cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_get_rings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "get_rings" '[] (IO Int) where nodeMethod = Godot.Core.CSGSphere.get_rings {-# NOINLINE bindCSGSphere_get_smooth_faces #-} bindCSGSphere_get_smooth_faces :: MethodBind bindCSGSphere_get_smooth_faces = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "get_smooth_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_smooth_faces :: (CSGSphere :< cls, Object :< cls) => cls -> IO Bool get_smooth_faces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_get_smooth_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "get_smooth_faces" '[] (IO Bool) where nodeMethod = Godot.Core.CSGSphere.get_smooth_faces {-# NOINLINE bindCSGSphere_set_material #-} bindCSGSphere_set_material :: MethodBind bindCSGSphere_set_material = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_material :: (CSGSphere :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.CSGSphere.set_material {-# NOINLINE bindCSGSphere_set_radial_segments #-} bindCSGSphere_set_radial_segments :: MethodBind bindCSGSphere_set_radial_segments = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "set_radial_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_radial_segments :: (CSGSphere :< cls, Object :< cls) => cls -> Int -> IO () set_radial_segments cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_set_radial_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "set_radial_segments" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGSphere.set_radial_segments {-# NOINLINE bindCSGSphere_set_radius #-} bindCSGSphere_set_radius :: MethodBind bindCSGSphere_set_radius = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_radius :: (CSGSphere :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGSphere.set_radius {-# NOINLINE bindCSGSphere_set_rings #-} bindCSGSphere_set_rings :: MethodBind bindCSGSphere_set_rings = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "set_rings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_rings :: (CSGSphere :< cls, Object :< cls) => cls -> Int -> IO () set_rings cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_set_rings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "set_rings" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGSphere.set_rings {-# NOINLINE bindCSGSphere_set_smooth_faces #-} bindCSGSphere_set_smooth_faces :: MethodBind bindCSGSphere_set_smooth_faces = unsafePerformIO $ withCString "CSGSphere" $ \ clsNamePtr -> withCString "set_smooth_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_smooth_faces :: (CSGSphere :< cls, Object :< cls) => cls -> Bool -> IO () set_smooth_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGSphere_set_smooth_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGSphere "set_smooth_faces" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGSphere.set_smooth_faces ================================================ FILE: src/Godot/Core/CSGTorus.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CSGTorus (Godot.Core.CSGTorus.get_inner_radius, Godot.Core.CSGTorus.get_material, Godot.Core.CSGTorus.get_outer_radius, Godot.Core.CSGTorus.get_ring_sides, Godot.Core.CSGTorus.get_sides, Godot.Core.CSGTorus.get_smooth_faces, Godot.Core.CSGTorus.set_inner_radius, Godot.Core.CSGTorus.set_material, Godot.Core.CSGTorus.set_outer_radius, Godot.Core.CSGTorus.set_ring_sides, Godot.Core.CSGTorus.set_sides, Godot.Core.CSGTorus.set_smooth_faces) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CSGPrimitive() instance NodeProperty CSGTorus "inner_radius" Float 'False where nodeProperty = (get_inner_radius, wrapDroppingSetter set_inner_radius, Nothing) instance NodeProperty CSGTorus "material" Material 'False where nodeProperty = (get_material, wrapDroppingSetter set_material, Nothing) instance NodeProperty CSGTorus "outer_radius" Float 'False where nodeProperty = (get_outer_radius, wrapDroppingSetter set_outer_radius, Nothing) instance NodeProperty CSGTorus "ring_sides" Int 'False where nodeProperty = (get_ring_sides, wrapDroppingSetter set_ring_sides, Nothing) instance NodeProperty CSGTorus "sides" Int 'False where nodeProperty = (get_sides, wrapDroppingSetter set_sides, Nothing) instance NodeProperty CSGTorus "smooth_faces" Bool 'False where nodeProperty = (get_smooth_faces, wrapDroppingSetter set_smooth_faces, Nothing) {-# NOINLINE bindCSGTorus_get_inner_radius #-} bindCSGTorus_get_inner_radius :: MethodBind bindCSGTorus_get_inner_radius = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "get_inner_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_inner_radius :: (CSGTorus :< cls, Object :< cls) => cls -> IO Float get_inner_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_get_inner_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "get_inner_radius" '[] (IO Float) where nodeMethod = Godot.Core.CSGTorus.get_inner_radius {-# NOINLINE bindCSGTorus_get_material #-} bindCSGTorus_get_material :: MethodBind bindCSGTorus_get_material = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_material :: (CSGTorus :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "get_material" '[] (IO Material) where nodeMethod = Godot.Core.CSGTorus.get_material {-# NOINLINE bindCSGTorus_get_outer_radius #-} bindCSGTorus_get_outer_radius :: MethodBind bindCSGTorus_get_outer_radius = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "get_outer_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_outer_radius :: (CSGTorus :< cls, Object :< cls) => cls -> IO Float get_outer_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_get_outer_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "get_outer_radius" '[] (IO Float) where nodeMethod = Godot.Core.CSGTorus.get_outer_radius {-# NOINLINE bindCSGTorus_get_ring_sides #-} bindCSGTorus_get_ring_sides :: MethodBind bindCSGTorus_get_ring_sides = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "get_ring_sides" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_ring_sides :: (CSGTorus :< cls, Object :< cls) => cls -> IO Int get_ring_sides cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_get_ring_sides (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "get_ring_sides" '[] (IO Int) where nodeMethod = Godot.Core.CSGTorus.get_ring_sides {-# NOINLINE bindCSGTorus_get_sides #-} bindCSGTorus_get_sides :: MethodBind bindCSGTorus_get_sides = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "get_sides" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_sides :: (CSGTorus :< cls, Object :< cls) => cls -> IO Int get_sides cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_get_sides (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "get_sides" '[] (IO Int) where nodeMethod = Godot.Core.CSGTorus.get_sides {-# NOINLINE bindCSGTorus_get_smooth_faces #-} bindCSGTorus_get_smooth_faces :: MethodBind bindCSGTorus_get_smooth_faces = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "get_smooth_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_smooth_faces :: (CSGTorus :< cls, Object :< cls) => cls -> IO Bool get_smooth_faces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_get_smooth_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "get_smooth_faces" '[] (IO Bool) where nodeMethod = Godot.Core.CSGTorus.get_smooth_faces {-# NOINLINE bindCSGTorus_set_inner_radius #-} bindCSGTorus_set_inner_radius :: MethodBind bindCSGTorus_set_inner_radius = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "set_inner_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_inner_radius :: (CSGTorus :< cls, Object :< cls) => cls -> Float -> IO () set_inner_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_set_inner_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "set_inner_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGTorus.set_inner_radius {-# NOINLINE bindCSGTorus_set_material #-} bindCSGTorus_set_material :: MethodBind bindCSGTorus_set_material = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_material :: (CSGTorus :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.CSGTorus.set_material {-# NOINLINE bindCSGTorus_set_outer_radius #-} bindCSGTorus_set_outer_radius :: MethodBind bindCSGTorus_set_outer_radius = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "set_outer_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_outer_radius :: (CSGTorus :< cls, Object :< cls) => cls -> Float -> IO () set_outer_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_set_outer_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "set_outer_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CSGTorus.set_outer_radius {-# NOINLINE bindCSGTorus_set_ring_sides #-} bindCSGTorus_set_ring_sides :: MethodBind bindCSGTorus_set_ring_sides = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "set_ring_sides" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_ring_sides :: (CSGTorus :< cls, Object :< cls) => cls -> Int -> IO () set_ring_sides cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_set_ring_sides (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "set_ring_sides" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGTorus.set_ring_sides {-# NOINLINE bindCSGTorus_set_sides #-} bindCSGTorus_set_sides :: MethodBind bindCSGTorus_set_sides = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "set_sides" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_sides :: (CSGTorus :< cls, Object :< cls) => cls -> Int -> IO () set_sides cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_set_sides (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "set_sides" '[Int] (IO ()) where nodeMethod = Godot.Core.CSGTorus.set_sides {-# NOINLINE bindCSGTorus_set_smooth_faces #-} bindCSGTorus_set_smooth_faces :: MethodBind bindCSGTorus_set_smooth_faces = unsafePerformIO $ withCString "CSGTorus" $ \ clsNamePtr -> withCString "set_smooth_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_smooth_faces :: (CSGTorus :< cls, Object :< cls) => cls -> Bool -> IO () set_smooth_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCSGTorus_set_smooth_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CSGTorus "set_smooth_faces" '[Bool] (IO ()) where nodeMethod = Godot.Core.CSGTorus.set_smooth_faces ================================================ FILE: src/Godot/Core/Camera.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Camera (Godot.Core.Camera._PROJECTION_FRUSTUM, Godot.Core.Camera._PROJECTION_ORTHOGONAL, Godot.Core.Camera._KEEP_HEIGHT, Godot.Core.Camera._DOPPLER_TRACKING_PHYSICS_STEP, Godot.Core.Camera._DOPPLER_TRACKING_DISABLED, Godot.Core.Camera._KEEP_WIDTH, Godot.Core.Camera._DOPPLER_TRACKING_IDLE_STEP, Godot.Core.Camera._PROJECTION_PERSPECTIVE, Godot.Core.Camera.clear_current, Godot.Core.Camera.get_camera_rid, Godot.Core.Camera.get_camera_transform, Godot.Core.Camera.get_cull_mask, Godot.Core.Camera.get_cull_mask_bit, Godot.Core.Camera.get_doppler_tracking, Godot.Core.Camera.get_environment, Godot.Core.Camera.get_fov, Godot.Core.Camera.get_frustum, Godot.Core.Camera.get_frustum_offset, Godot.Core.Camera.get_h_offset, Godot.Core.Camera.get_keep_aspect_mode, Godot.Core.Camera.get_projection, Godot.Core.Camera.get_size, Godot.Core.Camera.get_v_offset, Godot.Core.Camera.get_zfar, Godot.Core.Camera.get_znear, Godot.Core.Camera.is_current, Godot.Core.Camera.is_position_behind, Godot.Core.Camera.make_current, Godot.Core.Camera.project_local_ray_normal, Godot.Core.Camera.project_position, Godot.Core.Camera.project_ray_normal, Godot.Core.Camera.project_ray_origin, Godot.Core.Camera.set_cull_mask, Godot.Core.Camera.set_cull_mask_bit, Godot.Core.Camera.set_current, Godot.Core.Camera.set_doppler_tracking, Godot.Core.Camera.set_environment, Godot.Core.Camera.set_fov, Godot.Core.Camera.set_frustum, Godot.Core.Camera.set_frustum_offset, Godot.Core.Camera.set_h_offset, Godot.Core.Camera.set_keep_aspect_mode, Godot.Core.Camera.set_orthogonal, Godot.Core.Camera.set_perspective, Godot.Core.Camera.set_projection, Godot.Core.Camera.set_size, Godot.Core.Camera.set_v_offset, Godot.Core.Camera.set_zfar, Godot.Core.Camera.set_znear, Godot.Core.Camera.unproject_position) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() _PROJECTION_FRUSTUM :: Int _PROJECTION_FRUSTUM = 2 _PROJECTION_ORTHOGONAL :: Int _PROJECTION_ORTHOGONAL = 1 _KEEP_HEIGHT :: Int _KEEP_HEIGHT = 1 _DOPPLER_TRACKING_PHYSICS_STEP :: Int _DOPPLER_TRACKING_PHYSICS_STEP = 2 _DOPPLER_TRACKING_DISABLED :: Int _DOPPLER_TRACKING_DISABLED = 0 _KEEP_WIDTH :: Int _KEEP_WIDTH = 0 _DOPPLER_TRACKING_IDLE_STEP :: Int _DOPPLER_TRACKING_IDLE_STEP = 1 _PROJECTION_PERSPECTIVE :: Int _PROJECTION_PERSPECTIVE = 0 instance NodeProperty Camera "cull_mask" Int 'False where nodeProperty = (get_cull_mask, wrapDroppingSetter set_cull_mask, Nothing) instance NodeProperty Camera "current" Bool 'False where nodeProperty = (is_current, wrapDroppingSetter set_current, Nothing) instance NodeProperty Camera "doppler_tracking" Int 'False where nodeProperty = (get_doppler_tracking, wrapDroppingSetter set_doppler_tracking, Nothing) instance NodeProperty Camera "environment" Environment 'False where nodeProperty = (get_environment, wrapDroppingSetter set_environment, Nothing) instance NodeProperty Camera "far" Float 'False where nodeProperty = (get_zfar, wrapDroppingSetter set_zfar, Nothing) instance NodeProperty Camera "fov" Float 'False where nodeProperty = (get_fov, wrapDroppingSetter set_fov, Nothing) instance NodeProperty Camera "frustum_offset" Vector2 'False where nodeProperty = (get_frustum_offset, wrapDroppingSetter set_frustum_offset, Nothing) instance NodeProperty Camera "h_offset" Float 'False where nodeProperty = (get_h_offset, wrapDroppingSetter set_h_offset, Nothing) instance NodeProperty Camera "keep_aspect" Int 'False where nodeProperty = (get_keep_aspect_mode, wrapDroppingSetter set_keep_aspect_mode, Nothing) instance NodeProperty Camera "near" Float 'False where nodeProperty = (get_znear, wrapDroppingSetter set_znear, Nothing) instance NodeProperty Camera "projection" Int 'False where nodeProperty = (get_projection, wrapDroppingSetter set_projection, Nothing) instance NodeProperty Camera "size" Float 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) instance NodeProperty Camera "v_offset" Float 'False where nodeProperty = (get_v_offset, wrapDroppingSetter set_v_offset, Nothing) {-# NOINLINE bindCamera_clear_current #-} -- | If this is the current camera, remove it from being current. If @enable_next@ is @true@, request to make the next camera current, if any. bindCamera_clear_current :: MethodBind bindCamera_clear_current = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "clear_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If this is the current camera, remove it from being current. If @enable_next@ is @true@, request to make the next camera current, if any. clear_current :: (Camera :< cls, Object :< cls) => cls -> Maybe Bool -> IO () clear_current cls arg1 = withVariantArray [maybe (VariantBool True) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_clear_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "clear_current" '[Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Camera.clear_current {-# NOINLINE bindCamera_get_camera_rid #-} -- | Returns the camera's RID from the @VisualServer@. bindCamera_get_camera_rid :: MethodBind bindCamera_get_camera_rid = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_camera_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the camera's RID from the @VisualServer@. get_camera_rid :: (Camera :< cls, Object :< cls) => cls -> IO Rid get_camera_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_camera_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_camera_rid" '[] (IO Rid) where nodeMethod = Godot.Core.Camera.get_camera_rid {-# NOINLINE bindCamera_get_camera_transform #-} -- | Gets the camera transform. Subclassed cameras such as @InterpolatedCamera@ may provide different transforms than the @Node@ transform. bindCamera_get_camera_transform :: MethodBind bindCamera_get_camera_transform = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_camera_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the camera transform. Subclassed cameras such as @InterpolatedCamera@ may provide different transforms than the @Node@ transform. get_camera_transform :: (Camera :< cls, Object :< cls) => cls -> IO Transform get_camera_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_camera_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_camera_transform" '[] (IO Transform) where nodeMethod = Godot.Core.Camera.get_camera_transform {-# NOINLINE bindCamera_get_cull_mask #-} -- | The culling mask that describes which 3D render layers are rendered by this camera. bindCamera_get_cull_mask :: MethodBind bindCamera_get_cull_mask = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The culling mask that describes which 3D render layers are rendered by this camera. get_cull_mask :: (Camera :< cls, Object :< cls) => cls -> IO Int get_cull_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_cull_mask" '[] (IO Int) where nodeMethod = Godot.Core.Camera.get_cull_mask {-# NOINLINE bindCamera_get_cull_mask_bit #-} -- | Returns @true@ if the given @layer@ in the @cull_mask@ is enabled, @false@ otherwise. bindCamera_get_cull_mask_bit :: MethodBind bindCamera_get_cull_mask_bit = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_cull_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given @layer@ in the @cull_mask@ is enabled, @false@ otherwise. get_cull_mask_bit :: (Camera :< cls, Object :< cls) => cls -> Int -> IO Bool get_cull_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_cull_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_cull_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.Camera.get_cull_mask_bit {-# NOINLINE bindCamera_get_doppler_tracking #-} -- | If not @DOPPLER_TRACKING_DISABLED@, this camera will simulate the @url=https://en.wikipedia.org/wiki/Doppler_effect@Doppler effect@/url@ for objects changed in particular @_process@ methods. See @enum DopplerTracking@ for possible values. bindCamera_get_doppler_tracking :: MethodBind bindCamera_get_doppler_tracking = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_doppler_tracking" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If not @DOPPLER_TRACKING_DISABLED@, this camera will simulate the @url=https://en.wikipedia.org/wiki/Doppler_effect@Doppler effect@/url@ for objects changed in particular @_process@ methods. See @enum DopplerTracking@ for possible values. get_doppler_tracking :: (Camera :< cls, Object :< cls) => cls -> IO Int get_doppler_tracking cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_doppler_tracking (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_doppler_tracking" '[] (IO Int) where nodeMethod = Godot.Core.Camera.get_doppler_tracking {-# NOINLINE bindCamera_get_environment #-} -- | The @Environment@ to use for this camera. bindCamera_get_environment :: MethodBind bindCamera_get_environment = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Environment@ to use for this camera. get_environment :: (Camera :< cls, Object :< cls) => cls -> IO Environment get_environment cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_environment" '[] (IO Environment) where nodeMethod = Godot.Core.Camera.get_environment {-# NOINLINE bindCamera_get_fov #-} -- | The camera's field of view angle (in degrees). Only applicable in perspective mode. Since @keep_aspect@ locks one axis, @fov@ sets the other axis' field of view angle. bindCamera_get_fov :: MethodBind bindCamera_get_fov = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_fov" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's field of view angle (in degrees). Only applicable in perspective mode. Since @keep_aspect@ locks one axis, @fov@ sets the other axis' field of view angle. get_fov :: (Camera :< cls, Object :< cls) => cls -> IO Float get_fov cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_fov (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_fov" '[] (IO Float) where nodeMethod = Godot.Core.Camera.get_fov {-# NOINLINE bindCamera_get_frustum #-} -- | Returns the camera's frustum planes in world-space units as an array of @Plane@s in the following order: near, far, left, top, right, bottom. Not to be confused with @frustum_offset@. bindCamera_get_frustum :: MethodBind bindCamera_get_frustum = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_frustum" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the camera's frustum planes in world-space units as an array of @Plane@s in the following order: near, far, left, top, right, bottom. Not to be confused with @frustum_offset@. get_frustum :: (Camera :< cls, Object :< cls) => cls -> IO Array get_frustum cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_frustum (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_frustum" '[] (IO Array) where nodeMethod = Godot.Core.Camera.get_frustum {-# NOINLINE bindCamera_get_frustum_offset #-} -- | The camera's frustum offset. This can be changed from the default to create "tilted frustum" effects such as @url=https://zdoom.org/wiki/Y-shearing@Y-shearing@/url@. bindCamera_get_frustum_offset :: MethodBind bindCamera_get_frustum_offset = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_frustum_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's frustum offset. This can be changed from the default to create "tilted frustum" effects such as @url=https://zdoom.org/wiki/Y-shearing@Y-shearing@/url@. get_frustum_offset :: (Camera :< cls, Object :< cls) => cls -> IO Vector2 get_frustum_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_frustum_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_frustum_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.Camera.get_frustum_offset {-# NOINLINE bindCamera_get_h_offset #-} -- | The horizontal (X) offset of the camera viewport. bindCamera_get_h_offset :: MethodBind bindCamera_get_h_offset = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_h_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The horizontal (X) offset of the camera viewport. get_h_offset :: (Camera :< cls, Object :< cls) => cls -> IO Float get_h_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_h_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_h_offset" '[] (IO Float) where nodeMethod = Godot.Core.Camera.get_h_offset {-# NOINLINE bindCamera_get_keep_aspect_mode #-} -- | The axis to lock during @fov@/@size@ adjustments. Can be either @KEEP_WIDTH@ or @KEEP_HEIGHT@. bindCamera_get_keep_aspect_mode :: MethodBind bindCamera_get_keep_aspect_mode = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_keep_aspect_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The axis to lock during @fov@/@size@ adjustments. Can be either @KEEP_WIDTH@ or @KEEP_HEIGHT@. get_keep_aspect_mode :: (Camera :< cls, Object :< cls) => cls -> IO Int get_keep_aspect_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_keep_aspect_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_keep_aspect_mode" '[] (IO Int) where nodeMethod = Godot.Core.Camera.get_keep_aspect_mode {-# NOINLINE bindCamera_get_projection #-} -- | The camera's projection mode. In @PROJECTION_PERSPECTIVE@ mode, objects' Z distance from the camera's local space scales their perceived size. bindCamera_get_projection :: MethodBind bindCamera_get_projection = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_projection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's projection mode. In @PROJECTION_PERSPECTIVE@ mode, objects' Z distance from the camera's local space scales their perceived size. get_projection :: (Camera :< cls, Object :< cls) => cls -> IO Int get_projection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_projection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_projection" '[] (IO Int) where nodeMethod = Godot.Core.Camera.get_projection {-# NOINLINE bindCamera_get_size #-} -- | The camera's size measured as 1/2 the width or height. Only applicable in orthogonal mode. Since @keep_aspect@ locks on axis, @size@ sets the other axis' size length. bindCamera_get_size :: MethodBind bindCamera_get_size = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's size measured as 1/2 the width or height. Only applicable in orthogonal mode. Since @keep_aspect@ locks on axis, @size@ sets the other axis' size length. get_size :: (Camera :< cls, Object :< cls) => cls -> IO Float get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_size" '[] (IO Float) where nodeMethod = Godot.Core.Camera.get_size {-# NOINLINE bindCamera_get_v_offset #-} -- | The vertical (Y) offset of the camera viewport. bindCamera_get_v_offset :: MethodBind bindCamera_get_v_offset = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_v_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The vertical (Y) offset of the camera viewport. get_v_offset :: (Camera :< cls, Object :< cls) => cls -> IO Float get_v_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_v_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_v_offset" '[] (IO Float) where nodeMethod = Godot.Core.Camera.get_v_offset {-# NOINLINE bindCamera_get_zfar #-} -- | The distance to the far culling boundary for this camera relative to its local Z axis. bindCamera_get_zfar :: MethodBind bindCamera_get_zfar = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_zfar" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance to the far culling boundary for this camera relative to its local Z axis. get_zfar :: (Camera :< cls, Object :< cls) => cls -> IO Float get_zfar cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_zfar (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_zfar" '[] (IO Float) where nodeMethod = Godot.Core.Camera.get_zfar {-# NOINLINE bindCamera_get_znear #-} -- | The distance to the near culling boundary for this camera relative to its local Z axis. bindCamera_get_znear :: MethodBind bindCamera_get_znear = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "get_znear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance to the near culling boundary for this camera relative to its local Z axis. get_znear :: (Camera :< cls, Object :< cls) => cls -> IO Float get_znear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_get_znear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "get_znear" '[] (IO Float) where nodeMethod = Godot.Core.Camera.get_znear {-# NOINLINE bindCamera_is_current #-} -- | If @true@, the ancestor @Viewport@ is currently using this camera. bindCamera_is_current :: MethodBind bindCamera_is_current = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "is_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the ancestor @Viewport@ is currently using this camera. is_current :: (Camera :< cls, Object :< cls) => cls -> IO Bool is_current cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_is_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "is_current" '[] (IO Bool) where nodeMethod = Godot.Core.Camera.is_current {-# NOINLINE bindCamera_is_position_behind #-} -- | Returns @true@ if the given position is behind the camera. -- __Note:__ A position which returns @false@ may still be outside the camera's field of view. bindCamera_is_position_behind :: MethodBind bindCamera_is_position_behind = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "is_position_behind" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given position is behind the camera. -- __Note:__ A position which returns @false@ may still be outside the camera's field of view. is_position_behind :: (Camera :< cls, Object :< cls) => cls -> Vector3 -> IO Bool is_position_behind cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_is_position_behind (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "is_position_behind" '[Vector3] (IO Bool) where nodeMethod = Godot.Core.Camera.is_position_behind {-# NOINLINE bindCamera_make_current #-} -- | Makes this camera the current camera for the @Viewport@ (see class description). If the camera node is outside the scene tree, it will attempt to become current once it's added. bindCamera_make_current :: MethodBind bindCamera_make_current = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "make_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Makes this camera the current camera for the @Viewport@ (see class description). If the camera node is outside the scene tree, it will attempt to become current once it's added. make_current :: (Camera :< cls, Object :< cls) => cls -> IO () make_current cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_make_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "make_current" '[] (IO ()) where nodeMethod = Godot.Core.Camera.make_current {-# NOINLINE bindCamera_project_local_ray_normal #-} -- | Returns a normal vector from the screen point location directed along the camera. Orthogonal cameras are normalized. Perspective cameras account for perspective, screen width/height, etc. bindCamera_project_local_ray_normal :: MethodBind bindCamera_project_local_ray_normal = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "project_local_ray_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a normal vector from the screen point location directed along the camera. Orthogonal cameras are normalized. Perspective cameras account for perspective, screen width/height, etc. project_local_ray_normal :: (Camera :< cls, Object :< cls) => cls -> Vector2 -> IO Vector3 project_local_ray_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_project_local_ray_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "project_local_ray_normal" '[Vector2] (IO Vector3) where nodeMethod = Godot.Core.Camera.project_local_ray_normal {-# NOINLINE bindCamera_project_position #-} -- | Returns the 3D point in worldspace that maps to the given 2D coordinate in the @Viewport@ rectangle on a plane that is the given @z_depth@ distance into the scene away from the camera. bindCamera_project_position :: MethodBind bindCamera_project_position = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "project_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the 3D point in worldspace that maps to the given 2D coordinate in the @Viewport@ rectangle on a plane that is the given @z_depth@ distance into the scene away from the camera. project_position :: (Camera :< cls, Object :< cls) => cls -> Vector2 -> Float -> IO Vector3 project_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_project_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "project_position" '[Vector2, Float] (IO Vector3) where nodeMethod = Godot.Core.Camera.project_position {-# NOINLINE bindCamera_project_ray_normal #-} -- | Returns a normal vector in worldspace, that is the result of projecting a point on the @Viewport@ rectangle by the camera projection. This is useful for casting rays in the form of (origin, normal) for object intersection or picking. bindCamera_project_ray_normal :: MethodBind bindCamera_project_ray_normal = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "project_ray_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a normal vector in worldspace, that is the result of projecting a point on the @Viewport@ rectangle by the camera projection. This is useful for casting rays in the form of (origin, normal) for object intersection or picking. project_ray_normal :: (Camera :< cls, Object :< cls) => cls -> Vector2 -> IO Vector3 project_ray_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_project_ray_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "project_ray_normal" '[Vector2] (IO Vector3) where nodeMethod = Godot.Core.Camera.project_ray_normal {-# NOINLINE bindCamera_project_ray_origin #-} -- | Returns a 3D position in worldspace, that is the result of projecting a point on the @Viewport@ rectangle by the camera projection. This is useful for casting rays in the form of (origin, normal) for object intersection or picking. bindCamera_project_ray_origin :: MethodBind bindCamera_project_ray_origin = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "project_ray_origin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a 3D position in worldspace, that is the result of projecting a point on the @Viewport@ rectangle by the camera projection. This is useful for casting rays in the form of (origin, normal) for object intersection or picking. project_ray_origin :: (Camera :< cls, Object :< cls) => cls -> Vector2 -> IO Vector3 project_ray_origin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_project_ray_origin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "project_ray_origin" '[Vector2] (IO Vector3) where nodeMethod = Godot.Core.Camera.project_ray_origin {-# NOINLINE bindCamera_set_cull_mask #-} -- | The culling mask that describes which 3D render layers are rendered by this camera. bindCamera_set_cull_mask :: MethodBind bindCamera_set_cull_mask = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The culling mask that describes which 3D render layers are rendered by this camera. set_cull_mask :: (Camera :< cls, Object :< cls) => cls -> Int -> IO () set_cull_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_cull_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.Camera.set_cull_mask {-# NOINLINE bindCamera_set_cull_mask_bit #-} -- | Enables or disables the given @layer@ in the @cull_mask@. bindCamera_set_cull_mask_bit :: MethodBind bindCamera_set_cull_mask_bit = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_cull_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables the given @layer@ in the @cull_mask@. set_cull_mask_bit :: (Camera :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_cull_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_cull_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_cull_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Camera.set_cull_mask_bit {-# NOINLINE bindCamera_set_current #-} -- | If @true@, the ancestor @Viewport@ is currently using this camera. bindCamera_set_current :: MethodBind bindCamera_set_current = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the ancestor @Viewport@ is currently using this camera. set_current :: (Camera :< cls, Object :< cls) => cls -> Bool -> IO () set_current cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_current" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera.set_current {-# NOINLINE bindCamera_set_doppler_tracking #-} -- | If not @DOPPLER_TRACKING_DISABLED@, this camera will simulate the @url=https://en.wikipedia.org/wiki/Doppler_effect@Doppler effect@/url@ for objects changed in particular @_process@ methods. See @enum DopplerTracking@ for possible values. bindCamera_set_doppler_tracking :: MethodBind bindCamera_set_doppler_tracking = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_doppler_tracking" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If not @DOPPLER_TRACKING_DISABLED@, this camera will simulate the @url=https://en.wikipedia.org/wiki/Doppler_effect@Doppler effect@/url@ for objects changed in particular @_process@ methods. See @enum DopplerTracking@ for possible values. set_doppler_tracking :: (Camera :< cls, Object :< cls) => cls -> Int -> IO () set_doppler_tracking cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_doppler_tracking (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_doppler_tracking" '[Int] (IO ()) where nodeMethod = Godot.Core.Camera.set_doppler_tracking {-# NOINLINE bindCamera_set_environment #-} -- | The @Environment@ to use for this camera. bindCamera_set_environment :: MethodBind bindCamera_set_environment = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Environment@ to use for this camera. set_environment :: (Camera :< cls, Object :< cls) => cls -> Environment -> IO () set_environment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_environment" '[Environment] (IO ()) where nodeMethod = Godot.Core.Camera.set_environment {-# NOINLINE bindCamera_set_fov #-} -- | The camera's field of view angle (in degrees). Only applicable in perspective mode. Since @keep_aspect@ locks one axis, @fov@ sets the other axis' field of view angle. bindCamera_set_fov :: MethodBind bindCamera_set_fov = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_fov" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's field of view angle (in degrees). Only applicable in perspective mode. Since @keep_aspect@ locks one axis, @fov@ sets the other axis' field of view angle. set_fov :: (Camera :< cls, Object :< cls) => cls -> Float -> IO () set_fov cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_fov (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_fov" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_fov {-# NOINLINE bindCamera_set_frustum #-} -- | Sets the camera projection to frustum mode (see @PROJECTION_FRUSTUM@), by specifying a @size@, an @offset@, and the @z_near@ and @z_far@ clip planes in world-space units. bindCamera_set_frustum :: MethodBind bindCamera_set_frustum = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_frustum" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the camera projection to frustum mode (see @PROJECTION_FRUSTUM@), by specifying a @size@, an @offset@, and the @z_near@ and @z_far@ clip planes in world-space units. set_frustum :: (Camera :< cls, Object :< cls) => cls -> Float -> Vector2 -> Float -> Float -> IO () set_frustum cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_frustum (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_frustum" '[Float, Vector2, Float, Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_frustum {-# NOINLINE bindCamera_set_frustum_offset #-} -- | The camera's frustum offset. This can be changed from the default to create "tilted frustum" effects such as @url=https://zdoom.org/wiki/Y-shearing@Y-shearing@/url@. bindCamera_set_frustum_offset :: MethodBind bindCamera_set_frustum_offset = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_frustum_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's frustum offset. This can be changed from the default to create "tilted frustum" effects such as @url=https://zdoom.org/wiki/Y-shearing@Y-shearing@/url@. set_frustum_offset :: (Camera :< cls, Object :< cls) => cls -> Vector2 -> IO () set_frustum_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_frustum_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_frustum_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Camera.set_frustum_offset {-# NOINLINE bindCamera_set_h_offset #-} -- | The horizontal (X) offset of the camera viewport. bindCamera_set_h_offset :: MethodBind bindCamera_set_h_offset = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_h_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The horizontal (X) offset of the camera viewport. set_h_offset :: (Camera :< cls, Object :< cls) => cls -> Float -> IO () set_h_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_h_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_h_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_h_offset {-# NOINLINE bindCamera_set_keep_aspect_mode #-} -- | The axis to lock during @fov@/@size@ adjustments. Can be either @KEEP_WIDTH@ or @KEEP_HEIGHT@. bindCamera_set_keep_aspect_mode :: MethodBind bindCamera_set_keep_aspect_mode = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_keep_aspect_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The axis to lock during @fov@/@size@ adjustments. Can be either @KEEP_WIDTH@ or @KEEP_HEIGHT@. set_keep_aspect_mode :: (Camera :< cls, Object :< cls) => cls -> Int -> IO () set_keep_aspect_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_keep_aspect_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_keep_aspect_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Camera.set_keep_aspect_mode {-# NOINLINE bindCamera_set_orthogonal #-} -- | Sets the camera projection to orthogonal mode (see @PROJECTION_ORTHOGONAL@), by specifying a @size@, and the @z_near@ and @z_far@ clip planes in world-space units. (As a hint, 2D games often use this projection, with values specified in pixels.) bindCamera_set_orthogonal :: MethodBind bindCamera_set_orthogonal = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_orthogonal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the camera projection to orthogonal mode (see @PROJECTION_ORTHOGONAL@), by specifying a @size@, and the @z_near@ and @z_far@ clip planes in world-space units. (As a hint, 2D games often use this projection, with values specified in pixels.) set_orthogonal :: (Camera :< cls, Object :< cls) => cls -> Float -> Float -> Float -> IO () set_orthogonal cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_orthogonal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_orthogonal" '[Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_orthogonal {-# NOINLINE bindCamera_set_perspective #-} -- | Sets the camera projection to perspective mode (see @PROJECTION_PERSPECTIVE@), by specifying a @fov@ (field of view) angle in degrees, and the @z_near@ and @z_far@ clip planes in world-space units. bindCamera_set_perspective :: MethodBind bindCamera_set_perspective = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_perspective" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the camera projection to perspective mode (see @PROJECTION_PERSPECTIVE@), by specifying a @fov@ (field of view) angle in degrees, and the @z_near@ and @z_far@ clip planes in world-space units. set_perspective :: (Camera :< cls, Object :< cls) => cls -> Float -> Float -> Float -> IO () set_perspective cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_perspective (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_perspective" '[Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_perspective {-# NOINLINE bindCamera_set_projection #-} -- | The camera's projection mode. In @PROJECTION_PERSPECTIVE@ mode, objects' Z distance from the camera's local space scales their perceived size. bindCamera_set_projection :: MethodBind bindCamera_set_projection = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_projection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's projection mode. In @PROJECTION_PERSPECTIVE@ mode, objects' Z distance from the camera's local space scales their perceived size. set_projection :: (Camera :< cls, Object :< cls) => cls -> Int -> IO () set_projection cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_projection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_projection" '[Int] (IO ()) where nodeMethod = Godot.Core.Camera.set_projection {-# NOINLINE bindCamera_set_size #-} -- | The camera's size measured as 1/2 the width or height. Only applicable in orthogonal mode. Since @keep_aspect@ locks on axis, @size@ sets the other axis' size length. bindCamera_set_size :: MethodBind bindCamera_set_size = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's size measured as 1/2 the width or height. Only applicable in orthogonal mode. Since @keep_aspect@ locks on axis, @size@ sets the other axis' size length. set_size :: (Camera :< cls, Object :< cls) => cls -> Float -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_size" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_size {-# NOINLINE bindCamera_set_v_offset #-} -- | The vertical (Y) offset of the camera viewport. bindCamera_set_v_offset :: MethodBind bindCamera_set_v_offset = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_v_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The vertical (Y) offset of the camera viewport. set_v_offset :: (Camera :< cls, Object :< cls) => cls -> Float -> IO () set_v_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_v_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_v_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_v_offset {-# NOINLINE bindCamera_set_zfar #-} -- | The distance to the far culling boundary for this camera relative to its local Z axis. bindCamera_set_zfar :: MethodBind bindCamera_set_zfar = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_zfar" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance to the far culling boundary for this camera relative to its local Z axis. set_zfar :: (Camera :< cls, Object :< cls) => cls -> Float -> IO () set_zfar cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_zfar (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_zfar" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_zfar {-# NOINLINE bindCamera_set_znear #-} -- | The distance to the near culling boundary for this camera relative to its local Z axis. bindCamera_set_znear :: MethodBind bindCamera_set_znear = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "set_znear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance to the near culling boundary for this camera relative to its local Z axis. set_znear :: (Camera :< cls, Object :< cls) => cls -> Float -> IO () set_znear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_set_znear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "set_znear" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera.set_znear {-# NOINLINE bindCamera_unproject_position #-} -- | Returns the 2D coordinate in the @Viewport@ rectangle that maps to the given 3D point in worldspace. bindCamera_unproject_position :: MethodBind bindCamera_unproject_position = unsafePerformIO $ withCString "Camera" $ \ clsNamePtr -> withCString "unproject_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the 2D coordinate in the @Viewport@ rectangle that maps to the given 3D point in worldspace. unproject_position :: (Camera :< cls, Object :< cls) => cls -> Vector3 -> IO Vector2 unproject_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera_unproject_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera "unproject_position" '[Vector3] (IO Vector2) where nodeMethod = Godot.Core.Camera.unproject_position ================================================ FILE: src/Godot/Core/Camera2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Camera2D (Godot.Core.Camera2D._ANCHOR_MODE_FIXED_TOP_LEFT, Godot.Core.Camera2D._CAMERA2D_PROCESS_PHYSICS, Godot.Core.Camera2D._CAMERA2D_PROCESS_IDLE, Godot.Core.Camera2D._ANCHOR_MODE_DRAG_CENTER, Godot.Core.Camera2D._make_current, Godot.Core.Camera2D._set_current, Godot.Core.Camera2D._set_old_smoothing, Godot.Core.Camera2D._update_scroll, Godot.Core.Camera2D.align, Godot.Core.Camera2D.clear_current, Godot.Core.Camera2D.force_update_scroll, Godot.Core.Camera2D.get_anchor_mode, Godot.Core.Camera2D.get_camera_position, Godot.Core.Camera2D.get_camera_screen_center, Godot.Core.Camera2D.get_custom_viewport, Godot.Core.Camera2D.get_drag_margin, Godot.Core.Camera2D.get_follow_smoothing, Godot.Core.Camera2D.get_h_offset, Godot.Core.Camera2D.get_limit, Godot.Core.Camera2D.get_offset, Godot.Core.Camera2D.get_process_mode, Godot.Core.Camera2D.get_v_offset, Godot.Core.Camera2D.get_zoom, Godot.Core.Camera2D.is_current, Godot.Core.Camera2D.is_follow_smoothing_enabled, Godot.Core.Camera2D.is_h_drag_enabled, Godot.Core.Camera2D.is_limit_drawing_enabled, Godot.Core.Camera2D.is_limit_smoothing_enabled, Godot.Core.Camera2D.is_margin_drawing_enabled, Godot.Core.Camera2D.is_rotating, Godot.Core.Camera2D.is_screen_drawing_enabled, Godot.Core.Camera2D.is_v_drag_enabled, Godot.Core.Camera2D.make_current, Godot.Core.Camera2D.reset_smoothing, Godot.Core.Camera2D.set_anchor_mode, Godot.Core.Camera2D.set_custom_viewport, Godot.Core.Camera2D.set_drag_margin, Godot.Core.Camera2D.set_enable_follow_smoothing, Godot.Core.Camera2D.set_follow_smoothing, Godot.Core.Camera2D.set_h_drag_enabled, Godot.Core.Camera2D.set_h_offset, Godot.Core.Camera2D.set_limit, Godot.Core.Camera2D.set_limit_drawing_enabled, Godot.Core.Camera2D.set_limit_smoothing_enabled, Godot.Core.Camera2D.set_margin_drawing_enabled, Godot.Core.Camera2D.set_offset, Godot.Core.Camera2D.set_process_mode, Godot.Core.Camera2D.set_rotating, Godot.Core.Camera2D.set_screen_drawing_enabled, Godot.Core.Camera2D.set_v_drag_enabled, Godot.Core.Camera2D.set_v_offset, Godot.Core.Camera2D.set_zoom) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _ANCHOR_MODE_FIXED_TOP_LEFT :: Int _ANCHOR_MODE_FIXED_TOP_LEFT = 0 _CAMERA2D_PROCESS_PHYSICS :: Int _CAMERA2D_PROCESS_PHYSICS = 0 _CAMERA2D_PROCESS_IDLE :: Int _CAMERA2D_PROCESS_IDLE = 1 _ANCHOR_MODE_DRAG_CENTER :: Int _ANCHOR_MODE_DRAG_CENTER = 1 instance NodeProperty Camera2D "anchor_mode" Int 'False where nodeProperty = (get_anchor_mode, wrapDroppingSetter set_anchor_mode, Nothing) instance NodeProperty Camera2D "current" Bool 'False where nodeProperty = (is_current, wrapDroppingSetter _set_current, Nothing) instance NodeProperty Camera2D "custom_viewport" Node 'False where nodeProperty = (get_custom_viewport, wrapDroppingSetter set_custom_viewport, Nothing) instance NodeProperty Camera2D "drag_margin_bottom" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_drag_margin, wrapIndexedSetter 3 set_drag_margin, Nothing) instance NodeProperty Camera2D "drag_margin_h_enabled" Bool 'False where nodeProperty = (is_h_drag_enabled, wrapDroppingSetter set_h_drag_enabled, Nothing) instance NodeProperty Camera2D "drag_margin_left" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_drag_margin, wrapIndexedSetter 0 set_drag_margin, Nothing) instance NodeProperty Camera2D "drag_margin_right" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_drag_margin, wrapIndexedSetter 2 set_drag_margin, Nothing) instance NodeProperty Camera2D "drag_margin_top" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_drag_margin, wrapIndexedSetter 1 set_drag_margin, Nothing) instance NodeProperty Camera2D "drag_margin_v_enabled" Bool 'False where nodeProperty = (is_v_drag_enabled, wrapDroppingSetter set_v_drag_enabled, Nothing) instance NodeProperty Camera2D "editor_draw_drag_margin" Bool 'False where nodeProperty = (is_margin_drawing_enabled, wrapDroppingSetter set_margin_drawing_enabled, Nothing) instance NodeProperty Camera2D "editor_draw_limits" Bool 'False where nodeProperty = (is_limit_drawing_enabled, wrapDroppingSetter set_limit_drawing_enabled, Nothing) instance NodeProperty Camera2D "editor_draw_screen" Bool 'False where nodeProperty = (is_screen_drawing_enabled, wrapDroppingSetter set_screen_drawing_enabled, Nothing) instance NodeProperty Camera2D "limit_bottom" Int 'False where nodeProperty = (wrapIndexedGetter 3 get_limit, wrapIndexedSetter 3 set_limit, Nothing) instance NodeProperty Camera2D "limit_left" Int 'False where nodeProperty = (wrapIndexedGetter 0 get_limit, wrapIndexedSetter 0 set_limit, Nothing) instance NodeProperty Camera2D "limit_right" Int 'False where nodeProperty = (wrapIndexedGetter 2 get_limit, wrapIndexedSetter 2 set_limit, Nothing) instance NodeProperty Camera2D "limit_smoothed" Bool 'False where nodeProperty = (is_limit_smoothing_enabled, wrapDroppingSetter set_limit_smoothing_enabled, Nothing) instance NodeProperty Camera2D "limit_top" Int 'False where nodeProperty = (wrapIndexedGetter 1 get_limit, wrapIndexedSetter 1 set_limit, Nothing) instance NodeProperty Camera2D "offset" Vector2 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty Camera2D "offset_h" Float 'False where nodeProperty = (get_h_offset, wrapDroppingSetter set_h_offset, Nothing) instance NodeProperty Camera2D "offset_v" Float 'False where nodeProperty = (get_v_offset, wrapDroppingSetter set_v_offset, Nothing) instance NodeProperty Camera2D "process_mode" Int 'False where nodeProperty = (get_process_mode, wrapDroppingSetter set_process_mode, Nothing) instance NodeProperty Camera2D "rotating" Bool 'False where nodeProperty = (is_rotating, wrapDroppingSetter set_rotating, Nothing) instance NodeProperty Camera2D "smoothing_enabled" Bool 'False where nodeProperty = (is_follow_smoothing_enabled, wrapDroppingSetter set_enable_follow_smoothing, Nothing) instance NodeProperty Camera2D "smoothing_speed" Float 'False where nodeProperty = (get_follow_smoothing, wrapDroppingSetter set_follow_smoothing, Nothing) instance NodeProperty Camera2D "zoom" Vector2 'False where nodeProperty = (get_zoom, wrapDroppingSetter set_zoom, Nothing) {-# NOINLINE bindCamera2D__make_current #-} bindCamera2D__make_current :: MethodBind bindCamera2D__make_current = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "_make_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _make_current :: (Camera2D :< cls, Object :< cls) => cls -> Object -> IO () _make_current cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D__make_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "_make_current" '[Object] (IO ()) where nodeMethod = Godot.Core.Camera2D._make_current {-# NOINLINE bindCamera2D__set_current #-} -- | If @true@, the camera is the active camera for the current scene. Only one camera can be current, so setting a different camera @current@ will disable this one. bindCamera2D__set_current :: MethodBind bindCamera2D__set_current = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "_set_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera is the active camera for the current scene. Only one camera can be current, so setting a different camera @current@ will disable this one. _set_current :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () _set_current cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D__set_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "_set_current" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D._set_current {-# NOINLINE bindCamera2D__set_old_smoothing #-} bindCamera2D__set_old_smoothing :: MethodBind bindCamera2D__set_old_smoothing = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "_set_old_smoothing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_old_smoothing :: (Camera2D :< cls, Object :< cls) => cls -> Float -> IO () _set_old_smoothing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D__set_old_smoothing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "_set_old_smoothing" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera2D._set_old_smoothing {-# NOINLINE bindCamera2D__update_scroll #-} bindCamera2D__update_scroll :: MethodBind bindCamera2D__update_scroll = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "_update_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_scroll :: (Camera2D :< cls, Object :< cls) => cls -> IO () _update_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D__update_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "_update_scroll" '[] (IO ()) where nodeMethod = Godot.Core.Camera2D._update_scroll {-# NOINLINE bindCamera2D_align #-} -- | Aligns the camera to the tracked node. bindCamera2D_align :: MethodBind bindCamera2D_align = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Aligns the camera to the tracked node. align :: (Camera2D :< cls, Object :< cls) => cls -> IO () align cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "align" '[] (IO ()) where nodeMethod = Godot.Core.Camera2D.align {-# NOINLINE bindCamera2D_clear_current #-} -- | Removes any @Camera2D@ from the ancestor @Viewport@'s internal currently-assigned camera. bindCamera2D_clear_current :: MethodBind bindCamera2D_clear_current = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "clear_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes any @Camera2D@ from the ancestor @Viewport@'s internal currently-assigned camera. clear_current :: (Camera2D :< cls, Object :< cls) => cls -> IO () clear_current cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_clear_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "clear_current" '[] (IO ()) where nodeMethod = Godot.Core.Camera2D.clear_current {-# NOINLINE bindCamera2D_force_update_scroll #-} -- | Forces the camera to update scroll immediately. bindCamera2D_force_update_scroll :: MethodBind bindCamera2D_force_update_scroll = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "force_update_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Forces the camera to update scroll immediately. force_update_scroll :: (Camera2D :< cls, Object :< cls) => cls -> IO () force_update_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_force_update_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "force_update_scroll" '[] (IO ()) where nodeMethod = Godot.Core.Camera2D.force_update_scroll {-# NOINLINE bindCamera2D_get_anchor_mode #-} -- | The Camera2D's anchor point. See @enum AnchorMode@ constants. bindCamera2D_get_anchor_mode :: MethodBind bindCamera2D_get_anchor_mode = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_anchor_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Camera2D's anchor point. See @enum AnchorMode@ constants. get_anchor_mode :: (Camera2D :< cls, Object :< cls) => cls -> IO Int get_anchor_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_anchor_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_anchor_mode" '[] (IO Int) where nodeMethod = Godot.Core.Camera2D.get_anchor_mode {-# NOINLINE bindCamera2D_get_camera_position #-} -- | Returns the camera position. bindCamera2D_get_camera_position :: MethodBind bindCamera2D_get_camera_position = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_camera_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the camera position. get_camera_position :: (Camera2D :< cls, Object :< cls) => cls -> IO Vector2 get_camera_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_camera_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_camera_position" '[] (IO Vector2) where nodeMethod = Godot.Core.Camera2D.get_camera_position {-# NOINLINE bindCamera2D_get_camera_screen_center #-} -- | Returns the location of the @Camera2D@'s screen-center, relative to the origin. bindCamera2D_get_camera_screen_center :: MethodBind bindCamera2D_get_camera_screen_center = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_camera_screen_center" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the location of the @Camera2D@'s screen-center, relative to the origin. get_camera_screen_center :: (Camera2D :< cls, Object :< cls) => cls -> IO Vector2 get_camera_screen_center cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_camera_screen_center (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_camera_screen_center" '[] (IO Vector2) where nodeMethod = Godot.Core.Camera2D.get_camera_screen_center {-# NOINLINE bindCamera2D_get_custom_viewport #-} -- | The custom @Viewport@ node attached to the @Camera2D@. If @null@ or not a @Viewport@, uses the default viewport instead. bindCamera2D_get_custom_viewport :: MethodBind bindCamera2D_get_custom_viewport = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_custom_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @Viewport@ node attached to the @Camera2D@. If @null@ or not a @Viewport@, uses the default viewport instead. get_custom_viewport :: (Camera2D :< cls, Object :< cls) => cls -> IO Node get_custom_viewport cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_custom_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_custom_viewport" '[] (IO Node) where nodeMethod = Godot.Core.Camera2D.get_custom_viewport {-# NOINLINE bindCamera2D_get_drag_margin #-} -- | Returns the specified margin. See also @drag_margin_bottom@, @drag_margin_top@, @drag_margin_left@, and @drag_margin_right@. bindCamera2D_get_drag_margin :: MethodBind bindCamera2D_get_drag_margin = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_drag_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the specified margin. See also @drag_margin_bottom@, @drag_margin_top@, @drag_margin_left@, and @drag_margin_right@. get_drag_margin :: (Camera2D :< cls, Object :< cls) => cls -> Int -> IO Float get_drag_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_drag_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_drag_margin" '[Int] (IO Float) where nodeMethod = Godot.Core.Camera2D.get_drag_margin {-# NOINLINE bindCamera2D_get_follow_smoothing #-} -- | Speed in pixels per second of the camera's smoothing effect when @smoothing_enabled@ is @true@. bindCamera2D_get_follow_smoothing :: MethodBind bindCamera2D_get_follow_smoothing = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_follow_smoothing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Speed in pixels per second of the camera's smoothing effect when @smoothing_enabled@ is @true@. get_follow_smoothing :: (Camera2D :< cls, Object :< cls) => cls -> IO Float get_follow_smoothing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_follow_smoothing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_follow_smoothing" '[] (IO Float) where nodeMethod = Godot.Core.Camera2D.get_follow_smoothing {-# NOINLINE bindCamera2D_get_h_offset #-} -- | The horizontal offset of the camera, relative to the drag margins. -- __Note:__ Offset H is used only to force offset relative to margins. It's not updated in any way if drag margins are enabled and can be used to set initial offset. bindCamera2D_get_h_offset :: MethodBind bindCamera2D_get_h_offset = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_h_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The horizontal offset of the camera, relative to the drag margins. -- __Note:__ Offset H is used only to force offset relative to margins. It's not updated in any way if drag margins are enabled and can be used to set initial offset. get_h_offset :: (Camera2D :< cls, Object :< cls) => cls -> IO Float get_h_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_h_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_h_offset" '[] (IO Float) where nodeMethod = Godot.Core.Camera2D.get_h_offset {-# NOINLINE bindCamera2D_get_limit #-} -- | Returns the specified camera limit. See also @limit_bottom@, @limit_top@, @limit_left@, and @limit_right@. bindCamera2D_get_limit :: MethodBind bindCamera2D_get_limit = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the specified camera limit. See also @limit_bottom@, @limit_top@, @limit_left@, and @limit_right@. get_limit :: (Camera2D :< cls, Object :< cls) => cls -> Int -> IO Int get_limit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_limit" '[Int] (IO Int) where nodeMethod = Godot.Core.Camera2D.get_limit {-# NOINLINE bindCamera2D_get_offset #-} -- | The camera's offset, useful for looking around or camera shake animations. bindCamera2D_get_offset :: MethodBind bindCamera2D_get_offset = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's offset, useful for looking around or camera shake animations. get_offset :: (Camera2D :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.Camera2D.get_offset {-# NOINLINE bindCamera2D_get_process_mode #-} -- | The camera's process callback. See @enum Camera2DProcessMode@. bindCamera2D_get_process_mode :: MethodBind bindCamera2D_get_process_mode = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's process callback. See @enum Camera2DProcessMode@. get_process_mode :: (Camera2D :< cls, Object :< cls) => cls -> IO Int get_process_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_process_mode" '[] (IO Int) where nodeMethod = Godot.Core.Camera2D.get_process_mode {-# NOINLINE bindCamera2D_get_v_offset #-} -- | The vertical offset of the camera, relative to the drag margins. -- __Note:__ Used the same as @offset_h@. bindCamera2D_get_v_offset :: MethodBind bindCamera2D_get_v_offset = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_v_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The vertical offset of the camera, relative to the drag margins. -- __Note:__ Used the same as @offset_h@. get_v_offset :: (Camera2D :< cls, Object :< cls) => cls -> IO Float get_v_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_v_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_v_offset" '[] (IO Float) where nodeMethod = Godot.Core.Camera2D.get_v_offset {-# NOINLINE bindCamera2D_get_zoom #-} -- | The camera's zoom relative to the viewport. Values larger than @Vector2(1, 1)@ zoom out and smaller values zoom in. For an example, use @Vector2(0.5, 0.5)@ for a 2× zoom-in, and @Vector2(4, 4)@ for a 4× zoom-out. bindCamera2D_get_zoom :: MethodBind bindCamera2D_get_zoom = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "get_zoom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's zoom relative to the viewport. Values larger than @Vector2(1, 1)@ zoom out and smaller values zoom in. For an example, use @Vector2(0.5, 0.5)@ for a 2× zoom-in, and @Vector2(4, 4)@ for a 4× zoom-out. get_zoom :: (Camera2D :< cls, Object :< cls) => cls -> IO Vector2 get_zoom cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_get_zoom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "get_zoom" '[] (IO Vector2) where nodeMethod = Godot.Core.Camera2D.get_zoom {-# NOINLINE bindCamera2D_is_current #-} -- | If @true@, the camera is the active camera for the current scene. Only one camera can be current, so setting a different camera @current@ will disable this one. bindCamera2D_is_current :: MethodBind bindCamera2D_is_current = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera is the active camera for the current scene. Only one camera can be current, so setting a different camera @current@ will disable this one. is_current :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_current cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_current" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_current {-# NOINLINE bindCamera2D_is_follow_smoothing_enabled #-} -- | If @true@, the camera smoothly moves towards the target at @smoothing_speed@. bindCamera2D_is_follow_smoothing_enabled :: MethodBind bindCamera2D_is_follow_smoothing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_follow_smoothing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera smoothly moves towards the target at @smoothing_speed@. is_follow_smoothing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_follow_smoothing_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_follow_smoothing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_follow_smoothing_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_follow_smoothing_enabled {-# NOINLINE bindCamera2D_is_h_drag_enabled #-} -- | If @true@, the camera only moves when reaching the horizontal drag margins. If @false@, the camera moves horizontally regardless of margins. bindCamera2D_is_h_drag_enabled :: MethodBind bindCamera2D_is_h_drag_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_h_drag_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera only moves when reaching the horizontal drag margins. If @false@, the camera moves horizontally regardless of margins. is_h_drag_enabled :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_h_drag_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_h_drag_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_h_drag_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_h_drag_enabled {-# NOINLINE bindCamera2D_is_limit_drawing_enabled #-} -- | If @true@, draws the camera's limits rectangle in the editor. bindCamera2D_is_limit_drawing_enabled :: MethodBind bindCamera2D_is_limit_drawing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_limit_drawing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, draws the camera's limits rectangle in the editor. is_limit_drawing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_limit_drawing_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_limit_drawing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_limit_drawing_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_limit_drawing_enabled {-# NOINLINE bindCamera2D_is_limit_smoothing_enabled #-} -- | If @true@, the camera smoothly stops when reaches its limits. bindCamera2D_is_limit_smoothing_enabled :: MethodBind bindCamera2D_is_limit_smoothing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_limit_smoothing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera smoothly stops when reaches its limits. is_limit_smoothing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_limit_smoothing_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_limit_smoothing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_limit_smoothing_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_limit_smoothing_enabled {-# NOINLINE bindCamera2D_is_margin_drawing_enabled #-} -- | If @true@, draws the camera's drag margin rectangle in the editor. bindCamera2D_is_margin_drawing_enabled :: MethodBind bindCamera2D_is_margin_drawing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_margin_drawing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, draws the camera's drag margin rectangle in the editor. is_margin_drawing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_margin_drawing_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_margin_drawing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_margin_drawing_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_margin_drawing_enabled {-# NOINLINE bindCamera2D_is_rotating #-} -- | If @true@, the camera rotates with the target. bindCamera2D_is_rotating :: MethodBind bindCamera2D_is_rotating = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_rotating" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera rotates with the target. is_rotating :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_rotating cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_rotating (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_rotating" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_rotating {-# NOINLINE bindCamera2D_is_screen_drawing_enabled #-} -- | If @true@, draws the camera's screen rectangle in the editor. bindCamera2D_is_screen_drawing_enabled :: MethodBind bindCamera2D_is_screen_drawing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_screen_drawing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, draws the camera's screen rectangle in the editor. is_screen_drawing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_screen_drawing_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_screen_drawing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_screen_drawing_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_screen_drawing_enabled {-# NOINLINE bindCamera2D_is_v_drag_enabled #-} -- | If @true@, the camera only moves when reaching the vertical drag margins. If @false@, the camera moves vertically regardless of margins. bindCamera2D_is_v_drag_enabled :: MethodBind bindCamera2D_is_v_drag_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "is_v_drag_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera only moves when reaching the vertical drag margins. If @false@, the camera moves vertically regardless of margins. is_v_drag_enabled :: (Camera2D :< cls, Object :< cls) => cls -> IO Bool is_v_drag_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_is_v_drag_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "is_v_drag_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Camera2D.is_v_drag_enabled {-# NOINLINE bindCamera2D_make_current #-} -- | Make this the current 2D camera for the scene (viewport and layer), in case there are many cameras in the scene. bindCamera2D_make_current :: MethodBind bindCamera2D_make_current = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "make_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Make this the current 2D camera for the scene (viewport and layer), in case there are many cameras in the scene. make_current :: (Camera2D :< cls, Object :< cls) => cls -> IO () make_current cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_make_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "make_current" '[] (IO ()) where nodeMethod = Godot.Core.Camera2D.make_current {-# NOINLINE bindCamera2D_reset_smoothing #-} -- | Sets the camera's position immediately to its current smoothing destination. -- This has no effect if smoothing is disabled. bindCamera2D_reset_smoothing :: MethodBind bindCamera2D_reset_smoothing = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "reset_smoothing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the camera's position immediately to its current smoothing destination. -- This has no effect if smoothing is disabled. reset_smoothing :: (Camera2D :< cls, Object :< cls) => cls -> IO () reset_smoothing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_reset_smoothing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "reset_smoothing" '[] (IO ()) where nodeMethod = Godot.Core.Camera2D.reset_smoothing {-# NOINLINE bindCamera2D_set_anchor_mode #-} -- | The Camera2D's anchor point. See @enum AnchorMode@ constants. bindCamera2D_set_anchor_mode :: MethodBind bindCamera2D_set_anchor_mode = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_anchor_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Camera2D's anchor point. See @enum AnchorMode@ constants. set_anchor_mode :: (Camera2D :< cls, Object :< cls) => cls -> Int -> IO () set_anchor_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_anchor_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_anchor_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_anchor_mode {-# NOINLINE bindCamera2D_set_custom_viewport #-} -- | The custom @Viewport@ node attached to the @Camera2D@. If @null@ or not a @Viewport@, uses the default viewport instead. bindCamera2D_set_custom_viewport :: MethodBind bindCamera2D_set_custom_viewport = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_custom_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @Viewport@ node attached to the @Camera2D@. If @null@ or not a @Viewport@, uses the default viewport instead. set_custom_viewport :: (Camera2D :< cls, Object :< cls) => cls -> Node -> IO () set_custom_viewport cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_custom_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_custom_viewport" '[Node] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_custom_viewport {-# NOINLINE bindCamera2D_set_drag_margin #-} -- | Sets the specified margin. See also @drag_margin_bottom@, @drag_margin_top@, @drag_margin_left@, and @drag_margin_right@. bindCamera2D_set_drag_margin :: MethodBind bindCamera2D_set_drag_margin = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_drag_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified margin. See also @drag_margin_bottom@, @drag_margin_top@, @drag_margin_left@, and @drag_margin_right@. set_drag_margin :: (Camera2D :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_drag_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_drag_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_drag_margin" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_drag_margin {-# NOINLINE bindCamera2D_set_enable_follow_smoothing #-} -- | If @true@, the camera smoothly moves towards the target at @smoothing_speed@. bindCamera2D_set_enable_follow_smoothing :: MethodBind bindCamera2D_set_enable_follow_smoothing = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_enable_follow_smoothing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera smoothly moves towards the target at @smoothing_speed@. set_enable_follow_smoothing :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () set_enable_follow_smoothing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_enable_follow_smoothing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_enable_follow_smoothing" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_enable_follow_smoothing {-# NOINLINE bindCamera2D_set_follow_smoothing #-} -- | Speed in pixels per second of the camera's smoothing effect when @smoothing_enabled@ is @true@. bindCamera2D_set_follow_smoothing :: MethodBind bindCamera2D_set_follow_smoothing = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_follow_smoothing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Speed in pixels per second of the camera's smoothing effect when @smoothing_enabled@ is @true@. set_follow_smoothing :: (Camera2D :< cls, Object :< cls) => cls -> Float -> IO () set_follow_smoothing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_follow_smoothing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_follow_smoothing" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_follow_smoothing {-# NOINLINE bindCamera2D_set_h_drag_enabled #-} -- | If @true@, the camera only moves when reaching the horizontal drag margins. If @false@, the camera moves horizontally regardless of margins. bindCamera2D_set_h_drag_enabled :: MethodBind bindCamera2D_set_h_drag_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_h_drag_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera only moves when reaching the horizontal drag margins. If @false@, the camera moves horizontally regardless of margins. set_h_drag_enabled :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () set_h_drag_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_h_drag_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_h_drag_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_h_drag_enabled {-# NOINLINE bindCamera2D_set_h_offset #-} -- | The horizontal offset of the camera, relative to the drag margins. -- __Note:__ Offset H is used only to force offset relative to margins. It's not updated in any way if drag margins are enabled and can be used to set initial offset. bindCamera2D_set_h_offset :: MethodBind bindCamera2D_set_h_offset = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_h_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The horizontal offset of the camera, relative to the drag margins. -- __Note:__ Offset H is used only to force offset relative to margins. It's not updated in any way if drag margins are enabled and can be used to set initial offset. set_h_offset :: (Camera2D :< cls, Object :< cls) => cls -> Float -> IO () set_h_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_h_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_h_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_h_offset {-# NOINLINE bindCamera2D_set_limit #-} -- | Sets the specified camera limit. See also @limit_bottom@, @limit_top@, @limit_left@, and @limit_right@. bindCamera2D_set_limit :: MethodBind bindCamera2D_set_limit = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified camera limit. See also @limit_bottom@, @limit_top@, @limit_left@, and @limit_right@. set_limit :: (Camera2D :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_limit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_limit" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_limit {-# NOINLINE bindCamera2D_set_limit_drawing_enabled #-} -- | If @true@, draws the camera's limits rectangle in the editor. bindCamera2D_set_limit_drawing_enabled :: MethodBind bindCamera2D_set_limit_drawing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_limit_drawing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, draws the camera's limits rectangle in the editor. set_limit_drawing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () set_limit_drawing_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_limit_drawing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_limit_drawing_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_limit_drawing_enabled {-# NOINLINE bindCamera2D_set_limit_smoothing_enabled #-} -- | If @true@, the camera smoothly stops when reaches its limits. bindCamera2D_set_limit_smoothing_enabled :: MethodBind bindCamera2D_set_limit_smoothing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_limit_smoothing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera smoothly stops when reaches its limits. set_limit_smoothing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () set_limit_smoothing_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_limit_smoothing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_limit_smoothing_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_limit_smoothing_enabled {-# NOINLINE bindCamera2D_set_margin_drawing_enabled #-} -- | If @true@, draws the camera's drag margin rectangle in the editor. bindCamera2D_set_margin_drawing_enabled :: MethodBind bindCamera2D_set_margin_drawing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_margin_drawing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, draws the camera's drag margin rectangle in the editor. set_margin_drawing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () set_margin_drawing_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_margin_drawing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_margin_drawing_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_margin_drawing_enabled {-# NOINLINE bindCamera2D_set_offset #-} -- | The camera's offset, useful for looking around or camera shake animations. bindCamera2D_set_offset :: MethodBind bindCamera2D_set_offset = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's offset, useful for looking around or camera shake animations. set_offset :: (Camera2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_offset {-# NOINLINE bindCamera2D_set_process_mode #-} -- | The camera's process callback. See @enum Camera2DProcessMode@. bindCamera2D_set_process_mode :: MethodBind bindCamera2D_set_process_mode = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's process callback. See @enum Camera2DProcessMode@. set_process_mode :: (Camera2D :< cls, Object :< cls) => cls -> Int -> IO () set_process_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_process_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_process_mode {-# NOINLINE bindCamera2D_set_rotating #-} -- | If @true@, the camera rotates with the target. bindCamera2D_set_rotating :: MethodBind bindCamera2D_set_rotating = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_rotating" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera rotates with the target. set_rotating :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () set_rotating cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_rotating (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_rotating" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_rotating {-# NOINLINE bindCamera2D_set_screen_drawing_enabled #-} -- | If @true@, draws the camera's screen rectangle in the editor. bindCamera2D_set_screen_drawing_enabled :: MethodBind bindCamera2D_set_screen_drawing_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_screen_drawing_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, draws the camera's screen rectangle in the editor. set_screen_drawing_enabled :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () set_screen_drawing_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_screen_drawing_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_screen_drawing_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_screen_drawing_enabled {-# NOINLINE bindCamera2D_set_v_drag_enabled #-} -- | If @true@, the camera only moves when reaching the vertical drag margins. If @false@, the camera moves vertically regardless of margins. bindCamera2D_set_v_drag_enabled :: MethodBind bindCamera2D_set_v_drag_enabled = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_v_drag_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera only moves when reaching the vertical drag margins. If @false@, the camera moves vertically regardless of margins. set_v_drag_enabled :: (Camera2D :< cls, Object :< cls) => cls -> Bool -> IO () set_v_drag_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_v_drag_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_v_drag_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_v_drag_enabled {-# NOINLINE bindCamera2D_set_v_offset #-} -- | The vertical offset of the camera, relative to the drag margins. -- __Note:__ Used the same as @offset_h@. bindCamera2D_set_v_offset :: MethodBind bindCamera2D_set_v_offset = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_v_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The vertical offset of the camera, relative to the drag margins. -- __Note:__ Used the same as @offset_h@. set_v_offset :: (Camera2D :< cls, Object :< cls) => cls -> Float -> IO () set_v_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_v_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_v_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_v_offset {-# NOINLINE bindCamera2D_set_zoom #-} -- | The camera's zoom relative to the viewport. Values larger than @Vector2(1, 1)@ zoom out and smaller values zoom in. For an example, use @Vector2(0.5, 0.5)@ for a 2× zoom-in, and @Vector2(4, 4)@ for a 4× zoom-out. bindCamera2D_set_zoom :: MethodBind bindCamera2D_set_zoom = unsafePerformIO $ withCString "Camera2D" $ \ clsNamePtr -> withCString "set_zoom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's zoom relative to the viewport. Values larger than @Vector2(1, 1)@ zoom out and smaller values zoom in. For an example, use @Vector2(0.5, 0.5)@ for a 2× zoom-in, and @Vector2(4, 4)@ for a 4× zoom-out. set_zoom :: (Camera2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_zoom cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCamera2D_set_zoom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Camera2D "set_zoom" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Camera2D.set_zoom ================================================ FILE: src/Godot/Core/CameraFeed.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CameraFeed (Godot.Core.CameraFeed._FEED_FRONT, Godot.Core.CameraFeed._FEED_YCBCR_SEP, Godot.Core.CameraFeed._FEED_YCBCR, Godot.Core.CameraFeed._FEED_UNSPECIFIED, Godot.Core.CameraFeed._FEED_RGB, Godot.Core.CameraFeed._FEED_NOIMAGE, Godot.Core.CameraFeed._FEED_BACK, Godot.Core.CameraFeed._allocate_texture, Godot.Core.CameraFeed._set_RGB_img, Godot.Core.CameraFeed._set_YCbCr_img, Godot.Core.CameraFeed._set_YCbCr_imgs, Godot.Core.CameraFeed._set_name, Godot.Core.CameraFeed._set_position, Godot.Core.CameraFeed.get_id, Godot.Core.CameraFeed.get_name, Godot.Core.CameraFeed.get_position, Godot.Core.CameraFeed.get_transform, Godot.Core.CameraFeed.is_active, Godot.Core.CameraFeed.set_active, Godot.Core.CameraFeed.set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _FEED_FRONT :: Int _FEED_FRONT = 1 _FEED_YCBCR_SEP :: Int _FEED_YCBCR_SEP = 3 _FEED_YCBCR :: Int _FEED_YCBCR = 2 _FEED_UNSPECIFIED :: Int _FEED_UNSPECIFIED = 0 _FEED_RGB :: Int _FEED_RGB = 1 _FEED_NOIMAGE :: Int _FEED_NOIMAGE = 0 _FEED_BACK :: Int _FEED_BACK = 2 instance NodeProperty CameraFeed "feed_is_active" Bool 'False where nodeProperty = (is_active, wrapDroppingSetter set_active, Nothing) instance NodeProperty CameraFeed "feed_transform" Transform2d 'False where nodeProperty = (get_transform, wrapDroppingSetter set_transform, Nothing) {-# NOINLINE bindCameraFeed__allocate_texture #-} bindCameraFeed__allocate_texture :: MethodBind bindCameraFeed__allocate_texture = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "_allocate_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _allocate_texture :: (CameraFeed :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> Int -> IO () _allocate_texture cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed__allocate_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "_allocate_texture" '[Int, Int, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.CameraFeed._allocate_texture {-# NOINLINE bindCameraFeed__set_RGB_img #-} bindCameraFeed__set_RGB_img :: MethodBind bindCameraFeed__set_RGB_img = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "_set_RGB_img" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_RGB_img :: (CameraFeed :< cls, Object :< cls) => cls -> Image -> IO () _set_RGB_img cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed__set_RGB_img (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "_set_RGB_img" '[Image] (IO ()) where nodeMethod = Godot.Core.CameraFeed._set_RGB_img {-# NOINLINE bindCameraFeed__set_YCbCr_img #-} bindCameraFeed__set_YCbCr_img :: MethodBind bindCameraFeed__set_YCbCr_img = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "_set_YCbCr_img" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_YCbCr_img :: (CameraFeed :< cls, Object :< cls) => cls -> Image -> IO () _set_YCbCr_img cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed__set_YCbCr_img (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "_set_YCbCr_img" '[Image] (IO ()) where nodeMethod = Godot.Core.CameraFeed._set_YCbCr_img {-# NOINLINE bindCameraFeed__set_YCbCr_imgs #-} bindCameraFeed__set_YCbCr_imgs :: MethodBind bindCameraFeed__set_YCbCr_imgs = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "_set_YCbCr_imgs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_YCbCr_imgs :: (CameraFeed :< cls, Object :< cls) => cls -> Image -> Image -> IO () _set_YCbCr_imgs cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed__set_YCbCr_imgs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "_set_YCbCr_imgs" '[Image, Image] (IO ()) where nodeMethod = Godot.Core.CameraFeed._set_YCbCr_imgs {-# NOINLINE bindCameraFeed__set_name #-} bindCameraFeed__set_name :: MethodBind bindCameraFeed__set_name = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "_set_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_name :: (CameraFeed :< cls, Object :< cls) => cls -> GodotString -> IO () _set_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed__set_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "_set_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.CameraFeed._set_name {-# NOINLINE bindCameraFeed__set_position #-} bindCameraFeed__set_position :: MethodBind bindCameraFeed__set_position = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "_set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_position :: (CameraFeed :< cls, Object :< cls) => cls -> Int -> IO () _set_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed__set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "_set_position" '[Int] (IO ()) where nodeMethod = Godot.Core.CameraFeed._set_position {-# NOINLINE bindCameraFeed_get_id #-} -- | Returns the unique ID for this feed. bindCameraFeed_get_id :: MethodBind bindCameraFeed_get_id = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "get_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the unique ID for this feed. get_id :: (CameraFeed :< cls, Object :< cls) => cls -> IO Int get_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed_get_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "get_id" '[] (IO Int) where nodeMethod = Godot.Core.CameraFeed.get_id {-# NOINLINE bindCameraFeed_get_name #-} -- | Returns the camera's name. bindCameraFeed_get_name :: MethodBind bindCameraFeed_get_name = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the camera's name. get_name :: (CameraFeed :< cls, Object :< cls) => cls -> IO GodotString get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "get_name" '[] (IO GodotString) where nodeMethod = Godot.Core.CameraFeed.get_name {-# NOINLINE bindCameraFeed_get_position #-} -- | Returns the position of camera on the device. bindCameraFeed_get_position :: MethodBind bindCameraFeed_get_position = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of camera on the device. get_position :: (CameraFeed :< cls, Object :< cls) => cls -> IO Int get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "get_position" '[] (IO Int) where nodeMethod = Godot.Core.CameraFeed.get_position {-# NOINLINE bindCameraFeed_get_transform #-} -- | The transform applied to the camera's image. bindCameraFeed_get_transform :: MethodBind bindCameraFeed_get_transform = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The transform applied to the camera's image. get_transform :: (CameraFeed :< cls, Object :< cls) => cls -> IO Transform2d get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "get_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.CameraFeed.get_transform {-# NOINLINE bindCameraFeed_is_active #-} -- | If @true@, the feed is active. bindCameraFeed_is_active :: MethodBind bindCameraFeed_is_active = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the feed is active. is_active :: (CameraFeed :< cls, Object :< cls) => cls -> IO Bool is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "is_active" '[] (IO Bool) where nodeMethod = Godot.Core.CameraFeed.is_active {-# NOINLINE bindCameraFeed_set_active #-} -- | If @true@, the feed is active. bindCameraFeed_set_active :: MethodBind bindCameraFeed_set_active = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the feed is active. set_active :: (CameraFeed :< cls, Object :< cls) => cls -> Bool -> IO () set_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "set_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.CameraFeed.set_active {-# NOINLINE bindCameraFeed_set_transform #-} -- | The transform applied to the camera's image. bindCameraFeed_set_transform :: MethodBind bindCameraFeed_set_transform = unsafePerformIO $ withCString "CameraFeed" $ \ clsNamePtr -> withCString "set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The transform applied to the camera's image. set_transform :: (CameraFeed :< cls, Object :< cls) => cls -> Transform2d -> IO () set_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraFeed_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraFeed "set_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.CameraFeed.set_transform ================================================ FILE: src/Godot/Core/CameraServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CameraServer (Godot.Core.CameraServer._FEED_YCBCR_IMAGE, Godot.Core.CameraServer._FEED_Y_IMAGE, Godot.Core.CameraServer._FEED_CBCR_IMAGE, Godot.Core.CameraServer._FEED_RGBA_IMAGE, Godot.Core.CameraServer.sig_camera_feed_added, Godot.Core.CameraServer.sig_camera_feed_removed, Godot.Core.CameraServer.add_feed, Godot.Core.CameraServer.feeds, Godot.Core.CameraServer.get_feed, Godot.Core.CameraServer.get_feed_count, Godot.Core.CameraServer.remove_feed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _FEED_YCBCR_IMAGE :: Int _FEED_YCBCR_IMAGE = 0 _FEED_Y_IMAGE :: Int _FEED_Y_IMAGE = 0 _FEED_CBCR_IMAGE :: Int _FEED_CBCR_IMAGE = 1 _FEED_RGBA_IMAGE :: Int _FEED_RGBA_IMAGE = 0 -- | Emitted when a @CameraFeed@ is added (e.g. webcam is plugged in). sig_camera_feed_added :: Godot.Internal.Dispatch.Signal CameraServer sig_camera_feed_added = Godot.Internal.Dispatch.Signal "camera_feed_added" instance NodeSignal CameraServer "camera_feed_added" '[Int] -- | Emitted when a @CameraFeed@ is removed (e.g. webcam is unplugged). sig_camera_feed_removed :: Godot.Internal.Dispatch.Signal CameraServer sig_camera_feed_removed = Godot.Internal.Dispatch.Signal "camera_feed_removed" instance NodeSignal CameraServer "camera_feed_removed" '[Int] {-# NOINLINE bindCameraServer_add_feed #-} -- | Adds a camera feed to the camera server. bindCameraServer_add_feed :: MethodBind bindCameraServer_add_feed = unsafePerformIO $ withCString "CameraServer" $ \ clsNamePtr -> withCString "add_feed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a camera feed to the camera server. add_feed :: (CameraServer :< cls, Object :< cls) => cls -> CameraFeed -> IO () add_feed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraServer_add_feed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraServer "add_feed" '[CameraFeed] (IO ()) where nodeMethod = Godot.Core.CameraServer.add_feed {-# NOINLINE bindCameraServer_feeds #-} -- | Returns an array of @CameraFeed@s. bindCameraServer_feeds :: MethodBind bindCameraServer_feeds = unsafePerformIO $ withCString "CameraServer" $ \ clsNamePtr -> withCString "feeds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of @CameraFeed@s. feeds :: (CameraServer :< cls, Object :< cls) => cls -> IO Array feeds cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraServer_feeds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraServer "feeds" '[] (IO Array) where nodeMethod = Godot.Core.CameraServer.feeds {-# NOINLINE bindCameraServer_get_feed #-} -- | Returns the @CameraFeed@ with this id. bindCameraServer_get_feed :: MethodBind bindCameraServer_get_feed = unsafePerformIO $ withCString "CameraServer" $ \ clsNamePtr -> withCString "get_feed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @CameraFeed@ with this id. get_feed :: (CameraServer :< cls, Object :< cls) => cls -> Int -> IO CameraFeed get_feed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraServer_get_feed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraServer "get_feed" '[Int] (IO CameraFeed) where nodeMethod = Godot.Core.CameraServer.get_feed {-# NOINLINE bindCameraServer_get_feed_count #-} -- | Returns the number of @CameraFeed@s registered. bindCameraServer_get_feed_count :: MethodBind bindCameraServer_get_feed_count = unsafePerformIO $ withCString "CameraServer" $ \ clsNamePtr -> withCString "get_feed_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of @CameraFeed@s registered. get_feed_count :: (CameraServer :< cls, Object :< cls) => cls -> IO Int get_feed_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraServer_get_feed_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraServer "get_feed_count" '[] (IO Int) where nodeMethod = Godot.Core.CameraServer.get_feed_count {-# NOINLINE bindCameraServer_remove_feed #-} -- | Removes a @CameraFeed@. bindCameraServer_remove_feed :: MethodBind bindCameraServer_remove_feed = unsafePerformIO $ withCString "CameraServer" $ \ clsNamePtr -> withCString "remove_feed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a @CameraFeed@. remove_feed :: (CameraServer :< cls, Object :< cls) => cls -> CameraFeed -> IO () remove_feed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraServer_remove_feed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraServer "remove_feed" '[CameraFeed] (IO ()) where nodeMethod = Godot.Core.CameraServer.remove_feed ================================================ FILE: src/Godot/Core/CameraTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CameraTexture (Godot.Core.CameraTexture.get_camera_active, Godot.Core.CameraTexture.get_camera_feed_id, Godot.Core.CameraTexture.get_which_feed, Godot.Core.CameraTexture.set_camera_active, Godot.Core.CameraTexture.set_camera_feed_id, Godot.Core.CameraTexture.set_which_feed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty CameraTexture "camera_feed_id" Int 'False where nodeProperty = (get_camera_feed_id, wrapDroppingSetter set_camera_feed_id, Nothing) instance NodeProperty CameraTexture "camera_is_active" Bool 'False where nodeProperty = (get_camera_active, wrapDroppingSetter set_camera_active, Nothing) instance NodeProperty CameraTexture "which_feed" Int 'False where nodeProperty = (get_which_feed, wrapDroppingSetter set_which_feed, Nothing) {-# NOINLINE bindCameraTexture_get_camera_active #-} -- | Convenience property that gives access to the active property of the @CameraFeed@. bindCameraTexture_get_camera_active :: MethodBind bindCameraTexture_get_camera_active = unsafePerformIO $ withCString "CameraTexture" $ \ clsNamePtr -> withCString "get_camera_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Convenience property that gives access to the active property of the @CameraFeed@. get_camera_active :: (CameraTexture :< cls, Object :< cls) => cls -> IO Bool get_camera_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraTexture_get_camera_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraTexture "get_camera_active" '[] (IO Bool) where nodeMethod = Godot.Core.CameraTexture.get_camera_active {-# NOINLINE bindCameraTexture_get_camera_feed_id #-} -- | The ID of the @CameraFeed@ for which we want to display the image. bindCameraTexture_get_camera_feed_id :: MethodBind bindCameraTexture_get_camera_feed_id = unsafePerformIO $ withCString "CameraTexture" $ \ clsNamePtr -> withCString "get_camera_feed_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ID of the @CameraFeed@ for which we want to display the image. get_camera_feed_id :: (CameraTexture :< cls, Object :< cls) => cls -> IO Int get_camera_feed_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraTexture_get_camera_feed_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraTexture "get_camera_feed_id" '[] (IO Int) where nodeMethod = Godot.Core.CameraTexture.get_camera_feed_id {-# NOINLINE bindCameraTexture_get_which_feed #-} -- | Which image within the @CameraFeed@ we want access to, important if the camera image is split in a Y and CbCr component. bindCameraTexture_get_which_feed :: MethodBind bindCameraTexture_get_which_feed = unsafePerformIO $ withCString "CameraTexture" $ \ clsNamePtr -> withCString "get_which_feed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Which image within the @CameraFeed@ we want access to, important if the camera image is split in a Y and CbCr component. get_which_feed :: (CameraTexture :< cls, Object :< cls) => cls -> IO Int get_which_feed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCameraTexture_get_which_feed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraTexture "get_which_feed" '[] (IO Int) where nodeMethod = Godot.Core.CameraTexture.get_which_feed {-# NOINLINE bindCameraTexture_set_camera_active #-} -- | Convenience property that gives access to the active property of the @CameraFeed@. bindCameraTexture_set_camera_active :: MethodBind bindCameraTexture_set_camera_active = unsafePerformIO $ withCString "CameraTexture" $ \ clsNamePtr -> withCString "set_camera_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Convenience property that gives access to the active property of the @CameraFeed@. set_camera_active :: (CameraTexture :< cls, Object :< cls) => cls -> Bool -> IO () set_camera_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraTexture_set_camera_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraTexture "set_camera_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.CameraTexture.set_camera_active {-# NOINLINE bindCameraTexture_set_camera_feed_id #-} -- | The ID of the @CameraFeed@ for which we want to display the image. bindCameraTexture_set_camera_feed_id :: MethodBind bindCameraTexture_set_camera_feed_id = unsafePerformIO $ withCString "CameraTexture" $ \ clsNamePtr -> withCString "set_camera_feed_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ID of the @CameraFeed@ for which we want to display the image. set_camera_feed_id :: (CameraTexture :< cls, Object :< cls) => cls -> Int -> IO () set_camera_feed_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraTexture_set_camera_feed_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraTexture "set_camera_feed_id" '[Int] (IO ()) where nodeMethod = Godot.Core.CameraTexture.set_camera_feed_id {-# NOINLINE bindCameraTexture_set_which_feed #-} -- | Which image within the @CameraFeed@ we want access to, important if the camera image is split in a Y and CbCr component. bindCameraTexture_set_which_feed :: MethodBind bindCameraTexture_set_which_feed = unsafePerformIO $ withCString "CameraTexture" $ \ clsNamePtr -> withCString "set_which_feed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Which image within the @CameraFeed@ we want access to, important if the camera image is split in a Y and CbCr component. set_which_feed :: (CameraTexture :< cls, Object :< cls) => cls -> Int -> IO () set_which_feed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCameraTexture_set_which_feed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CameraTexture "set_which_feed" '[Int] (IO ()) where nodeMethod = Godot.Core.CameraTexture.set_which_feed ================================================ FILE: src/Godot/Core/CanvasItem.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CanvasItem (Godot.Core.CanvasItem._BLEND_MODE_DISABLED, Godot.Core.CanvasItem._NOTIFICATION_EXIT_CANVAS, Godot.Core.CanvasItem._NOTIFICATION_ENTER_CANVAS, Godot.Core.CanvasItem._NOTIFICATION_TRANSFORM_CHANGED, Godot.Core.CanvasItem._BLEND_MODE_ADD, Godot.Core.CanvasItem._BLEND_MODE_MIX, Godot.Core.CanvasItem._NOTIFICATION_DRAW, Godot.Core.CanvasItem._BLEND_MODE_MUL, Godot.Core.CanvasItem._BLEND_MODE_PREMULT_ALPHA, Godot.Core.CanvasItem._BLEND_MODE_SUB, Godot.Core.CanvasItem._NOTIFICATION_VISIBILITY_CHANGED, Godot.Core.CanvasItem.sig_draw, Godot.Core.CanvasItem.sig_hide, Godot.Core.CanvasItem.sig_item_rect_changed, Godot.Core.CanvasItem.sig_visibility_changed, Godot.Core.CanvasItem._draw, Godot.Core.CanvasItem._edit_get_pivot, Godot.Core.CanvasItem._edit_get_position, Godot.Core.CanvasItem._edit_get_rect, Godot.Core.CanvasItem._edit_get_rotation, Godot.Core.CanvasItem._edit_get_scale, Godot.Core.CanvasItem._edit_get_state, Godot.Core.CanvasItem._edit_get_transform, Godot.Core.CanvasItem._edit_set_pivot, Godot.Core.CanvasItem._edit_set_position, Godot.Core.CanvasItem._edit_set_rect, Godot.Core.CanvasItem._edit_set_rotation, Godot.Core.CanvasItem._edit_set_scale, Godot.Core.CanvasItem._edit_set_state, Godot.Core.CanvasItem._edit_use_pivot, Godot.Core.CanvasItem._edit_use_rect, Godot.Core.CanvasItem._edit_use_rotation, Godot.Core.CanvasItem._is_on_top, Godot.Core.CanvasItem._set_on_top, Godot.Core.CanvasItem._toplevel_raise_self, Godot.Core.CanvasItem._update_callback, Godot.Core.CanvasItem.draw_arc, Godot.Core.CanvasItem.draw_char, Godot.Core.CanvasItem.draw_circle, Godot.Core.CanvasItem.draw_colored_polygon, Godot.Core.CanvasItem.draw_line, Godot.Core.CanvasItem.draw_mesh, Godot.Core.CanvasItem.draw_multiline, Godot.Core.CanvasItem.draw_multiline_colors, Godot.Core.CanvasItem.draw_multimesh, Godot.Core.CanvasItem.draw_polygon, Godot.Core.CanvasItem.draw_polyline, Godot.Core.CanvasItem.draw_polyline_colors, Godot.Core.CanvasItem.draw_primitive, Godot.Core.CanvasItem.draw_rect, Godot.Core.CanvasItem.draw_set_transform, Godot.Core.CanvasItem.draw_set_transform_matrix, Godot.Core.CanvasItem.draw_string, Godot.Core.CanvasItem.draw_style_box, Godot.Core.CanvasItem.draw_texture, Godot.Core.CanvasItem.draw_texture_rect, Godot.Core.CanvasItem.draw_texture_rect_region, Godot.Core.CanvasItem.force_update_transform, Godot.Core.CanvasItem.get_canvas, Godot.Core.CanvasItem.get_canvas_item, Godot.Core.CanvasItem.get_canvas_transform, Godot.Core.CanvasItem.get_global_mouse_position, Godot.Core.CanvasItem.get_global_transform, Godot.Core.CanvasItem.get_global_transform_with_canvas, Godot.Core.CanvasItem.get_light_mask, Godot.Core.CanvasItem.get_local_mouse_position, Godot.Core.CanvasItem.get_material, Godot.Core.CanvasItem.get_modulate, Godot.Core.CanvasItem.get_self_modulate, Godot.Core.CanvasItem.get_transform, Godot.Core.CanvasItem.get_use_parent_material, Godot.Core.CanvasItem.get_viewport_rect, Godot.Core.CanvasItem.get_viewport_transform, Godot.Core.CanvasItem.get_world_2d, Godot.Core.CanvasItem.hide, Godot.Core.CanvasItem.is_draw_behind_parent_enabled, Godot.Core.CanvasItem.is_local_transform_notification_enabled, Godot.Core.CanvasItem.is_set_as_toplevel, Godot.Core.CanvasItem.is_transform_notification_enabled, Godot.Core.CanvasItem.is_visible, Godot.Core.CanvasItem.is_visible_in_tree, Godot.Core.CanvasItem.make_canvas_position_local, Godot.Core.CanvasItem.make_input_local, Godot.Core.CanvasItem.set_as_toplevel, Godot.Core.CanvasItem.set_draw_behind_parent, Godot.Core.CanvasItem.set_light_mask, Godot.Core.CanvasItem.set_material, Godot.Core.CanvasItem.set_modulate, Godot.Core.CanvasItem.set_notify_local_transform, Godot.Core.CanvasItem.set_notify_transform, Godot.Core.CanvasItem.set_self_modulate, Godot.Core.CanvasItem.set_use_parent_material, Godot.Core.CanvasItem.set_visible, Godot.Core.CanvasItem.show, Godot.Core.CanvasItem.update) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _BLEND_MODE_DISABLED :: Int _BLEND_MODE_DISABLED = 5 _NOTIFICATION_EXIT_CANVAS :: Int _NOTIFICATION_EXIT_CANVAS = 33 _NOTIFICATION_ENTER_CANVAS :: Int _NOTIFICATION_ENTER_CANVAS = 32 _NOTIFICATION_TRANSFORM_CHANGED :: Int _NOTIFICATION_TRANSFORM_CHANGED = 2000 _BLEND_MODE_ADD :: Int _BLEND_MODE_ADD = 1 _BLEND_MODE_MIX :: Int _BLEND_MODE_MIX = 0 _NOTIFICATION_DRAW :: Int _NOTIFICATION_DRAW = 30 _BLEND_MODE_MUL :: Int _BLEND_MODE_MUL = 3 _BLEND_MODE_PREMULT_ALPHA :: Int _BLEND_MODE_PREMULT_ALPHA = 4 _BLEND_MODE_SUB :: Int _BLEND_MODE_SUB = 2 _NOTIFICATION_VISIBILITY_CHANGED :: Int _NOTIFICATION_VISIBILITY_CHANGED = 31 -- | Emitted when the @CanvasItem@ must redraw. This can only be connected realtime, as deferred will not allow drawing. sig_draw :: Godot.Internal.Dispatch.Signal CanvasItem sig_draw = Godot.Internal.Dispatch.Signal "draw" instance NodeSignal CanvasItem "draw" '[] -- | Emitted when becoming hidden. sig_hide :: Godot.Internal.Dispatch.Signal CanvasItem sig_hide = Godot.Internal.Dispatch.Signal "hide" instance NodeSignal CanvasItem "hide" '[] -- | Emitted when the item rect has changed. sig_item_rect_changed :: Godot.Internal.Dispatch.Signal CanvasItem sig_item_rect_changed = Godot.Internal.Dispatch.Signal "item_rect_changed" instance NodeSignal CanvasItem "item_rect_changed" '[] -- | Emitted when the visibility (hidden/visible) changes. sig_visibility_changed :: Godot.Internal.Dispatch.Signal CanvasItem sig_visibility_changed = Godot.Internal.Dispatch.Signal "visibility_changed" instance NodeSignal CanvasItem "visibility_changed" '[] instance NodeProperty CanvasItem "light_mask" Int 'False where nodeProperty = (get_light_mask, wrapDroppingSetter set_light_mask, Nothing) instance NodeProperty CanvasItem "material" Material 'False where nodeProperty = (get_material, wrapDroppingSetter set_material, Nothing) instance NodeProperty CanvasItem "modulate" Color 'False where nodeProperty = (get_modulate, wrapDroppingSetter set_modulate, Nothing) instance NodeProperty CanvasItem "self_modulate" Color 'False where nodeProperty = (get_self_modulate, wrapDroppingSetter set_self_modulate, Nothing) instance NodeProperty CanvasItem "show_behind_parent" Bool 'False where nodeProperty = (is_draw_behind_parent_enabled, wrapDroppingSetter set_draw_behind_parent, Nothing) instance NodeProperty CanvasItem "show_on_top" Bool 'False where nodeProperty = (_is_on_top, wrapDroppingSetter _set_on_top, Nothing) instance NodeProperty CanvasItem "use_parent_material" Bool 'False where nodeProperty = (get_use_parent_material, wrapDroppingSetter set_use_parent_material, Nothing) instance NodeProperty CanvasItem "visible" Bool 'False where nodeProperty = (is_visible, wrapDroppingSetter set_visible, Nothing) {-# NOINLINE bindCanvasItem__draw #-} -- | Overridable function called by the engine (if defined) to draw the canvas item. bindCanvasItem__draw :: MethodBind bindCanvasItem__draw = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overridable function called by the engine (if defined) to draw the canvas item. _draw :: (CanvasItem :< cls, Object :< cls) => cls -> IO () _draw cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_draw" '[] (IO ()) where nodeMethod = Godot.Core.CanvasItem._draw {-# NOINLINE bindCanvasItem__edit_get_pivot #-} bindCanvasItem__edit_get_pivot :: MethodBind bindCanvasItem__edit_get_pivot = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_get_pivot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_get_pivot :: (CanvasItem :< cls, Object :< cls) => cls -> IO Vector2 _edit_get_pivot cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_get_pivot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_get_pivot" '[] (IO Vector2) where nodeMethod = Godot.Core.CanvasItem._edit_get_pivot {-# NOINLINE bindCanvasItem__edit_get_position #-} bindCanvasItem__edit_get_position :: MethodBind bindCanvasItem__edit_get_position = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_get_position :: (CanvasItem :< cls, Object :< cls) => cls -> IO Vector2 _edit_get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_get_position" '[] (IO Vector2) where nodeMethod = Godot.Core.CanvasItem._edit_get_position {-# NOINLINE bindCanvasItem__edit_get_rect #-} bindCanvasItem__edit_get_rect :: MethodBind bindCanvasItem__edit_get_rect = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_get_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_get_rect :: (CanvasItem :< cls, Object :< cls) => cls -> IO Rect2 _edit_get_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_get_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_get_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.CanvasItem._edit_get_rect {-# NOINLINE bindCanvasItem__edit_get_rotation #-} bindCanvasItem__edit_get_rotation :: MethodBind bindCanvasItem__edit_get_rotation = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_get_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_get_rotation :: (CanvasItem :< cls, Object :< cls) => cls -> IO Float _edit_get_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_get_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_get_rotation" '[] (IO Float) where nodeMethod = Godot.Core.CanvasItem._edit_get_rotation {-# NOINLINE bindCanvasItem__edit_get_scale #-} bindCanvasItem__edit_get_scale :: MethodBind bindCanvasItem__edit_get_scale = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_get_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_get_scale :: (CanvasItem :< cls, Object :< cls) => cls -> IO Vector2 _edit_get_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_get_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_get_scale" '[] (IO Vector2) where nodeMethod = Godot.Core.CanvasItem._edit_get_scale {-# NOINLINE bindCanvasItem__edit_get_state #-} bindCanvasItem__edit_get_state :: MethodBind bindCanvasItem__edit_get_state = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_get_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_get_state :: (CanvasItem :< cls, Object :< cls) => cls -> IO Dictionary _edit_get_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_get_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_get_state" '[] (IO Dictionary) where nodeMethod = Godot.Core.CanvasItem._edit_get_state {-# NOINLINE bindCanvasItem__edit_get_transform #-} bindCanvasItem__edit_get_transform :: MethodBind bindCanvasItem__edit_get_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_get_transform :: (CanvasItem :< cls, Object :< cls) => cls -> IO Transform2d _edit_get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_get_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.CanvasItem._edit_get_transform {-# NOINLINE bindCanvasItem__edit_set_pivot #-} bindCanvasItem__edit_set_pivot :: MethodBind bindCanvasItem__edit_set_pivot = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_set_pivot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_set_pivot :: (CanvasItem :< cls, Object :< cls) => cls -> Vector2 -> IO () _edit_set_pivot cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_set_pivot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_set_pivot" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CanvasItem._edit_set_pivot {-# NOINLINE bindCanvasItem__edit_set_position #-} bindCanvasItem__edit_set_position :: MethodBind bindCanvasItem__edit_set_position = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_set_position :: (CanvasItem :< cls, Object :< cls) => cls -> Vector2 -> IO () _edit_set_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_set_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CanvasItem._edit_set_position {-# NOINLINE bindCanvasItem__edit_set_rect #-} bindCanvasItem__edit_set_rect :: MethodBind bindCanvasItem__edit_set_rect = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_set_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_set_rect :: (CanvasItem :< cls, Object :< cls) => cls -> Rect2 -> IO () _edit_set_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_set_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_set_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.CanvasItem._edit_set_rect {-# NOINLINE bindCanvasItem__edit_set_rotation #-} bindCanvasItem__edit_set_rotation :: MethodBind bindCanvasItem__edit_set_rotation = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_set_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_set_rotation :: (CanvasItem :< cls, Object :< cls) => cls -> Float -> IO () _edit_set_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_set_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_set_rotation" '[Float] (IO ()) where nodeMethod = Godot.Core.CanvasItem._edit_set_rotation {-# NOINLINE bindCanvasItem__edit_set_scale #-} bindCanvasItem__edit_set_scale :: MethodBind bindCanvasItem__edit_set_scale = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_set_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_set_scale :: (CanvasItem :< cls, Object :< cls) => cls -> Vector2 -> IO () _edit_set_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_set_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_set_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CanvasItem._edit_set_scale {-# NOINLINE bindCanvasItem__edit_set_state #-} bindCanvasItem__edit_set_state :: MethodBind bindCanvasItem__edit_set_state = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_set_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_set_state :: (CanvasItem :< cls, Object :< cls) => cls -> Dictionary -> IO () _edit_set_state cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_set_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_set_state" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.CanvasItem._edit_set_state {-# NOINLINE bindCanvasItem__edit_use_pivot #-} bindCanvasItem__edit_use_pivot :: MethodBind bindCanvasItem__edit_use_pivot = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_use_pivot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_use_pivot :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool _edit_use_pivot cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_use_pivot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_use_pivot" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem._edit_use_pivot {-# NOINLINE bindCanvasItem__edit_use_rect #-} bindCanvasItem__edit_use_rect :: MethodBind bindCanvasItem__edit_use_rect = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_use_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_use_rect :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool _edit_use_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_use_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_use_rect" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem._edit_use_rect {-# NOINLINE bindCanvasItem__edit_use_rotation #-} bindCanvasItem__edit_use_rotation :: MethodBind bindCanvasItem__edit_use_rotation = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_edit_use_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_use_rotation :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool _edit_use_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__edit_use_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_edit_use_rotation" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem._edit_use_rotation {-# NOINLINE bindCanvasItem__is_on_top #-} -- | If @true@, the object draws on top of its parent. bindCanvasItem__is_on_top :: MethodBind bindCanvasItem__is_on_top = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_is_on_top" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the object draws on top of its parent. _is_on_top :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool _is_on_top cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__is_on_top (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_is_on_top" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem._is_on_top {-# NOINLINE bindCanvasItem__set_on_top #-} -- | If @true@, the object draws on top of its parent. bindCanvasItem__set_on_top :: MethodBind bindCanvasItem__set_on_top = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_set_on_top" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the object draws on top of its parent. _set_on_top :: (CanvasItem :< cls, Object :< cls) => cls -> Bool -> IO () _set_on_top cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__set_on_top (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_set_on_top" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem._set_on_top {-# NOINLINE bindCanvasItem__toplevel_raise_self #-} bindCanvasItem__toplevel_raise_self :: MethodBind bindCanvasItem__toplevel_raise_self = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_toplevel_raise_self" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _toplevel_raise_self :: (CanvasItem :< cls, Object :< cls) => cls -> IO () _toplevel_raise_self cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__toplevel_raise_self (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_toplevel_raise_self" '[] (IO ()) where nodeMethod = Godot.Core.CanvasItem._toplevel_raise_self {-# NOINLINE bindCanvasItem__update_callback #-} bindCanvasItem__update_callback :: MethodBind bindCanvasItem__update_callback = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "_update_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_callback :: (CanvasItem :< cls, Object :< cls) => cls -> IO () _update_callback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem__update_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "_update_callback" '[] (IO ()) where nodeMethod = Godot.Core.CanvasItem._update_callback {-# NOINLINE bindCanvasItem_draw_arc #-} -- | Draws an arc between the given angles. The larger the value of @point_count@, the smoother the curve. bindCanvasItem_draw_arc :: MethodBind bindCanvasItem_draw_arc = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_arc" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws an arc between the given angles. The larger the value of @point_count@, the smoother the curve. draw_arc :: (CanvasItem :< cls, Object :< cls) => cls -> Vector2 -> Float -> Float -> Float -> Int -> Color -> Maybe Float -> Maybe Bool -> IO () draw_arc cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, maybe (VariantReal (1)) toVariant arg7, maybe (VariantBool False) toVariant arg8] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_arc (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_arc" '[Vector2, Float, Float, Float, Int, Color, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_arc {-# NOINLINE bindCanvasItem_draw_char #-} -- | Draws a string character using a custom font. Returns the advance, depending on the character width and kerning with an optional next character. bindCanvasItem_draw_char :: MethodBind bindCanvasItem_draw_char = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_char" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a string character using a custom font. Returns the advance, depending on the character width and kerning with an optional next character. draw_char :: (CanvasItem :< cls, Object :< cls) => cls -> Font -> Vector2 -> GodotString -> GodotString -> Maybe Color -> IO Float draw_char cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg5] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_char (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_char" '[Font, Vector2, GodotString, GodotString, Maybe Color] (IO Float) where nodeMethod = Godot.Core.CanvasItem.draw_char {-# NOINLINE bindCanvasItem_draw_circle #-} -- | Draws a colored circle. bindCanvasItem_draw_circle :: MethodBind bindCanvasItem_draw_circle = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_circle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a colored circle. draw_circle :: (CanvasItem :< cls, Object :< cls) => cls -> Vector2 -> Float -> Color -> IO () draw_circle cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_circle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_circle" '[Vector2, Float, Color] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_circle {-# NOINLINE bindCanvasItem_draw_colored_polygon #-} -- | Draws a colored polygon of any amount of points, convex or concave. bindCanvasItem_draw_colored_polygon :: MethodBind bindCanvasItem_draw_colored_polygon = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_colored_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a colored polygon of any amount of points, convex or concave. draw_colored_polygon :: (CanvasItem :< cls, Object :< cls) => cls -> PoolVector2Array -> Color -> Maybe PoolVector2Array -> Maybe Texture -> Maybe Texture -> Maybe Bool -> IO () draw_colored_polygon cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantPoolVector2Array V.empty arg3, maybe VariantNil toVariant arg4, maybe VariantNil toVariant arg5, maybe (VariantBool False) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_colored_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_colored_polygon" '[PoolVector2Array, Color, Maybe PoolVector2Array, Maybe Texture, Maybe Texture, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_colored_polygon {-# NOINLINE bindCanvasItem_draw_line #-} -- | Draws a line from a 2D point to another, with a given color and width. It can be optionally antialiased. bindCanvasItem_draw_line :: MethodBind bindCanvasItem_draw_line = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a line from a 2D point to another, with a given color and width. It can be optionally antialiased. draw_line :: (CanvasItem :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Color -> Maybe Float -> Maybe Bool -> IO () draw_line cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantReal (1)) toVariant arg4, maybe (VariantBool False) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_line" '[Vector2, Vector2, Color, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_line {-# NOINLINE bindCanvasItem_draw_mesh #-} -- | Draws a @Mesh@ in 2D, using the provided texture. See @MeshInstance2D@ for related documentation. bindCanvasItem_draw_mesh :: MethodBind bindCanvasItem_draw_mesh = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a @Mesh@ in 2D, using the provided texture. See @MeshInstance2D@ for related documentation. draw_mesh :: (CanvasItem :< cls, Object :< cls) => cls -> Mesh -> Texture -> Maybe Texture -> Maybe Transform2d -> Maybe Color -> IO () draw_mesh cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3, defaultedVariant VariantTransform2d (TF2d (V2 1 0) (V2 0 1) (V2 0 0)) arg4, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg5] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_mesh" '[Mesh, Texture, Maybe Texture, Maybe Transform2d, Maybe Color] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_mesh {-# NOINLINE bindCanvasItem_draw_multiline #-} -- | Draws multiple, parallel lines with a uniform @color@. -- __Note:__ @width@ and @antialiased@ are currently not implemented and have no effect. bindCanvasItem_draw_multiline :: MethodBind bindCanvasItem_draw_multiline = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_multiline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws multiple, parallel lines with a uniform @color@. -- __Note:__ @width@ and @antialiased@ are currently not implemented and have no effect. draw_multiline :: (CanvasItem :< cls, Object :< cls) => cls -> PoolVector2Array -> Color -> Maybe Float -> Maybe Bool -> IO () draw_multiline cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantReal (1)) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_multiline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_multiline" '[PoolVector2Array, Color, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_multiline {-# NOINLINE bindCanvasItem_draw_multiline_colors #-} -- | Draws multiple, parallel lines with a uniform @width@ and segment-by-segment coloring. Colors assigned to line segments match by index between @points@ and @colors@. -- __Note:__ @width@ and @antialiased@ are currently not implemented and have no effect. bindCanvasItem_draw_multiline_colors :: MethodBind bindCanvasItem_draw_multiline_colors = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_multiline_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws multiple, parallel lines with a uniform @width@ and segment-by-segment coloring. Colors assigned to line segments match by index between @points@ and @colors@. -- __Note:__ @width@ and @antialiased@ are currently not implemented and have no effect. draw_multiline_colors :: (CanvasItem :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolColorArray -> Maybe Float -> Maybe Bool -> IO () draw_multiline_colors cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantReal (1)) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_multiline_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_multiline_colors" '[PoolVector2Array, PoolColorArray, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_multiline_colors {-# NOINLINE bindCanvasItem_draw_multimesh #-} -- | Draws a @MultiMesh@ in 2D with the provided texture. See @MultiMeshInstance2D@ for related documentation. bindCanvasItem_draw_multimesh :: MethodBind bindCanvasItem_draw_multimesh = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_multimesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a @MultiMesh@ in 2D with the provided texture. See @MultiMeshInstance2D@ for related documentation. draw_multimesh :: (CanvasItem :< cls, Object :< cls) => cls -> MultiMesh -> Texture -> Maybe Texture -> IO () draw_multimesh cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_multimesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_multimesh" '[MultiMesh, Texture, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_multimesh {-# NOINLINE bindCanvasItem_draw_polygon #-} -- | Draws a polygon of any amount of points, convex or concave. bindCanvasItem_draw_polygon :: MethodBind bindCanvasItem_draw_polygon = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a polygon of any amount of points, convex or concave. draw_polygon :: (CanvasItem :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolColorArray -> Maybe PoolVector2Array -> Maybe Texture -> Maybe Texture -> Maybe Bool -> IO () draw_polygon cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantPoolVector2Array V.empty arg3, maybe VariantNil toVariant arg4, maybe VariantNil toVariant arg5, maybe (VariantBool False) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_polygon" '[PoolVector2Array, PoolColorArray, Maybe PoolVector2Array, Maybe Texture, Maybe Texture, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_polygon {-# NOINLINE bindCanvasItem_draw_polyline #-} -- | Draws interconnected line segments with a uniform @color@ and @width@ and optional antialiasing. bindCanvasItem_draw_polyline :: MethodBind bindCanvasItem_draw_polyline = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_polyline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws interconnected line segments with a uniform @color@ and @width@ and optional antialiasing. draw_polyline :: (CanvasItem :< cls, Object :< cls) => cls -> PoolVector2Array -> Color -> Maybe Float -> Maybe Bool -> IO () draw_polyline cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantReal (1)) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_polyline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_polyline" '[PoolVector2Array, Color, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_polyline {-# NOINLINE bindCanvasItem_draw_polyline_colors #-} -- | Draws interconnected line segments with a uniform @width@, segment-by-segment coloring, and optional antialiasing. Colors assigned to line segments match by index between @points@ and @colors@. bindCanvasItem_draw_polyline_colors :: MethodBind bindCanvasItem_draw_polyline_colors = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_polyline_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws interconnected line segments with a uniform @width@, segment-by-segment coloring, and optional antialiasing. Colors assigned to line segments match by index between @points@ and @colors@. draw_polyline_colors :: (CanvasItem :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolColorArray -> Maybe Float -> Maybe Bool -> IO () draw_polyline_colors cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantReal (1)) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_polyline_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_polyline_colors" '[PoolVector2Array, PoolColorArray, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_polyline_colors {-# NOINLINE bindCanvasItem_draw_primitive #-} -- | Draws a custom primitive. 1 point for a point, 2 points for a line, 3 points for a triangle and 4 points for a quad. bindCanvasItem_draw_primitive :: MethodBind bindCanvasItem_draw_primitive = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_primitive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a custom primitive. 1 point for a point, 2 points for a line, 3 points for a triangle and 4 points for a quad. draw_primitive :: (CanvasItem :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolColorArray -> PoolVector2Array -> Maybe Texture -> Maybe Float -> Maybe Texture -> IO () draw_primitive cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4, maybe (VariantReal (1)) toVariant arg5, maybe VariantNil toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_primitive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_primitive" '[PoolVector2Array, PoolColorArray, PoolVector2Array, Maybe Texture, Maybe Float, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_primitive {-# NOINLINE bindCanvasItem_draw_rect #-} -- | Draws a rectangle. If @filled@ is @true@, the rectangle will be filled with the @color@ specified. If @filled@ is @false@, the rectangle will be drawn as a stroke with the @color@ and @width@ specified. If @antialiased@ is @true@, the lines will be antialiased. -- __Note:__ @width@ and @antialiased@ are only effective if @filled@ is @false@. bindCanvasItem_draw_rect :: MethodBind bindCanvasItem_draw_rect = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a rectangle. If @filled@ is @true@, the rectangle will be filled with the @color@ specified. If @filled@ is @false@, the rectangle will be drawn as a stroke with the @color@ and @width@ specified. If @antialiased@ is @true@, the lines will be antialiased. -- __Note:__ @width@ and @antialiased@ are only effective if @filled@ is @false@. draw_rect :: (CanvasItem :< cls, Object :< cls) => cls -> Rect2 -> Color -> Maybe Bool -> Maybe Float -> Maybe Bool -> IO () draw_rect cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3, maybe (VariantReal (1)) toVariant arg4, maybe (VariantBool False) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_rect" '[Rect2, Color, Maybe Bool, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_rect {-# NOINLINE bindCanvasItem_draw_set_transform #-} -- | Sets a custom transform for drawing via components. Anything drawn afterwards will be transformed by this. bindCanvasItem_draw_set_transform :: MethodBind bindCanvasItem_draw_set_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a custom transform for drawing via components. Anything drawn afterwards will be transformed by this. draw_set_transform :: (CanvasItem :< cls, Object :< cls) => cls -> Vector2 -> Float -> Vector2 -> IO () draw_set_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_set_transform" '[Vector2, Float, Vector2] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_set_transform {-# NOINLINE bindCanvasItem_draw_set_transform_matrix #-} -- | Sets a custom transform for drawing via matrix. Anything drawn afterwards will be transformed by this. bindCanvasItem_draw_set_transform_matrix :: MethodBind bindCanvasItem_draw_set_transform_matrix = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_set_transform_matrix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a custom transform for drawing via matrix. Anything drawn afterwards will be transformed by this. draw_set_transform_matrix :: (CanvasItem :< cls, Object :< cls) => cls -> Transform2d -> IO () draw_set_transform_matrix cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_set_transform_matrix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_set_transform_matrix" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_set_transform_matrix {-# NOINLINE bindCanvasItem_draw_string #-} -- | Draws @text@ using the specified @font@ at the @position@ (top-left corner). The text will have its color multiplied by @modulate@. If @clip_w@ is greater than or equal to 0, the text will be clipped if it exceeds the specified width. -- __Example using the default project font:__ -- -- @ -- -- # If using this method in a script that redraws constantly, move the -- # `default_font` declaration to a member variable assigned in `_ready()` -- # so the Control is only created once. -- var default_font = Control.new().get_font("font") -- draw_string(default_font, Vector2(64, 64), "Hello world") -- -- @ -- -- See also @method Font.draw@. bindCanvasItem_draw_string :: MethodBind bindCanvasItem_draw_string = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws @text@ using the specified @font@ at the @position@ (top-left corner). The text will have its color multiplied by @modulate@. If @clip_w@ is greater than or equal to 0, the text will be clipped if it exceeds the specified width. -- __Example using the default project font:__ -- -- @ -- -- # If using this method in a script that redraws constantly, move the -- # `default_font` declaration to a member variable assigned in `_ready()` -- # so the Control is only created once. -- var default_font = Control.new().get_font("font") -- draw_string(default_font, Vector2(64, 64), "Hello world") -- -- @ -- -- See also @method Font.draw@. draw_string :: (CanvasItem :< cls, Object :< cls) => cls -> Font -> Vector2 -> GodotString -> Maybe Color -> Maybe Int -> IO () draw_string cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4, maybe (VariantInt (-1)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_string" '[Font, Vector2, GodotString, Maybe Color, Maybe Int] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_string {-# NOINLINE bindCanvasItem_draw_style_box #-} -- | Draws a styled rectangle. bindCanvasItem_draw_style_box :: MethodBind bindCanvasItem_draw_style_box = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_style_box" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a styled rectangle. draw_style_box :: (CanvasItem :< cls, Object :< cls) => cls -> StyleBox -> Rect2 -> IO () draw_style_box cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_style_box (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_style_box" '[StyleBox, Rect2] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_style_box {-# NOINLINE bindCanvasItem_draw_texture #-} -- | Draws a texture at a given position. bindCanvasItem_draw_texture :: MethodBind bindCanvasItem_draw_texture = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a texture at a given position. draw_texture :: (CanvasItem :< cls, Object :< cls) => cls -> Texture -> Vector2 -> Maybe Color -> Maybe Texture -> IO () draw_texture cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_texture" '[Texture, Vector2, Maybe Color, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_texture {-# NOINLINE bindCanvasItem_draw_texture_rect #-} -- | Draws a textured rectangle at a given position, optionally modulated by a color. If @transpose@ is @true@, the texture will have its X and Y coordinates swapped. bindCanvasItem_draw_texture_rect :: MethodBind bindCanvasItem_draw_texture_rect = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_texture_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a textured rectangle at a given position, optionally modulated by a color. If @transpose@ is @true@, the texture will have its X and Y coordinates swapped. draw_texture_rect :: (CanvasItem :< cls, Object :< cls) => cls -> Texture -> Rect2 -> Bool -> Maybe Color -> Maybe Bool -> Maybe Texture -> IO () draw_texture_rect cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4, maybe (VariantBool False) toVariant arg5, maybe VariantNil toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_texture_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_texture_rect" '[Texture, Rect2, Bool, Maybe Color, Maybe Bool, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_texture_rect {-# NOINLINE bindCanvasItem_draw_texture_rect_region #-} -- | Draws a textured rectangle region at a given position, optionally modulated by a color. If @transpose@ is @true@, the texture will have its X and Y coordinates swapped. bindCanvasItem_draw_texture_rect_region :: MethodBind bindCanvasItem_draw_texture_rect_region = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "draw_texture_rect_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a textured rectangle region at a given position, optionally modulated by a color. If @transpose@ is @true@, the texture will have its X and Y coordinates swapped. draw_texture_rect_region :: (CanvasItem :< cls, Object :< cls) => cls -> Texture -> Rect2 -> Rect2 -> Maybe Color -> Maybe Bool -> Maybe Texture -> Maybe Bool -> IO () draw_texture_rect_region cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4, maybe (VariantBool False) toVariant arg5, maybe VariantNil toVariant arg6, maybe (VariantBool True) toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_draw_texture_rect_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "draw_texture_rect_region" '[Texture, Rect2, Rect2, Maybe Color, Maybe Bool, Maybe Texture, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.draw_texture_rect_region {-# NOINLINE bindCanvasItem_force_update_transform #-} -- | Forces the transform to update. Transform changes in physics are not instant for performance reasons. Transforms are accumulated and then set. Use this if you need an up-to-date transform when doing physics operations. bindCanvasItem_force_update_transform :: MethodBind bindCanvasItem_force_update_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "force_update_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Forces the transform to update. Transform changes in physics are not instant for performance reasons. Transforms are accumulated and then set. Use this if you need an up-to-date transform when doing physics operations. force_update_transform :: (CanvasItem :< cls, Object :< cls) => cls -> IO () force_update_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_force_update_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "force_update_transform" '[] (IO ()) where nodeMethod = Godot.Core.CanvasItem.force_update_transform {-# NOINLINE bindCanvasItem_get_canvas #-} -- | Returns the @RID@ of the @World2D@ canvas where this item is in. bindCanvasItem_get_canvas :: MethodBind bindCanvasItem_get_canvas = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the @World2D@ canvas where this item is in. get_canvas :: (CanvasItem :< cls, Object :< cls) => cls -> IO Rid get_canvas cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_canvas" '[] (IO Rid) where nodeMethod = Godot.Core.CanvasItem.get_canvas {-# NOINLINE bindCanvasItem_get_canvas_item #-} -- | Returns the canvas item RID used by @VisualServer@ for this item. bindCanvasItem_get_canvas_item :: MethodBind bindCanvasItem_get_canvas_item = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_canvas_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the canvas item RID used by @VisualServer@ for this item. get_canvas_item :: (CanvasItem :< cls, Object :< cls) => cls -> IO Rid get_canvas_item cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_canvas_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_canvas_item" '[] (IO Rid) where nodeMethod = Godot.Core.CanvasItem.get_canvas_item {-# NOINLINE bindCanvasItem_get_canvas_transform #-} -- | Returns the transform matrix of this item's canvas. bindCanvasItem_get_canvas_transform :: MethodBind bindCanvasItem_get_canvas_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_canvas_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform matrix of this item's canvas. get_canvas_transform :: (CanvasItem :< cls, Object :< cls) => cls -> IO Transform2d get_canvas_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_canvas_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_canvas_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.CanvasItem.get_canvas_transform {-# NOINLINE bindCanvasItem_get_global_mouse_position #-} -- | Returns the global position of the mouse. bindCanvasItem_get_global_mouse_position :: MethodBind bindCanvasItem_get_global_mouse_position = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_global_mouse_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the global position of the mouse. get_global_mouse_position :: (CanvasItem :< cls, Object :< cls) => cls -> IO Vector2 get_global_mouse_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_global_mouse_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_global_mouse_position" '[] (IO Vector2) where nodeMethod = Godot.Core.CanvasItem.get_global_mouse_position {-# NOINLINE bindCanvasItem_get_global_transform #-} -- | Returns the global transform matrix of this item. bindCanvasItem_get_global_transform :: MethodBind bindCanvasItem_get_global_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_global_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the global transform matrix of this item. get_global_transform :: (CanvasItem :< cls, Object :< cls) => cls -> IO Transform2d get_global_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_global_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_global_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.CanvasItem.get_global_transform {-# NOINLINE bindCanvasItem_get_global_transform_with_canvas #-} -- | Returns the global transform matrix of this item in relation to the canvas. bindCanvasItem_get_global_transform_with_canvas :: MethodBind bindCanvasItem_get_global_transform_with_canvas = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_global_transform_with_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the global transform matrix of this item in relation to the canvas. get_global_transform_with_canvas :: (CanvasItem :< cls, Object :< cls) => cls -> IO Transform2d get_global_transform_with_canvas cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_global_transform_with_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_global_transform_with_canvas" '[] (IO Transform2d) where nodeMethod = Godot.Core.CanvasItem.get_global_transform_with_canvas {-# NOINLINE bindCanvasItem_get_light_mask #-} -- | The rendering layers in which this @CanvasItem@ responds to @Light2D@ nodes. bindCanvasItem_get_light_mask :: MethodBind bindCanvasItem_get_light_mask = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_light_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rendering layers in which this @CanvasItem@ responds to @Light2D@ nodes. get_light_mask :: (CanvasItem :< cls, Object :< cls) => cls -> IO Int get_light_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_light_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_light_mask" '[] (IO Int) where nodeMethod = Godot.Core.CanvasItem.get_light_mask {-# NOINLINE bindCanvasItem_get_local_mouse_position #-} -- | Returns the mouse position relative to this item's position. bindCanvasItem_get_local_mouse_position :: MethodBind bindCanvasItem_get_local_mouse_position = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_local_mouse_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the mouse position relative to this item's position. get_local_mouse_position :: (CanvasItem :< cls, Object :< cls) => cls -> IO Vector2 get_local_mouse_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_local_mouse_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_local_mouse_position" '[] (IO Vector2) where nodeMethod = Godot.Core.CanvasItem.get_local_mouse_position {-# NOINLINE bindCanvasItem_get_material #-} -- | The material applied to textures on this @CanvasItem@. bindCanvasItem_get_material :: MethodBind bindCanvasItem_get_material = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The material applied to textures on this @CanvasItem@. get_material :: (CanvasItem :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_material" '[] (IO Material) where nodeMethod = Godot.Core.CanvasItem.get_material {-# NOINLINE bindCanvasItem_get_modulate #-} -- | The color applied to textures on this @CanvasItem@. bindCanvasItem_get_modulate :: MethodBind bindCanvasItem_get_modulate = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color applied to textures on this @CanvasItem@. get_modulate :: (CanvasItem :< cls, Object :< cls) => cls -> IO Color get_modulate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_modulate" '[] (IO Color) where nodeMethod = Godot.Core.CanvasItem.get_modulate {-# NOINLINE bindCanvasItem_get_self_modulate #-} -- | The color applied to textures on this @CanvasItem@. This is not inherited by children @CanvasItem@s. bindCanvasItem_get_self_modulate :: MethodBind bindCanvasItem_get_self_modulate = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_self_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color applied to textures on this @CanvasItem@. This is not inherited by children @CanvasItem@s. get_self_modulate :: (CanvasItem :< cls, Object :< cls) => cls -> IO Color get_self_modulate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_self_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_self_modulate" '[] (IO Color) where nodeMethod = Godot.Core.CanvasItem.get_self_modulate {-# NOINLINE bindCanvasItem_get_transform #-} -- | Returns the transform matrix of this item. bindCanvasItem_get_transform :: MethodBind bindCanvasItem_get_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform matrix of this item. get_transform :: (CanvasItem :< cls, Object :< cls) => cls -> IO Transform2d get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.CanvasItem.get_transform {-# NOINLINE bindCanvasItem_get_use_parent_material #-} -- | If @true@, the parent @CanvasItem@'s @material@ property is used as this one's material. bindCanvasItem_get_use_parent_material :: MethodBind bindCanvasItem_get_use_parent_material = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_use_parent_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the parent @CanvasItem@'s @material@ property is used as this one's material. get_use_parent_material :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool get_use_parent_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_use_parent_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_use_parent_material" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem.get_use_parent_material {-# NOINLINE bindCanvasItem_get_viewport_rect #-} -- | Returns the viewport's boundaries as a @Rect2@. bindCanvasItem_get_viewport_rect :: MethodBind bindCanvasItem_get_viewport_rect = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_viewport_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the viewport's boundaries as a @Rect2@. get_viewport_rect :: (CanvasItem :< cls, Object :< cls) => cls -> IO Rect2 get_viewport_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_viewport_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_viewport_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.CanvasItem.get_viewport_rect {-# NOINLINE bindCanvasItem_get_viewport_transform #-} -- | Returns this item's transform in relation to the viewport. bindCanvasItem_get_viewport_transform :: MethodBind bindCanvasItem_get_viewport_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_viewport_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns this item's transform in relation to the viewport. get_viewport_transform :: (CanvasItem :< cls, Object :< cls) => cls -> IO Transform2d get_viewport_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_viewport_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_viewport_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.CanvasItem.get_viewport_transform {-# NOINLINE bindCanvasItem_get_world_2d #-} -- | Returns the @World2D@ where this item is in. bindCanvasItem_get_world_2d :: MethodBind bindCanvasItem_get_world_2d = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "get_world_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @World2D@ where this item is in. get_world_2d :: (CanvasItem :< cls, Object :< cls) => cls -> IO World2D get_world_2d cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_get_world_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "get_world_2d" '[] (IO World2D) where nodeMethod = Godot.Core.CanvasItem.get_world_2d {-# NOINLINE bindCanvasItem_hide #-} -- | Hide the @CanvasItem@ if it's currently visible. bindCanvasItem_hide :: MethodBind bindCanvasItem_hide = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "hide" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Hide the @CanvasItem@ if it's currently visible. hide :: (CanvasItem :< cls, Object :< cls) => cls -> IO () hide cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_hide (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "hide" '[] (IO ()) where nodeMethod = Godot.Core.CanvasItem.hide {-# NOINLINE bindCanvasItem_is_draw_behind_parent_enabled #-} -- | If @true@, the object draws behind its parent. bindCanvasItem_is_draw_behind_parent_enabled :: MethodBind bindCanvasItem_is_draw_behind_parent_enabled = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "is_draw_behind_parent_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the object draws behind its parent. is_draw_behind_parent_enabled :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool is_draw_behind_parent_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_is_draw_behind_parent_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "is_draw_behind_parent_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem.is_draw_behind_parent_enabled {-# NOINLINE bindCanvasItem_is_local_transform_notification_enabled #-} -- | Returns @true@ if local transform notifications are communicated to children. bindCanvasItem_is_local_transform_notification_enabled :: MethodBind bindCanvasItem_is_local_transform_notification_enabled = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "is_local_transform_notification_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if local transform notifications are communicated to children. is_local_transform_notification_enabled :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool is_local_transform_notification_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_is_local_transform_notification_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "is_local_transform_notification_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem.is_local_transform_notification_enabled {-# NOINLINE bindCanvasItem_is_set_as_toplevel #-} -- | Returns @true@ if the node is set as top-level. See @method set_as_toplevel@. bindCanvasItem_is_set_as_toplevel :: MethodBind bindCanvasItem_is_set_as_toplevel = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "is_set_as_toplevel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node is set as top-level. See @method set_as_toplevel@. is_set_as_toplevel :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool is_set_as_toplevel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_is_set_as_toplevel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "is_set_as_toplevel" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem.is_set_as_toplevel {-# NOINLINE bindCanvasItem_is_transform_notification_enabled #-} -- | Returns @true@ if global transform notifications are communicated to children. bindCanvasItem_is_transform_notification_enabled :: MethodBind bindCanvasItem_is_transform_notification_enabled = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "is_transform_notification_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if global transform notifications are communicated to children. is_transform_notification_enabled :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool is_transform_notification_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_is_transform_notification_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "is_transform_notification_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem.is_transform_notification_enabled {-# NOINLINE bindCanvasItem_is_visible #-} -- | If @true@, this @CanvasItem@ is drawn. The node is only visible if all of its antecedents are visible as well (in other words, @method is_visible_in_tree@ must return @true@). -- __Note:__ For controls that inherit @Popup@, the correct way to make them visible is to call one of the multiple @popup*()@ functions instead. bindCanvasItem_is_visible :: MethodBind bindCanvasItem_is_visible = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "is_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this @CanvasItem@ is drawn. The node is only visible if all of its antecedents are visible as well (in other words, @method is_visible_in_tree@ must return @true@). -- __Note:__ For controls that inherit @Popup@, the correct way to make them visible is to call one of the multiple @popup*()@ functions instead. is_visible :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool is_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_is_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "is_visible" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem.is_visible {-# NOINLINE bindCanvasItem_is_visible_in_tree #-} -- | Returns @true@ if the node is present in the @SceneTree@, its @visible@ property is @true@ and all its antecedents are also visible. If any antecedent is hidden, this node will not be visible in the scene tree. bindCanvasItem_is_visible_in_tree :: MethodBind bindCanvasItem_is_visible_in_tree = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "is_visible_in_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node is present in the @SceneTree@, its @visible@ property is @true@ and all its antecedents are also visible. If any antecedent is hidden, this node will not be visible in the scene tree. is_visible_in_tree :: (CanvasItem :< cls, Object :< cls) => cls -> IO Bool is_visible_in_tree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_is_visible_in_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "is_visible_in_tree" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItem.is_visible_in_tree {-# NOINLINE bindCanvasItem_make_canvas_position_local #-} -- | Assigns @screen_point@ as this node's new local transform. bindCanvasItem_make_canvas_position_local :: MethodBind bindCanvasItem_make_canvas_position_local = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "make_canvas_position_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns @screen_point@ as this node's new local transform. make_canvas_position_local :: (CanvasItem :< cls, Object :< cls) => cls -> Vector2 -> IO Vector2 make_canvas_position_local cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_make_canvas_position_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "make_canvas_position_local" '[Vector2] (IO Vector2) where nodeMethod = Godot.Core.CanvasItem.make_canvas_position_local {-# NOINLINE bindCanvasItem_make_input_local #-} -- | Transformations issued by @event@'s inputs are applied in local space instead of global space. bindCanvasItem_make_input_local :: MethodBind bindCanvasItem_make_input_local = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "make_input_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Transformations issued by @event@'s inputs are applied in local space instead of global space. make_input_local :: (CanvasItem :< cls, Object :< cls) => cls -> InputEvent -> IO InputEvent make_input_local cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_make_input_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "make_input_local" '[InputEvent] (IO InputEvent) where nodeMethod = Godot.Core.CanvasItem.make_input_local {-# NOINLINE bindCanvasItem_set_as_toplevel #-} -- | If @enable@ is @true@, the node won't inherit its transform from parent canvas items. bindCanvasItem_set_as_toplevel :: MethodBind bindCanvasItem_set_as_toplevel = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_as_toplevel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @enable@ is @true@, the node won't inherit its transform from parent canvas items. set_as_toplevel :: (CanvasItem :< cls, Object :< cls) => cls -> Bool -> IO () set_as_toplevel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_as_toplevel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_as_toplevel" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_as_toplevel {-# NOINLINE bindCanvasItem_set_draw_behind_parent #-} -- | If @true@, the object draws behind its parent. bindCanvasItem_set_draw_behind_parent :: MethodBind bindCanvasItem_set_draw_behind_parent = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_draw_behind_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the object draws behind its parent. set_draw_behind_parent :: (CanvasItem :< cls, Object :< cls) => cls -> Bool -> IO () set_draw_behind_parent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_draw_behind_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_draw_behind_parent" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_draw_behind_parent {-# NOINLINE bindCanvasItem_set_light_mask #-} -- | The rendering layers in which this @CanvasItem@ responds to @Light2D@ nodes. bindCanvasItem_set_light_mask :: MethodBind bindCanvasItem_set_light_mask = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_light_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rendering layers in which this @CanvasItem@ responds to @Light2D@ nodes. set_light_mask :: (CanvasItem :< cls, Object :< cls) => cls -> Int -> IO () set_light_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_light_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_light_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_light_mask {-# NOINLINE bindCanvasItem_set_material #-} -- | The material applied to textures on this @CanvasItem@. bindCanvasItem_set_material :: MethodBind bindCanvasItem_set_material = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The material applied to textures on this @CanvasItem@. set_material :: (CanvasItem :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_material {-# NOINLINE bindCanvasItem_set_modulate #-} -- | The color applied to textures on this @CanvasItem@. bindCanvasItem_set_modulate :: MethodBind bindCanvasItem_set_modulate = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color applied to textures on this @CanvasItem@. set_modulate :: (CanvasItem :< cls, Object :< cls) => cls -> Color -> IO () set_modulate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_modulate" '[Color] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_modulate {-# NOINLINE bindCanvasItem_set_notify_local_transform #-} -- | If @enable@ is @true@, children will be updated with local transform data. bindCanvasItem_set_notify_local_transform :: MethodBind bindCanvasItem_set_notify_local_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_notify_local_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @enable@ is @true@, children will be updated with local transform data. set_notify_local_transform :: (CanvasItem :< cls, Object :< cls) => cls -> Bool -> IO () set_notify_local_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_notify_local_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_notify_local_transform" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_notify_local_transform {-# NOINLINE bindCanvasItem_set_notify_transform #-} -- | If @enable@ is @true@, children will be updated with global transform data. bindCanvasItem_set_notify_transform :: MethodBind bindCanvasItem_set_notify_transform = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_notify_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @enable@ is @true@, children will be updated with global transform data. set_notify_transform :: (CanvasItem :< cls, Object :< cls) => cls -> Bool -> IO () set_notify_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_notify_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_notify_transform" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_notify_transform {-# NOINLINE bindCanvasItem_set_self_modulate #-} -- | The color applied to textures on this @CanvasItem@. This is not inherited by children @CanvasItem@s. bindCanvasItem_set_self_modulate :: MethodBind bindCanvasItem_set_self_modulate = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_self_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color applied to textures on this @CanvasItem@. This is not inherited by children @CanvasItem@s. set_self_modulate :: (CanvasItem :< cls, Object :< cls) => cls -> Color -> IO () set_self_modulate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_self_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_self_modulate" '[Color] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_self_modulate {-# NOINLINE bindCanvasItem_set_use_parent_material #-} -- | If @true@, the parent @CanvasItem@'s @material@ property is used as this one's material. bindCanvasItem_set_use_parent_material :: MethodBind bindCanvasItem_set_use_parent_material = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_use_parent_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the parent @CanvasItem@'s @material@ property is used as this one's material. set_use_parent_material :: (CanvasItem :< cls, Object :< cls) => cls -> Bool -> IO () set_use_parent_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_use_parent_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_use_parent_material" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_use_parent_material {-# NOINLINE bindCanvasItem_set_visible #-} -- | If @true@, this @CanvasItem@ is drawn. The node is only visible if all of its antecedents are visible as well (in other words, @method is_visible_in_tree@ must return @true@). -- __Note:__ For controls that inherit @Popup@, the correct way to make them visible is to call one of the multiple @popup*()@ functions instead. bindCanvasItem_set_visible :: MethodBind bindCanvasItem_set_visible = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "set_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this @CanvasItem@ is drawn. The node is only visible if all of its antecedents are visible as well (in other words, @method is_visible_in_tree@ must return @true@). -- __Note:__ For controls that inherit @Popup@, the correct way to make them visible is to call one of the multiple @popup*()@ functions instead. set_visible :: (CanvasItem :< cls, Object :< cls) => cls -> Bool -> IO () set_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_set_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "set_visible" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItem.set_visible {-# NOINLINE bindCanvasItem_show #-} -- | Show the @CanvasItem@ if it's currently hidden. For controls that inherit @Popup@, the correct way to make them visible is to call one of the multiple @popup*()@ functions instead. bindCanvasItem_show :: MethodBind bindCanvasItem_show = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "show" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Show the @CanvasItem@ if it's currently hidden. For controls that inherit @Popup@, the correct way to make them visible is to call one of the multiple @popup*()@ functions instead. show :: (CanvasItem :< cls, Object :< cls) => cls -> IO () show cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_show (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "show" '[] (IO ()) where nodeMethod = Godot.Core.CanvasItem.show {-# NOINLINE bindCanvasItem_update #-} -- | Queue the @CanvasItem@ for update. @NOTIFICATION_DRAW@ will be called on idle time to request redraw. bindCanvasItem_update :: MethodBind bindCanvasItem_update = unsafePerformIO $ withCString "CanvasItem" $ \ clsNamePtr -> withCString "update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Queue the @CanvasItem@ for update. @NOTIFICATION_DRAW@ will be called on idle time to request redraw. update :: (CanvasItem :< cls, Object :< cls) => cls -> IO () update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItem_update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItem "update" '[] (IO ()) where nodeMethod = Godot.Core.CanvasItem.update ================================================ FILE: src/Godot/Core/CanvasItemMaterial.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CanvasItemMaterial (Godot.Core.CanvasItemMaterial._BLEND_MODE_ADD, Godot.Core.CanvasItemMaterial._BLEND_MODE_MIX, Godot.Core.CanvasItemMaterial._LIGHT_MODE_LIGHT_ONLY, Godot.Core.CanvasItemMaterial._BLEND_MODE_MUL, Godot.Core.CanvasItemMaterial._BLEND_MODE_PREMULT_ALPHA, Godot.Core.CanvasItemMaterial._LIGHT_MODE_NORMAL, Godot.Core.CanvasItemMaterial._BLEND_MODE_SUB, Godot.Core.CanvasItemMaterial._LIGHT_MODE_UNSHADED, Godot.Core.CanvasItemMaterial.get_blend_mode, Godot.Core.CanvasItemMaterial.get_light_mode, Godot.Core.CanvasItemMaterial.get_particles_anim_h_frames, Godot.Core.CanvasItemMaterial.get_particles_anim_loop, Godot.Core.CanvasItemMaterial.get_particles_anim_v_frames, Godot.Core.CanvasItemMaterial.get_particles_animation, Godot.Core.CanvasItemMaterial.set_blend_mode, Godot.Core.CanvasItemMaterial.set_light_mode, Godot.Core.CanvasItemMaterial.set_particles_anim_h_frames, Godot.Core.CanvasItemMaterial.set_particles_anim_loop, Godot.Core.CanvasItemMaterial.set_particles_anim_v_frames, Godot.Core.CanvasItemMaterial.set_particles_animation) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Material() _BLEND_MODE_ADD :: Int _BLEND_MODE_ADD = 1 _BLEND_MODE_MIX :: Int _BLEND_MODE_MIX = 0 _LIGHT_MODE_LIGHT_ONLY :: Int _LIGHT_MODE_LIGHT_ONLY = 2 _BLEND_MODE_MUL :: Int _BLEND_MODE_MUL = 3 _BLEND_MODE_PREMULT_ALPHA :: Int _BLEND_MODE_PREMULT_ALPHA = 4 _LIGHT_MODE_NORMAL :: Int _LIGHT_MODE_NORMAL = 0 _BLEND_MODE_SUB :: Int _BLEND_MODE_SUB = 2 _LIGHT_MODE_UNSHADED :: Int _LIGHT_MODE_UNSHADED = 1 instance NodeProperty CanvasItemMaterial "blend_mode" Int 'False where nodeProperty = (get_blend_mode, wrapDroppingSetter set_blend_mode, Nothing) instance NodeProperty CanvasItemMaterial "light_mode" Int 'False where nodeProperty = (get_light_mode, wrapDroppingSetter set_light_mode, Nothing) instance NodeProperty CanvasItemMaterial "particles_anim_h_frames" Int 'False where nodeProperty = (get_particles_anim_h_frames, wrapDroppingSetter set_particles_anim_h_frames, Nothing) instance NodeProperty CanvasItemMaterial "particles_anim_loop" Bool 'False where nodeProperty = (get_particles_anim_loop, wrapDroppingSetter set_particles_anim_loop, Nothing) instance NodeProperty CanvasItemMaterial "particles_anim_v_frames" Int 'False where nodeProperty = (get_particles_anim_v_frames, wrapDroppingSetter set_particles_anim_v_frames, Nothing) instance NodeProperty CanvasItemMaterial "particles_animation" Bool 'False where nodeProperty = (get_particles_animation, wrapDroppingSetter set_particles_animation, Nothing) {-# NOINLINE bindCanvasItemMaterial_get_blend_mode #-} -- | The manner in which a material's rendering is applied to underlying textures. bindCanvasItemMaterial_get_blend_mode :: MethodBind bindCanvasItemMaterial_get_blend_mode = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "get_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The manner in which a material's rendering is applied to underlying textures. get_blend_mode :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> IO Int get_blend_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_get_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "get_blend_mode" '[] (IO Int) where nodeMethod = Godot.Core.CanvasItemMaterial.get_blend_mode {-# NOINLINE bindCanvasItemMaterial_get_light_mode #-} -- | The manner in which material reacts to lighting. bindCanvasItemMaterial_get_light_mode :: MethodBind bindCanvasItemMaterial_get_light_mode = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "get_light_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The manner in which material reacts to lighting. get_light_mode :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> IO Int get_light_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_get_light_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "get_light_mode" '[] (IO Int) where nodeMethod = Godot.Core.CanvasItemMaterial.get_light_mode {-# NOINLINE bindCanvasItemMaterial_get_particles_anim_h_frames #-} -- | The number of columns in the spritesheet assigned as @Texture@ for a @Particles2D@ or @CPUParticles2D@. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. bindCanvasItemMaterial_get_particles_anim_h_frames :: MethodBind bindCanvasItemMaterial_get_particles_anim_h_frames = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "get_particles_anim_h_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns in the spritesheet assigned as @Texture@ for a @Particles2D@ or @CPUParticles2D@. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. get_particles_anim_h_frames :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> IO Int get_particles_anim_h_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_get_particles_anim_h_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "get_particles_anim_h_frames" '[] (IO Int) where nodeMethod = Godot.Core.CanvasItemMaterial.get_particles_anim_h_frames {-# NOINLINE bindCanvasItemMaterial_get_particles_anim_loop #-} -- | If @true@, the particles animation will loop. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. bindCanvasItemMaterial_get_particles_anim_loop :: MethodBind bindCanvasItemMaterial_get_particles_anim_loop = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "get_particles_anim_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the particles animation will loop. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. get_particles_anim_loop :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> IO Bool get_particles_anim_loop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_get_particles_anim_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "get_particles_anim_loop" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItemMaterial.get_particles_anim_loop {-# NOINLINE bindCanvasItemMaterial_get_particles_anim_v_frames #-} -- | The number of rows in the spritesheet assigned as @Texture@ for a @Particles2D@ or @CPUParticles2D@. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. bindCanvasItemMaterial_get_particles_anim_v_frames :: MethodBind bindCanvasItemMaterial_get_particles_anim_v_frames = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "get_particles_anim_v_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of rows in the spritesheet assigned as @Texture@ for a @Particles2D@ or @CPUParticles2D@. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. get_particles_anim_v_frames :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> IO Int get_particles_anim_v_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_get_particles_anim_v_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "get_particles_anim_v_frames" '[] (IO Int) where nodeMethod = Godot.Core.CanvasItemMaterial.get_particles_anim_v_frames {-# NOINLINE bindCanvasItemMaterial_get_particles_animation #-} -- | If @true@, enable spritesheet-based animation features when assigned to @Particles2D@ and @CPUParticles2D@ nodes. The @ParticlesMaterial.anim_speed@ or @CPUParticles2D.anim_speed@ should also be set to a positive value for the animation to play. -- This property (and other @particles_anim_*@ properties that depend on it) has no effect on other types of nodes. bindCanvasItemMaterial_get_particles_animation :: MethodBind bindCanvasItemMaterial_get_particles_animation = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "get_particles_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enable spritesheet-based animation features when assigned to @Particles2D@ and @CPUParticles2D@ nodes. The @ParticlesMaterial.anim_speed@ or @CPUParticles2D.anim_speed@ should also be set to a positive value for the animation to play. -- This property (and other @particles_anim_*@ properties that depend on it) has no effect on other types of nodes. get_particles_animation :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> IO Bool get_particles_animation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_get_particles_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "get_particles_animation" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasItemMaterial.get_particles_animation {-# NOINLINE bindCanvasItemMaterial_set_blend_mode #-} -- | The manner in which a material's rendering is applied to underlying textures. bindCanvasItemMaterial_set_blend_mode :: MethodBind bindCanvasItemMaterial_set_blend_mode = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "set_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The manner in which a material's rendering is applied to underlying textures. set_blend_mode :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_blend_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_set_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "set_blend_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.CanvasItemMaterial.set_blend_mode {-# NOINLINE bindCanvasItemMaterial_set_light_mode #-} -- | The manner in which material reacts to lighting. bindCanvasItemMaterial_set_light_mode :: MethodBind bindCanvasItemMaterial_set_light_mode = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "set_light_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The manner in which material reacts to lighting. set_light_mode :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_light_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_set_light_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "set_light_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.CanvasItemMaterial.set_light_mode {-# NOINLINE bindCanvasItemMaterial_set_particles_anim_h_frames #-} -- | The number of columns in the spritesheet assigned as @Texture@ for a @Particles2D@ or @CPUParticles2D@. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. bindCanvasItemMaterial_set_particles_anim_h_frames :: MethodBind bindCanvasItemMaterial_set_particles_anim_h_frames = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "set_particles_anim_h_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns in the spritesheet assigned as @Texture@ for a @Particles2D@ or @CPUParticles2D@. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. set_particles_anim_h_frames :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_particles_anim_h_frames cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_set_particles_anim_h_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "set_particles_anim_h_frames" '[Int] (IO ()) where nodeMethod = Godot.Core.CanvasItemMaterial.set_particles_anim_h_frames {-# NOINLINE bindCanvasItemMaterial_set_particles_anim_loop #-} -- | If @true@, the particles animation will loop. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. bindCanvasItemMaterial_set_particles_anim_loop :: MethodBind bindCanvasItemMaterial_set_particles_anim_loop = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "set_particles_anim_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the particles animation will loop. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. set_particles_anim_loop :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_particles_anim_loop cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_set_particles_anim_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "set_particles_anim_loop" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItemMaterial.set_particles_anim_loop {-# NOINLINE bindCanvasItemMaterial_set_particles_anim_v_frames #-} -- | The number of rows in the spritesheet assigned as @Texture@ for a @Particles2D@ or @CPUParticles2D@. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. bindCanvasItemMaterial_set_particles_anim_v_frames :: MethodBind bindCanvasItemMaterial_set_particles_anim_v_frames = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "set_particles_anim_v_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of rows in the spritesheet assigned as @Texture@ for a @Particles2D@ or @CPUParticles2D@. -- __Note:__ This property is only used and visible in the editor if @particles_animation@ is @true@. set_particles_anim_v_frames :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_particles_anim_v_frames cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_set_particles_anim_v_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "set_particles_anim_v_frames" '[Int] (IO ()) where nodeMethod = Godot.Core.CanvasItemMaterial.set_particles_anim_v_frames {-# NOINLINE bindCanvasItemMaterial_set_particles_animation #-} -- | If @true@, enable spritesheet-based animation features when assigned to @Particles2D@ and @CPUParticles2D@ nodes. The @ParticlesMaterial.anim_speed@ or @CPUParticles2D.anim_speed@ should also be set to a positive value for the animation to play. -- This property (and other @particles_anim_*@ properties that depend on it) has no effect on other types of nodes. bindCanvasItemMaterial_set_particles_animation :: MethodBind bindCanvasItemMaterial_set_particles_animation = unsafePerformIO $ withCString "CanvasItemMaterial" $ \ clsNamePtr -> withCString "set_particles_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enable spritesheet-based animation features when assigned to @Particles2D@ and @CPUParticles2D@ nodes. The @ParticlesMaterial.anim_speed@ or @CPUParticles2D.anim_speed@ should also be set to a positive value for the animation to play. -- This property (and other @particles_anim_*@ properties that depend on it) has no effect on other types of nodes. set_particles_animation :: (CanvasItemMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_particles_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasItemMaterial_set_particles_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasItemMaterial "set_particles_animation" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasItemMaterial.set_particles_animation ================================================ FILE: src/Godot/Core/CanvasLayer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CanvasLayer (Godot.Core.CanvasLayer.get_canvas, Godot.Core.CanvasLayer.get_custom_viewport, Godot.Core.CanvasLayer.get_follow_viewport_scale, Godot.Core.CanvasLayer.get_layer, Godot.Core.CanvasLayer.get_offset, Godot.Core.CanvasLayer.get_rotation, Godot.Core.CanvasLayer.get_rotation_degrees, Godot.Core.CanvasLayer.get_scale, Godot.Core.CanvasLayer.get_transform, Godot.Core.CanvasLayer.is_following_viewport, Godot.Core.CanvasLayer.set_custom_viewport, Godot.Core.CanvasLayer.set_follow_viewport, Godot.Core.CanvasLayer.set_follow_viewport_scale, Godot.Core.CanvasLayer.set_layer, Godot.Core.CanvasLayer.set_offset, Godot.Core.CanvasLayer.set_rotation, Godot.Core.CanvasLayer.set_rotation_degrees, Godot.Core.CanvasLayer.set_scale, Godot.Core.CanvasLayer.set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() instance NodeProperty CanvasLayer "custom_viewport" Node 'False where nodeProperty = (get_custom_viewport, wrapDroppingSetter set_custom_viewport, Nothing) instance NodeProperty CanvasLayer "follow_viewport_enable" Bool 'False where nodeProperty = (is_following_viewport, wrapDroppingSetter set_follow_viewport, Nothing) instance NodeProperty CanvasLayer "follow_viewport_scale" Float 'False where nodeProperty = (get_follow_viewport_scale, wrapDroppingSetter set_follow_viewport_scale, Nothing) instance NodeProperty CanvasLayer "layer" Int 'False where nodeProperty = (get_layer, wrapDroppingSetter set_layer, Nothing) instance NodeProperty CanvasLayer "offset" Vector2 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty CanvasLayer "rotation" Float 'False where nodeProperty = (get_rotation, wrapDroppingSetter set_rotation, Nothing) instance NodeProperty CanvasLayer "rotation_degrees" Float 'False where nodeProperty = (get_rotation_degrees, wrapDroppingSetter set_rotation_degrees, Nothing) instance NodeProperty CanvasLayer "scale" Vector2 'False where nodeProperty = (get_scale, wrapDroppingSetter set_scale, Nothing) instance NodeProperty CanvasLayer "transform" Transform2d 'False where nodeProperty = (get_transform, wrapDroppingSetter set_transform, Nothing) {-# NOINLINE bindCanvasLayer_get_canvas #-} -- | Returns the RID of the canvas used by this layer. bindCanvasLayer_get_canvas :: MethodBind bindCanvasLayer_get_canvas = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the RID of the canvas used by this layer. get_canvas :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Rid get_canvas cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_canvas" '[] (IO Rid) where nodeMethod = Godot.Core.CanvasLayer.get_canvas {-# NOINLINE bindCanvasLayer_get_custom_viewport #-} -- | The custom @Viewport@ node assigned to the @CanvasLayer@. If @null@, uses the default viewport instead. bindCanvasLayer_get_custom_viewport :: MethodBind bindCanvasLayer_get_custom_viewport = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_custom_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @Viewport@ node assigned to the @CanvasLayer@. If @null@, uses the default viewport instead. get_custom_viewport :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Node get_custom_viewport cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_custom_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_custom_viewport" '[] (IO Node) where nodeMethod = Godot.Core.CanvasLayer.get_custom_viewport {-# NOINLINE bindCanvasLayer_get_follow_viewport_scale #-} -- | Scales the layer when using @follow_viewport_enable@. Layers moving into the foreground should have increasing scales, while layers moving into the background should have decreasing scales. bindCanvasLayer_get_follow_viewport_scale :: MethodBind bindCanvasLayer_get_follow_viewport_scale = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_follow_viewport_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scales the layer when using @follow_viewport_enable@. Layers moving into the foreground should have increasing scales, while layers moving into the background should have decreasing scales. get_follow_viewport_scale :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Float get_follow_viewport_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_follow_viewport_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_follow_viewport_scale" '[] (IO Float) where nodeMethod = Godot.Core.CanvasLayer.get_follow_viewport_scale {-# NOINLINE bindCanvasLayer_get_layer #-} -- | Layer index for draw order. Lower values are drawn first. bindCanvasLayer_get_layer :: MethodBind bindCanvasLayer_get_layer = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Layer index for draw order. Lower values are drawn first. get_layer :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Int get_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_layer" '[] (IO Int) where nodeMethod = Godot.Core.CanvasLayer.get_layer {-# NOINLINE bindCanvasLayer_get_offset #-} -- | The layer's base offset. bindCanvasLayer_get_offset :: MethodBind bindCanvasLayer_get_offset = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's base offset. get_offset :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.CanvasLayer.get_offset {-# NOINLINE bindCanvasLayer_get_rotation #-} -- | The layer's rotation in radians. bindCanvasLayer_get_rotation :: MethodBind bindCanvasLayer_get_rotation = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's rotation in radians. get_rotation :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Float get_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_rotation" '[] (IO Float) where nodeMethod = Godot.Core.CanvasLayer.get_rotation {-# NOINLINE bindCanvasLayer_get_rotation_degrees #-} -- | The layer's rotation in degrees. bindCanvasLayer_get_rotation_degrees :: MethodBind bindCanvasLayer_get_rotation_degrees = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's rotation in degrees. get_rotation_degrees :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Float get_rotation_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_rotation_degrees" '[] (IO Float) where nodeMethod = Godot.Core.CanvasLayer.get_rotation_degrees {-# NOINLINE bindCanvasLayer_get_scale #-} -- | The layer's scale. bindCanvasLayer_get_scale :: MethodBind bindCanvasLayer_get_scale = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's scale. get_scale :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Vector2 get_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_scale" '[] (IO Vector2) where nodeMethod = Godot.Core.CanvasLayer.get_scale {-# NOINLINE bindCanvasLayer_get_transform #-} -- | The layer's transform. bindCanvasLayer_get_transform :: MethodBind bindCanvasLayer_get_transform = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's transform. get_transform :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Transform2d get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "get_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.CanvasLayer.get_transform {-# NOINLINE bindCanvasLayer_is_following_viewport #-} -- | Sets the layer to follow the viewport in order to simulate a pseudo 3D effect. bindCanvasLayer_is_following_viewport :: MethodBind bindCanvasLayer_is_following_viewport = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "is_following_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the layer to follow the viewport in order to simulate a pseudo 3D effect. is_following_viewport :: (CanvasLayer :< cls, Object :< cls) => cls -> IO Bool is_following_viewport cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_is_following_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "is_following_viewport" '[] (IO Bool) where nodeMethod = Godot.Core.CanvasLayer.is_following_viewport {-# NOINLINE bindCanvasLayer_set_custom_viewport #-} -- | The custom @Viewport@ node assigned to the @CanvasLayer@. If @null@, uses the default viewport instead. bindCanvasLayer_set_custom_viewport :: MethodBind bindCanvasLayer_set_custom_viewport = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_custom_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @Viewport@ node assigned to the @CanvasLayer@. If @null@, uses the default viewport instead. set_custom_viewport :: (CanvasLayer :< cls, Object :< cls) => cls -> Node -> IO () set_custom_viewport cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_custom_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_custom_viewport" '[Node] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_custom_viewport {-# NOINLINE bindCanvasLayer_set_follow_viewport #-} -- | Sets the layer to follow the viewport in order to simulate a pseudo 3D effect. bindCanvasLayer_set_follow_viewport :: MethodBind bindCanvasLayer_set_follow_viewport = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_follow_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the layer to follow the viewport in order to simulate a pseudo 3D effect. set_follow_viewport :: (CanvasLayer :< cls, Object :< cls) => cls -> Bool -> IO () set_follow_viewport cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_follow_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_follow_viewport" '[Bool] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_follow_viewport {-# NOINLINE bindCanvasLayer_set_follow_viewport_scale #-} -- | Scales the layer when using @follow_viewport_enable@. Layers moving into the foreground should have increasing scales, while layers moving into the background should have decreasing scales. bindCanvasLayer_set_follow_viewport_scale :: MethodBind bindCanvasLayer_set_follow_viewport_scale = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_follow_viewport_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scales the layer when using @follow_viewport_enable@. Layers moving into the foreground should have increasing scales, while layers moving into the background should have decreasing scales. set_follow_viewport_scale :: (CanvasLayer :< cls, Object :< cls) => cls -> Float -> IO () set_follow_viewport_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_follow_viewport_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_follow_viewport_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_follow_viewport_scale {-# NOINLINE bindCanvasLayer_set_layer #-} -- | Layer index for draw order. Lower values are drawn first. bindCanvasLayer_set_layer :: MethodBind bindCanvasLayer_set_layer = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Layer index for draw order. Lower values are drawn first. set_layer :: (CanvasLayer :< cls, Object :< cls) => cls -> Int -> IO () set_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_layer {-# NOINLINE bindCanvasLayer_set_offset #-} -- | The layer's base offset. bindCanvasLayer_set_offset :: MethodBind bindCanvasLayer_set_offset = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's base offset. set_offset :: (CanvasLayer :< cls, Object :< cls) => cls -> Vector2 -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_offset {-# NOINLINE bindCanvasLayer_set_rotation #-} -- | The layer's rotation in radians. bindCanvasLayer_set_rotation :: MethodBind bindCanvasLayer_set_rotation = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's rotation in radians. set_rotation :: (CanvasLayer :< cls, Object :< cls) => cls -> Float -> IO () set_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_rotation" '[Float] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_rotation {-# NOINLINE bindCanvasLayer_set_rotation_degrees #-} -- | The layer's rotation in degrees. bindCanvasLayer_set_rotation_degrees :: MethodBind bindCanvasLayer_set_rotation_degrees = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's rotation in degrees. set_rotation_degrees :: (CanvasLayer :< cls, Object :< cls) => cls -> Float -> IO () set_rotation_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_rotation_degrees" '[Float] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_rotation_degrees {-# NOINLINE bindCanvasLayer_set_scale #-} -- | The layer's scale. bindCanvasLayer_set_scale :: MethodBind bindCanvasLayer_set_scale = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's scale. set_scale :: (CanvasLayer :< cls, Object :< cls) => cls -> Vector2 -> IO () set_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_scale {-# NOINLINE bindCanvasLayer_set_transform #-} -- | The layer's transform. bindCanvasLayer_set_transform :: MethodBind bindCanvasLayer_set_transform = unsafePerformIO $ withCString "CanvasLayer" $ \ clsNamePtr -> withCString "set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer's transform. set_transform :: (CanvasLayer :< cls, Object :< cls) => cls -> Transform2d -> IO () set_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasLayer_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasLayer "set_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.CanvasLayer.set_transform ================================================ FILE: src/Godot/Core/CanvasModulate.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CanvasModulate (Godot.Core.CanvasModulate.get_color, Godot.Core.CanvasModulate.set_color) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty CanvasModulate "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) {-# NOINLINE bindCanvasModulate_get_color #-} -- | The tint color to apply. bindCanvasModulate_get_color :: MethodBind bindCanvasModulate_get_color = unsafePerformIO $ withCString "CanvasModulate" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The tint color to apply. get_color :: (CanvasModulate :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasModulate_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasModulate "get_color" '[] (IO Color) where nodeMethod = Godot.Core.CanvasModulate.get_color {-# NOINLINE bindCanvasModulate_set_color #-} -- | The tint color to apply. bindCanvasModulate_set_color :: MethodBind bindCanvasModulate_set_color = unsafePerformIO $ withCString "CanvasModulate" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The tint color to apply. set_color :: (CanvasModulate :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCanvasModulate_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CanvasModulate "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.CanvasModulate.set_color ================================================ FILE: src/Godot/Core/CapsuleMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CapsuleMesh (Godot.Core.CapsuleMesh.get_mid_height, Godot.Core.CapsuleMesh.get_radial_segments, Godot.Core.CapsuleMesh.get_radius, Godot.Core.CapsuleMesh.get_rings, Godot.Core.CapsuleMesh.set_mid_height, Godot.Core.CapsuleMesh.set_radial_segments, Godot.Core.CapsuleMesh.set_radius, Godot.Core.CapsuleMesh.set_rings) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PrimitiveMesh() instance NodeProperty CapsuleMesh "mid_height" Float 'False where nodeProperty = (get_mid_height, wrapDroppingSetter set_mid_height, Nothing) instance NodeProperty CapsuleMesh "radial_segments" Int 'False where nodeProperty = (get_radial_segments, wrapDroppingSetter set_radial_segments, Nothing) instance NodeProperty CapsuleMesh "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) instance NodeProperty CapsuleMesh "rings" Int 'False where nodeProperty = (get_rings, wrapDroppingSetter set_rings, Nothing) {-# NOINLINE bindCapsuleMesh_get_mid_height #-} -- | Height of the capsule mesh from the center point. bindCapsuleMesh_get_mid_height :: MethodBind bindCapsuleMesh_get_mid_height = unsafePerformIO $ withCString "CapsuleMesh" $ \ clsNamePtr -> withCString "get_mid_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Height of the capsule mesh from the center point. get_mid_height :: (CapsuleMesh :< cls, Object :< cls) => cls -> IO Float get_mid_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleMesh_get_mid_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleMesh "get_mid_height" '[] (IO Float) where nodeMethod = Godot.Core.CapsuleMesh.get_mid_height {-# NOINLINE bindCapsuleMesh_get_radial_segments #-} -- | Number of radial segments on the capsule mesh. bindCapsuleMesh_get_radial_segments :: MethodBind bindCapsuleMesh_get_radial_segments = unsafePerformIO $ withCString "CapsuleMesh" $ \ clsNamePtr -> withCString "get_radial_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of radial segments on the capsule mesh. get_radial_segments :: (CapsuleMesh :< cls, Object :< cls) => cls -> IO Int get_radial_segments cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleMesh_get_radial_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleMesh "get_radial_segments" '[] (IO Int) where nodeMethod = Godot.Core.CapsuleMesh.get_radial_segments {-# NOINLINE bindCapsuleMesh_get_radius #-} -- | Radius of the capsule mesh. bindCapsuleMesh_get_radius :: MethodBind bindCapsuleMesh_get_radius = unsafePerformIO $ withCString "CapsuleMesh" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Radius of the capsule mesh. get_radius :: (CapsuleMesh :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleMesh_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleMesh "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.CapsuleMesh.get_radius {-# NOINLINE bindCapsuleMesh_get_rings #-} -- | Number of rings along the height of the capsule. bindCapsuleMesh_get_rings :: MethodBind bindCapsuleMesh_get_rings = unsafePerformIO $ withCString "CapsuleMesh" $ \ clsNamePtr -> withCString "get_rings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of rings along the height of the capsule. get_rings :: (CapsuleMesh :< cls, Object :< cls) => cls -> IO Int get_rings cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleMesh_get_rings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleMesh "get_rings" '[] (IO Int) where nodeMethod = Godot.Core.CapsuleMesh.get_rings {-# NOINLINE bindCapsuleMesh_set_mid_height #-} -- | Height of the capsule mesh from the center point. bindCapsuleMesh_set_mid_height :: MethodBind bindCapsuleMesh_set_mid_height = unsafePerformIO $ withCString "CapsuleMesh" $ \ clsNamePtr -> withCString "set_mid_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Height of the capsule mesh from the center point. set_mid_height :: (CapsuleMesh :< cls, Object :< cls) => cls -> Float -> IO () set_mid_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleMesh_set_mid_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleMesh "set_mid_height" '[Float] (IO ()) where nodeMethod = Godot.Core.CapsuleMesh.set_mid_height {-# NOINLINE bindCapsuleMesh_set_radial_segments #-} -- | Number of radial segments on the capsule mesh. bindCapsuleMesh_set_radial_segments :: MethodBind bindCapsuleMesh_set_radial_segments = unsafePerformIO $ withCString "CapsuleMesh" $ \ clsNamePtr -> withCString "set_radial_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of radial segments on the capsule mesh. set_radial_segments :: (CapsuleMesh :< cls, Object :< cls) => cls -> Int -> IO () set_radial_segments cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleMesh_set_radial_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleMesh "set_radial_segments" '[Int] (IO ()) where nodeMethod = Godot.Core.CapsuleMesh.set_radial_segments {-# NOINLINE bindCapsuleMesh_set_radius #-} -- | Radius of the capsule mesh. bindCapsuleMesh_set_radius :: MethodBind bindCapsuleMesh_set_radius = unsafePerformIO $ withCString "CapsuleMesh" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Radius of the capsule mesh. set_radius :: (CapsuleMesh :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleMesh_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleMesh "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CapsuleMesh.set_radius {-# NOINLINE bindCapsuleMesh_set_rings #-} -- | Number of rings along the height of the capsule. bindCapsuleMesh_set_rings :: MethodBind bindCapsuleMesh_set_rings = unsafePerformIO $ withCString "CapsuleMesh" $ \ clsNamePtr -> withCString "set_rings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of rings along the height of the capsule. set_rings :: (CapsuleMesh :< cls, Object :< cls) => cls -> Int -> IO () set_rings cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleMesh_set_rings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleMesh "set_rings" '[Int] (IO ()) where nodeMethod = Godot.Core.CapsuleMesh.set_rings ================================================ FILE: src/Godot/Core/CapsuleShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CapsuleShape (Godot.Core.CapsuleShape.get_height, Godot.Core.CapsuleShape.get_radius, Godot.Core.CapsuleShape.set_height, Godot.Core.CapsuleShape.set_radius) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty CapsuleShape "height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty CapsuleShape "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) {-# NOINLINE bindCapsuleShape_get_height #-} -- | The capsule's height. bindCapsuleShape_get_height :: MethodBind bindCapsuleShape_get_height = unsafePerformIO $ withCString "CapsuleShape" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The capsule's height. get_height :: (CapsuleShape :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleShape_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleShape "get_height" '[] (IO Float) where nodeMethod = Godot.Core.CapsuleShape.get_height {-# NOINLINE bindCapsuleShape_get_radius #-} -- | The capsule's radius. bindCapsuleShape_get_radius :: MethodBind bindCapsuleShape_get_radius = unsafePerformIO $ withCString "CapsuleShape" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The capsule's radius. get_radius :: (CapsuleShape :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleShape_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleShape "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.CapsuleShape.get_radius {-# NOINLINE bindCapsuleShape_set_height #-} -- | The capsule's height. bindCapsuleShape_set_height :: MethodBind bindCapsuleShape_set_height = unsafePerformIO $ withCString "CapsuleShape" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The capsule's height. set_height :: (CapsuleShape :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleShape_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleShape "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.CapsuleShape.set_height {-# NOINLINE bindCapsuleShape_set_radius #-} -- | The capsule's radius. bindCapsuleShape_set_radius :: MethodBind bindCapsuleShape_set_radius = unsafePerformIO $ withCString "CapsuleShape" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The capsule's radius. set_radius :: (CapsuleShape :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleShape_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleShape "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CapsuleShape.set_radius ================================================ FILE: src/Godot/Core/CapsuleShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CapsuleShape2D (Godot.Core.CapsuleShape2D.get_height, Godot.Core.CapsuleShape2D.get_radius, Godot.Core.CapsuleShape2D.set_height, Godot.Core.CapsuleShape2D.set_radius) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape2D() instance NodeProperty CapsuleShape2D "height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty CapsuleShape2D "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) {-# NOINLINE bindCapsuleShape2D_get_height #-} -- | The capsule's height. bindCapsuleShape2D_get_height :: MethodBind bindCapsuleShape2D_get_height = unsafePerformIO $ withCString "CapsuleShape2D" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The capsule's height. get_height :: (CapsuleShape2D :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleShape2D_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleShape2D "get_height" '[] (IO Float) where nodeMethod = Godot.Core.CapsuleShape2D.get_height {-# NOINLINE bindCapsuleShape2D_get_radius #-} -- | The capsule's radius. bindCapsuleShape2D_get_radius :: MethodBind bindCapsuleShape2D_get_radius = unsafePerformIO $ withCString "CapsuleShape2D" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The capsule's radius. get_radius :: (CapsuleShape2D :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleShape2D_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleShape2D "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.CapsuleShape2D.get_radius {-# NOINLINE bindCapsuleShape2D_set_height #-} -- | The capsule's height. bindCapsuleShape2D_set_height :: MethodBind bindCapsuleShape2D_set_height = unsafePerformIO $ withCString "CapsuleShape2D" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The capsule's height. set_height :: (CapsuleShape2D :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleShape2D_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleShape2D "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.CapsuleShape2D.set_height {-# NOINLINE bindCapsuleShape2D_set_radius #-} -- | The capsule's radius. bindCapsuleShape2D_set_radius :: MethodBind bindCapsuleShape2D_set_radius = unsafePerformIO $ withCString "CapsuleShape2D" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The capsule's radius. set_radius :: (CapsuleShape2D :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCapsuleShape2D_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CapsuleShape2D "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CapsuleShape2D.set_radius ================================================ FILE: src/Godot/Core/CenterContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CenterContainer (Godot.Core.CenterContainer.is_using_top_left, Godot.Core.CenterContainer.set_use_top_left) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() instance NodeProperty CenterContainer "use_top_left" Bool 'False where nodeProperty = (is_using_top_left, wrapDroppingSetter set_use_top_left, Nothing) {-# NOINLINE bindCenterContainer_is_using_top_left #-} -- | If @true@, centers children relative to the @CenterContainer@'s top left corner. bindCenterContainer_is_using_top_left :: MethodBind bindCenterContainer_is_using_top_left = unsafePerformIO $ withCString "CenterContainer" $ \ clsNamePtr -> withCString "is_using_top_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, centers children relative to the @CenterContainer@'s top left corner. is_using_top_left :: (CenterContainer :< cls, Object :< cls) => cls -> IO Bool is_using_top_left cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCenterContainer_is_using_top_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CenterContainer "is_using_top_left" '[] (IO Bool) where nodeMethod = Godot.Core.CenterContainer.is_using_top_left {-# NOINLINE bindCenterContainer_set_use_top_left #-} -- | If @true@, centers children relative to the @CenterContainer@'s top left corner. bindCenterContainer_set_use_top_left :: MethodBind bindCenterContainer_set_use_top_left = unsafePerformIO $ withCString "CenterContainer" $ \ clsNamePtr -> withCString "set_use_top_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, centers children relative to the @CenterContainer@'s top left corner. set_use_top_left :: (CenterContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_use_top_left cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCenterContainer_set_use_top_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CenterContainer "set_use_top_left" '[Bool] (IO ()) where nodeMethod = Godot.Core.CenterContainer.set_use_top_left ================================================ FILE: src/Godot/Core/CharFXTransform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CharFXTransform (Godot.Core.CharFXTransform.get_absolute_index, Godot.Core.CharFXTransform.get_character, Godot.Core.CharFXTransform.get_color, Godot.Core.CharFXTransform.get_elapsed_time, Godot.Core.CharFXTransform.get_environment, Godot.Core.CharFXTransform.get_offset, Godot.Core.CharFXTransform.get_relative_index, Godot.Core.CharFXTransform.is_visible, Godot.Core.CharFXTransform.set_absolute_index, Godot.Core.CharFXTransform.set_character, Godot.Core.CharFXTransform.set_color, Godot.Core.CharFXTransform.set_elapsed_time, Godot.Core.CharFXTransform.set_environment, Godot.Core.CharFXTransform.set_offset, Godot.Core.CharFXTransform.set_relative_index, Godot.Core.CharFXTransform.set_visibility) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty CharFXTransform "absolute_index" Int 'False where nodeProperty = (get_absolute_index, wrapDroppingSetter set_absolute_index, Nothing) instance NodeProperty CharFXTransform "character" Int 'False where nodeProperty = (get_character, wrapDroppingSetter set_character, Nothing) instance NodeProperty CharFXTransform "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) instance NodeProperty CharFXTransform "elapsed_time" Float 'False where nodeProperty = (get_elapsed_time, wrapDroppingSetter set_elapsed_time, Nothing) instance NodeProperty CharFXTransform "env" Dictionary 'False where nodeProperty = (get_environment, wrapDroppingSetter set_environment, Nothing) instance NodeProperty CharFXTransform "offset" Vector2 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty CharFXTransform "relative_index" Int 'False where nodeProperty = (get_relative_index, wrapDroppingSetter set_relative_index, Nothing) instance NodeProperty CharFXTransform "visible" Bool 'False where nodeProperty = (is_visible, wrapDroppingSetter set_visibility, Nothing) {-# NOINLINE bindCharFXTransform_get_absolute_index #-} -- | The index of the current character (starting from 0). Setting this property won't affect drawing. bindCharFXTransform_get_absolute_index :: MethodBind bindCharFXTransform_get_absolute_index = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "get_absolute_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The index of the current character (starting from 0). Setting this property won't affect drawing. get_absolute_index :: (CharFXTransform :< cls, Object :< cls) => cls -> IO Int get_absolute_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_get_absolute_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "get_absolute_index" '[] (IO Int) where nodeMethod = Godot.Core.CharFXTransform.get_absolute_index {-# NOINLINE bindCharFXTransform_get_character #-} -- | The Unicode codepoint the character will use. This only affects non-whitespace characters. @method @GDScript.ord@ can be useful here. For example, the following will replace all characters with asterisks: -- -- @ -- -- # `char_fx` is the CharFXTransform parameter from `_process_custom_fx()`. -- # See the RichTextEffect documentation for details. -- char_fx.character = ord("*") -- -- @ bindCharFXTransform_get_character :: MethodBind bindCharFXTransform_get_character = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "get_character" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Unicode codepoint the character will use. This only affects non-whitespace characters. @method @GDScript.ord@ can be useful here. For example, the following will replace all characters with asterisks: -- -- @ -- -- # `char_fx` is the CharFXTransform parameter from `_process_custom_fx()`. -- # See the RichTextEffect documentation for details. -- char_fx.character = ord("*") -- -- @ get_character :: (CharFXTransform :< cls, Object :< cls) => cls -> IO Int get_character cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_get_character (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "get_character" '[] (IO Int) where nodeMethod = Godot.Core.CharFXTransform.get_character {-# NOINLINE bindCharFXTransform_get_color #-} -- | The color the character will be drawn with. bindCharFXTransform_get_color :: MethodBind bindCharFXTransform_get_color = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color the character will be drawn with. get_color :: (CharFXTransform :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "get_color" '[] (IO Color) where nodeMethod = Godot.Core.CharFXTransform.get_color {-# NOINLINE bindCharFXTransform_get_elapsed_time #-} -- | The time elapsed since the @RichTextLabel@ was added to the scene tree (in seconds). Time stops when the project is paused, unless the @RichTextLabel@'s @Node.pause_mode@ is set to @Node.PAUSE_MODE_PROCESS@. -- __Note:__ Time still passes while the @RichTextLabel@ is hidden. bindCharFXTransform_get_elapsed_time :: MethodBind bindCharFXTransform_get_elapsed_time = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "get_elapsed_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The time elapsed since the @RichTextLabel@ was added to the scene tree (in seconds). Time stops when the project is paused, unless the @RichTextLabel@'s @Node.pause_mode@ is set to @Node.PAUSE_MODE_PROCESS@. -- __Note:__ Time still passes while the @RichTextLabel@ is hidden. get_elapsed_time :: (CharFXTransform :< cls, Object :< cls) => cls -> IO Float get_elapsed_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_get_elapsed_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "get_elapsed_time" '[] (IO Float) where nodeMethod = Godot.Core.CharFXTransform.get_elapsed_time {-# NOINLINE bindCharFXTransform_get_environment #-} -- | Contains the arguments passed in the opening BBCode tag. By default, arguments are strings; if their contents match a type such as @bool@, @int@ or @float@, they will be converted automatically. Color codes in the form @#rrggbb@ or @#rgb@ will be converted to an opaque @Color@. String arguments may not contain spaces, even if they're quoted. If present, quotes will also be present in the final string. -- For example, the opening BBCode tag @@example foo=hello bar=true baz=42 color=#ffffff@@ will map to the following @Dictionary@: -- -- @ -- -- {"foo": "hello", "bar": true, "baz": 42, "color": Color(1, 1, 1, 1)} -- -- @ bindCharFXTransform_get_environment :: MethodBind bindCharFXTransform_get_environment = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "get_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Contains the arguments passed in the opening BBCode tag. By default, arguments are strings; if their contents match a type such as @bool@, @int@ or @float@, they will be converted automatically. Color codes in the form @#rrggbb@ or @#rgb@ will be converted to an opaque @Color@. String arguments may not contain spaces, even if they're quoted. If present, quotes will also be present in the final string. -- For example, the opening BBCode tag @@example foo=hello bar=true baz=42 color=#ffffff@@ will map to the following @Dictionary@: -- -- @ -- -- {"foo": "hello", "bar": true, "baz": 42, "color": Color(1, 1, 1, 1)} -- -- @ get_environment :: (CharFXTransform :< cls, Object :< cls) => cls -> IO Dictionary get_environment cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_get_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "get_environment" '[] (IO Dictionary) where nodeMethod = Godot.Core.CharFXTransform.get_environment {-# NOINLINE bindCharFXTransform_get_offset #-} -- | The position offset the character will be drawn with (in pixels). bindCharFXTransform_get_offset :: MethodBind bindCharFXTransform_get_offset = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The position offset the character will be drawn with (in pixels). get_offset :: (CharFXTransform :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.CharFXTransform.get_offset {-# NOINLINE bindCharFXTransform_get_relative_index #-} -- | The index of the current character (starting from 0). Setting this property won't affect drawing. bindCharFXTransform_get_relative_index :: MethodBind bindCharFXTransform_get_relative_index = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "get_relative_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The index of the current character (starting from 0). Setting this property won't affect drawing. get_relative_index :: (CharFXTransform :< cls, Object :< cls) => cls -> IO Int get_relative_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_get_relative_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "get_relative_index" '[] (IO Int) where nodeMethod = Godot.Core.CharFXTransform.get_relative_index {-# NOINLINE bindCharFXTransform_is_visible #-} -- | If @true@, the character will be drawn. If @false@, the character will be hidden. Characters around hidden characters will reflow to take the space of hidden characters. If this is not desired, set their @color@ to @Color(1, 1, 1, 0)@ instead. bindCharFXTransform_is_visible :: MethodBind bindCharFXTransform_is_visible = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "is_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the character will be drawn. If @false@, the character will be hidden. Characters around hidden characters will reflow to take the space of hidden characters. If this is not desired, set their @color@ to @Color(1, 1, 1, 0)@ instead. is_visible :: (CharFXTransform :< cls, Object :< cls) => cls -> IO Bool is_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_is_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "is_visible" '[] (IO Bool) where nodeMethod = Godot.Core.CharFXTransform.is_visible {-# NOINLINE bindCharFXTransform_set_absolute_index #-} -- | The index of the current character (starting from 0). Setting this property won't affect drawing. bindCharFXTransform_set_absolute_index :: MethodBind bindCharFXTransform_set_absolute_index = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "set_absolute_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The index of the current character (starting from 0). Setting this property won't affect drawing. set_absolute_index :: (CharFXTransform :< cls, Object :< cls) => cls -> Int -> IO () set_absolute_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_set_absolute_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "set_absolute_index" '[Int] (IO ()) where nodeMethod = Godot.Core.CharFXTransform.set_absolute_index {-# NOINLINE bindCharFXTransform_set_character #-} -- | The Unicode codepoint the character will use. This only affects non-whitespace characters. @method @GDScript.ord@ can be useful here. For example, the following will replace all characters with asterisks: -- -- @ -- -- # `char_fx` is the CharFXTransform parameter from `_process_custom_fx()`. -- # See the RichTextEffect documentation for details. -- char_fx.character = ord("*") -- -- @ bindCharFXTransform_set_character :: MethodBind bindCharFXTransform_set_character = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "set_character" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Unicode codepoint the character will use. This only affects non-whitespace characters. @method @GDScript.ord@ can be useful here. For example, the following will replace all characters with asterisks: -- -- @ -- -- # `char_fx` is the CharFXTransform parameter from `_process_custom_fx()`. -- # See the RichTextEffect documentation for details. -- char_fx.character = ord("*") -- -- @ set_character :: (CharFXTransform :< cls, Object :< cls) => cls -> Int -> IO () set_character cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_set_character (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "set_character" '[Int] (IO ()) where nodeMethod = Godot.Core.CharFXTransform.set_character {-# NOINLINE bindCharFXTransform_set_color #-} -- | The color the character will be drawn with. bindCharFXTransform_set_color :: MethodBind bindCharFXTransform_set_color = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color the character will be drawn with. set_color :: (CharFXTransform :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.CharFXTransform.set_color {-# NOINLINE bindCharFXTransform_set_elapsed_time #-} -- | The time elapsed since the @RichTextLabel@ was added to the scene tree (in seconds). Time stops when the project is paused, unless the @RichTextLabel@'s @Node.pause_mode@ is set to @Node.PAUSE_MODE_PROCESS@. -- __Note:__ Time still passes while the @RichTextLabel@ is hidden. bindCharFXTransform_set_elapsed_time :: MethodBind bindCharFXTransform_set_elapsed_time = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "set_elapsed_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The time elapsed since the @RichTextLabel@ was added to the scene tree (in seconds). Time stops when the project is paused, unless the @RichTextLabel@'s @Node.pause_mode@ is set to @Node.PAUSE_MODE_PROCESS@. -- __Note:__ Time still passes while the @RichTextLabel@ is hidden. set_elapsed_time :: (CharFXTransform :< cls, Object :< cls) => cls -> Float -> IO () set_elapsed_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_set_elapsed_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "set_elapsed_time" '[Float] (IO ()) where nodeMethod = Godot.Core.CharFXTransform.set_elapsed_time {-# NOINLINE bindCharFXTransform_set_environment #-} -- | Contains the arguments passed in the opening BBCode tag. By default, arguments are strings; if their contents match a type such as @bool@, @int@ or @float@, they will be converted automatically. Color codes in the form @#rrggbb@ or @#rgb@ will be converted to an opaque @Color@. String arguments may not contain spaces, even if they're quoted. If present, quotes will also be present in the final string. -- For example, the opening BBCode tag @@example foo=hello bar=true baz=42 color=#ffffff@@ will map to the following @Dictionary@: -- -- @ -- -- {"foo": "hello", "bar": true, "baz": 42, "color": Color(1, 1, 1, 1)} -- -- @ bindCharFXTransform_set_environment :: MethodBind bindCharFXTransform_set_environment = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "set_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Contains the arguments passed in the opening BBCode tag. By default, arguments are strings; if their contents match a type such as @bool@, @int@ or @float@, they will be converted automatically. Color codes in the form @#rrggbb@ or @#rgb@ will be converted to an opaque @Color@. String arguments may not contain spaces, even if they're quoted. If present, quotes will also be present in the final string. -- For example, the opening BBCode tag @@example foo=hello bar=true baz=42 color=#ffffff@@ will map to the following @Dictionary@: -- -- @ -- -- {"foo": "hello", "bar": true, "baz": 42, "color": Color(1, 1, 1, 1)} -- -- @ set_environment :: (CharFXTransform :< cls, Object :< cls) => cls -> Dictionary -> IO () set_environment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_set_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "set_environment" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.CharFXTransform.set_environment {-# NOINLINE bindCharFXTransform_set_offset #-} -- | The position offset the character will be drawn with (in pixels). bindCharFXTransform_set_offset :: MethodBind bindCharFXTransform_set_offset = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The position offset the character will be drawn with (in pixels). set_offset :: (CharFXTransform :< cls, Object :< cls) => cls -> Vector2 -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "set_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.CharFXTransform.set_offset {-# NOINLINE bindCharFXTransform_set_relative_index #-} -- | The index of the current character (starting from 0). Setting this property won't affect drawing. bindCharFXTransform_set_relative_index :: MethodBind bindCharFXTransform_set_relative_index = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "set_relative_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The index of the current character (starting from 0). Setting this property won't affect drawing. set_relative_index :: (CharFXTransform :< cls, Object :< cls) => cls -> Int -> IO () set_relative_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_set_relative_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "set_relative_index" '[Int] (IO ()) where nodeMethod = Godot.Core.CharFXTransform.set_relative_index {-# NOINLINE bindCharFXTransform_set_visibility #-} -- | If @true@, the character will be drawn. If @false@, the character will be hidden. Characters around hidden characters will reflow to take the space of hidden characters. If this is not desired, set their @color@ to @Color(1, 1, 1, 0)@ instead. bindCharFXTransform_set_visibility :: MethodBind bindCharFXTransform_set_visibility = unsafePerformIO $ withCString "CharFXTransform" $ \ clsNamePtr -> withCString "set_visibility" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the character will be drawn. If @false@, the character will be hidden. Characters around hidden characters will reflow to take the space of hidden characters. If this is not desired, set their @color@ to @Color(1, 1, 1, 0)@ instead. set_visibility :: (CharFXTransform :< cls, Object :< cls) => cls -> Bool -> IO () set_visibility cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCharFXTransform_set_visibility (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CharFXTransform "set_visibility" '[Bool] (IO ()) where nodeMethod = Godot.Core.CharFXTransform.set_visibility ================================================ FILE: src/Godot/Core/CheckBox.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CheckBox () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Button() ================================================ FILE: src/Godot/Core/CheckButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CheckButton () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Button() ================================================ FILE: src/Godot/Core/CircleShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CircleShape2D (Godot.Core.CircleShape2D.get_radius, Godot.Core.CircleShape2D.set_radius) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape2D() instance NodeProperty CircleShape2D "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) {-# NOINLINE bindCircleShape2D_get_radius #-} -- | The circle's radius. bindCircleShape2D_get_radius :: MethodBind bindCircleShape2D_get_radius = unsafePerformIO $ withCString "CircleShape2D" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The circle's radius. get_radius :: (CircleShape2D :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCircleShape2D_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CircleShape2D "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.CircleShape2D.get_radius {-# NOINLINE bindCircleShape2D_set_radius #-} -- | The circle's radius. bindCircleShape2D_set_radius :: MethodBind bindCircleShape2D_set_radius = unsafePerformIO $ withCString "CircleShape2D" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The circle's radius. set_radius :: (CircleShape2D :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCircleShape2D_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CircleShape2D "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CircleShape2D.set_radius ================================================ FILE: src/Godot/Core/ClassDB.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ClassDB (Godot.Core.ClassDB.can_instance, Godot.Core.ClassDB.class_exists, Godot.Core.ClassDB.class_get_category, Godot.Core.ClassDB.class_get_integer_constant, Godot.Core.ClassDB.class_get_integer_constant_list, Godot.Core.ClassDB.class_get_method_list, Godot.Core.ClassDB.class_get_property, Godot.Core.ClassDB.class_get_property_list, Godot.Core.ClassDB.class_get_signal, Godot.Core.ClassDB.class_get_signal_list, Godot.Core.ClassDB.class_has_integer_constant, Godot.Core.ClassDB.class_has_method, Godot.Core.ClassDB.class_has_signal, Godot.Core.ClassDB.class_set_property, Godot.Core.ClassDB.get_class_list, Godot.Core.ClassDB.get_inheriters_from_class, Godot.Core.ClassDB.get_parent_class, Godot.Core.ClassDB.instance', Godot.Core.ClassDB.is_class_enabled, Godot.Core.ClassDB.is_parent_class) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindClassDB_can_instance #-} -- | Returns @true@ if you can instance objects from the specified @class@, @false@ in other case. bindClassDB_can_instance :: MethodBind bindClassDB_can_instance = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "can_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if you can instance objects from the specified @class@, @false@ in other case. can_instance :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> IO Bool can_instance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_can_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "can_instance" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ClassDB.can_instance {-# NOINLINE bindClassDB_class_exists #-} -- | Returns whether the specified @class@ is available or not. bindClassDB_class_exists :: MethodBind bindClassDB_class_exists = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_exists" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the specified @class@ is available or not. class_exists :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> IO Bool class_exists cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_exists (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_exists" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ClassDB.class_exists {-# NOINLINE bindClassDB_class_get_category #-} -- | Returns a category associated with the class for use in documentation and the Asset Library. Debug mode required. bindClassDB_class_get_category :: MethodBind bindClassDB_class_get_category = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_get_category" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a category associated with the class for use in documentation and the Asset Library. Debug mode required. class_get_category :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> IO GodotString class_get_category cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_get_category (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_get_category" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.ClassDB.class_get_category {-# NOINLINE bindClassDB_class_get_integer_constant #-} -- | Returns the value of the integer constant @name@ of @class@ or its ancestry. Always returns 0 when the constant could not be found. bindClassDB_class_get_integer_constant :: MethodBind bindClassDB_class_get_integer_constant = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_get_integer_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the integer constant @name@ of @class@ or its ancestry. Always returns 0 when the constant could not be found. class_get_integer_constant :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int class_get_integer_constant cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_get_integer_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_get_integer_constant" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.ClassDB.class_get_integer_constant {-# NOINLINE bindClassDB_class_get_integer_constant_list #-} -- | Returns an array with the names all the integer constants of @class@ or its ancestry. bindClassDB_class_get_integer_constant_list :: MethodBind bindClassDB_class_get_integer_constant_list = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_get_integer_constant_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with the names all the integer constants of @class@ or its ancestry. class_get_integer_constant_list :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO PoolStringArray class_get_integer_constant_list cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_get_integer_constant_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_get_integer_constant_list" '[GodotString, Maybe Bool] (IO PoolStringArray) where nodeMethod = Godot.Core.ClassDB.class_get_integer_constant_list {-# NOINLINE bindClassDB_class_get_method_list #-} -- | Returns an array with all the methods of @class@ or its ancestry if @no_inheritance@ is @false@. Every element of the array is a @Dictionary@ with the following keys: @args@, @default_args@, @flags@, @id@, @name@, @return: (class_name, hint, hint_string, name, type, usage)@. bindClassDB_class_get_method_list :: MethodBind bindClassDB_class_get_method_list = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_get_method_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with all the methods of @class@ or its ancestry if @no_inheritance@ is @false@. Every element of the array is a @Dictionary@ with the following keys: @args@, @default_args@, @flags@, @id@, @name@, @return: (class_name, hint, hint_string, name, type, usage)@. class_get_method_list :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO Array class_get_method_list cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_get_method_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_get_method_list" '[GodotString, Maybe Bool] (IO Array) where nodeMethod = Godot.Core.ClassDB.class_get_method_list {-# NOINLINE bindClassDB_class_get_property #-} -- | Returns the value of @property@ of @class@ or its ancestry. bindClassDB_class_get_property :: MethodBind bindClassDB_class_get_property = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_get_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of @property@ of @class@ or its ancestry. class_get_property :: (ClassDB :< cls, Object :< cls) => cls -> Object -> GodotString -> IO GodotVariant class_get_property cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_get_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_get_property" '[Object, GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.ClassDB.class_get_property {-# NOINLINE bindClassDB_class_get_property_list #-} -- | Returns an array with all the properties of @class@ or its ancestry if @no_inheritance@ is @false@. bindClassDB_class_get_property_list :: MethodBind bindClassDB_class_get_property_list = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_get_property_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with all the properties of @class@ or its ancestry if @no_inheritance@ is @false@. class_get_property_list :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO Array class_get_property_list cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_get_property_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_get_property_list" '[GodotString, Maybe Bool] (IO Array) where nodeMethod = Godot.Core.ClassDB.class_get_property_list {-# NOINLINE bindClassDB_class_get_signal #-} -- | Returns the @signal@ data of @class@ or its ancestry. The returned value is a @Dictionary@ with the following keys: @args@, @default_args@, @flags@, @id@, @name@, @return: (class_name, hint, hint_string, name, type, usage)@. bindClassDB_class_get_signal :: MethodBind bindClassDB_class_get_signal = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_get_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @signal@ data of @class@ or its ancestry. The returned value is a @Dictionary@ with the following keys: @args@, @default_args@, @flags@, @id@, @name@, @return: (class_name, hint, hint_string, name, type, usage)@. class_get_signal :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Dictionary class_get_signal cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_get_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_get_signal" '[GodotString, GodotString] (IO Dictionary) where nodeMethod = Godot.Core.ClassDB.class_get_signal {-# NOINLINE bindClassDB_class_get_signal_list #-} -- | Returns an array with all the signals of @class@ or its ancestry if @no_inheritance@ is @false@. Every element of the array is a @Dictionary@ as described in @method class_get_signal@. bindClassDB_class_get_signal_list :: MethodBind bindClassDB_class_get_signal_list = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_get_signal_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with all the signals of @class@ or its ancestry if @no_inheritance@ is @false@. Every element of the array is a @Dictionary@ as described in @method class_get_signal@. class_get_signal_list :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO Array class_get_signal_list cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_get_signal_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_get_signal_list" '[GodotString, Maybe Bool] (IO Array) where nodeMethod = Godot.Core.ClassDB.class_get_signal_list {-# NOINLINE bindClassDB_class_has_integer_constant #-} -- | Returns whether @class@ or its ancestry has an integer constant called @name@ or not. bindClassDB_class_has_integer_constant :: MethodBind bindClassDB_class_has_integer_constant = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_has_integer_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether @class@ or its ancestry has an integer constant called @name@ or not. class_has_integer_constant :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool class_has_integer_constant cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_has_integer_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_has_integer_constant" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.ClassDB.class_has_integer_constant {-# NOINLINE bindClassDB_class_has_method #-} -- | Returns whether @class@ (or its ancestry if @no_inheritance@ is @false@) has a method called @method@ or not. bindClassDB_class_has_method :: MethodBind bindClassDB_class_has_method = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_has_method" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether @class@ (or its ancestry if @no_inheritance@ is @false@) has a method called @method@ or not. class_has_method :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Maybe Bool -> IO Bool class_has_method cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_has_method (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_has_method" '[GodotString, GodotString, Maybe Bool] (IO Bool) where nodeMethod = Godot.Core.ClassDB.class_has_method {-# NOINLINE bindClassDB_class_has_signal #-} -- | Returns whether @class@ or its ancestry has a signal called @signal@ or not. bindClassDB_class_has_signal :: MethodBind bindClassDB_class_has_signal = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_has_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether @class@ or its ancestry has a signal called @signal@ or not. class_has_signal :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool class_has_signal cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_has_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_has_signal" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.ClassDB.class_has_signal {-# NOINLINE bindClassDB_class_set_property #-} -- | Sets @property@ value of @class@ to @value@. bindClassDB_class_set_property :: MethodBind bindClassDB_class_set_property = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "class_set_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets @property@ value of @class@ to @value@. class_set_property :: (ClassDB :< cls, Object :< cls) => cls -> Object -> GodotString -> GodotVariant -> IO Int class_set_property cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_class_set_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "class_set_property" '[Object, GodotString, GodotVariant] (IO Int) where nodeMethod = Godot.Core.ClassDB.class_set_property {-# NOINLINE bindClassDB_get_class_list #-} -- | Returns the names of all the classes available. bindClassDB_get_class_list :: MethodBind bindClassDB_get_class_list = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "get_class_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the names of all the classes available. get_class_list :: (ClassDB :< cls, Object :< cls) => cls -> IO PoolStringArray get_class_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_get_class_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "get_class_list" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.ClassDB.get_class_list {-# NOINLINE bindClassDB_get_inheriters_from_class #-} -- | Returns the names of all the classes that directly or indirectly inherit from @class@. bindClassDB_get_inheriters_from_class :: MethodBind bindClassDB_get_inheriters_from_class = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "get_inheriters_from_class" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the names of all the classes that directly or indirectly inherit from @class@. get_inheriters_from_class :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_inheriters_from_class cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_get_inheriters_from_class (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "get_inheriters_from_class" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.ClassDB.get_inheriters_from_class {-# NOINLINE bindClassDB_get_parent_class #-} -- | Returns the parent class of @class@. bindClassDB_get_parent_class :: MethodBind bindClassDB_get_parent_class = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "get_parent_class" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parent class of @class@. get_parent_class :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_parent_class cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_get_parent_class (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "get_parent_class" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.ClassDB.get_parent_class {-# NOINLINE bindClassDB_instance' #-} -- | Creates an instance of @class@. bindClassDB_instance' :: MethodBind bindClassDB_instance' = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an instance of @class@. instance' :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant instance' cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_instance' (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "instance" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.ClassDB.instance' {-# NOINLINE bindClassDB_is_class_enabled #-} -- | Returns whether this @class@ is enabled or not. bindClassDB_is_class_enabled :: MethodBind bindClassDB_is_class_enabled = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "is_class_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether this @class@ is enabled or not. is_class_enabled :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_class_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_is_class_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "is_class_enabled" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ClassDB.is_class_enabled {-# NOINLINE bindClassDB_is_parent_class #-} -- | Returns whether @inherits@ is an ancestor of @class@ or not. bindClassDB_is_parent_class :: MethodBind bindClassDB_is_parent_class = unsafePerformIO $ withCString "_ClassDB" $ \ clsNamePtr -> withCString "is_parent_class" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether @inherits@ is an ancestor of @class@ or not. is_parent_class :: (ClassDB :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool is_parent_class cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClassDB_is_parent_class (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClassDB "is_parent_class" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.ClassDB.is_parent_class ================================================ FILE: src/Godot/Core/ClippedCamera.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ClippedCamera (Godot.Core.ClippedCamera._CLIP_PROCESS_PHYSICS, Godot.Core.ClippedCamera._CLIP_PROCESS_IDLE, Godot.Core.ClippedCamera.add_exception, Godot.Core.ClippedCamera.add_exception_rid, Godot.Core.ClippedCamera.clear_exceptions, Godot.Core.ClippedCamera.get_clip_offset, Godot.Core.ClippedCamera.get_collision_mask, Godot.Core.ClippedCamera.get_collision_mask_bit, Godot.Core.ClippedCamera.get_margin, Godot.Core.ClippedCamera.get_process_mode, Godot.Core.ClippedCamera.is_clip_to_areas_enabled, Godot.Core.ClippedCamera.is_clip_to_bodies_enabled, Godot.Core.ClippedCamera.remove_exception, Godot.Core.ClippedCamera.remove_exception_rid, Godot.Core.ClippedCamera.set_clip_to_areas, Godot.Core.ClippedCamera.set_clip_to_bodies, Godot.Core.ClippedCamera.set_collision_mask, Godot.Core.ClippedCamera.set_collision_mask_bit, Godot.Core.ClippedCamera.set_margin, Godot.Core.ClippedCamera.set_process_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Camera() _CLIP_PROCESS_PHYSICS :: Int _CLIP_PROCESS_PHYSICS = 0 _CLIP_PROCESS_IDLE :: Int _CLIP_PROCESS_IDLE = 1 instance NodeProperty ClippedCamera "clip_to_areas" Bool 'False where nodeProperty = (is_clip_to_areas_enabled, wrapDroppingSetter set_clip_to_areas, Nothing) instance NodeProperty ClippedCamera "clip_to_bodies" Bool 'False where nodeProperty = (is_clip_to_bodies_enabled, wrapDroppingSetter set_clip_to_bodies, Nothing) instance NodeProperty ClippedCamera "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty ClippedCamera "margin" Float 'False where nodeProperty = (get_margin, wrapDroppingSetter set_margin, Nothing) instance NodeProperty ClippedCamera "process_mode" Int 'False where nodeProperty = (get_process_mode, wrapDroppingSetter set_process_mode, Nothing) {-# NOINLINE bindClippedCamera_add_exception #-} -- | Adds a collision exception so the camera does not collide with the specified node. bindClippedCamera_add_exception :: MethodBind bindClippedCamera_add_exception = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "add_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a collision exception so the camera does not collide with the specified node. add_exception :: (ClippedCamera :< cls, Object :< cls) => cls -> Object -> IO () add_exception cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_add_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "add_exception" '[Object] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.add_exception {-# NOINLINE bindClippedCamera_add_exception_rid #-} -- | Adds a collision exception so the camera does not collide with the specified @RID@. bindClippedCamera_add_exception_rid :: MethodBind bindClippedCamera_add_exception_rid = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "add_exception_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a collision exception so the camera does not collide with the specified @RID@. add_exception_rid :: (ClippedCamera :< cls, Object :< cls) => cls -> Rid -> IO () add_exception_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_add_exception_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "add_exception_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.add_exception_rid {-# NOINLINE bindClippedCamera_clear_exceptions #-} -- | Removes all collision exceptions. bindClippedCamera_clear_exceptions :: MethodBind bindClippedCamera_clear_exceptions = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "clear_exceptions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all collision exceptions. clear_exceptions :: (ClippedCamera :< cls, Object :< cls) => cls -> IO () clear_exceptions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_clear_exceptions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "clear_exceptions" '[] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.clear_exceptions {-# NOINLINE bindClippedCamera_get_clip_offset #-} -- | Returns the distance the camera has been offset due to a collision. bindClippedCamera_get_clip_offset :: MethodBind bindClippedCamera_get_clip_offset = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "get_clip_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the distance the camera has been offset due to a collision. get_clip_offset :: (ClippedCamera :< cls, Object :< cls) => cls -> IO Float get_clip_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_get_clip_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "get_clip_offset" '[] (IO Float) where nodeMethod = Godot.Core.ClippedCamera.get_clip_offset {-# NOINLINE bindClippedCamera_get_collision_mask #-} -- | The camera's collision mask. Only objects in at least one collision layer matching the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindClippedCamera_get_collision_mask :: MethodBind bindClippedCamera_get_collision_mask = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's collision mask. Only objects in at least one collision layer matching the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (ClippedCamera :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.ClippedCamera.get_collision_mask {-# NOINLINE bindClippedCamera_get_collision_mask_bit #-} -- | Returns @true@ if the specified bit index is on. -- __Note:__ Bit indices range from 0-19. bindClippedCamera_get_collision_mask_bit :: MethodBind bindClippedCamera_get_collision_mask_bit = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified bit index is on. -- __Note:__ Bit indices range from 0-19. get_collision_mask_bit :: (ClippedCamera :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.ClippedCamera.get_collision_mask_bit {-# NOINLINE bindClippedCamera_get_margin #-} -- | The camera's collision margin. The camera can't get closer than this distance to a colliding object. bindClippedCamera_get_margin :: MethodBind bindClippedCamera_get_margin = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "get_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's collision margin. The camera can't get closer than this distance to a colliding object. get_margin :: (ClippedCamera :< cls, Object :< cls) => cls -> IO Float get_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_get_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "get_margin" '[] (IO Float) where nodeMethod = Godot.Core.ClippedCamera.get_margin {-# NOINLINE bindClippedCamera_get_process_mode #-} -- | The camera's process callback. See @enum ProcessMode@. bindClippedCamera_get_process_mode :: MethodBind bindClippedCamera_get_process_mode = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "get_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's process callback. See @enum ProcessMode@. get_process_mode :: (ClippedCamera :< cls, Object :< cls) => cls -> IO Int get_process_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_get_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "get_process_mode" '[] (IO Int) where nodeMethod = Godot.Core.ClippedCamera.get_process_mode {-# NOINLINE bindClippedCamera_is_clip_to_areas_enabled #-} -- | If @true@, the camera stops on contact with @Area@s. bindClippedCamera_is_clip_to_areas_enabled :: MethodBind bindClippedCamera_is_clip_to_areas_enabled = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "is_clip_to_areas_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera stops on contact with @Area@s. is_clip_to_areas_enabled :: (ClippedCamera :< cls, Object :< cls) => cls -> IO Bool is_clip_to_areas_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_is_clip_to_areas_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "is_clip_to_areas_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ClippedCamera.is_clip_to_areas_enabled {-# NOINLINE bindClippedCamera_is_clip_to_bodies_enabled #-} -- | If @true@, the camera stops on contact with @PhysicsBody@s. bindClippedCamera_is_clip_to_bodies_enabled :: MethodBind bindClippedCamera_is_clip_to_bodies_enabled = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "is_clip_to_bodies_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera stops on contact with @PhysicsBody@s. is_clip_to_bodies_enabled :: (ClippedCamera :< cls, Object :< cls) => cls -> IO Bool is_clip_to_bodies_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_is_clip_to_bodies_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "is_clip_to_bodies_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ClippedCamera.is_clip_to_bodies_enabled {-# NOINLINE bindClippedCamera_remove_exception #-} -- | Removes a collision exception with the specified node. bindClippedCamera_remove_exception :: MethodBind bindClippedCamera_remove_exception = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "remove_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a collision exception with the specified node. remove_exception :: (ClippedCamera :< cls, Object :< cls) => cls -> Object -> IO () remove_exception cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_remove_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "remove_exception" '[Object] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.remove_exception {-# NOINLINE bindClippedCamera_remove_exception_rid #-} -- | Removes a collision exception with the specified @RID@. bindClippedCamera_remove_exception_rid :: MethodBind bindClippedCamera_remove_exception_rid = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "remove_exception_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a collision exception with the specified @RID@. remove_exception_rid :: (ClippedCamera :< cls, Object :< cls) => cls -> Rid -> IO () remove_exception_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_remove_exception_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "remove_exception_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.remove_exception_rid {-# NOINLINE bindClippedCamera_set_clip_to_areas #-} -- | If @true@, the camera stops on contact with @Area@s. bindClippedCamera_set_clip_to_areas :: MethodBind bindClippedCamera_set_clip_to_areas = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "set_clip_to_areas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera stops on contact with @Area@s. set_clip_to_areas :: (ClippedCamera :< cls, Object :< cls) => cls -> Bool -> IO () set_clip_to_areas cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_set_clip_to_areas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "set_clip_to_areas" '[Bool] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.set_clip_to_areas {-# NOINLINE bindClippedCamera_set_clip_to_bodies #-} -- | If @true@, the camera stops on contact with @PhysicsBody@s. bindClippedCamera_set_clip_to_bodies :: MethodBind bindClippedCamera_set_clip_to_bodies = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "set_clip_to_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the camera stops on contact with @PhysicsBody@s. set_clip_to_bodies :: (ClippedCamera :< cls, Object :< cls) => cls -> Bool -> IO () set_clip_to_bodies cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_set_clip_to_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "set_clip_to_bodies" '[Bool] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.set_clip_to_bodies {-# NOINLINE bindClippedCamera_set_collision_mask #-} -- | The camera's collision mask. Only objects in at least one collision layer matching the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindClippedCamera_set_collision_mask :: MethodBind bindClippedCamera_set_collision_mask = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's collision mask. Only objects in at least one collision layer matching the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (ClippedCamera :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.set_collision_mask {-# NOINLINE bindClippedCamera_set_collision_mask_bit #-} -- | Sets the specified bit index to the @value@. -- __Note:__ Bit indices range from 0-19. bindClippedCamera_set_collision_mask_bit :: MethodBind bindClippedCamera_set_collision_mask_bit = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified bit index to the @value@. -- __Note:__ Bit indices range from 0-19. set_collision_mask_bit :: (ClippedCamera :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.set_collision_mask_bit {-# NOINLINE bindClippedCamera_set_margin #-} -- | The camera's collision margin. The camera can't get closer than this distance to a colliding object. bindClippedCamera_set_margin :: MethodBind bindClippedCamera_set_margin = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "set_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's collision margin. The camera can't get closer than this distance to a colliding object. set_margin :: (ClippedCamera :< cls, Object :< cls) => cls -> Float -> IO () set_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_set_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "set_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.set_margin {-# NOINLINE bindClippedCamera_set_process_mode #-} -- | The camera's process callback. See @enum ProcessMode@. bindClippedCamera_set_process_mode :: MethodBind bindClippedCamera_set_process_mode = unsafePerformIO $ withCString "ClippedCamera" $ \ clsNamePtr -> withCString "set_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The camera's process callback. See @enum ProcessMode@. set_process_mode :: (ClippedCamera :< cls, Object :< cls) => cls -> Int -> IO () set_process_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindClippedCamera_set_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ClippedCamera "set_process_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.ClippedCamera.set_process_mode ================================================ FILE: src/Godot/Core/CollisionObject.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CollisionObject (Godot.Core.CollisionObject.sig_input_event, Godot.Core.CollisionObject.sig_mouse_entered, Godot.Core.CollisionObject.sig_mouse_exited, Godot.Core.CollisionObject._input_event, Godot.Core.CollisionObject.create_shape_owner, Godot.Core.CollisionObject.get_capture_input_on_drag, Godot.Core.CollisionObject.get_rid, Godot.Core.CollisionObject.get_shape_owners, Godot.Core.CollisionObject.is_ray_pickable, Godot.Core.CollisionObject.is_shape_owner_disabled, Godot.Core.CollisionObject.remove_shape_owner, Godot.Core.CollisionObject.set_capture_input_on_drag, Godot.Core.CollisionObject.set_ray_pickable, Godot.Core.CollisionObject.shape_find_owner, Godot.Core.CollisionObject.shape_owner_add_shape, Godot.Core.CollisionObject.shape_owner_clear_shapes, Godot.Core.CollisionObject.shape_owner_get_owner, Godot.Core.CollisionObject.shape_owner_get_shape, Godot.Core.CollisionObject.shape_owner_get_shape_count, Godot.Core.CollisionObject.shape_owner_get_shape_index, Godot.Core.CollisionObject.shape_owner_get_transform, Godot.Core.CollisionObject.shape_owner_remove_shape, Godot.Core.CollisionObject.shape_owner_set_disabled, Godot.Core.CollisionObject.shape_owner_set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() -- | Emitted when @method _input_event@ receives an event. See its description for details. sig_input_event :: Godot.Internal.Dispatch.Signal CollisionObject sig_input_event = Godot.Internal.Dispatch.Signal "input_event" instance NodeSignal CollisionObject "input_event" '[Node, InputEvent, Vector3, Vector3, Int] -- | Emitted when the mouse pointer enters any of this object's shapes. sig_mouse_entered :: Godot.Internal.Dispatch.Signal CollisionObject sig_mouse_entered = Godot.Internal.Dispatch.Signal "mouse_entered" instance NodeSignal CollisionObject "mouse_entered" '[] -- | Emitted when the mouse pointer exits all this object's shapes. sig_mouse_exited :: Godot.Internal.Dispatch.Signal CollisionObject sig_mouse_exited = Godot.Internal.Dispatch.Signal "mouse_exited" instance NodeSignal CollisionObject "mouse_exited" '[] instance NodeProperty CollisionObject "input_capture_on_drag" Bool 'False where nodeProperty = (get_capture_input_on_drag, wrapDroppingSetter set_capture_input_on_drag, Nothing) instance NodeProperty CollisionObject "input_ray_pickable" Bool 'False where nodeProperty = (is_ray_pickable, wrapDroppingSetter set_ray_pickable, Nothing) {-# NOINLINE bindCollisionObject__input_event #-} -- | Accepts unhandled @InputEvent@s. @click_position@ is the clicked location in world space and @click_normal@ is the normal vector extending from the clicked surface of the @Shape@ at @shape_idx@. Connect to the @input_event@ signal to easily pick up these events. bindCollisionObject__input_event :: MethodBind bindCollisionObject__input_event = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "_input_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Accepts unhandled @InputEvent@s. @click_position@ is the clicked location in world space and @click_normal@ is the normal vector extending from the clicked surface of the @Shape@ at @shape_idx@. Connect to the @input_event@ signal to easily pick up these events. _input_event :: (CollisionObject :< cls, Object :< cls) => cls -> Object -> InputEvent -> Vector3 -> Vector3 -> Int -> IO () _input_event cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject__input_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "_input_event" '[Object, InputEvent, Vector3, Vector3, Int] (IO ()) where nodeMethod = Godot.Core.CollisionObject._input_event {-# NOINLINE bindCollisionObject_create_shape_owner #-} -- | Creates a new shape owner for the given object. Returns @owner_id@ of the new owner for future reference. bindCollisionObject_create_shape_owner :: MethodBind bindCollisionObject_create_shape_owner = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "create_shape_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new shape owner for the given object. Returns @owner_id@ of the new owner for future reference. create_shape_owner :: (CollisionObject :< cls, Object :< cls) => cls -> Object -> IO Int create_shape_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_create_shape_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "create_shape_owner" '[Object] (IO Int) where nodeMethod = Godot.Core.CollisionObject.create_shape_owner {-# NOINLINE bindCollisionObject_get_capture_input_on_drag #-} -- | If @true@, the @CollisionObject@ will continue to receive input events as the mouse is dragged across its shapes. bindCollisionObject_get_capture_input_on_drag :: MethodBind bindCollisionObject_get_capture_input_on_drag = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "get_capture_input_on_drag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @CollisionObject@ will continue to receive input events as the mouse is dragged across its shapes. get_capture_input_on_drag :: (CollisionObject :< cls, Object :< cls) => cls -> IO Bool get_capture_input_on_drag cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_get_capture_input_on_drag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "get_capture_input_on_drag" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionObject.get_capture_input_on_drag {-# NOINLINE bindCollisionObject_get_rid #-} -- | Returns the object's @RID@. bindCollisionObject_get_rid :: MethodBind bindCollisionObject_get_rid = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "get_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's @RID@. get_rid :: (CollisionObject :< cls, Object :< cls) => cls -> IO Rid get_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_get_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "get_rid" '[] (IO Rid) where nodeMethod = Godot.Core.CollisionObject.get_rid {-# NOINLINE bindCollisionObject_get_shape_owners #-} -- | Returns an @Array@ of @owner_id@ identifiers. You can use these ids in other methods that take @owner_id@ as an argument. bindCollisionObject_get_shape_owners :: MethodBind bindCollisionObject_get_shape_owners = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "get_shape_owners" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ of @owner_id@ identifiers. You can use these ids in other methods that take @owner_id@ as an argument. get_shape_owners :: (CollisionObject :< cls, Object :< cls) => cls -> IO Array get_shape_owners cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_get_shape_owners (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "get_shape_owners" '[] (IO Array) where nodeMethod = Godot.Core.CollisionObject.get_shape_owners {-# NOINLINE bindCollisionObject_is_ray_pickable #-} -- | If @true@, the @CollisionObject@'s shapes will respond to @RayCast@s. bindCollisionObject_is_ray_pickable :: MethodBind bindCollisionObject_is_ray_pickable = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "is_ray_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @CollisionObject@'s shapes will respond to @RayCast@s. is_ray_pickable :: (CollisionObject :< cls, Object :< cls) => cls -> IO Bool is_ray_pickable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_is_ray_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "is_ray_pickable" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionObject.is_ray_pickable {-# NOINLINE bindCollisionObject_is_shape_owner_disabled #-} -- | If @true@, the shape owner and its shapes are disabled. bindCollisionObject_is_shape_owner_disabled :: MethodBind bindCollisionObject_is_shape_owner_disabled = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "is_shape_owner_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the shape owner and its shapes are disabled. is_shape_owner_disabled :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> IO Bool is_shape_owner_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_is_shape_owner_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "is_shape_owner_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.CollisionObject.is_shape_owner_disabled {-# NOINLINE bindCollisionObject_remove_shape_owner #-} -- | Removes the given shape owner. bindCollisionObject_remove_shape_owner :: MethodBind bindCollisionObject_remove_shape_owner = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "remove_shape_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the given shape owner. remove_shape_owner :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> IO () remove_shape_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_remove_shape_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "remove_shape_owner" '[Int] (IO ()) where nodeMethod = Godot.Core.CollisionObject.remove_shape_owner {-# NOINLINE bindCollisionObject_set_capture_input_on_drag #-} -- | If @true@, the @CollisionObject@ will continue to receive input events as the mouse is dragged across its shapes. bindCollisionObject_set_capture_input_on_drag :: MethodBind bindCollisionObject_set_capture_input_on_drag = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "set_capture_input_on_drag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @CollisionObject@ will continue to receive input events as the mouse is dragged across its shapes. set_capture_input_on_drag :: (CollisionObject :< cls, Object :< cls) => cls -> Bool -> IO () set_capture_input_on_drag cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_set_capture_input_on_drag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "set_capture_input_on_drag" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionObject.set_capture_input_on_drag {-# NOINLINE bindCollisionObject_set_ray_pickable #-} -- | If @true@, the @CollisionObject@'s shapes will respond to @RayCast@s. bindCollisionObject_set_ray_pickable :: MethodBind bindCollisionObject_set_ray_pickable = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "set_ray_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @CollisionObject@'s shapes will respond to @RayCast@s. set_ray_pickable :: (CollisionObject :< cls, Object :< cls) => cls -> Bool -> IO () set_ray_pickable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_set_ray_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "set_ray_pickable" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionObject.set_ray_pickable {-# NOINLINE bindCollisionObject_shape_find_owner #-} -- | Returns the @owner_id@ of the given shape. bindCollisionObject_shape_find_owner :: MethodBind bindCollisionObject_shape_find_owner = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_find_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @owner_id@ of the given shape. shape_find_owner :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> IO Int shape_find_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_find_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_find_owner" '[Int] (IO Int) where nodeMethod = Godot.Core.CollisionObject.shape_find_owner {-# NOINLINE bindCollisionObject_shape_owner_add_shape #-} -- | Adds a @Shape@ to the shape owner. bindCollisionObject_shape_owner_add_shape :: MethodBind bindCollisionObject_shape_owner_add_shape = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_add_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @Shape@ to the shape owner. shape_owner_add_shape :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> Shape -> IO () shape_owner_add_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_add_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_add_shape" '[Int, Shape] (IO ()) where nodeMethod = Godot.Core.CollisionObject.shape_owner_add_shape {-# NOINLINE bindCollisionObject_shape_owner_clear_shapes #-} -- | Removes all shapes from the shape owner. bindCollisionObject_shape_owner_clear_shapes :: MethodBind bindCollisionObject_shape_owner_clear_shapes = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_clear_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all shapes from the shape owner. shape_owner_clear_shapes :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> IO () shape_owner_clear_shapes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_clear_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_clear_shapes" '[Int] (IO ()) where nodeMethod = Godot.Core.CollisionObject.shape_owner_clear_shapes {-# NOINLINE bindCollisionObject_shape_owner_get_owner #-} -- | Returns the parent object of the given shape owner. bindCollisionObject_shape_owner_get_owner :: MethodBind bindCollisionObject_shape_owner_get_owner = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_get_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parent object of the given shape owner. shape_owner_get_owner :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> IO Object shape_owner_get_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_get_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_get_owner" '[Int] (IO Object) where nodeMethod = Godot.Core.CollisionObject.shape_owner_get_owner {-# NOINLINE bindCollisionObject_shape_owner_get_shape #-} -- | Returns the @Shape@ with the given id from the given shape owner. bindCollisionObject_shape_owner_get_shape :: MethodBind bindCollisionObject_shape_owner_get_shape = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Shape@ with the given id from the given shape owner. shape_owner_get_shape :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> Int -> IO Shape shape_owner_get_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_get_shape" '[Int, Int] (IO Shape) where nodeMethod = Godot.Core.CollisionObject.shape_owner_get_shape {-# NOINLINE bindCollisionObject_shape_owner_get_shape_count #-} -- | Returns the number of shapes the given shape owner contains. bindCollisionObject_shape_owner_get_shape_count :: MethodBind bindCollisionObject_shape_owner_get_shape_count = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_get_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of shapes the given shape owner contains. shape_owner_get_shape_count :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> IO Int shape_owner_get_shape_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_get_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_get_shape_count" '[Int] (IO Int) where nodeMethod = Godot.Core.CollisionObject.shape_owner_get_shape_count {-# NOINLINE bindCollisionObject_shape_owner_get_shape_index #-} -- | Returns the child index of the @Shape@ with the given id from the given shape owner. bindCollisionObject_shape_owner_get_shape_index :: MethodBind bindCollisionObject_shape_owner_get_shape_index = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_get_shape_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the child index of the @Shape@ with the given id from the given shape owner. shape_owner_get_shape_index :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> Int -> IO Int shape_owner_get_shape_index cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_get_shape_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_get_shape_index" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.CollisionObject.shape_owner_get_shape_index {-# NOINLINE bindCollisionObject_shape_owner_get_transform #-} -- | Returns the shape owner's @Transform@. bindCollisionObject_shape_owner_get_transform :: MethodBind bindCollisionObject_shape_owner_get_transform = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shape owner's @Transform@. shape_owner_get_transform :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> IO Transform shape_owner_get_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_get_transform" '[Int] (IO Transform) where nodeMethod = Godot.Core.CollisionObject.shape_owner_get_transform {-# NOINLINE bindCollisionObject_shape_owner_remove_shape #-} -- | Removes a shape from the given shape owner. bindCollisionObject_shape_owner_remove_shape :: MethodBind bindCollisionObject_shape_owner_remove_shape = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_remove_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a shape from the given shape owner. shape_owner_remove_shape :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> Int -> IO () shape_owner_remove_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_remove_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_remove_shape" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.CollisionObject.shape_owner_remove_shape {-# NOINLINE bindCollisionObject_shape_owner_set_disabled #-} -- | If @true@, disables the given shape owner. bindCollisionObject_shape_owner_set_disabled :: MethodBind bindCollisionObject_shape_owner_set_disabled = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_set_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, disables the given shape owner. shape_owner_set_disabled :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> Bool -> IO () shape_owner_set_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_set_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_set_disabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.CollisionObject.shape_owner_set_disabled {-# NOINLINE bindCollisionObject_shape_owner_set_transform #-} -- | Sets the @Transform@ of the given shape owner. bindCollisionObject_shape_owner_set_transform :: MethodBind bindCollisionObject_shape_owner_set_transform = unsafePerformIO $ withCString "CollisionObject" $ \ clsNamePtr -> withCString "shape_owner_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform@ of the given shape owner. shape_owner_set_transform :: (CollisionObject :< cls, Object :< cls) => cls -> Int -> Transform -> IO () shape_owner_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject_shape_owner_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject "shape_owner_set_transform" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.CollisionObject.shape_owner_set_transform ================================================ FILE: src/Godot/Core/CollisionObject2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CollisionObject2D (Godot.Core.CollisionObject2D.sig_input_event, Godot.Core.CollisionObject2D.sig_mouse_entered, Godot.Core.CollisionObject2D.sig_mouse_exited, Godot.Core.CollisionObject2D._input_event, Godot.Core.CollisionObject2D.create_shape_owner, Godot.Core.CollisionObject2D.get_rid, Godot.Core.CollisionObject2D.get_shape_owner_one_way_collision_margin, Godot.Core.CollisionObject2D.get_shape_owners, Godot.Core.CollisionObject2D.is_pickable, Godot.Core.CollisionObject2D.is_shape_owner_disabled, Godot.Core.CollisionObject2D.is_shape_owner_one_way_collision_enabled, Godot.Core.CollisionObject2D.remove_shape_owner, Godot.Core.CollisionObject2D.set_pickable, Godot.Core.CollisionObject2D.shape_find_owner, Godot.Core.CollisionObject2D.shape_owner_add_shape, Godot.Core.CollisionObject2D.shape_owner_clear_shapes, Godot.Core.CollisionObject2D.shape_owner_get_owner, Godot.Core.CollisionObject2D.shape_owner_get_shape, Godot.Core.CollisionObject2D.shape_owner_get_shape_count, Godot.Core.CollisionObject2D.shape_owner_get_shape_index, Godot.Core.CollisionObject2D.shape_owner_get_transform, Godot.Core.CollisionObject2D.shape_owner_remove_shape, Godot.Core.CollisionObject2D.shape_owner_set_disabled, Godot.Core.CollisionObject2D.shape_owner_set_one_way_collision, Godot.Core.CollisionObject2D.shape_owner_set_one_way_collision_margin, Godot.Core.CollisionObject2D.shape_owner_set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() -- | Emitted when an input event occurs. Requires @input_pickable@ to be @true@ and at least one @collision_layer@ bit to be set. See @method _input_event@ for details. sig_input_event :: Godot.Internal.Dispatch.Signal CollisionObject2D sig_input_event = Godot.Internal.Dispatch.Signal "input_event" instance NodeSignal CollisionObject2D "input_event" '[Node, InputEvent, Int] -- | Emitted when the mouse pointer enters any of this object's shapes. Requires @input_pickable@ to be @true@ and at least one @collision_layer@ bit to be set. sig_mouse_entered :: Godot.Internal.Dispatch.Signal CollisionObject2D sig_mouse_entered = Godot.Internal.Dispatch.Signal "mouse_entered" instance NodeSignal CollisionObject2D "mouse_entered" '[] -- | Emitted when the mouse pointer exits all this object's shapes. Requires @input_pickable@ to be @true@ and at least one @collision_layer@ bit to be set. sig_mouse_exited :: Godot.Internal.Dispatch.Signal CollisionObject2D sig_mouse_exited = Godot.Internal.Dispatch.Signal "mouse_exited" instance NodeSignal CollisionObject2D "mouse_exited" '[] instance NodeProperty CollisionObject2D "input_pickable" Bool 'False where nodeProperty = (is_pickable, wrapDroppingSetter set_pickable, Nothing) {-# NOINLINE bindCollisionObject2D__input_event #-} -- | Accepts unhandled @InputEvent@s. Requires @input_pickable@ to be @true@. @shape_idx@ is the child index of the clicked @Shape2D@. Connect to the @input_event@ signal to easily pick up these events. bindCollisionObject2D__input_event :: MethodBind bindCollisionObject2D__input_event = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "_input_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Accepts unhandled @InputEvent@s. Requires @input_pickable@ to be @true@. @shape_idx@ is the child index of the clicked @Shape2D@. Connect to the @input_event@ signal to easily pick up these events. _input_event :: (CollisionObject2D :< cls, Object :< cls) => cls -> Object -> InputEvent -> Int -> IO () _input_event cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D__input_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "_input_event" '[Object, InputEvent, Int] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D._input_event {-# NOINLINE bindCollisionObject2D_create_shape_owner #-} -- | Creates a new shape owner for the given object. Returns @owner_id@ of the new owner for future reference. bindCollisionObject2D_create_shape_owner :: MethodBind bindCollisionObject2D_create_shape_owner = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "create_shape_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new shape owner for the given object. Returns @owner_id@ of the new owner for future reference. create_shape_owner :: (CollisionObject2D :< cls, Object :< cls) => cls -> Object -> IO Int create_shape_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_create_shape_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "create_shape_owner" '[Object] (IO Int) where nodeMethod = Godot.Core.CollisionObject2D.create_shape_owner {-# NOINLINE bindCollisionObject2D_get_rid #-} -- | Returns the object's @RID@. bindCollisionObject2D_get_rid :: MethodBind bindCollisionObject2D_get_rid = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "get_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's @RID@. get_rid :: (CollisionObject2D :< cls, Object :< cls) => cls -> IO Rid get_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_get_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "get_rid" '[] (IO Rid) where nodeMethod = Godot.Core.CollisionObject2D.get_rid {-# NOINLINE bindCollisionObject2D_get_shape_owner_one_way_collision_margin #-} -- | Returns the @one_way_collision_margin@ of the shape owner identified by given @owner_id@. bindCollisionObject2D_get_shape_owner_one_way_collision_margin :: MethodBind bindCollisionObject2D_get_shape_owner_one_way_collision_margin = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "get_shape_owner_one_way_collision_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @one_way_collision_margin@ of the shape owner identified by given @owner_id@. get_shape_owner_one_way_collision_margin :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO Float get_shape_owner_one_way_collision_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_get_shape_owner_one_way_collision_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "get_shape_owner_one_way_collision_margin" '[Int] (IO Float) where nodeMethod = Godot.Core.CollisionObject2D.get_shape_owner_one_way_collision_margin {-# NOINLINE bindCollisionObject2D_get_shape_owners #-} -- | Returns an @Array@ of @owner_id@ identifiers. You can use these ids in other methods that take @owner_id@ as an argument. bindCollisionObject2D_get_shape_owners :: MethodBind bindCollisionObject2D_get_shape_owners = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "get_shape_owners" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ of @owner_id@ identifiers. You can use these ids in other methods that take @owner_id@ as an argument. get_shape_owners :: (CollisionObject2D :< cls, Object :< cls) => cls -> IO Array get_shape_owners cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_get_shape_owners (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "get_shape_owners" '[] (IO Array) where nodeMethod = Godot.Core.CollisionObject2D.get_shape_owners {-# NOINLINE bindCollisionObject2D_is_pickable #-} -- | If @true@, this object is pickable. A pickable object can detect the mouse pointer entering/leaving, and if the mouse is inside it, report input events. Requires at least one @collision_layer@ bit to be set. bindCollisionObject2D_is_pickable :: MethodBind bindCollisionObject2D_is_pickable = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "is_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this object is pickable. A pickable object can detect the mouse pointer entering/leaving, and if the mouse is inside it, report input events. Requires at least one @collision_layer@ bit to be set. is_pickable :: (CollisionObject2D :< cls, Object :< cls) => cls -> IO Bool is_pickable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_is_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "is_pickable" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionObject2D.is_pickable {-# NOINLINE bindCollisionObject2D_is_shape_owner_disabled #-} -- | If @true@, the shape owner and its shapes are disabled. bindCollisionObject2D_is_shape_owner_disabled :: MethodBind bindCollisionObject2D_is_shape_owner_disabled = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "is_shape_owner_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the shape owner and its shapes are disabled. is_shape_owner_disabled :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO Bool is_shape_owner_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_is_shape_owner_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "is_shape_owner_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.CollisionObject2D.is_shape_owner_disabled {-# NOINLINE bindCollisionObject2D_is_shape_owner_one_way_collision_enabled #-} -- | Returns @true@ if collisions for the shape owner originating from this @CollisionObject2D@ will not be reported to collided with @CollisionObject2D@s. bindCollisionObject2D_is_shape_owner_one_way_collision_enabled :: MethodBind bindCollisionObject2D_is_shape_owner_one_way_collision_enabled = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "is_shape_owner_one_way_collision_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if collisions for the shape owner originating from this @CollisionObject2D@ will not be reported to collided with @CollisionObject2D@s. is_shape_owner_one_way_collision_enabled :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO Bool is_shape_owner_one_way_collision_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_is_shape_owner_one_way_collision_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "is_shape_owner_one_way_collision_enabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.CollisionObject2D.is_shape_owner_one_way_collision_enabled {-# NOINLINE bindCollisionObject2D_remove_shape_owner #-} -- | Removes the given shape owner. bindCollisionObject2D_remove_shape_owner :: MethodBind bindCollisionObject2D_remove_shape_owner = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "remove_shape_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the given shape owner. remove_shape_owner :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO () remove_shape_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_remove_shape_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "remove_shape_owner" '[Int] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.remove_shape_owner {-# NOINLINE bindCollisionObject2D_set_pickable #-} -- | If @true@, this object is pickable. A pickable object can detect the mouse pointer entering/leaving, and if the mouse is inside it, report input events. Requires at least one @collision_layer@ bit to be set. bindCollisionObject2D_set_pickable :: MethodBind bindCollisionObject2D_set_pickable = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "set_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this object is pickable. A pickable object can detect the mouse pointer entering/leaving, and if the mouse is inside it, report input events. Requires at least one @collision_layer@ bit to be set. set_pickable :: (CollisionObject2D :< cls, Object :< cls) => cls -> Bool -> IO () set_pickable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_set_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "set_pickable" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.set_pickable {-# NOINLINE bindCollisionObject2D_shape_find_owner #-} -- | Returns the @owner_id@ of the given shape. bindCollisionObject2D_shape_find_owner :: MethodBind bindCollisionObject2D_shape_find_owner = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_find_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @owner_id@ of the given shape. shape_find_owner :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO Int shape_find_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_find_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_find_owner" '[Int] (IO Int) where nodeMethod = Godot.Core.CollisionObject2D.shape_find_owner {-# NOINLINE bindCollisionObject2D_shape_owner_add_shape #-} -- | Adds a @Shape2D@ to the shape owner. bindCollisionObject2D_shape_owner_add_shape :: MethodBind bindCollisionObject2D_shape_owner_add_shape = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_add_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @Shape2D@ to the shape owner. shape_owner_add_shape :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> Shape2D -> IO () shape_owner_add_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_add_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_add_shape" '[Int, Shape2D] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_add_shape {-# NOINLINE bindCollisionObject2D_shape_owner_clear_shapes #-} -- | Removes all shapes from the shape owner. bindCollisionObject2D_shape_owner_clear_shapes :: MethodBind bindCollisionObject2D_shape_owner_clear_shapes = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_clear_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all shapes from the shape owner. shape_owner_clear_shapes :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO () shape_owner_clear_shapes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_clear_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_clear_shapes" '[Int] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_clear_shapes {-# NOINLINE bindCollisionObject2D_shape_owner_get_owner #-} -- | Returns the parent object of the given shape owner. bindCollisionObject2D_shape_owner_get_owner :: MethodBind bindCollisionObject2D_shape_owner_get_owner = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_get_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parent object of the given shape owner. shape_owner_get_owner :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO Object shape_owner_get_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_get_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_get_owner" '[Int] (IO Object) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_get_owner {-# NOINLINE bindCollisionObject2D_shape_owner_get_shape #-} -- | Returns the @Shape2D@ with the given id from the given shape owner. bindCollisionObject2D_shape_owner_get_shape :: MethodBind bindCollisionObject2D_shape_owner_get_shape = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Shape2D@ with the given id from the given shape owner. shape_owner_get_shape :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> Int -> IO Shape2D shape_owner_get_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_get_shape" '[Int, Int] (IO Shape2D) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_get_shape {-# NOINLINE bindCollisionObject2D_shape_owner_get_shape_count #-} -- | Returns the number of shapes the given shape owner contains. bindCollisionObject2D_shape_owner_get_shape_count :: MethodBind bindCollisionObject2D_shape_owner_get_shape_count = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_get_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of shapes the given shape owner contains. shape_owner_get_shape_count :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO Int shape_owner_get_shape_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_get_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_get_shape_count" '[Int] (IO Int) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_get_shape_count {-# NOINLINE bindCollisionObject2D_shape_owner_get_shape_index #-} -- | Returns the child index of the @Shape2D@ with the given id from the given shape owner. bindCollisionObject2D_shape_owner_get_shape_index :: MethodBind bindCollisionObject2D_shape_owner_get_shape_index = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_get_shape_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the child index of the @Shape2D@ with the given id from the given shape owner. shape_owner_get_shape_index :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> Int -> IO Int shape_owner_get_shape_index cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_get_shape_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_get_shape_index" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_get_shape_index {-# NOINLINE bindCollisionObject2D_shape_owner_get_transform #-} -- | Returns the shape owner's @Transform2D@. bindCollisionObject2D_shape_owner_get_transform :: MethodBind bindCollisionObject2D_shape_owner_get_transform = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shape owner's @Transform2D@. shape_owner_get_transform :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> IO Transform2d shape_owner_get_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_get_transform" '[Int] (IO Transform2d) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_get_transform {-# NOINLINE bindCollisionObject2D_shape_owner_remove_shape #-} -- | Removes a shape from the given shape owner. bindCollisionObject2D_shape_owner_remove_shape :: MethodBind bindCollisionObject2D_shape_owner_remove_shape = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_remove_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a shape from the given shape owner. shape_owner_remove_shape :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> Int -> IO () shape_owner_remove_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_remove_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_remove_shape" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_remove_shape {-# NOINLINE bindCollisionObject2D_shape_owner_set_disabled #-} -- | If @true@, disables the given shape owner. bindCollisionObject2D_shape_owner_set_disabled :: MethodBind bindCollisionObject2D_shape_owner_set_disabled = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_set_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, disables the given shape owner. shape_owner_set_disabled :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () shape_owner_set_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_set_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_set_disabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_set_disabled {-# NOINLINE bindCollisionObject2D_shape_owner_set_one_way_collision #-} -- | If @enable@ is @true@, collisions for the shape owner originating from this @CollisionObject2D@ will not be reported to collided with @CollisionObject2D@s. bindCollisionObject2D_shape_owner_set_one_way_collision :: MethodBind bindCollisionObject2D_shape_owner_set_one_way_collision = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_set_one_way_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @enable@ is @true@, collisions for the shape owner originating from this @CollisionObject2D@ will not be reported to collided with @CollisionObject2D@s. shape_owner_set_one_way_collision :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () shape_owner_set_one_way_collision cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_set_one_way_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_set_one_way_collision" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_set_one_way_collision {-# NOINLINE bindCollisionObject2D_shape_owner_set_one_way_collision_margin #-} -- | Sets the @one_way_collision_margin@ of the shape owner identified by given @owner_id@ to @margin@ pixels. bindCollisionObject2D_shape_owner_set_one_way_collision_margin :: MethodBind bindCollisionObject2D_shape_owner_set_one_way_collision_margin = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_set_one_way_collision_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @one_way_collision_margin@ of the shape owner identified by given @owner_id@ to @margin@ pixels. shape_owner_set_one_way_collision_margin :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> Float -> IO () shape_owner_set_one_way_collision_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_set_one_way_collision_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_set_one_way_collision_margin" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_set_one_way_collision_margin {-# NOINLINE bindCollisionObject2D_shape_owner_set_transform #-} -- | Sets the @Transform2D@ of the given shape owner. bindCollisionObject2D_shape_owner_set_transform :: MethodBind bindCollisionObject2D_shape_owner_set_transform = unsafePerformIO $ withCString "CollisionObject2D" $ \ clsNamePtr -> withCString "shape_owner_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform2D@ of the given shape owner. shape_owner_set_transform :: (CollisionObject2D :< cls, Object :< cls) => cls -> Int -> Transform2d -> IO () shape_owner_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionObject2D_shape_owner_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionObject2D "shape_owner_set_transform" '[Int, Transform2d] (IO ()) where nodeMethod = Godot.Core.CollisionObject2D.shape_owner_set_transform ================================================ FILE: src/Godot/Core/CollisionPolygon.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CollisionPolygon (Godot.Core.CollisionPolygon._is_editable_3d_polygon, Godot.Core.CollisionPolygon.get_depth, Godot.Core.CollisionPolygon.get_polygon, Godot.Core.CollisionPolygon.is_disabled, Godot.Core.CollisionPolygon.set_depth, Godot.Core.CollisionPolygon.set_disabled, Godot.Core.CollisionPolygon.set_polygon) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty CollisionPolygon "depth" Float 'False where nodeProperty = (get_depth, wrapDroppingSetter set_depth, Nothing) instance NodeProperty CollisionPolygon "disabled" Bool 'False where nodeProperty = (is_disabled, wrapDroppingSetter set_disabled, Nothing) instance NodeProperty CollisionPolygon "polygon" PoolVector2Array 'False where nodeProperty = (get_polygon, wrapDroppingSetter set_polygon, Nothing) {-# NOINLINE bindCollisionPolygon__is_editable_3d_polygon #-} bindCollisionPolygon__is_editable_3d_polygon :: MethodBind bindCollisionPolygon__is_editable_3d_polygon = unsafePerformIO $ withCString "CollisionPolygon" $ \ clsNamePtr -> withCString "_is_editable_3d_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _is_editable_3d_polygon :: (CollisionPolygon :< cls, Object :< cls) => cls -> IO Bool _is_editable_3d_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon__is_editable_3d_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon "_is_editable_3d_polygon" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionPolygon._is_editable_3d_polygon {-# NOINLINE bindCollisionPolygon_get_depth #-} -- | Length that the resulting collision extends in either direction perpendicular to its polygon. bindCollisionPolygon_get_depth :: MethodBind bindCollisionPolygon_get_depth = unsafePerformIO $ withCString "CollisionPolygon" $ \ clsNamePtr -> withCString "get_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Length that the resulting collision extends in either direction perpendicular to its polygon. get_depth :: (CollisionPolygon :< cls, Object :< cls) => cls -> IO Float get_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon_get_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon "get_depth" '[] (IO Float) where nodeMethod = Godot.Core.CollisionPolygon.get_depth {-# NOINLINE bindCollisionPolygon_get_polygon #-} -- | Array of vertices which define the polygon. -- __Note:__ The returned value is a copy of the original. Methods which mutate the size or properties of the return value will not impact the original polygon. To change properties of the polygon, assign it to a temporary variable and make changes before reassigning the @polygon@ member. bindCollisionPolygon_get_polygon :: MethodBind bindCollisionPolygon_get_polygon = unsafePerformIO $ withCString "CollisionPolygon" $ \ clsNamePtr -> withCString "get_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Array of vertices which define the polygon. -- __Note:__ The returned value is a copy of the original. Methods which mutate the size or properties of the return value will not impact the original polygon. To change properties of the polygon, assign it to a temporary variable and make changes before reassigning the @polygon@ member. get_polygon :: (CollisionPolygon :< cls, Object :< cls) => cls -> IO PoolVector2Array get_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon_get_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon "get_polygon" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.CollisionPolygon.get_polygon {-# NOINLINE bindCollisionPolygon_is_disabled #-} -- | If @true@, no collision will be produced. bindCollisionPolygon_is_disabled :: MethodBind bindCollisionPolygon_is_disabled = unsafePerformIO $ withCString "CollisionPolygon" $ \ clsNamePtr -> withCString "is_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, no collision will be produced. is_disabled :: (CollisionPolygon :< cls, Object :< cls) => cls -> IO Bool is_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon_is_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon "is_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionPolygon.is_disabled {-# NOINLINE bindCollisionPolygon_set_depth #-} -- | Length that the resulting collision extends in either direction perpendicular to its polygon. bindCollisionPolygon_set_depth :: MethodBind bindCollisionPolygon_set_depth = unsafePerformIO $ withCString "CollisionPolygon" $ \ clsNamePtr -> withCString "set_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Length that the resulting collision extends in either direction perpendicular to its polygon. set_depth :: (CollisionPolygon :< cls, Object :< cls) => cls -> Float -> IO () set_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon_set_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon "set_depth" '[Float] (IO ()) where nodeMethod = Godot.Core.CollisionPolygon.set_depth {-# NOINLINE bindCollisionPolygon_set_disabled #-} -- | If @true@, no collision will be produced. bindCollisionPolygon_set_disabled :: MethodBind bindCollisionPolygon_set_disabled = unsafePerformIO $ withCString "CollisionPolygon" $ \ clsNamePtr -> withCString "set_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, no collision will be produced. set_disabled :: (CollisionPolygon :< cls, Object :< cls) => cls -> Bool -> IO () set_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon_set_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon "set_disabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionPolygon.set_disabled {-# NOINLINE bindCollisionPolygon_set_polygon #-} -- | Array of vertices which define the polygon. -- __Note:__ The returned value is a copy of the original. Methods which mutate the size or properties of the return value will not impact the original polygon. To change properties of the polygon, assign it to a temporary variable and make changes before reassigning the @polygon@ member. bindCollisionPolygon_set_polygon :: MethodBind bindCollisionPolygon_set_polygon = unsafePerformIO $ withCString "CollisionPolygon" $ \ clsNamePtr -> withCString "set_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Array of vertices which define the polygon. -- __Note:__ The returned value is a copy of the original. Methods which mutate the size or properties of the return value will not impact the original polygon. To change properties of the polygon, assign it to a temporary variable and make changes before reassigning the @polygon@ member. set_polygon :: (CollisionPolygon :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon_set_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon "set_polygon" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.CollisionPolygon.set_polygon ================================================ FILE: src/Godot/Core/CollisionPolygon2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CollisionPolygon2D (Godot.Core.CollisionPolygon2D._BUILD_SOLIDS, Godot.Core.CollisionPolygon2D._BUILD_SEGMENTS, Godot.Core.CollisionPolygon2D.get_build_mode, Godot.Core.CollisionPolygon2D.get_one_way_collision_margin, Godot.Core.CollisionPolygon2D.get_polygon, Godot.Core.CollisionPolygon2D.is_disabled, Godot.Core.CollisionPolygon2D.is_one_way_collision_enabled, Godot.Core.CollisionPolygon2D.set_build_mode, Godot.Core.CollisionPolygon2D.set_disabled, Godot.Core.CollisionPolygon2D.set_one_way_collision, Godot.Core.CollisionPolygon2D.set_one_way_collision_margin, Godot.Core.CollisionPolygon2D.set_polygon) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _BUILD_SOLIDS :: Int _BUILD_SOLIDS = 0 _BUILD_SEGMENTS :: Int _BUILD_SEGMENTS = 1 instance NodeProperty CollisionPolygon2D "build_mode" Int 'False where nodeProperty = (get_build_mode, wrapDroppingSetter set_build_mode, Nothing) instance NodeProperty CollisionPolygon2D "disabled" Bool 'False where nodeProperty = (is_disabled, wrapDroppingSetter set_disabled, Nothing) instance NodeProperty CollisionPolygon2D "one_way_collision" Bool 'False where nodeProperty = (is_one_way_collision_enabled, wrapDroppingSetter set_one_way_collision, Nothing) instance NodeProperty CollisionPolygon2D "one_way_collision_margin" Float 'False where nodeProperty = (get_one_way_collision_margin, wrapDroppingSetter set_one_way_collision_margin, Nothing) instance NodeProperty CollisionPolygon2D "polygon" PoolVector2Array 'False where nodeProperty = (get_polygon, wrapDroppingSetter set_polygon, Nothing) {-# NOINLINE bindCollisionPolygon2D_get_build_mode #-} -- | Collision build mode. Use one of the @enum BuildMode@ constants. bindCollisionPolygon2D_get_build_mode :: MethodBind bindCollisionPolygon2D_get_build_mode = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "get_build_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Collision build mode. Use one of the @enum BuildMode@ constants. get_build_mode :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> IO Int get_build_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_get_build_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "get_build_mode" '[] (IO Int) where nodeMethod = Godot.Core.CollisionPolygon2D.get_build_mode {-# NOINLINE bindCollisionPolygon2D_get_one_way_collision_margin #-} -- | 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. bindCollisionPolygon2D_get_one_way_collision_margin :: MethodBind bindCollisionPolygon2D_get_one_way_collision_margin = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "get_one_way_collision_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | 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. get_one_way_collision_margin :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> IO Float get_one_way_collision_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_get_one_way_collision_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "get_one_way_collision_margin" '[] (IO Float) where nodeMethod = Godot.Core.CollisionPolygon2D.get_one_way_collision_margin {-# NOINLINE bindCollisionPolygon2D_get_polygon #-} -- | The polygon's list of vertices. The final point will be connected to the first. The returned value is a clone of the @PoolVector2Array@, not a reference. bindCollisionPolygon2D_get_polygon :: MethodBind bindCollisionPolygon2D_get_polygon = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "get_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's list of vertices. The final point will be connected to the first. The returned value is a clone of the @PoolVector2Array@, not a reference. get_polygon :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_get_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "get_polygon" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.CollisionPolygon2D.get_polygon {-# NOINLINE bindCollisionPolygon2D_is_disabled #-} -- | If @true@, no collisions will be detected. bindCollisionPolygon2D_is_disabled :: MethodBind bindCollisionPolygon2D_is_disabled = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "is_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, no collisions will be detected. is_disabled :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> IO Bool is_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_is_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "is_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionPolygon2D.is_disabled {-# NOINLINE bindCollisionPolygon2D_is_one_way_collision_enabled #-} -- | If @true@, only edges that face up, relative to @CollisionPolygon2D@'s rotation, will collide with other objects. bindCollisionPolygon2D_is_one_way_collision_enabled :: MethodBind bindCollisionPolygon2D_is_one_way_collision_enabled = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "is_one_way_collision_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only edges that face up, relative to @CollisionPolygon2D@'s rotation, will collide with other objects. is_one_way_collision_enabled :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> IO Bool is_one_way_collision_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_is_one_way_collision_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "is_one_way_collision_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionPolygon2D.is_one_way_collision_enabled {-# NOINLINE bindCollisionPolygon2D_set_build_mode #-} -- | Collision build mode. Use one of the @enum BuildMode@ constants. bindCollisionPolygon2D_set_build_mode :: MethodBind bindCollisionPolygon2D_set_build_mode = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "set_build_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Collision build mode. Use one of the @enum BuildMode@ constants. set_build_mode :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> Int -> IO () set_build_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_set_build_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "set_build_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.CollisionPolygon2D.set_build_mode {-# NOINLINE bindCollisionPolygon2D_set_disabled #-} -- | If @true@, no collisions will be detected. bindCollisionPolygon2D_set_disabled :: MethodBind bindCollisionPolygon2D_set_disabled = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "set_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, no collisions will be detected. set_disabled :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> Bool -> IO () set_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_set_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "set_disabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionPolygon2D.set_disabled {-# NOINLINE bindCollisionPolygon2D_set_one_way_collision #-} -- | If @true@, only edges that face up, relative to @CollisionPolygon2D@'s rotation, will collide with other objects. bindCollisionPolygon2D_set_one_way_collision :: MethodBind bindCollisionPolygon2D_set_one_way_collision = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "set_one_way_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only edges that face up, relative to @CollisionPolygon2D@'s rotation, will collide with other objects. set_one_way_collision :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> Bool -> IO () set_one_way_collision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_set_one_way_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "set_one_way_collision" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionPolygon2D.set_one_way_collision {-# NOINLINE bindCollisionPolygon2D_set_one_way_collision_margin #-} -- | 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. bindCollisionPolygon2D_set_one_way_collision_margin :: MethodBind bindCollisionPolygon2D_set_one_way_collision_margin = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "set_one_way_collision_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | 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. set_one_way_collision_margin :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> Float -> IO () set_one_way_collision_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_set_one_way_collision_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "set_one_way_collision_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.CollisionPolygon2D.set_one_way_collision_margin {-# NOINLINE bindCollisionPolygon2D_set_polygon #-} -- | The polygon's list of vertices. The final point will be connected to the first. The returned value is a clone of the @PoolVector2Array@, not a reference. bindCollisionPolygon2D_set_polygon :: MethodBind bindCollisionPolygon2D_set_polygon = unsafePerformIO $ withCString "CollisionPolygon2D" $ \ clsNamePtr -> withCString "set_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's list of vertices. The final point will be connected to the first. The returned value is a clone of the @PoolVector2Array@, not a reference. set_polygon :: (CollisionPolygon2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionPolygon2D_set_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionPolygon2D "set_polygon" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.CollisionPolygon2D.set_polygon ================================================ FILE: src/Godot/Core/CollisionShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CollisionShape (Godot.Core.CollisionShape._shape_changed, Godot.Core.CollisionShape._update_debug_shape, Godot.Core.CollisionShape.get_shape, Godot.Core.CollisionShape.is_disabled, Godot.Core.CollisionShape.make_convex_from_brothers, Godot.Core.CollisionShape.resource_changed, Godot.Core.CollisionShape.set_disabled, Godot.Core.CollisionShape.set_shape) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty CollisionShape "disabled" Bool 'False where nodeProperty = (is_disabled, wrapDroppingSetter set_disabled, Nothing) instance NodeProperty CollisionShape "shape" Shape 'False where nodeProperty = (get_shape, wrapDroppingSetter set_shape, Nothing) {-# NOINLINE bindCollisionShape__shape_changed #-} bindCollisionShape__shape_changed :: MethodBind bindCollisionShape__shape_changed = unsafePerformIO $ withCString "CollisionShape" $ \ clsNamePtr -> withCString "_shape_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _shape_changed :: (CollisionShape :< cls, Object :< cls) => cls -> IO () _shape_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape__shape_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape "_shape_changed" '[] (IO ()) where nodeMethod = Godot.Core.CollisionShape._shape_changed {-# NOINLINE bindCollisionShape__update_debug_shape #-} bindCollisionShape__update_debug_shape :: MethodBind bindCollisionShape__update_debug_shape = unsafePerformIO $ withCString "CollisionShape" $ \ clsNamePtr -> withCString "_update_debug_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_debug_shape :: (CollisionShape :< cls, Object :< cls) => cls -> IO () _update_debug_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape__update_debug_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape "_update_debug_shape" '[] (IO ()) where nodeMethod = Godot.Core.CollisionShape._update_debug_shape {-# NOINLINE bindCollisionShape_get_shape #-} -- | The actual shape owned by this collision shape. bindCollisionShape_get_shape :: MethodBind bindCollisionShape_get_shape = unsafePerformIO $ withCString "CollisionShape" $ \ clsNamePtr -> withCString "get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The actual shape owned by this collision shape. get_shape :: (CollisionShape :< cls, Object :< cls) => cls -> IO Shape get_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape "get_shape" '[] (IO Shape) where nodeMethod = Godot.Core.CollisionShape.get_shape {-# NOINLINE bindCollisionShape_is_disabled #-} -- | A disabled collision shape has no effect in the world. bindCollisionShape_is_disabled :: MethodBind bindCollisionShape_is_disabled = unsafePerformIO $ withCString "CollisionShape" $ \ clsNamePtr -> withCString "is_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A disabled collision shape has no effect in the world. is_disabled :: (CollisionShape :< cls, Object :< cls) => cls -> IO Bool is_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape_is_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape "is_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionShape.is_disabled {-# NOINLINE bindCollisionShape_make_convex_from_brothers #-} -- | Sets the collision shape's shape to the addition of all its convexed @MeshInstance@ siblings geometry. bindCollisionShape_make_convex_from_brothers :: MethodBind bindCollisionShape_make_convex_from_brothers = unsafePerformIO $ withCString "CollisionShape" $ \ clsNamePtr -> withCString "make_convex_from_brothers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the collision shape's shape to the addition of all its convexed @MeshInstance@ siblings geometry. make_convex_from_brothers :: (CollisionShape :< cls, Object :< cls) => cls -> IO () make_convex_from_brothers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape_make_convex_from_brothers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape "make_convex_from_brothers" '[] (IO ()) where nodeMethod = Godot.Core.CollisionShape.make_convex_from_brothers {-# NOINLINE bindCollisionShape_resource_changed #-} -- | If this method exists within a script it will be called whenever the shape resource has been modified. bindCollisionShape_resource_changed :: MethodBind bindCollisionShape_resource_changed = unsafePerformIO $ withCString "CollisionShape" $ \ clsNamePtr -> withCString "resource_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If this method exists within a script it will be called whenever the shape resource has been modified. resource_changed :: (CollisionShape :< cls, Object :< cls) => cls -> Resource -> IO () resource_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape_resource_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape "resource_changed" '[Resource] (IO ()) where nodeMethod = Godot.Core.CollisionShape.resource_changed {-# NOINLINE bindCollisionShape_set_disabled #-} -- | A disabled collision shape has no effect in the world. bindCollisionShape_set_disabled :: MethodBind bindCollisionShape_set_disabled = unsafePerformIO $ withCString "CollisionShape" $ \ clsNamePtr -> withCString "set_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A disabled collision shape has no effect in the world. set_disabled :: (CollisionShape :< cls, Object :< cls) => cls -> Bool -> IO () set_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape_set_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape "set_disabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionShape.set_disabled {-# NOINLINE bindCollisionShape_set_shape #-} -- | The actual shape owned by this collision shape. bindCollisionShape_set_shape :: MethodBind bindCollisionShape_set_shape = unsafePerformIO $ withCString "CollisionShape" $ \ clsNamePtr -> withCString "set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The actual shape owned by this collision shape. set_shape :: (CollisionShape :< cls, Object :< cls) => cls -> Shape -> IO () set_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape "set_shape" '[Shape] (IO ()) where nodeMethod = Godot.Core.CollisionShape.set_shape ================================================ FILE: src/Godot/Core/CollisionShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CollisionShape2D (Godot.Core.CollisionShape2D._shape_changed, Godot.Core.CollisionShape2D.get_one_way_collision_margin, Godot.Core.CollisionShape2D.get_shape, Godot.Core.CollisionShape2D.is_disabled, Godot.Core.CollisionShape2D.is_one_way_collision_enabled, Godot.Core.CollisionShape2D.set_disabled, Godot.Core.CollisionShape2D.set_one_way_collision, Godot.Core.CollisionShape2D.set_one_way_collision_margin, Godot.Core.CollisionShape2D.set_shape) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty CollisionShape2D "disabled" Bool 'False where nodeProperty = (is_disabled, wrapDroppingSetter set_disabled, Nothing) instance NodeProperty CollisionShape2D "one_way_collision" Bool 'False where nodeProperty = (is_one_way_collision_enabled, wrapDroppingSetter set_one_way_collision, Nothing) instance NodeProperty CollisionShape2D "one_way_collision_margin" Float 'False where nodeProperty = (get_one_way_collision_margin, wrapDroppingSetter set_one_way_collision_margin, Nothing) instance NodeProperty CollisionShape2D "shape" Shape2D 'False where nodeProperty = (get_shape, wrapDroppingSetter set_shape, Nothing) {-# NOINLINE bindCollisionShape2D__shape_changed #-} bindCollisionShape2D__shape_changed :: MethodBind bindCollisionShape2D__shape_changed = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "_shape_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _shape_changed :: (CollisionShape2D :< cls, Object :< cls) => cls -> IO () _shape_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D__shape_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "_shape_changed" '[] (IO ()) where nodeMethod = Godot.Core.CollisionShape2D._shape_changed {-# NOINLINE bindCollisionShape2D_get_one_way_collision_margin #-} -- | The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the shape at a high velocity. bindCollisionShape2D_get_one_way_collision_margin :: MethodBind bindCollisionShape2D_get_one_way_collision_margin = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "get_one_way_collision_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the shape at a high velocity. get_one_way_collision_margin :: (CollisionShape2D :< cls, Object :< cls) => cls -> IO Float get_one_way_collision_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D_get_one_way_collision_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "get_one_way_collision_margin" '[] (IO Float) where nodeMethod = Godot.Core.CollisionShape2D.get_one_way_collision_margin {-# NOINLINE bindCollisionShape2D_get_shape #-} -- | The actual shape owned by this collision shape. bindCollisionShape2D_get_shape :: MethodBind bindCollisionShape2D_get_shape = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The actual shape owned by this collision shape. get_shape :: (CollisionShape2D :< cls, Object :< cls) => cls -> IO Shape2D get_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "get_shape" '[] (IO Shape2D) where nodeMethod = Godot.Core.CollisionShape2D.get_shape {-# NOINLINE bindCollisionShape2D_is_disabled #-} -- | A disabled collision shape has no effect in the world. This property should be changed with @method Object.set_deferred@. bindCollisionShape2D_is_disabled :: MethodBind bindCollisionShape2D_is_disabled = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "is_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A disabled collision shape has no effect in the world. This property should be changed with @method Object.set_deferred@. is_disabled :: (CollisionShape2D :< cls, Object :< cls) => cls -> IO Bool is_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D_is_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "is_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionShape2D.is_disabled {-# NOINLINE bindCollisionShape2D_is_one_way_collision_enabled #-} -- | Sets whether this collision shape should only detect collision on one side (top or bottom). bindCollisionShape2D_is_one_way_collision_enabled :: MethodBind bindCollisionShape2D_is_one_way_collision_enabled = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "is_one_way_collision_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether this collision shape should only detect collision on one side (top or bottom). is_one_way_collision_enabled :: (CollisionShape2D :< cls, Object :< cls) => cls -> IO Bool is_one_way_collision_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D_is_one_way_collision_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "is_one_way_collision_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.CollisionShape2D.is_one_way_collision_enabled {-# NOINLINE bindCollisionShape2D_set_disabled #-} -- | A disabled collision shape has no effect in the world. This property should be changed with @method Object.set_deferred@. bindCollisionShape2D_set_disabled :: MethodBind bindCollisionShape2D_set_disabled = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "set_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A disabled collision shape has no effect in the world. This property should be changed with @method Object.set_deferred@. set_disabled :: (CollisionShape2D :< cls, Object :< cls) => cls -> Bool -> IO () set_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D_set_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "set_disabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionShape2D.set_disabled {-# NOINLINE bindCollisionShape2D_set_one_way_collision #-} -- | Sets whether this collision shape should only detect collision on one side (top or bottom). bindCollisionShape2D_set_one_way_collision :: MethodBind bindCollisionShape2D_set_one_way_collision = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "set_one_way_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether this collision shape should only detect collision on one side (top or bottom). set_one_way_collision :: (CollisionShape2D :< cls, Object :< cls) => cls -> Bool -> IO () set_one_way_collision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D_set_one_way_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "set_one_way_collision" '[Bool] (IO ()) where nodeMethod = Godot.Core.CollisionShape2D.set_one_way_collision {-# NOINLINE bindCollisionShape2D_set_one_way_collision_margin #-} -- | The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the shape at a high velocity. bindCollisionShape2D_set_one_way_collision_margin :: MethodBind bindCollisionShape2D_set_one_way_collision_margin = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "set_one_way_collision_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the shape at a high velocity. set_one_way_collision_margin :: (CollisionShape2D :< cls, Object :< cls) => cls -> Float -> IO () set_one_way_collision_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D_set_one_way_collision_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "set_one_way_collision_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.CollisionShape2D.set_one_way_collision_margin {-# NOINLINE bindCollisionShape2D_set_shape #-} -- | The actual shape owned by this collision shape. bindCollisionShape2D_set_shape :: MethodBind bindCollisionShape2D_set_shape = unsafePerformIO $ withCString "CollisionShape2D" $ \ clsNamePtr -> withCString "set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The actual shape owned by this collision shape. set_shape :: (CollisionShape2D :< cls, Object :< cls) => cls -> Shape2D -> IO () set_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCollisionShape2D_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CollisionShape2D "set_shape" '[Shape2D] (IO ()) where nodeMethod = Godot.Core.CollisionShape2D.set_shape ================================================ FILE: src/Godot/Core/ColorPicker.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ColorPicker (Godot.Core.ColorPicker.sig_color_changed, Godot.Core.ColorPicker.sig_preset_added, Godot.Core.ColorPicker.sig_preset_removed, Godot.Core.ColorPicker._add_preset_pressed, Godot.Core.ColorPicker._focus_enter, Godot.Core.ColorPicker._focus_exit, Godot.Core.ColorPicker._hsv_draw, Godot.Core.ColorPicker._html_entered, Godot.Core.ColorPicker._html_focus_exit, Godot.Core.ColorPicker._preset_input, Godot.Core.ColorPicker._sample_draw, Godot.Core.ColorPicker._screen_input, Godot.Core.ColorPicker._screen_pick_pressed, Godot.Core.ColorPicker._text_type_toggled, Godot.Core.ColorPicker._update_presets, Godot.Core.ColorPicker._uv_input, Godot.Core.ColorPicker._value_changed, Godot.Core.ColorPicker._w_input, Godot.Core.ColorPicker.add_preset, Godot.Core.ColorPicker.are_presets_enabled, Godot.Core.ColorPicker.are_presets_visible, Godot.Core.ColorPicker.erase_preset, Godot.Core.ColorPicker.get_pick_color, Godot.Core.ColorPicker.get_presets, Godot.Core.ColorPicker.is_deferred_mode, Godot.Core.ColorPicker.is_editing_alpha, Godot.Core.ColorPicker.is_hsv_mode, Godot.Core.ColorPicker.is_raw_mode, Godot.Core.ColorPicker.set_deferred_mode, Godot.Core.ColorPicker.set_edit_alpha, Godot.Core.ColorPicker.set_hsv_mode, Godot.Core.ColorPicker.set_pick_color, Godot.Core.ColorPicker.set_presets_enabled, Godot.Core.ColorPicker.set_presets_visible, Godot.Core.ColorPicker.set_raw_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.BoxContainer() -- | Emitted when the color is changed. sig_color_changed :: Godot.Internal.Dispatch.Signal ColorPicker sig_color_changed = Godot.Internal.Dispatch.Signal "color_changed" instance NodeSignal ColorPicker "color_changed" '[Color] -- | Emitted when a preset is added. sig_preset_added :: Godot.Internal.Dispatch.Signal ColorPicker sig_preset_added = Godot.Internal.Dispatch.Signal "preset_added" instance NodeSignal ColorPicker "preset_added" '[Color] -- | Emitted when a preset is removed. sig_preset_removed :: Godot.Internal.Dispatch.Signal ColorPicker sig_preset_removed = Godot.Internal.Dispatch.Signal "preset_removed" instance NodeSignal ColorPicker "preset_removed" '[Color] instance NodeProperty ColorPicker "color" Color 'False where nodeProperty = (get_pick_color, wrapDroppingSetter set_pick_color, Nothing) instance NodeProperty ColorPicker "deferred_mode" Bool 'False where nodeProperty = (is_deferred_mode, wrapDroppingSetter set_deferred_mode, Nothing) instance NodeProperty ColorPicker "edit_alpha" Bool 'False where nodeProperty = (is_editing_alpha, wrapDroppingSetter set_edit_alpha, Nothing) instance NodeProperty ColorPicker "hsv_mode" Bool 'False where nodeProperty = (is_hsv_mode, wrapDroppingSetter set_hsv_mode, Nothing) instance NodeProperty ColorPicker "presets_enabled" Bool 'False where nodeProperty = (are_presets_enabled, wrapDroppingSetter set_presets_enabled, Nothing) instance NodeProperty ColorPicker "presets_visible" Bool 'False where nodeProperty = (are_presets_visible, wrapDroppingSetter set_presets_visible, Nothing) instance NodeProperty ColorPicker "raw_mode" Bool 'False where nodeProperty = (is_raw_mode, wrapDroppingSetter set_raw_mode, Nothing) {-# NOINLINE bindColorPicker__add_preset_pressed #-} bindColorPicker__add_preset_pressed :: MethodBind bindColorPicker__add_preset_pressed = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_add_preset_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _add_preset_pressed :: (ColorPicker :< cls, Object :< cls) => cls -> IO () _add_preset_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__add_preset_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_add_preset_pressed" '[] (IO ()) where nodeMethod = Godot.Core.ColorPicker._add_preset_pressed {-# NOINLINE bindColorPicker__focus_enter #-} bindColorPicker__focus_enter :: MethodBind bindColorPicker__focus_enter = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_focus_enter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _focus_enter :: (ColorPicker :< cls, Object :< cls) => cls -> IO () _focus_enter cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__focus_enter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_focus_enter" '[] (IO ()) where nodeMethod = Godot.Core.ColorPicker._focus_enter {-# NOINLINE bindColorPicker__focus_exit #-} bindColorPicker__focus_exit :: MethodBind bindColorPicker__focus_exit = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_focus_exit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _focus_exit :: (ColorPicker :< cls, Object :< cls) => cls -> IO () _focus_exit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__focus_exit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_focus_exit" '[] (IO ()) where nodeMethod = Godot.Core.ColorPicker._focus_exit {-# NOINLINE bindColorPicker__hsv_draw #-} bindColorPicker__hsv_draw :: MethodBind bindColorPicker__hsv_draw = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_hsv_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _hsv_draw :: (ColorPicker :< cls, Object :< cls) => cls -> Int -> Control -> IO () _hsv_draw cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__hsv_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_hsv_draw" '[Int, Control] (IO ()) where nodeMethod = Godot.Core.ColorPicker._hsv_draw {-# NOINLINE bindColorPicker__html_entered #-} bindColorPicker__html_entered :: MethodBind bindColorPicker__html_entered = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_html_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _html_entered :: (ColorPicker :< cls, Object :< cls) => cls -> GodotString -> IO () _html_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__html_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_html_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Core.ColorPicker._html_entered {-# NOINLINE bindColorPicker__html_focus_exit #-} bindColorPicker__html_focus_exit :: MethodBind bindColorPicker__html_focus_exit = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_html_focus_exit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _html_focus_exit :: (ColorPicker :< cls, Object :< cls) => cls -> IO () _html_focus_exit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__html_focus_exit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_html_focus_exit" '[] (IO ()) where nodeMethod = Godot.Core.ColorPicker._html_focus_exit {-# NOINLINE bindColorPicker__preset_input #-} bindColorPicker__preset_input :: MethodBind bindColorPicker__preset_input = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_preset_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _preset_input :: (ColorPicker :< cls, Object :< cls) => cls -> InputEvent -> IO () _preset_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__preset_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_preset_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ColorPicker._preset_input {-# NOINLINE bindColorPicker__sample_draw #-} bindColorPicker__sample_draw :: MethodBind bindColorPicker__sample_draw = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_sample_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _sample_draw :: (ColorPicker :< cls, Object :< cls) => cls -> IO () _sample_draw cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__sample_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_sample_draw" '[] (IO ()) where nodeMethod = Godot.Core.ColorPicker._sample_draw {-# NOINLINE bindColorPicker__screen_input #-} bindColorPicker__screen_input :: MethodBind bindColorPicker__screen_input = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_screen_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _screen_input :: (ColorPicker :< cls, Object :< cls) => cls -> InputEvent -> IO () _screen_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__screen_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_screen_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ColorPicker._screen_input {-# NOINLINE bindColorPicker__screen_pick_pressed #-} bindColorPicker__screen_pick_pressed :: MethodBind bindColorPicker__screen_pick_pressed = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_screen_pick_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _screen_pick_pressed :: (ColorPicker :< cls, Object :< cls) => cls -> IO () _screen_pick_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__screen_pick_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_screen_pick_pressed" '[] (IO ()) where nodeMethod = Godot.Core.ColorPicker._screen_pick_pressed {-# NOINLINE bindColorPicker__text_type_toggled #-} bindColorPicker__text_type_toggled :: MethodBind bindColorPicker__text_type_toggled = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_text_type_toggled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _text_type_toggled :: (ColorPicker :< cls, Object :< cls) => cls -> IO () _text_type_toggled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__text_type_toggled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_text_type_toggled" '[] (IO ()) where nodeMethod = Godot.Core.ColorPicker._text_type_toggled {-# NOINLINE bindColorPicker__update_presets #-} bindColorPicker__update_presets :: MethodBind bindColorPicker__update_presets = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_update_presets" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_presets :: (ColorPicker :< cls, Object :< cls) => cls -> IO () _update_presets cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__update_presets (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_update_presets" '[] (IO ()) where nodeMethod = Godot.Core.ColorPicker._update_presets {-# NOINLINE bindColorPicker__uv_input #-} bindColorPicker__uv_input :: MethodBind bindColorPicker__uv_input = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_uv_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _uv_input :: (ColorPicker :< cls, Object :< cls) => cls -> InputEvent -> IO () _uv_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__uv_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_uv_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ColorPicker._uv_input {-# NOINLINE bindColorPicker__value_changed #-} bindColorPicker__value_changed :: MethodBind bindColorPicker__value_changed = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_value_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _value_changed :: (ColorPicker :< cls, Object :< cls) => cls -> Float -> IO () _value_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__value_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_value_changed" '[Float] (IO ()) where nodeMethod = Godot.Core.ColorPicker._value_changed {-# NOINLINE bindColorPicker__w_input #-} bindColorPicker__w_input :: MethodBind bindColorPicker__w_input = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "_w_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _w_input :: (ColorPicker :< cls, Object :< cls) => cls -> InputEvent -> IO () _w_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker__w_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "_w_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ColorPicker._w_input {-# NOINLINE bindColorPicker_add_preset #-} -- | Adds the given color to a list of color presets. The presets are displayed in the color picker and the user will be able to select them. -- __Note:__ the presets list is only for @i@this@/i@ color picker. bindColorPicker_add_preset :: MethodBind bindColorPicker_add_preset = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "add_preset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the given color to a list of color presets. The presets are displayed in the color picker and the user will be able to select them. -- __Note:__ the presets list is only for @i@this@/i@ color picker. add_preset :: (ColorPicker :< cls, Object :< cls) => cls -> Color -> IO () add_preset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_add_preset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "add_preset" '[Color] (IO ()) where nodeMethod = Godot.Core.ColorPicker.add_preset {-# NOINLINE bindColorPicker_are_presets_enabled #-} -- | If @true@, the "add preset" button is enabled. bindColorPicker_are_presets_enabled :: MethodBind bindColorPicker_are_presets_enabled = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "are_presets_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the "add preset" button is enabled. are_presets_enabled :: (ColorPicker :< cls, Object :< cls) => cls -> IO Bool are_presets_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_are_presets_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "are_presets_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ColorPicker.are_presets_enabled {-# NOINLINE bindColorPicker_are_presets_visible #-} -- | If @true@, saved color presets are visible. bindColorPicker_are_presets_visible :: MethodBind bindColorPicker_are_presets_visible = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "are_presets_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, saved color presets are visible. are_presets_visible :: (ColorPicker :< cls, Object :< cls) => cls -> IO Bool are_presets_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_are_presets_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "are_presets_visible" '[] (IO Bool) where nodeMethod = Godot.Core.ColorPicker.are_presets_visible {-# NOINLINE bindColorPicker_erase_preset #-} -- | Removes the given color from the list of color presets of this color picker. bindColorPicker_erase_preset :: MethodBind bindColorPicker_erase_preset = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "erase_preset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the given color from the list of color presets of this color picker. erase_preset :: (ColorPicker :< cls, Object :< cls) => cls -> Color -> IO () erase_preset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_erase_preset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "erase_preset" '[Color] (IO ()) where nodeMethod = Godot.Core.ColorPicker.erase_preset {-# NOINLINE bindColorPicker_get_pick_color #-} -- | The currently selected color. bindColorPicker_get_pick_color :: MethodBind bindColorPicker_get_pick_color = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "get_pick_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected color. get_pick_color :: (ColorPicker :< cls, Object :< cls) => cls -> IO Color get_pick_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_get_pick_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "get_pick_color" '[] (IO Color) where nodeMethod = Godot.Core.ColorPicker.get_pick_color {-# NOINLINE bindColorPicker_get_presets #-} -- | Returns the list of colors in the presets of the color picker. bindColorPicker_get_presets :: MethodBind bindColorPicker_get_presets = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "get_presets" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of colors in the presets of the color picker. get_presets :: (ColorPicker :< cls, Object :< cls) => cls -> IO PoolColorArray get_presets cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_get_presets (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "get_presets" '[] (IO PoolColorArray) where nodeMethod = Godot.Core.ColorPicker.get_presets {-# NOINLINE bindColorPicker_is_deferred_mode #-} -- | If @true@, the color will apply only after the user releases the mouse button, otherwise it will apply immediately even in mouse motion event (which can cause performance issues). bindColorPicker_is_deferred_mode :: MethodBind bindColorPicker_is_deferred_mode = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "is_deferred_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the color will apply only after the user releases the mouse button, otherwise it will apply immediately even in mouse motion event (which can cause performance issues). is_deferred_mode :: (ColorPicker :< cls, Object :< cls) => cls -> IO Bool is_deferred_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_is_deferred_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "is_deferred_mode" '[] (IO Bool) where nodeMethod = Godot.Core.ColorPicker.is_deferred_mode {-# NOINLINE bindColorPicker_is_editing_alpha #-} -- | If @true@, shows an alpha channel slider (transparency). bindColorPicker_is_editing_alpha :: MethodBind bindColorPicker_is_editing_alpha = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "is_editing_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, shows an alpha channel slider (transparency). is_editing_alpha :: (ColorPicker :< cls, Object :< cls) => cls -> IO Bool is_editing_alpha cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_is_editing_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "is_editing_alpha" '[] (IO Bool) where nodeMethod = Godot.Core.ColorPicker.is_editing_alpha {-# NOINLINE bindColorPicker_is_hsv_mode #-} -- | If @true@, allows editing the color with Hue/Saturation/Value sliders. -- __Note:__ Cannot be enabled if raw mode is on. bindColorPicker_is_hsv_mode :: MethodBind bindColorPicker_is_hsv_mode = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "is_hsv_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allows editing the color with Hue/Saturation/Value sliders. -- __Note:__ Cannot be enabled if raw mode is on. is_hsv_mode :: (ColorPicker :< cls, Object :< cls) => cls -> IO Bool is_hsv_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_is_hsv_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "is_hsv_mode" '[] (IO Bool) where nodeMethod = Godot.Core.ColorPicker.is_hsv_mode {-# NOINLINE bindColorPicker_is_raw_mode #-} -- | If @true@, allows the color R, G, B component values to go beyond 1.0, which can be used for certain special operations that require it (like tinting without darkening or rendering sprites in HDR). -- __Note:__ Cannot be enabled if HSV mode is on. bindColorPicker_is_raw_mode :: MethodBind bindColorPicker_is_raw_mode = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "is_raw_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allows the color R, G, B component values to go beyond 1.0, which can be used for certain special operations that require it (like tinting without darkening or rendering sprites in HDR). -- __Note:__ Cannot be enabled if HSV mode is on. is_raw_mode :: (ColorPicker :< cls, Object :< cls) => cls -> IO Bool is_raw_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_is_raw_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "is_raw_mode" '[] (IO Bool) where nodeMethod = Godot.Core.ColorPicker.is_raw_mode {-# NOINLINE bindColorPicker_set_deferred_mode #-} -- | If @true@, the color will apply only after the user releases the mouse button, otherwise it will apply immediately even in mouse motion event (which can cause performance issues). bindColorPicker_set_deferred_mode :: MethodBind bindColorPicker_set_deferred_mode = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "set_deferred_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the color will apply only after the user releases the mouse button, otherwise it will apply immediately even in mouse motion event (which can cause performance issues). set_deferred_mode :: (ColorPicker :< cls, Object :< cls) => cls -> Bool -> IO () set_deferred_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_set_deferred_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "set_deferred_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.ColorPicker.set_deferred_mode {-# NOINLINE bindColorPicker_set_edit_alpha #-} -- | If @true@, shows an alpha channel slider (transparency). bindColorPicker_set_edit_alpha :: MethodBind bindColorPicker_set_edit_alpha = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "set_edit_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, shows an alpha channel slider (transparency). set_edit_alpha :: (ColorPicker :< cls, Object :< cls) => cls -> Bool -> IO () set_edit_alpha cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_set_edit_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "set_edit_alpha" '[Bool] (IO ()) where nodeMethod = Godot.Core.ColorPicker.set_edit_alpha {-# NOINLINE bindColorPicker_set_hsv_mode #-} -- | If @true@, allows editing the color with Hue/Saturation/Value sliders. -- __Note:__ Cannot be enabled if raw mode is on. bindColorPicker_set_hsv_mode :: MethodBind bindColorPicker_set_hsv_mode = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "set_hsv_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allows editing the color with Hue/Saturation/Value sliders. -- __Note:__ Cannot be enabled if raw mode is on. set_hsv_mode :: (ColorPicker :< cls, Object :< cls) => cls -> Bool -> IO () set_hsv_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_set_hsv_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "set_hsv_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.ColorPicker.set_hsv_mode {-# NOINLINE bindColorPicker_set_pick_color #-} -- | The currently selected color. bindColorPicker_set_pick_color :: MethodBind bindColorPicker_set_pick_color = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "set_pick_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected color. set_pick_color :: (ColorPicker :< cls, Object :< cls) => cls -> Color -> IO () set_pick_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_set_pick_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "set_pick_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ColorPicker.set_pick_color {-# NOINLINE bindColorPicker_set_presets_enabled #-} -- | If @true@, the "add preset" button is enabled. bindColorPicker_set_presets_enabled :: MethodBind bindColorPicker_set_presets_enabled = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "set_presets_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the "add preset" button is enabled. set_presets_enabled :: (ColorPicker :< cls, Object :< cls) => cls -> Bool -> IO () set_presets_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_set_presets_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "set_presets_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.ColorPicker.set_presets_enabled {-# NOINLINE bindColorPicker_set_presets_visible #-} -- | If @true@, saved color presets are visible. bindColorPicker_set_presets_visible :: MethodBind bindColorPicker_set_presets_visible = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "set_presets_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, saved color presets are visible. set_presets_visible :: (ColorPicker :< cls, Object :< cls) => cls -> Bool -> IO () set_presets_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_set_presets_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "set_presets_visible" '[Bool] (IO ()) where nodeMethod = Godot.Core.ColorPicker.set_presets_visible {-# NOINLINE bindColorPicker_set_raw_mode #-} -- | If @true@, allows the color R, G, B component values to go beyond 1.0, which can be used for certain special operations that require it (like tinting without darkening or rendering sprites in HDR). -- __Note:__ Cannot be enabled if HSV mode is on. bindColorPicker_set_raw_mode :: MethodBind bindColorPicker_set_raw_mode = unsafePerformIO $ withCString "ColorPicker" $ \ clsNamePtr -> withCString "set_raw_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allows the color R, G, B component values to go beyond 1.0, which can be used for certain special operations that require it (like tinting without darkening or rendering sprites in HDR). -- __Note:__ Cannot be enabled if HSV mode is on. set_raw_mode :: (ColorPicker :< cls, Object :< cls) => cls -> Bool -> IO () set_raw_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPicker_set_raw_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPicker "set_raw_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.ColorPicker.set_raw_mode ================================================ FILE: src/Godot/Core/ColorPickerButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ColorPickerButton (Godot.Core.ColorPickerButton.sig_color_changed, Godot.Core.ColorPickerButton.sig_picker_created, Godot.Core.ColorPickerButton.sig_popup_closed, Godot.Core.ColorPickerButton._color_changed, Godot.Core.ColorPickerButton._modal_closed, Godot.Core.ColorPickerButton.get_pick_color, Godot.Core.ColorPickerButton.get_picker, Godot.Core.ColorPickerButton.get_popup, Godot.Core.ColorPickerButton.is_editing_alpha, Godot.Core.ColorPickerButton.set_edit_alpha, Godot.Core.ColorPickerButton.set_pick_color) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Button() -- | Emitted when the color changes. sig_color_changed :: Godot.Internal.Dispatch.Signal ColorPickerButton sig_color_changed = Godot.Internal.Dispatch.Signal "color_changed" instance NodeSignal ColorPickerButton "color_changed" '[Color] -- | Emitted when the @ColorPicker@ is created (the button is pressed for the first time). sig_picker_created :: Godot.Internal.Dispatch.Signal ColorPickerButton sig_picker_created = Godot.Internal.Dispatch.Signal "picker_created" instance NodeSignal ColorPickerButton "picker_created" '[] -- | Emitted when the @ColorPicker@ is closed. sig_popup_closed :: Godot.Internal.Dispatch.Signal ColorPickerButton sig_popup_closed = Godot.Internal.Dispatch.Signal "popup_closed" instance NodeSignal ColorPickerButton "popup_closed" '[] instance NodeProperty ColorPickerButton "color" Color 'False where nodeProperty = (get_pick_color, wrapDroppingSetter set_pick_color, Nothing) instance NodeProperty ColorPickerButton "edit_alpha" Bool 'False where nodeProperty = (is_editing_alpha, wrapDroppingSetter set_edit_alpha, Nothing) {-# NOINLINE bindColorPickerButton__color_changed #-} bindColorPickerButton__color_changed :: MethodBind bindColorPickerButton__color_changed = unsafePerformIO $ withCString "ColorPickerButton" $ \ clsNamePtr -> withCString "_color_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _color_changed :: (ColorPickerButton :< cls, Object :< cls) => cls -> Color -> IO () _color_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPickerButton__color_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPickerButton "_color_changed" '[Color] (IO ()) where nodeMethod = Godot.Core.ColorPickerButton._color_changed {-# NOINLINE bindColorPickerButton__modal_closed #-} bindColorPickerButton__modal_closed :: MethodBind bindColorPickerButton__modal_closed = unsafePerformIO $ withCString "ColorPickerButton" $ \ clsNamePtr -> withCString "_modal_closed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _modal_closed :: (ColorPickerButton :< cls, Object :< cls) => cls -> IO () _modal_closed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPickerButton__modal_closed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPickerButton "_modal_closed" '[] (IO ()) where nodeMethod = Godot.Core.ColorPickerButton._modal_closed {-# NOINLINE bindColorPickerButton_get_pick_color #-} -- | The currently selected color. bindColorPickerButton_get_pick_color :: MethodBind bindColorPickerButton_get_pick_color = unsafePerformIO $ withCString "ColorPickerButton" $ \ clsNamePtr -> withCString "get_pick_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected color. get_pick_color :: (ColorPickerButton :< cls, Object :< cls) => cls -> IO Color get_pick_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPickerButton_get_pick_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPickerButton "get_pick_color" '[] (IO Color) where nodeMethod = Godot.Core.ColorPickerButton.get_pick_color {-# NOINLINE bindColorPickerButton_get_picker #-} -- | Returns the @ColorPicker@ that this node toggles. bindColorPickerButton_get_picker :: MethodBind bindColorPickerButton_get_picker = unsafePerformIO $ withCString "ColorPickerButton" $ \ clsNamePtr -> withCString "get_picker" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @ColorPicker@ that this node toggles. get_picker :: (ColorPickerButton :< cls, Object :< cls) => cls -> IO ColorPicker get_picker cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPickerButton_get_picker (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPickerButton "get_picker" '[] (IO ColorPicker) where nodeMethod = Godot.Core.ColorPickerButton.get_picker {-# NOINLINE bindColorPickerButton_get_popup #-} -- | Returns the control's @PopupPanel@ which allows you to connect to popup signals. This allows you to handle events when the ColorPicker is shown or hidden. bindColorPickerButton_get_popup :: MethodBind bindColorPickerButton_get_popup = unsafePerformIO $ withCString "ColorPickerButton" $ \ clsNamePtr -> withCString "get_popup" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the control's @PopupPanel@ which allows you to connect to popup signals. This allows you to handle events when the ColorPicker is shown or hidden. get_popup :: (ColorPickerButton :< cls, Object :< cls) => cls -> IO PopupPanel get_popup cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPickerButton_get_popup (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPickerButton "get_popup" '[] (IO PopupPanel) where nodeMethod = Godot.Core.ColorPickerButton.get_popup {-# NOINLINE bindColorPickerButton_is_editing_alpha #-} -- | If @true@, the alpha channel in the displayed @ColorPicker@ will be visible. bindColorPickerButton_is_editing_alpha :: MethodBind bindColorPickerButton_is_editing_alpha = unsafePerformIO $ withCString "ColorPickerButton" $ \ clsNamePtr -> withCString "is_editing_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the alpha channel in the displayed @ColorPicker@ will be visible. is_editing_alpha :: (ColorPickerButton :< cls, Object :< cls) => cls -> IO Bool is_editing_alpha cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorPickerButton_is_editing_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPickerButton "is_editing_alpha" '[] (IO Bool) where nodeMethod = Godot.Core.ColorPickerButton.is_editing_alpha {-# NOINLINE bindColorPickerButton_set_edit_alpha #-} -- | If @true@, the alpha channel in the displayed @ColorPicker@ will be visible. bindColorPickerButton_set_edit_alpha :: MethodBind bindColorPickerButton_set_edit_alpha = unsafePerformIO $ withCString "ColorPickerButton" $ \ clsNamePtr -> withCString "set_edit_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the alpha channel in the displayed @ColorPicker@ will be visible. set_edit_alpha :: (ColorPickerButton :< cls, Object :< cls) => cls -> Bool -> IO () set_edit_alpha cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPickerButton_set_edit_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPickerButton "set_edit_alpha" '[Bool] (IO ()) where nodeMethod = Godot.Core.ColorPickerButton.set_edit_alpha {-# NOINLINE bindColorPickerButton_set_pick_color #-} -- | The currently selected color. bindColorPickerButton_set_pick_color :: MethodBind bindColorPickerButton_set_pick_color = unsafePerformIO $ withCString "ColorPickerButton" $ \ clsNamePtr -> withCString "set_pick_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected color. set_pick_color :: (ColorPickerButton :< cls, Object :< cls) => cls -> Color -> IO () set_pick_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorPickerButton_set_pick_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorPickerButton "set_pick_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ColorPickerButton.set_pick_color ================================================ FILE: src/Godot/Core/ColorRect.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ColorRect (Godot.Core.ColorRect.get_frame_color, Godot.Core.ColorRect.set_frame_color) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() instance NodeProperty ColorRect "color" Color 'False where nodeProperty = (get_frame_color, wrapDroppingSetter set_frame_color, Nothing) {-# NOINLINE bindColorRect_get_frame_color #-} -- | The fill color. -- -- @ -- -- $ColorRect.color = Color(1, 0, 0, 1) # Set ColorRect's color to red. -- -- @ bindColorRect_get_frame_color :: MethodBind bindColorRect_get_frame_color = unsafePerformIO $ withCString "ColorRect" $ \ clsNamePtr -> withCString "get_frame_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fill color. -- -- @ -- -- $ColorRect.color = Color(1, 0, 0, 1) # Set ColorRect's color to red. -- -- @ get_frame_color :: (ColorRect :< cls, Object :< cls) => cls -> IO Color get_frame_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindColorRect_get_frame_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorRect "get_frame_color" '[] (IO Color) where nodeMethod = Godot.Core.ColorRect.get_frame_color {-# NOINLINE bindColorRect_set_frame_color #-} -- | The fill color. -- -- @ -- -- $ColorRect.color = Color(1, 0, 0, 1) # Set ColorRect's color to red. -- -- @ bindColorRect_set_frame_color :: MethodBind bindColorRect_set_frame_color = unsafePerformIO $ withCString "ColorRect" $ \ clsNamePtr -> withCString "set_frame_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fill color. -- -- @ -- -- $ColorRect.color = Color(1, 0, 0, 1) # Set ColorRect's color to red. -- -- @ set_frame_color :: (ColorRect :< cls, Object :< cls) => cls -> Color -> IO () set_frame_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindColorRect_set_frame_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ColorRect "set_frame_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ColorRect.set_frame_color ================================================ FILE: src/Godot/Core/ConcavePolygonShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ConcavePolygonShape (Godot.Core.ConcavePolygonShape.get_faces, Godot.Core.ConcavePolygonShape.set_faces) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty ConcavePolygonShape "data" PoolVector3Array 'False where nodeProperty = (get_faces, wrapDroppingSetter set_faces, Nothing) {-# NOINLINE bindConcavePolygonShape_get_faces #-} -- | Returns the faces (an array of triangles). bindConcavePolygonShape_get_faces :: MethodBind bindConcavePolygonShape_get_faces = unsafePerformIO $ withCString "ConcavePolygonShape" $ \ clsNamePtr -> withCString "get_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the faces (an array of triangles). get_faces :: (ConcavePolygonShape :< cls, Object :< cls) => cls -> IO PoolVector3Array get_faces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindConcavePolygonShape_get_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConcavePolygonShape "get_faces" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.ConcavePolygonShape.get_faces {-# NOINLINE bindConcavePolygonShape_set_faces #-} -- | Sets the faces (an array of triangles). bindConcavePolygonShape_set_faces :: MethodBind bindConcavePolygonShape_set_faces = unsafePerformIO $ withCString "ConcavePolygonShape" $ \ clsNamePtr -> withCString "set_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the faces (an array of triangles). set_faces :: (ConcavePolygonShape :< cls, Object :< cls) => cls -> PoolVector3Array -> IO () set_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConcavePolygonShape_set_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConcavePolygonShape "set_faces" '[PoolVector3Array] (IO ()) where nodeMethod = Godot.Core.ConcavePolygonShape.set_faces ================================================ FILE: src/Godot/Core/ConcavePolygonShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ConcavePolygonShape2D (Godot.Core.ConcavePolygonShape2D.get_segments, Godot.Core.ConcavePolygonShape2D.set_segments) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape2D() instance NodeProperty ConcavePolygonShape2D "segments" PoolVector2Array 'False where nodeProperty = (get_segments, wrapDroppingSetter set_segments, Nothing) {-# NOINLINE bindConcavePolygonShape2D_get_segments #-} -- | The array of points that make up the @ConcavePolygonShape2D@'s line segments. bindConcavePolygonShape2D_get_segments :: MethodBind bindConcavePolygonShape2D_get_segments = unsafePerformIO $ withCString "ConcavePolygonShape2D" $ \ clsNamePtr -> withCString "get_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The array of points that make up the @ConcavePolygonShape2D@'s line segments. get_segments :: (ConcavePolygonShape2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_segments cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindConcavePolygonShape2D_get_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConcavePolygonShape2D "get_segments" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.ConcavePolygonShape2D.get_segments {-# NOINLINE bindConcavePolygonShape2D_set_segments #-} -- | The array of points that make up the @ConcavePolygonShape2D@'s line segments. bindConcavePolygonShape2D_set_segments :: MethodBind bindConcavePolygonShape2D_set_segments = unsafePerformIO $ withCString "ConcavePolygonShape2D" $ \ clsNamePtr -> withCString "set_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The array of points that make up the @ConcavePolygonShape2D@'s line segments. set_segments :: (ConcavePolygonShape2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_segments cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConcavePolygonShape2D_set_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConcavePolygonShape2D "set_segments" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.ConcavePolygonShape2D.set_segments ================================================ FILE: src/Godot/Core/ConeTwistJoint.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ConeTwistJoint (Godot.Core.ConeTwistJoint._PARAM_SWING_SPAN, Godot.Core.ConeTwistJoint._PARAM_SOFTNESS, Godot.Core.ConeTwistJoint._PARAM_TWIST_SPAN, Godot.Core.ConeTwistJoint._PARAM_MAX, Godot.Core.ConeTwistJoint._PARAM_RELAXATION, Godot.Core.ConeTwistJoint._PARAM_BIAS, Godot.Core.ConeTwistJoint._get_swing_span, Godot.Core.ConeTwistJoint._get_twist_span, Godot.Core.ConeTwistJoint._set_swing_span, Godot.Core.ConeTwistJoint._set_twist_span, Godot.Core.ConeTwistJoint.get_param, Godot.Core.ConeTwistJoint.set_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Joint() _PARAM_SWING_SPAN :: Int _PARAM_SWING_SPAN = 0 _PARAM_SOFTNESS :: Int _PARAM_SOFTNESS = 3 _PARAM_TWIST_SPAN :: Int _PARAM_TWIST_SPAN = 1 _PARAM_MAX :: Int _PARAM_MAX = 5 _PARAM_RELAXATION :: Int _PARAM_RELAXATION = 4 _PARAM_BIAS :: Int _PARAM_BIAS = 2 instance NodeProperty ConeTwistJoint "bias" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param, wrapIndexedSetter 2 set_param, Nothing) instance NodeProperty ConeTwistJoint "relaxation" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param, wrapIndexedSetter 4 set_param, Nothing) instance NodeProperty ConeTwistJoint "softness" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param, wrapIndexedSetter 3 set_param, Nothing) instance NodeProperty ConeTwistJoint "swing_span" Float 'False where nodeProperty = (_get_swing_span, wrapDroppingSetter _set_swing_span, Nothing) instance NodeProperty ConeTwistJoint "twist_span" Float 'False where nodeProperty = (_get_twist_span, wrapDroppingSetter _set_twist_span, Nothing) {-# NOINLINE bindConeTwistJoint__get_swing_span #-} -- | Swing is rotation from side to side, around the axis perpendicular to the twist axis. -- The swing span defines, how much rotation will not get corrected along the swing axis. -- Could be defined as looseness in the @ConeTwistJoint@. -- If below 0.05, this behavior is locked. bindConeTwistJoint__get_swing_span :: MethodBind bindConeTwistJoint__get_swing_span = unsafePerformIO $ withCString "ConeTwistJoint" $ \ clsNamePtr -> withCString "_get_swing_span" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Swing is rotation from side to side, around the axis perpendicular to the twist axis. -- The swing span defines, how much rotation will not get corrected along the swing axis. -- Could be defined as looseness in the @ConeTwistJoint@. -- If below 0.05, this behavior is locked. _get_swing_span :: (ConeTwistJoint :< cls, Object :< cls) => cls -> IO Float _get_swing_span cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindConeTwistJoint__get_swing_span (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConeTwistJoint "_get_swing_span" '[] (IO Float) where nodeMethod = Godot.Core.ConeTwistJoint._get_swing_span {-# NOINLINE bindConeTwistJoint__get_twist_span #-} -- | Twist is the rotation around the twist axis, this value defined how far the joint can twist. -- Twist is locked if below 0.05. bindConeTwistJoint__get_twist_span :: MethodBind bindConeTwistJoint__get_twist_span = unsafePerformIO $ withCString "ConeTwistJoint" $ \ clsNamePtr -> withCString "_get_twist_span" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Twist is the rotation around the twist axis, this value defined how far the joint can twist. -- Twist is locked if below 0.05. _get_twist_span :: (ConeTwistJoint :< cls, Object :< cls) => cls -> IO Float _get_twist_span cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindConeTwistJoint__get_twist_span (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConeTwistJoint "_get_twist_span" '[] (IO Float) where nodeMethod = Godot.Core.ConeTwistJoint._get_twist_span {-# NOINLINE bindConeTwistJoint__set_swing_span #-} -- | Swing is rotation from side to side, around the axis perpendicular to the twist axis. -- The swing span defines, how much rotation will not get corrected along the swing axis. -- Could be defined as looseness in the @ConeTwistJoint@. -- If below 0.05, this behavior is locked. bindConeTwistJoint__set_swing_span :: MethodBind bindConeTwistJoint__set_swing_span = unsafePerformIO $ withCString "ConeTwistJoint" $ \ clsNamePtr -> withCString "_set_swing_span" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Swing is rotation from side to side, around the axis perpendicular to the twist axis. -- The swing span defines, how much rotation will not get corrected along the swing axis. -- Could be defined as looseness in the @ConeTwistJoint@. -- If below 0.05, this behavior is locked. _set_swing_span :: (ConeTwistJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_swing_span cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConeTwistJoint__set_swing_span (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConeTwistJoint "_set_swing_span" '[Float] (IO ()) where nodeMethod = Godot.Core.ConeTwistJoint._set_swing_span {-# NOINLINE bindConeTwistJoint__set_twist_span #-} -- | Twist is the rotation around the twist axis, this value defined how far the joint can twist. -- Twist is locked if below 0.05. bindConeTwistJoint__set_twist_span :: MethodBind bindConeTwistJoint__set_twist_span = unsafePerformIO $ withCString "ConeTwistJoint" $ \ clsNamePtr -> withCString "_set_twist_span" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Twist is the rotation around the twist axis, this value defined how far the joint can twist. -- Twist is locked if below 0.05. _set_twist_span :: (ConeTwistJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_twist_span cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConeTwistJoint__set_twist_span (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConeTwistJoint "_set_twist_span" '[Float] (IO ()) where nodeMethod = Godot.Core.ConeTwistJoint._set_twist_span {-# NOINLINE bindConeTwistJoint_get_param #-} -- | The speed with which the swing or twist will take place. -- The higher, the faster. bindConeTwistJoint_get_param :: MethodBind bindConeTwistJoint_get_param = unsafePerformIO $ withCString "ConeTwistJoint" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The speed with which the swing or twist will take place. -- The higher, the faster. get_param :: (ConeTwistJoint :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConeTwistJoint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConeTwistJoint "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.ConeTwistJoint.get_param {-# NOINLINE bindConeTwistJoint_set_param #-} -- | The speed with which the swing or twist will take place. -- The higher, the faster. bindConeTwistJoint_set_param :: MethodBind bindConeTwistJoint_set_param = unsafePerformIO $ withCString "ConeTwistJoint" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The speed with which the swing or twist will take place. -- The higher, the faster. set_param :: (ConeTwistJoint :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindConeTwistJoint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConeTwistJoint "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.ConeTwistJoint.set_param ================================================ FILE: src/Godot/Core/ConfigFile.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ConfigFile (Godot.Core.ConfigFile.erase_section, Godot.Core.ConfigFile.erase_section_key, Godot.Core.ConfigFile.get_section_keys, Godot.Core.ConfigFile.get_sections, Godot.Core.ConfigFile.get_value, Godot.Core.ConfigFile.has_section, Godot.Core.ConfigFile.has_section_key, Godot.Core.ConfigFile.load, Godot.Core.ConfigFile.load_encrypted, Godot.Core.ConfigFile.load_encrypted_pass, Godot.Core.ConfigFile.save, Godot.Core.ConfigFile.save_encrypted, Godot.Core.ConfigFile.save_encrypted_pass, Godot.Core.ConfigFile.set_value) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindConfigFile_erase_section #-} -- | Deletes the specified section along with all the key-value pairs inside. Raises an error if the section does not exist. bindConfigFile_erase_section :: MethodBind bindConfigFile_erase_section = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "erase_section" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the specified section along with all the key-value pairs inside. Raises an error if the section does not exist. erase_section :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> IO () erase_section cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_erase_section (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "erase_section" '[GodotString] (IO ()) where nodeMethod = Godot.Core.ConfigFile.erase_section {-# NOINLINE bindConfigFile_erase_section_key #-} -- | Deletes the specified key in a section. Raises an error if either the section or the key do not exist. bindConfigFile_erase_section_key :: MethodBind bindConfigFile_erase_section_key = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "erase_section_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the specified key in a section. Raises an error if either the section or the key do not exist. erase_section_key :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () erase_section_key cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_erase_section_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "erase_section_key" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.ConfigFile.erase_section_key {-# NOINLINE bindConfigFile_get_section_keys #-} -- | Returns an array of all defined key identifiers in the specified section. Raises an error and returns an empty array if the section does not exist. bindConfigFile_get_section_keys :: MethodBind bindConfigFile_get_section_keys = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "get_section_keys" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of all defined key identifiers in the specified section. Raises an error and returns an empty array if the section does not exist. get_section_keys :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_section_keys cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_get_section_keys (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "get_section_keys" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.ConfigFile.get_section_keys {-# NOINLINE bindConfigFile_get_sections #-} -- | Returns an array of all defined section identifiers. bindConfigFile_get_sections :: MethodBind bindConfigFile_get_sections = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "get_sections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of all defined section identifiers. get_sections :: (ConfigFile :< cls, Object :< cls) => cls -> IO PoolStringArray get_sections cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_get_sections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "get_sections" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.ConfigFile.get_sections {-# NOINLINE bindConfigFile_get_value #-} -- | Returns the current value for the specified section and key. If either the section or the key do not exist, the method returns the fallback @default@ value. If @default@ is not specified or set to @null@, an error is also raised. bindConfigFile_get_value :: MethodBind bindConfigFile_get_value = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "get_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current value for the specified section and key. If either the section or the key do not exist, the method returns the fallback @default@ value. If @default@ is not specified or set to @null@, an error is also raised. get_value :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Maybe GodotVariant -> IO GodotVariant get_value cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_get_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "get_value" '[GodotString, GodotString, Maybe GodotVariant] (IO GodotVariant) where nodeMethod = Godot.Core.ConfigFile.get_value {-# NOINLINE bindConfigFile_has_section #-} -- | Returns @true@ if the specified section exists. bindConfigFile_has_section :: MethodBind bindConfigFile_has_section = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "has_section" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified section exists. has_section :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_section cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_has_section (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "has_section" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ConfigFile.has_section {-# NOINLINE bindConfigFile_has_section_key #-} -- | Returns @true@ if the specified section-key pair exists. bindConfigFile_has_section_key :: MethodBind bindConfigFile_has_section_key = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "has_section_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified section-key pair exists. has_section_key :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool has_section_key cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_has_section_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "has_section_key" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.ConfigFile.has_section_key {-# NOINLINE bindConfigFile_load #-} -- | Loads the config file specified as a parameter. The file's contents are parsed and loaded in the @ConfigFile@ object which the method was called on. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindConfigFile_load :: MethodBind bindConfigFile_load = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "load" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads the config file specified as a parameter. The file's contents are parsed and loaded in the @ConfigFile@ object which the method was called on. -- Returns one of the @enum Error@ code constants (@OK@ on success). load :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> IO Int load cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_load (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "load" '[GodotString] (IO Int) where nodeMethod = Godot.Core.ConfigFile.load {-# NOINLINE bindConfigFile_load_encrypted #-} -- | Loads the encrypted config file specified as a parameter, using the provided @key@ to decrypt it. The file's contents are parsed and loaded in the @ConfigFile@ object which the method was called on. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindConfigFile_load_encrypted :: MethodBind bindConfigFile_load_encrypted = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "load_encrypted" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads the encrypted config file specified as a parameter, using the provided @key@ to decrypt it. The file's contents are parsed and loaded in the @ConfigFile@ object which the method was called on. -- Returns one of the @enum Error@ code constants (@OK@ on success). load_encrypted :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> PoolByteArray -> IO Int load_encrypted cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_load_encrypted (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "load_encrypted" '[GodotString, PoolByteArray] (IO Int) where nodeMethod = Godot.Core.ConfigFile.load_encrypted {-# NOINLINE bindConfigFile_load_encrypted_pass #-} -- | Loads the encrypted config file specified as a parameter, using the provided @password@ to decrypt it. The file's contents are parsed and loaded in the @ConfigFile@ object which the method was called on. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindConfigFile_load_encrypted_pass :: MethodBind bindConfigFile_load_encrypted_pass = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "load_encrypted_pass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads the encrypted config file specified as a parameter, using the provided @password@ to decrypt it. The file's contents are parsed and loaded in the @ConfigFile@ object which the method was called on. -- Returns one of the @enum Error@ code constants (@OK@ on success). load_encrypted_pass :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int load_encrypted_pass cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_load_encrypted_pass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "load_encrypted_pass" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.ConfigFile.load_encrypted_pass {-# NOINLINE bindConfigFile_save #-} -- | Saves the contents of the @ConfigFile@ object to the file specified as a parameter. The output file uses an INI-style structure. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindConfigFile_save :: MethodBind bindConfigFile_save = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "save" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the contents of the @ConfigFile@ object to the file specified as a parameter. The output file uses an INI-style structure. -- Returns one of the @enum Error@ code constants (@OK@ on success). save :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> IO Int save cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_save (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "save" '[GodotString] (IO Int) where nodeMethod = Godot.Core.ConfigFile.save {-# NOINLINE bindConfigFile_save_encrypted #-} -- | Saves the contents of the @ConfigFile@ object to the AES-256 encrypted file specified as a parameter, using the provided @key@ to encrypt it. The output file uses an INI-style structure. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindConfigFile_save_encrypted :: MethodBind bindConfigFile_save_encrypted = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "save_encrypted" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the contents of the @ConfigFile@ object to the AES-256 encrypted file specified as a parameter, using the provided @key@ to encrypt it. The output file uses an INI-style structure. -- Returns one of the @enum Error@ code constants (@OK@ on success). save_encrypted :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> PoolByteArray -> IO Int save_encrypted cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_save_encrypted (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "save_encrypted" '[GodotString, PoolByteArray] (IO Int) where nodeMethod = Godot.Core.ConfigFile.save_encrypted {-# NOINLINE bindConfigFile_save_encrypted_pass #-} -- | Saves the contents of the @ConfigFile@ object to the AES-256 encrypted file specified as a parameter, using the provided @password@ to encrypt it. The output file uses an INI-style structure. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindConfigFile_save_encrypted_pass :: MethodBind bindConfigFile_save_encrypted_pass = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "save_encrypted_pass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the contents of the @ConfigFile@ object to the AES-256 encrypted file specified as a parameter, using the provided @password@ to encrypt it. The output file uses an INI-style structure. -- Returns one of the @enum Error@ code constants (@OK@ on success). save_encrypted_pass :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int save_encrypted_pass cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_save_encrypted_pass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "save_encrypted_pass" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.ConfigFile.save_encrypted_pass {-# NOINLINE bindConfigFile_set_value #-} -- | Assigns a value to the specified key of the specified section. If either the section or the key do not exist, they are created. Passing a @null@ value deletes the specified key if it exists, and deletes the section if it ends up empty once the key has been removed. bindConfigFile_set_value :: MethodBind bindConfigFile_set_value = unsafePerformIO $ withCString "ConfigFile" $ \ clsNamePtr -> withCString "set_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a value to the specified key of the specified section. If either the section or the key do not exist, they are created. Passing a @null@ value deletes the specified key if it exists, and deletes the section if it ends up empty once the key has been removed. set_value :: (ConfigFile :< cls, Object :< cls) => cls -> GodotString -> GodotString -> GodotVariant -> IO () set_value cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindConfigFile_set_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfigFile "set_value" '[GodotString, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.ConfigFile.set_value ================================================ FILE: src/Godot/Core/ConfirmationDialog.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ConfirmationDialog (Godot.Core.ConfirmationDialog.get_cancel) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.AcceptDialog() {-# NOINLINE bindConfirmationDialog_get_cancel #-} -- | Returns the cancel button. bindConfirmationDialog_get_cancel :: MethodBind bindConfirmationDialog_get_cancel = unsafePerformIO $ withCString "ConfirmationDialog" $ \ clsNamePtr -> withCString "get_cancel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cancel button. get_cancel :: (ConfirmationDialog :< cls, Object :< cls) => cls -> IO Button get_cancel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindConfirmationDialog_get_cancel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConfirmationDialog "get_cancel" '[] (IO Button) where nodeMethod = Godot.Core.ConfirmationDialog.get_cancel ================================================ FILE: src/Godot/Core/Container.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Container (Godot.Core.Container._NOTIFICATION_SORT_CHILDREN, Godot.Core.Container.sig_sort_children, Godot.Core.Container._child_minsize_changed, Godot.Core.Container._sort_children, Godot.Core.Container.fit_child_in_rect, Godot.Core.Container.queue_sort) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _NOTIFICATION_SORT_CHILDREN :: Int _NOTIFICATION_SORT_CHILDREN = 50 -- | Emitted when sorting the children is needed. sig_sort_children :: Godot.Internal.Dispatch.Signal Container sig_sort_children = Godot.Internal.Dispatch.Signal "sort_children" instance NodeSignal Container "sort_children" '[] {-# NOINLINE bindContainer__child_minsize_changed #-} bindContainer__child_minsize_changed :: MethodBind bindContainer__child_minsize_changed = unsafePerformIO $ withCString "Container" $ \ clsNamePtr -> withCString "_child_minsize_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _child_minsize_changed :: (Container :< cls, Object :< cls) => cls -> IO () _child_minsize_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindContainer__child_minsize_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Container "_child_minsize_changed" '[] (IO ()) where nodeMethod = Godot.Core.Container._child_minsize_changed {-# NOINLINE bindContainer__sort_children #-} bindContainer__sort_children :: MethodBind bindContainer__sort_children = unsafePerformIO $ withCString "Container" $ \ clsNamePtr -> withCString "_sort_children" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _sort_children :: (Container :< cls, Object :< cls) => cls -> IO () _sort_children cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindContainer__sort_children (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Container "_sort_children" '[] (IO ()) where nodeMethod = Godot.Core.Container._sort_children {-# NOINLINE bindContainer_fit_child_in_rect #-} -- | Fit a child control in a given rect. This is mainly a helper for creating custom container classes. bindContainer_fit_child_in_rect :: MethodBind bindContainer_fit_child_in_rect = unsafePerformIO $ withCString "Container" $ \ clsNamePtr -> withCString "fit_child_in_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Fit a child control in a given rect. This is mainly a helper for creating custom container classes. fit_child_in_rect :: (Container :< cls, Object :< cls) => cls -> Control -> Rect2 -> IO () fit_child_in_rect cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindContainer_fit_child_in_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Container "fit_child_in_rect" '[Control, Rect2] (IO ()) where nodeMethod = Godot.Core.Container.fit_child_in_rect {-# NOINLINE bindContainer_queue_sort #-} -- | Queue resort of the contained children. This is called automatically anyway, but can be called upon request. bindContainer_queue_sort :: MethodBind bindContainer_queue_sort = unsafePerformIO $ withCString "Container" $ \ clsNamePtr -> withCString "queue_sort" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Queue resort of the contained children. This is called automatically anyway, but can be called upon request. queue_sort :: (Container :< cls, Object :< cls) => cls -> IO () queue_sort cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindContainer_queue_sort (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Container "queue_sort" '[] (IO ()) where nodeMethod = Godot.Core.Container.queue_sort ================================================ FILE: src/Godot/Core/Control.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Control (Godot.Core.Control._NOTIFICATION_MOUSE_EXIT, Godot.Core.Control._CURSOR_MOVE, Godot.Core.Control._NOTIFICATION_MOUSE_ENTER, Godot.Core.Control._PRESET_MODE_KEEP_WIDTH, Godot.Core.Control._CURSOR_ARROW, Godot.Core.Control._GROW_DIRECTION_BEGIN, Godot.Core.Control._CURSOR_IBEAM, Godot.Core.Control._NOTIFICATION_SCROLL_END, Godot.Core.Control._CURSOR_HSPLIT, Godot.Core.Control._FOCUS_ALL, Godot.Core.Control._PRESET_BOTTOM_RIGHT, Godot.Core.Control._CURSOR_DRAG, Godot.Core.Control._PRESET_TOP_LEFT, Godot.Core.Control._PRESET_CENTER_TOP, Godot.Core.Control._FOCUS_CLICK, Godot.Core.Control._CURSOR_BUSY, Godot.Core.Control._SIZE_SHRINK_CENTER, Godot.Core.Control._CURSOR_CROSS, Godot.Core.Control._CURSOR_WAIT, Godot.Core.Control._PRESET_TOP_RIGHT, Godot.Core.Control._NOTIFICATION_THEME_CHANGED, Godot.Core.Control._CURSOR_BDIAGSIZE, Godot.Core.Control._PRESET_HCENTER_WIDE, Godot.Core.Control._GROW_DIRECTION_BOTH, Godot.Core.Control._ANCHOR_BEGIN, Godot.Core.Control._MOUSE_FILTER_IGNORE, Godot.Core.Control._PRESET_TOP_WIDE, Godot.Core.Control._PRESET_MODE_MINSIZE, Godot.Core.Control._NOTIFICATION_FOCUS_ENTER, Godot.Core.Control._SIZE_EXPAND_FILL, Godot.Core.Control._CURSOR_HELP, Godot.Core.Control._NOTIFICATION_RESIZED, Godot.Core.Control._SIZE_EXPAND, Godot.Core.Control._CURSOR_CAN_DROP, Godot.Core.Control._NOTIFICATION_SCROLL_BEGIN, Godot.Core.Control._PRESET_MODE_KEEP_SIZE, Godot.Core.Control._GROW_DIRECTION_END, Godot.Core.Control._PRESET_VCENTER_WIDE, Godot.Core.Control._SIZE_SHRINK_END, Godot.Core.Control._PRESET_RIGHT_WIDE, Godot.Core.Control._SIZE_FILL, Godot.Core.Control._PRESET_BOTTOM_WIDE, Godot.Core.Control._CURSOR_POINTING_HAND, Godot.Core.Control._PRESET_MODE_KEEP_HEIGHT, Godot.Core.Control._CURSOR_FDIAGSIZE, Godot.Core.Control._PRESET_WIDE, Godot.Core.Control._PRESET_CENTER_LEFT, Godot.Core.Control._MOUSE_FILTER_PASS, Godot.Core.Control._NOTIFICATION_MODAL_CLOSE, Godot.Core.Control._CURSOR_HSIZE, Godot.Core.Control._PRESET_CENTER_RIGHT, Godot.Core.Control._CURSOR_FORBIDDEN, Godot.Core.Control._CURSOR_VSIZE, Godot.Core.Control._PRESET_CENTER_BOTTOM, Godot.Core.Control._NOTIFICATION_FOCUS_EXIT, Godot.Core.Control._PRESET_LEFT_WIDE, Godot.Core.Control._ANCHOR_END, Godot.Core.Control._MOUSE_FILTER_STOP, Godot.Core.Control._PRESET_BOTTOM_LEFT, Godot.Core.Control._PRESET_CENTER, Godot.Core.Control._CURSOR_VSPLIT, Godot.Core.Control._FOCUS_NONE, Godot.Core.Control.sig_focus_entered, Godot.Core.Control.sig_focus_exited, Godot.Core.Control.sig_gui_input, Godot.Core.Control.sig_minimum_size_changed, Godot.Core.Control.sig_modal_closed, Godot.Core.Control.sig_mouse_entered, Godot.Core.Control.sig_mouse_exited, Godot.Core.Control.sig_resized, Godot.Core.Control.sig_size_flags_changed, Godot.Core.Control._clips_input, Godot.Core.Control._get_minimum_size, Godot.Core.Control._get_tooltip, Godot.Core.Control._gui_input, Godot.Core.Control._make_custom_tooltip, Godot.Core.Control._override_changed, Godot.Core.Control._set_anchor, Godot.Core.Control._set_global_position, Godot.Core.Control._set_position, Godot.Core.Control._set_size, Godot.Core.Control._size_changed, Godot.Core.Control._theme_changed, Godot.Core.Control._update_minimum_size, Godot.Core.Control.accept_event, Godot.Core.Control.add_color_override, Godot.Core.Control.add_constant_override, Godot.Core.Control.add_font_override, Godot.Core.Control.add_icon_override, Godot.Core.Control.add_shader_override, Godot.Core.Control.add_stylebox_override, Godot.Core.Control.can_drop_data, Godot.Core.Control.drop_data, Godot.Core.Control.force_drag, Godot.Core.Control.get_anchor, Godot.Core.Control.get_begin, Godot.Core.Control.get_color, Godot.Core.Control.get_combined_minimum_size, Godot.Core.Control.get_constant, Godot.Core.Control.get_cursor_shape, Godot.Core.Control.get_custom_minimum_size, Godot.Core.Control.get_default_cursor_shape, Godot.Core.Control.get_drag_data, Godot.Core.Control.get_end, Godot.Core.Control.get_focus_mode, Godot.Core.Control.get_focus_neighbour, Godot.Core.Control.get_focus_next, Godot.Core.Control.get_focus_owner, Godot.Core.Control.get_focus_previous, Godot.Core.Control.get_font, Godot.Core.Control.get_global_position, Godot.Core.Control.get_global_rect, Godot.Core.Control.get_h_grow_direction, Godot.Core.Control.get_h_size_flags, Godot.Core.Control.get_icon, Godot.Core.Control.get_margin, Godot.Core.Control.get_minimum_size, Godot.Core.Control.get_mouse_filter, Godot.Core.Control.get_parent_area_size, Godot.Core.Control.get_parent_control, Godot.Core.Control.get_pivot_offset, Godot.Core.Control.get_position, Godot.Core.Control.get_rect, Godot.Core.Control.get_rotation, Godot.Core.Control.get_rotation_degrees, Godot.Core.Control.get_scale, Godot.Core.Control.get_size, Godot.Core.Control.get_stretch_ratio, Godot.Core.Control.get_stylebox, Godot.Core.Control.get_theme, Godot.Core.Control.get_tooltip, Godot.Core.Control.get_v_grow_direction, Godot.Core.Control.get_v_size_flags, Godot.Core.Control.grab_click_focus, Godot.Core.Control.grab_focus, Godot.Core.Control.has_color, Godot.Core.Control.has_color_override, Godot.Core.Control.has_constant, Godot.Core.Control.has_constant_override, Godot.Core.Control.has_focus, Godot.Core.Control.has_font, Godot.Core.Control.has_font_override, Godot.Core.Control.has_icon, Godot.Core.Control.has_icon_override, Godot.Core.Control.has_point, Godot.Core.Control.has_shader_override, Godot.Core.Control.has_stylebox, Godot.Core.Control.has_stylebox_override, Godot.Core.Control.is_clipping_contents, Godot.Core.Control.minimum_size_changed, Godot.Core.Control.release_focus, Godot.Core.Control.set_anchor, Godot.Core.Control.set_anchor_and_margin, Godot.Core.Control.set_anchors_and_margins_preset, Godot.Core.Control.set_anchors_preset, Godot.Core.Control.set_begin, Godot.Core.Control.set_clip_contents, Godot.Core.Control.set_custom_minimum_size, Godot.Core.Control.set_default_cursor_shape, Godot.Core.Control.set_drag_forwarding, Godot.Core.Control.set_drag_preview, Godot.Core.Control.set_end, Godot.Core.Control.set_focus_mode, Godot.Core.Control.set_focus_neighbour, Godot.Core.Control.set_focus_next, Godot.Core.Control.set_focus_previous, Godot.Core.Control.set_global_position, Godot.Core.Control.set_h_grow_direction, Godot.Core.Control.set_h_size_flags, Godot.Core.Control.set_margin, Godot.Core.Control.set_margins_preset, Godot.Core.Control.set_mouse_filter, Godot.Core.Control.set_pivot_offset, Godot.Core.Control.set_position, Godot.Core.Control.set_rotation, Godot.Core.Control.set_rotation_degrees, Godot.Core.Control.set_scale, Godot.Core.Control.set_size, Godot.Core.Control.set_stretch_ratio, Godot.Core.Control.set_theme, Godot.Core.Control.set_tooltip, Godot.Core.Control.set_v_grow_direction, Godot.Core.Control.set_v_size_flags, Godot.Core.Control.show_modal, Godot.Core.Control.warp_mouse) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CanvasItem() _NOTIFICATION_MOUSE_EXIT :: Int _NOTIFICATION_MOUSE_EXIT = 42 _CURSOR_MOVE :: Int _CURSOR_MOVE = 13 _NOTIFICATION_MOUSE_ENTER :: Int _NOTIFICATION_MOUSE_ENTER = 41 _PRESET_MODE_KEEP_WIDTH :: Int _PRESET_MODE_KEEP_WIDTH = 1 _CURSOR_ARROW :: Int _CURSOR_ARROW = 0 _GROW_DIRECTION_BEGIN :: Int _GROW_DIRECTION_BEGIN = 0 _CURSOR_IBEAM :: Int _CURSOR_IBEAM = 1 _NOTIFICATION_SCROLL_END :: Int _NOTIFICATION_SCROLL_END = 48 _CURSOR_HSPLIT :: Int _CURSOR_HSPLIT = 15 _FOCUS_ALL :: Int _FOCUS_ALL = 2 _PRESET_BOTTOM_RIGHT :: Int _PRESET_BOTTOM_RIGHT = 3 _CURSOR_DRAG :: Int _CURSOR_DRAG = 6 _PRESET_TOP_LEFT :: Int _PRESET_TOP_LEFT = 0 _PRESET_CENTER_TOP :: Int _PRESET_CENTER_TOP = 5 _FOCUS_CLICK :: Int _FOCUS_CLICK = 1 _CURSOR_BUSY :: Int _CURSOR_BUSY = 5 _SIZE_SHRINK_CENTER :: Int _SIZE_SHRINK_CENTER = 4 _CURSOR_CROSS :: Int _CURSOR_CROSS = 3 _CURSOR_WAIT :: Int _CURSOR_WAIT = 4 _PRESET_TOP_RIGHT :: Int _PRESET_TOP_RIGHT = 1 _NOTIFICATION_THEME_CHANGED :: Int _NOTIFICATION_THEME_CHANGED = 45 _CURSOR_BDIAGSIZE :: Int _CURSOR_BDIAGSIZE = 11 _PRESET_HCENTER_WIDE :: Int _PRESET_HCENTER_WIDE = 14 _GROW_DIRECTION_BOTH :: Int _GROW_DIRECTION_BOTH = 2 _ANCHOR_BEGIN :: Int _ANCHOR_BEGIN = 0 _MOUSE_FILTER_IGNORE :: Int _MOUSE_FILTER_IGNORE = 2 _PRESET_TOP_WIDE :: Int _PRESET_TOP_WIDE = 10 _PRESET_MODE_MINSIZE :: Int _PRESET_MODE_MINSIZE = 0 _NOTIFICATION_FOCUS_ENTER :: Int _NOTIFICATION_FOCUS_ENTER = 43 _SIZE_EXPAND_FILL :: Int _SIZE_EXPAND_FILL = 3 _CURSOR_HELP :: Int _CURSOR_HELP = 16 _NOTIFICATION_RESIZED :: Int _NOTIFICATION_RESIZED = 40 _SIZE_EXPAND :: Int _SIZE_EXPAND = 2 _CURSOR_CAN_DROP :: Int _CURSOR_CAN_DROP = 7 _NOTIFICATION_SCROLL_BEGIN :: Int _NOTIFICATION_SCROLL_BEGIN = 47 _PRESET_MODE_KEEP_SIZE :: Int _PRESET_MODE_KEEP_SIZE = 3 _GROW_DIRECTION_END :: Int _GROW_DIRECTION_END = 1 _PRESET_VCENTER_WIDE :: Int _PRESET_VCENTER_WIDE = 13 _SIZE_SHRINK_END :: Int _SIZE_SHRINK_END = 8 _PRESET_RIGHT_WIDE :: Int _PRESET_RIGHT_WIDE = 11 _SIZE_FILL :: Int _SIZE_FILL = 1 _PRESET_BOTTOM_WIDE :: Int _PRESET_BOTTOM_WIDE = 12 _CURSOR_POINTING_HAND :: Int _CURSOR_POINTING_HAND = 2 _PRESET_MODE_KEEP_HEIGHT :: Int _PRESET_MODE_KEEP_HEIGHT = 2 _CURSOR_FDIAGSIZE :: Int _CURSOR_FDIAGSIZE = 12 _PRESET_WIDE :: Int _PRESET_WIDE = 15 _PRESET_CENTER_LEFT :: Int _PRESET_CENTER_LEFT = 4 _MOUSE_FILTER_PASS :: Int _MOUSE_FILTER_PASS = 1 _NOTIFICATION_MODAL_CLOSE :: Int _NOTIFICATION_MODAL_CLOSE = 46 _CURSOR_HSIZE :: Int _CURSOR_HSIZE = 10 _PRESET_CENTER_RIGHT :: Int _PRESET_CENTER_RIGHT = 6 _CURSOR_FORBIDDEN :: Int _CURSOR_FORBIDDEN = 8 _CURSOR_VSIZE :: Int _CURSOR_VSIZE = 9 _PRESET_CENTER_BOTTOM :: Int _PRESET_CENTER_BOTTOM = 7 _NOTIFICATION_FOCUS_EXIT :: Int _NOTIFICATION_FOCUS_EXIT = 44 _PRESET_LEFT_WIDE :: Int _PRESET_LEFT_WIDE = 9 _ANCHOR_END :: Int _ANCHOR_END = 1 _MOUSE_FILTER_STOP :: Int _MOUSE_FILTER_STOP = 0 _PRESET_BOTTOM_LEFT :: Int _PRESET_BOTTOM_LEFT = 2 _PRESET_CENTER :: Int _PRESET_CENTER = 8 _CURSOR_VSPLIT :: Int _CURSOR_VSPLIT = 14 _FOCUS_NONE :: Int _FOCUS_NONE = 0 -- | Emitted when the node gains keyboard focus. sig_focus_entered :: Godot.Internal.Dispatch.Signal Control sig_focus_entered = Godot.Internal.Dispatch.Signal "focus_entered" instance NodeSignal Control "focus_entered" '[] -- | Emitted when the node loses keyboard focus. sig_focus_exited :: Godot.Internal.Dispatch.Signal Control sig_focus_exited = Godot.Internal.Dispatch.Signal "focus_exited" instance NodeSignal Control "focus_exited" '[] -- | Emitted when the node receives an @InputEvent@. sig_gui_input :: Godot.Internal.Dispatch.Signal Control sig_gui_input = Godot.Internal.Dispatch.Signal "gui_input" instance NodeSignal Control "gui_input" '[InputEvent] -- | Emitted when the node's minimum size changes. sig_minimum_size_changed :: Godot.Internal.Dispatch.Signal Control sig_minimum_size_changed = Godot.Internal.Dispatch.Signal "minimum_size_changed" instance NodeSignal Control "minimum_size_changed" '[] -- | Emitted when a modal @Control@ is closed. See @method show_modal@. sig_modal_closed :: Godot.Internal.Dispatch.Signal Control sig_modal_closed = Godot.Internal.Dispatch.Signal "modal_closed" instance NodeSignal Control "modal_closed" '[] -- | Emitted when the mouse enters the control's @Rect@ area, provided its @mouse_filter@ lets the event reach it. sig_mouse_entered :: Godot.Internal.Dispatch.Signal Control sig_mouse_entered = Godot.Internal.Dispatch.Signal "mouse_entered" instance NodeSignal Control "mouse_entered" '[] -- | Emitted when the mouse leaves the control's @Rect@ area, provided its @mouse_filter@ lets the event reach it. sig_mouse_exited :: Godot.Internal.Dispatch.Signal Control sig_mouse_exited = Godot.Internal.Dispatch.Signal "mouse_exited" instance NodeSignal Control "mouse_exited" '[] -- | Emitted when the control changes size. sig_resized :: Godot.Internal.Dispatch.Signal Control sig_resized = Godot.Internal.Dispatch.Signal "resized" instance NodeSignal Control "resized" '[] -- | Emitted when one of the size flags changes. See @size_flags_horizontal@ and @size_flags_vertical@. sig_size_flags_changed :: Godot.Internal.Dispatch.Signal Control sig_size_flags_changed = Godot.Internal.Dispatch.Signal "size_flags_changed" instance NodeSignal Control "size_flags_changed" '[] instance NodeProperty Control "anchor_bottom" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_anchor, wrapIndexedSetter 3 _set_anchor, Nothing) instance NodeProperty Control "anchor_left" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_anchor, wrapIndexedSetter 0 _set_anchor, Nothing) instance NodeProperty Control "anchor_right" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_anchor, wrapIndexedSetter 2 _set_anchor, Nothing) instance NodeProperty Control "anchor_top" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_anchor, wrapIndexedSetter 1 _set_anchor, Nothing) instance NodeProperty Control "focus_mode" Int 'False where nodeProperty = (get_focus_mode, wrapDroppingSetter set_focus_mode, Nothing) instance NodeProperty Control "focus_neighbour_bottom" NodePath 'False where nodeProperty = (wrapIndexedGetter 3 get_focus_neighbour, wrapIndexedSetter 3 set_focus_neighbour, Nothing) instance NodeProperty Control "focus_neighbour_left" NodePath 'False where nodeProperty = (wrapIndexedGetter 0 get_focus_neighbour, wrapIndexedSetter 0 set_focus_neighbour, Nothing) instance NodeProperty Control "focus_neighbour_right" NodePath 'False where nodeProperty = (wrapIndexedGetter 2 get_focus_neighbour, wrapIndexedSetter 2 set_focus_neighbour, Nothing) instance NodeProperty Control "focus_neighbour_top" NodePath 'False where nodeProperty = (wrapIndexedGetter 1 get_focus_neighbour, wrapIndexedSetter 1 set_focus_neighbour, Nothing) instance NodeProperty Control "focus_next" NodePath 'False where nodeProperty = (get_focus_next, wrapDroppingSetter set_focus_next, Nothing) instance NodeProperty Control "focus_previous" NodePath 'False where nodeProperty = (get_focus_previous, wrapDroppingSetter set_focus_previous, Nothing) instance NodeProperty Control "grow_horizontal" Int 'False where nodeProperty = (get_h_grow_direction, wrapDroppingSetter set_h_grow_direction, Nothing) instance NodeProperty Control "grow_vertical" Int 'False where nodeProperty = (get_v_grow_direction, wrapDroppingSetter set_v_grow_direction, Nothing) instance NodeProperty Control "hint_tooltip" GodotString 'False where nodeProperty = (_get_tooltip, wrapDroppingSetter set_tooltip, Nothing) instance NodeProperty Control "margin_bottom" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_margin, wrapIndexedSetter 3 set_margin, Nothing) instance NodeProperty Control "margin_left" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_margin, wrapIndexedSetter 0 set_margin, Nothing) instance NodeProperty Control "margin_right" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_margin, wrapIndexedSetter 2 set_margin, Nothing) instance NodeProperty Control "margin_top" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_margin, wrapIndexedSetter 1 set_margin, Nothing) instance NodeProperty Control "mouse_default_cursor_shape" Int 'False where nodeProperty = (get_default_cursor_shape, wrapDroppingSetter set_default_cursor_shape, Nothing) instance NodeProperty Control "mouse_filter" Int 'False where nodeProperty = (get_mouse_filter, wrapDroppingSetter set_mouse_filter, Nothing) instance NodeProperty Control "rect_clip_content" Bool 'False where nodeProperty = (is_clipping_contents, wrapDroppingSetter set_clip_contents, Nothing) instance NodeProperty Control "rect_global_position" Vector2 'False where nodeProperty = (get_global_position, wrapDroppingSetter _set_global_position, Nothing) instance NodeProperty Control "rect_min_size" Vector2 'False where nodeProperty = (get_custom_minimum_size, wrapDroppingSetter set_custom_minimum_size, Nothing) instance NodeProperty Control "rect_pivot_offset" Vector2 'False where nodeProperty = (get_pivot_offset, wrapDroppingSetter set_pivot_offset, Nothing) instance NodeProperty Control "rect_position" Vector2 'False where nodeProperty = (get_position, wrapDroppingSetter _set_position, Nothing) instance NodeProperty Control "rect_rotation" Float 'False where nodeProperty = (get_rotation_degrees, wrapDroppingSetter set_rotation_degrees, Nothing) instance NodeProperty Control "rect_scale" Vector2 'False where nodeProperty = (get_scale, wrapDroppingSetter set_scale, Nothing) instance NodeProperty Control "rect_size" Vector2 'False where nodeProperty = (get_size, wrapDroppingSetter _set_size, Nothing) instance NodeProperty Control "size_flags_horizontal" Int 'False where nodeProperty = (get_h_size_flags, wrapDroppingSetter set_h_size_flags, Nothing) instance NodeProperty Control "size_flags_stretch_ratio" Float 'False where nodeProperty = (get_stretch_ratio, wrapDroppingSetter set_stretch_ratio, Nothing) instance NodeProperty Control "size_flags_vertical" Int 'False where nodeProperty = (get_v_size_flags, wrapDroppingSetter set_v_size_flags, Nothing) instance NodeProperty Control "theme" Theme 'False where nodeProperty = (get_theme, wrapDroppingSetter set_theme, Nothing) {-# NOINLINE bindControl__clips_input #-} -- | Virtual method to be implemented by the user. Returns whether @method _gui_input@ should not be called for children controls outside this control's rectangle. Input will be clipped to the Rect of this @Control@. Similar to @rect_clip_content@, but doesn't affect visibility. -- If not overridden, defaults to @false@. bindControl__clips_input :: MethodBind bindControl__clips_input = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_clips_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method to be implemented by the user. Returns whether @method _gui_input@ should not be called for children controls outside this control's rectangle. Input will be clipped to the Rect of this @Control@. Similar to @rect_clip_content@, but doesn't affect visibility. -- If not overridden, defaults to @false@. _clips_input :: (Control :< cls, Object :< cls) => cls -> IO Bool _clips_input cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl__clips_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_clips_input" '[] (IO Bool) where nodeMethod = Godot.Core.Control._clips_input {-# NOINLINE bindControl__get_minimum_size #-} -- | Virtual method to be implemented by the user. Returns the minimum size for this control. Alternative to @rect_min_size@ for controlling minimum size via code. The actual minimum size will be the max value of these two (in each axis separately). -- If not overridden, defaults to @Vector2.ZERO@. bindControl__get_minimum_size :: MethodBind bindControl__get_minimum_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_get_minimum_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method to be implemented by the user. Returns the minimum size for this control. Alternative to @rect_min_size@ for controlling minimum size via code. The actual minimum size will be the max value of these two (in each axis separately). -- If not overridden, defaults to @Vector2.ZERO@. _get_minimum_size :: (Control :< cls, Object :< cls) => cls -> IO Vector2 _get_minimum_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl__get_minimum_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_get_minimum_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Control._get_minimum_size {-# NOINLINE bindControl__get_tooltip #-} -- | Changes the tooltip text. The tooltip appears when the user's mouse cursor stays idle over this control for a few moments, provided that the @mouse_filter@ property is not @MOUSE_FILTER_IGNORE@. You can change the time required for the tooltip to appear with @gui/timers/tooltip_delay_sec@ option in Project Settings. bindControl__get_tooltip :: MethodBind bindControl__get_tooltip = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_get_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the tooltip text. The tooltip appears when the user's mouse cursor stays idle over this control for a few moments, provided that the @mouse_filter@ property is not @MOUSE_FILTER_IGNORE@. You can change the time required for the tooltip to appear with @gui/timers/tooltip_delay_sec@ option in Project Settings. _get_tooltip :: (Control :< cls, Object :< cls) => cls -> IO GodotString _get_tooltip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl__get_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_get_tooltip" '[] (IO GodotString) where nodeMethod = Godot.Core.Control._get_tooltip {-# NOINLINE bindControl__gui_input #-} -- | Virtual method to be implemented by the user. Use this method to process and accept inputs on UI elements. See @method accept_event@. -- Example: clicking a control. -- -- @ -- -- func _gui_input(event): -- if event is InputEventMouseButton: -- if event.button_index == BUTTON_LEFT and event.pressed: -- print("I've been clicked D:") -- -- @ -- -- The event won't trigger if: -- * clicking outside the control (see @method has_point@); -- * control has @mouse_filter@ set to @MOUSE_FILTER_IGNORE@; -- * control is obstructed by another @Control@ on top of it, which doesn't have @mouse_filter@ set to @MOUSE_FILTER_IGNORE@; -- * control's parent has @mouse_filter@ set to @MOUSE_FILTER_STOP@ or has accepted the event; -- * it happens outside parent's rectangle and the parent has either @rect_clip_content@ or @method _clips_input@ enabled. bindControl__gui_input :: MethodBind bindControl__gui_input = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method to be implemented by the user. Use this method to process and accept inputs on UI elements. See @method accept_event@. -- Example: clicking a control. -- -- @ -- -- func _gui_input(event): -- if event is InputEventMouseButton: -- if event.button_index == BUTTON_LEFT and event.pressed: -- print("I've been clicked D:") -- -- @ -- -- The event won't trigger if: -- * clicking outside the control (see @method has_point@); -- * control has @mouse_filter@ set to @MOUSE_FILTER_IGNORE@; -- * control is obstructed by another @Control@ on top of it, which doesn't have @mouse_filter@ set to @MOUSE_FILTER_IGNORE@; -- * control's parent has @mouse_filter@ set to @MOUSE_FILTER_STOP@ or has accepted the event; -- * it happens outside parent's rectangle and the parent has either @rect_clip_content@ or @method _clips_input@ enabled. _gui_input :: (Control :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Control._gui_input {-# NOINLINE bindControl__make_custom_tooltip #-} -- | Virtual method to be implemented by the user. Returns a @Control@ node that should be used as a tooltip instead of the default one. Use @for_text@ parameter to determine what text the tooltip should contain (likely the contents of @hint_tooltip@). -- The returned node must be of type @Control@ or Control-derieved. It can have child nodes of any type. It is freed when the tooltip disappears, so make sure you always provide a new instance, not e.g. a node from scene. When @null@ or non-Control node is returned, the default tooltip will be used instead. -- __Note:__ The tooltip is shrunk to minimal size. If you want to ensure it's fully visible, you might want to set its @rect_min_size@ to some non-zero value. -- Example of usage with custom-constructed node: -- -- @ -- -- func _make_custom_tooltip(for_text): -- var label = Label.new() -- label.text = for_text -- return label -- -- @ -- -- Example of usage with custom scene instance: -- -- @ -- -- func _make_custom_tooltip(for_text): -- var tooltip = preload("SomeTooltipScene.tscn").instance() -- tooltip.get_node("Label").text = for_text -- return tooltip -- -- @ bindControl__make_custom_tooltip :: MethodBind bindControl__make_custom_tooltip = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_make_custom_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method to be implemented by the user. Returns a @Control@ node that should be used as a tooltip instead of the default one. Use @for_text@ parameter to determine what text the tooltip should contain (likely the contents of @hint_tooltip@). -- The returned node must be of type @Control@ or Control-derieved. It can have child nodes of any type. It is freed when the tooltip disappears, so make sure you always provide a new instance, not e.g. a node from scene. When @null@ or non-Control node is returned, the default tooltip will be used instead. -- __Note:__ The tooltip is shrunk to minimal size. If you want to ensure it's fully visible, you might want to set its @rect_min_size@ to some non-zero value. -- Example of usage with custom-constructed node: -- -- @ -- -- func _make_custom_tooltip(for_text): -- var label = Label.new() -- label.text = for_text -- return label -- -- @ -- -- Example of usage with custom scene instance: -- -- @ -- -- func _make_custom_tooltip(for_text): -- var tooltip = preload("SomeTooltipScene.tscn").instance() -- tooltip.get_node("Label").text = for_text -- return tooltip -- -- @ _make_custom_tooltip :: (Control :< cls, Object :< cls) => cls -> GodotString -> IO Object _make_custom_tooltip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl__make_custom_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_make_custom_tooltip" '[GodotString] (IO Object) where nodeMethod = Godot.Core.Control._make_custom_tooltip {-# NOINLINE bindControl__override_changed #-} bindControl__override_changed :: MethodBind bindControl__override_changed = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_override_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _override_changed :: (Control :< cls, Object :< cls) => cls -> IO () _override_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl__override_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_override_changed" '[] (IO ()) where nodeMethod = Godot.Core.Control._override_changed {-# NOINLINE bindControl__set_anchor #-} -- | Anchors the bottom edge of the node to the origin, the center, or the end of its parent control. It changes how the bottom margin updates when the node moves or changes size. You can use one of the @enum Anchor@ constants for convenience. bindControl__set_anchor :: MethodBind bindControl__set_anchor = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_set_anchor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Anchors the bottom edge of the node to the origin, the center, or the end of its parent control. It changes how the bottom margin updates when the node moves or changes size. You can use one of the @enum Anchor@ constants for convenience. _set_anchor :: (Control :< cls, Object :< cls) => cls -> Int -> Float -> IO () _set_anchor cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl__set_anchor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_set_anchor" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Control._set_anchor {-# NOINLINE bindControl__set_global_position #-} -- | The node's global position, relative to the world (usually to the top-left corner of the window). bindControl__set_global_position :: MethodBind bindControl__set_global_position = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_set_global_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's global position, relative to the world (usually to the top-left corner of the window). _set_global_position :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () _set_global_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl__set_global_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_set_global_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control._set_global_position {-# NOINLINE bindControl__set_position #-} -- | The node's position, relative to its parent. It corresponds to the rectangle's top-left corner. The property is not affected by @rect_pivot_offset@. bindControl__set_position :: MethodBind bindControl__set_position = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's position, relative to its parent. It corresponds to the rectangle's top-left corner. The property is not affected by @rect_pivot_offset@. _set_position :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () _set_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl__set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_set_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control._set_position {-# NOINLINE bindControl__set_size #-} -- | The size of the node's bounding rectangle, in pixels. @Container@ nodes update this property automatically. bindControl__set_size :: MethodBind bindControl__set_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the node's bounding rectangle, in pixels. @Container@ nodes update this property automatically. _set_size :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () _set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl__set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_set_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control._set_size {-# NOINLINE bindControl__size_changed #-} bindControl__size_changed :: MethodBind bindControl__size_changed = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_size_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _size_changed :: (Control :< cls, Object :< cls) => cls -> IO () _size_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl__size_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_size_changed" '[] (IO ()) where nodeMethod = Godot.Core.Control._size_changed {-# NOINLINE bindControl__theme_changed #-} bindControl__theme_changed :: MethodBind bindControl__theme_changed = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_theme_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _theme_changed :: (Control :< cls, Object :< cls) => cls -> IO () _theme_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl__theme_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_theme_changed" '[] (IO ()) where nodeMethod = Godot.Core.Control._theme_changed {-# NOINLINE bindControl__update_minimum_size #-} bindControl__update_minimum_size :: MethodBind bindControl__update_minimum_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "_update_minimum_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_minimum_size :: (Control :< cls, Object :< cls) => cls -> IO () _update_minimum_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl__update_minimum_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "_update_minimum_size" '[] (IO ()) where nodeMethod = Godot.Core.Control._update_minimum_size {-# NOINLINE bindControl_accept_event #-} -- | Marks an input event as handled. Once you accept an input event, it stops propagating, even to nodes listening to @method Node._unhandled_input@ or @method Node._unhandled_key_input@. bindControl_accept_event :: MethodBind bindControl_accept_event = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "accept_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Marks an input event as handled. Once you accept an input event, it stops propagating, even to nodes listening to @method Node._unhandled_input@ or @method Node._unhandled_key_input@. accept_event :: (Control :< cls, Object :< cls) => cls -> IO () accept_event cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_accept_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "accept_event" '[] (IO ()) where nodeMethod = Godot.Core.Control.accept_event {-# NOINLINE bindControl_add_color_override #-} -- | Overrides the @Color@ with given @name@ in the @theme@ resource the control uses. -- __Note:__ Unlike other theme overrides, there is no way to undo a color override without manually assigning the previous color. -- __Example of overriding a label's color and resetting it later:__ -- -- @ -- -- # Override the child node "MyLabel"'s font color to orange. -- $MyLabel.add_color_override("font_color", Color(1, 0.5, 0)) -- -- # Reset the color by creating a new node to get the default value: -- var default_label_color = Label.new().get_color("font_color") -- $MyLabel.add_color_override("font_color", default_label_color) -- -- @ bindControl_add_color_override :: MethodBind bindControl_add_color_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "add_color_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the @Color@ with given @name@ in the @theme@ resource the control uses. -- __Note:__ Unlike other theme overrides, there is no way to undo a color override without manually assigning the previous color. -- __Example of overriding a label's color and resetting it later:__ -- -- @ -- -- # Override the child node "MyLabel"'s font color to orange. -- $MyLabel.add_color_override("font_color", Color(1, 0.5, 0)) -- -- # Reset the color by creating a new node to get the default value: -- var default_label_color = Label.new().get_color("font_color") -- $MyLabel.add_color_override("font_color", default_label_color) -- -- @ add_color_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> Color -> IO () add_color_override cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_add_color_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "add_color_override" '[GodotString, Color] (IO ()) where nodeMethod = Godot.Core.Control.add_color_override {-# NOINLINE bindControl_add_constant_override #-} -- | Overrides an integer constant with given @name@ in the @theme@ resource the control uses. If the @constant@ is @0@, the override is cleared and the constant from assigned @Theme@ is used. bindControl_add_constant_override :: MethodBind bindControl_add_constant_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "add_constant_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides an integer constant with given @name@ in the @theme@ resource the control uses. If the @constant@ is @0@, the override is cleared and the constant from assigned @Theme@ is used. add_constant_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () add_constant_override cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_add_constant_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "add_constant_override" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.Control.add_constant_override {-# NOINLINE bindControl_add_font_override #-} -- | Overrides the font with given @name@ in the @theme@ resource the control uses. If @font@ is @null@ or invalid, the override is cleared and the font from assigned @Theme@ is used. bindControl_add_font_override :: MethodBind bindControl_add_font_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "add_font_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the font with given @name@ in the @theme@ resource the control uses. If @font@ is @null@ or invalid, the override is cleared and the font from assigned @Theme@ is used. add_font_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> Font -> IO () add_font_override cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_add_font_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "add_font_override" '[GodotString, Font] (IO ()) where nodeMethod = Godot.Core.Control.add_font_override {-# NOINLINE bindControl_add_icon_override #-} -- | Overrides the icon with given @name@ in the @theme@ resource the control uses. If @icon@ is @null@ or invalid, the override is cleared and the icon from assigned @Theme@ is used. bindControl_add_icon_override :: MethodBind bindControl_add_icon_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "add_icon_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the icon with given @name@ in the @theme@ resource the control uses. If @icon@ is @null@ or invalid, the override is cleared and the icon from assigned @Theme@ is used. add_icon_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> Texture -> IO () add_icon_override cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_add_icon_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "add_icon_override" '[GodotString, Texture] (IO ()) where nodeMethod = Godot.Core.Control.add_icon_override {-# NOINLINE bindControl_add_shader_override #-} -- | Overrides the @Shader@ with given @name@ in the @theme@ resource the control uses. If @shader@ is @null@ or invalid, the override is cleared and the shader from assigned @Theme@ is used. bindControl_add_shader_override :: MethodBind bindControl_add_shader_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "add_shader_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the @Shader@ with given @name@ in the @theme@ resource the control uses. If @shader@ is @null@ or invalid, the override is cleared and the shader from assigned @Theme@ is used. add_shader_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> Shader -> IO () add_shader_override cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_add_shader_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "add_shader_override" '[GodotString, Shader] (IO ()) where nodeMethod = Godot.Core.Control.add_shader_override {-# NOINLINE bindControl_add_stylebox_override #-} -- | Overrides the @StyleBox@ with given @name@ in the @theme@ resource the control uses. If @stylebox@ is empty or invalid, the override is cleared and the @StyleBox@ from assigned @Theme@ is used. -- __Example of modifying a property in a StyleBox by duplicating it:__ -- -- @ -- -- # The snippet below assumes the child node MyButton has a StyleBoxFlat assigned. -- # Resources are shared across instances, so we need to duplicate it -- # to avoid modifying the appearance of all other buttons. -- var new_stylebox_normal = $MyButton.get_stylebox("normal").duplicate() -- new_stylebox_normal.border_width_top = 3 -- new_stylebox_normal.border_color = Color(0, 1, 0.5) -- $MyButton.add_stylebox_override("normal", new_stylebox_normal) -- -- # Remove the stylebox override: -- $MyButton.add_stylebox_override("normal", null) -- -- @ bindControl_add_stylebox_override :: MethodBind bindControl_add_stylebox_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "add_stylebox_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the @StyleBox@ with given @name@ in the @theme@ resource the control uses. If @stylebox@ is empty or invalid, the override is cleared and the @StyleBox@ from assigned @Theme@ is used. -- __Example of modifying a property in a StyleBox by duplicating it:__ -- -- @ -- -- # The snippet below assumes the child node MyButton has a StyleBoxFlat assigned. -- # Resources are shared across instances, so we need to duplicate it -- # to avoid modifying the appearance of all other buttons. -- var new_stylebox_normal = $MyButton.get_stylebox("normal").duplicate() -- new_stylebox_normal.border_width_top = 3 -- new_stylebox_normal.border_color = Color(0, 1, 0.5) -- $MyButton.add_stylebox_override("normal", new_stylebox_normal) -- -- # Remove the stylebox override: -- $MyButton.add_stylebox_override("normal", null) -- -- @ add_stylebox_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> StyleBox -> IO () add_stylebox_override cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_add_stylebox_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "add_stylebox_override" '[GodotString, StyleBox] (IO ()) where nodeMethod = Godot.Core.Control.add_stylebox_override {-# NOINLINE bindControl_can_drop_data #-} -- | Godot calls this method to test if @data@ from a control's @method get_drag_data@ can be dropped at @position@. @position@ is local to this control. -- This method should only be used to test the data. Process the data in @method drop_data@. -- -- @ -- -- func can_drop_data(position, data): -- # Check position if it is relevant to you -- # Otherwise, just check data -- return typeof(data) == TYPE_DICTIONARY and data.has("expected") -- -- @ bindControl_can_drop_data :: MethodBind bindControl_can_drop_data = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "can_drop_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Godot calls this method to test if @data@ from a control's @method get_drag_data@ can be dropped at @position@. @position@ is local to this control. -- This method should only be used to test the data. Process the data in @method drop_data@. -- -- @ -- -- func can_drop_data(position, data): -- # Check position if it is relevant to you -- # Otherwise, just check data -- return typeof(data) == TYPE_DICTIONARY and data.has("expected") -- -- @ can_drop_data :: (Control :< cls, Object :< cls) => cls -> Vector2 -> GodotVariant -> IO Bool can_drop_data cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_can_drop_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "can_drop_data" '[Vector2, GodotVariant] (IO Bool) where nodeMethod = Godot.Core.Control.can_drop_data {-# NOINLINE bindControl_drop_data #-} -- | Godot calls this method to pass you the @data@ from a control's @method get_drag_data@ result. Godot first calls @method can_drop_data@ to test if @data@ is allowed to drop at @position@ where @position@ is local to this control. -- -- @ -- -- func can_drop_data(position, data): -- return typeof(data) == TYPE_DICTIONARY and data.has("color") -- -- func drop_data(position, data): -- color = data@"color"@ -- -- @ bindControl_drop_data :: MethodBind bindControl_drop_data = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "drop_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Godot calls this method to pass you the @data@ from a control's @method get_drag_data@ result. Godot first calls @method can_drop_data@ to test if @data@ is allowed to drop at @position@ where @position@ is local to this control. -- -- @ -- -- func can_drop_data(position, data): -- return typeof(data) == TYPE_DICTIONARY and data.has("color") -- -- func drop_data(position, data): -- color = data@"color"@ -- -- @ drop_data :: (Control :< cls, Object :< cls) => cls -> Vector2 -> GodotVariant -> IO () drop_data cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_drop_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "drop_data" '[Vector2, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Control.drop_data {-# NOINLINE bindControl_force_drag #-} -- | Forces drag and bypasses @method get_drag_data@ and @method set_drag_preview@ by passing @data@ and @preview@. Drag will start even if the mouse is neither over nor pressed on this control. -- The methods @method can_drop_data@ and @method drop_data@ must be implemented on controls that want to receive drop data. bindControl_force_drag :: MethodBind bindControl_force_drag = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "force_drag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Forces drag and bypasses @method get_drag_data@ and @method set_drag_preview@ by passing @data@ and @preview@. Drag will start even if the mouse is neither over nor pressed on this control. -- The methods @method can_drop_data@ and @method drop_data@ must be implemented on controls that want to receive drop data. force_drag :: (Control :< cls, Object :< cls) => cls -> GodotVariant -> Control -> IO () force_drag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_force_drag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "force_drag" '[GodotVariant, Control] (IO ()) where nodeMethod = Godot.Core.Control.force_drag {-# NOINLINE bindControl_get_anchor #-} -- | Returns the anchor identified by @margin@ constant from @enum Margin@ enum. A getter method for @anchor_bottom@, @anchor_left@, @anchor_right@ and @anchor_top@. bindControl_get_anchor :: MethodBind bindControl_get_anchor = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_anchor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the anchor identified by @margin@ constant from @enum Margin@ enum. A getter method for @anchor_bottom@, @anchor_left@, @anchor_right@ and @anchor_top@. get_anchor :: (Control :< cls, Object :< cls) => cls -> Int -> IO Float get_anchor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_anchor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_anchor" '[Int] (IO Float) where nodeMethod = Godot.Core.Control.get_anchor {-# NOINLINE bindControl_get_begin #-} -- | Returns @margin_left@ and @margin_top@. See also @rect_position@. bindControl_get_begin :: MethodBind bindControl_get_begin = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @margin_left@ and @margin_top@. See also @rect_position@. get_begin :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_begin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_begin" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_begin {-# NOINLINE bindControl_get_color #-} -- | Returns a color from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. -- -- @ -- -- func _ready(): -- modulate = get_color("font_color", "Button") #get the color defined for button fonts -- -- @ bindControl_get_color :: MethodBind bindControl_get_color = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a color from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. -- -- @ -- -- func _ready(): -- modulate = get_color("font_color", "Button") #get the color defined for button fonts -- -- @ get_color :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Color get_color cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_color" '[GodotString, Maybe GodotString] (IO Color) where nodeMethod = Godot.Core.Control.get_color {-# NOINLINE bindControl_get_combined_minimum_size #-} -- | Returns combined minimum size from @rect_min_size@ and @method get_minimum_size@. bindControl_get_combined_minimum_size :: MethodBind bindControl_get_combined_minimum_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_combined_minimum_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns combined minimum size from @rect_min_size@ and @method get_minimum_size@. get_combined_minimum_size :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_combined_minimum_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_combined_minimum_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_combined_minimum_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_combined_minimum_size {-# NOINLINE bindControl_get_constant #-} -- | Returns a constant from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. bindControl_get_constant :: MethodBind bindControl_get_constant = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a constant from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. get_constant :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Int get_constant cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_constant" '[GodotString, Maybe GodotString] (IO Int) where nodeMethod = Godot.Core.Control.get_constant {-# NOINLINE bindControl_get_cursor_shape #-} -- | Returns the mouse cursor shape the control displays on mouse hover. See @enum CursorShape@. bindControl_get_cursor_shape :: MethodBind bindControl_get_cursor_shape = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_cursor_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the mouse cursor shape the control displays on mouse hover. See @enum CursorShape@. get_cursor_shape :: (Control :< cls, Object :< cls) => cls -> Maybe Vector2 -> IO Int get_cursor_shape cls arg1 = withVariantArray [defaultedVariant VariantVector2 (V2 0 0) arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_cursor_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_cursor_shape" '[Maybe Vector2] (IO Int) where nodeMethod = Godot.Core.Control.get_cursor_shape {-# NOINLINE bindControl_get_custom_minimum_size #-} -- | The minimum size of the node's bounding rectangle. If you set it to a value greater than (0, 0), the node's bounding rectangle will always have at least this size, even if its content is smaller. If it's set to (0, 0), the node sizes automatically to fit its content, be it a texture or child nodes. bindControl_get_custom_minimum_size :: MethodBind bindControl_get_custom_minimum_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_custom_minimum_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum size of the node's bounding rectangle. If you set it to a value greater than (0, 0), the node's bounding rectangle will always have at least this size, even if its content is smaller. If it's set to (0, 0), the node sizes automatically to fit its content, be it a texture or child nodes. get_custom_minimum_size :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_custom_minimum_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_custom_minimum_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_custom_minimum_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_custom_minimum_size {-# NOINLINE bindControl_get_default_cursor_shape #-} -- | The default cursor shape for this control. Useful for Godot plugins and applications or games that use the system's mouse cursors. -- __Note:__ On Linux, shapes may vary depending on the cursor theme of the system. bindControl_get_default_cursor_shape :: MethodBind bindControl_get_default_cursor_shape = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_default_cursor_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The default cursor shape for this control. Useful for Godot plugins and applications or games that use the system's mouse cursors. -- __Note:__ On Linux, shapes may vary depending on the cursor theme of the system. get_default_cursor_shape :: (Control :< cls, Object :< cls) => cls -> IO Int get_default_cursor_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_default_cursor_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_default_cursor_shape" '[] (IO Int) where nodeMethod = Godot.Core.Control.get_default_cursor_shape {-# NOINLINE bindControl_get_drag_data #-} -- | Godot calls this method to get data that can be dragged and dropped onto controls that expect drop data. Returns @null@ if there is no data to drag. Controls that want to receive drop data should implement @method can_drop_data@ and @method drop_data@. @position@ is local to this control. Drag may be forced with @method force_drag@. -- A preview that will follow the mouse that should represent the data can be set with @method set_drag_preview@. A good time to set the preview is in this method. -- -- @ -- -- func get_drag_data(position): -- var mydata = make_data() -- set_drag_preview(make_preview(mydata)) -- return mydata -- -- @ bindControl_get_drag_data :: MethodBind bindControl_get_drag_data = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_drag_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Godot calls this method to get data that can be dragged and dropped onto controls that expect drop data. Returns @null@ if there is no data to drag. Controls that want to receive drop data should implement @method can_drop_data@ and @method drop_data@. @position@ is local to this control. Drag may be forced with @method force_drag@. -- A preview that will follow the mouse that should represent the data can be set with @method set_drag_preview@. A good time to set the preview is in this method. -- -- @ -- -- func get_drag_data(position): -- var mydata = make_data() -- set_drag_preview(make_preview(mydata)) -- return mydata -- -- @ get_drag_data :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO GodotVariant get_drag_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_drag_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_drag_data" '[Vector2] (IO GodotVariant) where nodeMethod = Godot.Core.Control.get_drag_data {-# NOINLINE bindControl_get_end #-} -- | Returns @margin_right@ and @margin_bottom@. bindControl_get_end :: MethodBind bindControl_get_end = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @margin_right@ and @margin_bottom@. get_end :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_end" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_end {-# NOINLINE bindControl_get_focus_mode #-} -- | The focus access mode for the control (None, Click or All). Only one Control can be focused at the same time, and it will receive keyboard signals. bindControl_get_focus_mode :: MethodBind bindControl_get_focus_mode = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_focus_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The focus access mode for the control (None, Click or All). Only one Control can be focused at the same time, and it will receive keyboard signals. get_focus_mode :: (Control :< cls, Object :< cls) => cls -> IO Int get_focus_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_focus_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_focus_mode" '[] (IO Int) where nodeMethod = Godot.Core.Control.get_focus_mode {-# NOINLINE bindControl_get_focus_neighbour #-} -- | Returns the focus neighbour identified by @margin@ constant from @enum Margin@ enum. A getter method for @focus_neighbour_bottom@, @focus_neighbour_left@, @focus_neighbour_right@ and @focus_neighbour_top@. bindControl_get_focus_neighbour :: MethodBind bindControl_get_focus_neighbour = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_focus_neighbour" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the focus neighbour identified by @margin@ constant from @enum Margin@ enum. A getter method for @focus_neighbour_bottom@, @focus_neighbour_left@, @focus_neighbour_right@ and @focus_neighbour_top@. get_focus_neighbour :: (Control :< cls, Object :< cls) => cls -> Int -> IO NodePath get_focus_neighbour cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_focus_neighbour (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_focus_neighbour" '[Int] (IO NodePath) where nodeMethod = Godot.Core.Control.get_focus_neighbour {-# NOINLINE bindControl_get_focus_next #-} -- | Tells Godot which node it should give keyboard focus to if the user presses Tab on a keyboard by default. You can change the key by editing the @ui_focus_next@ input action. -- If this property is not set, Godot will select a "best guess" based on surrounding nodes in the scene tree. bindControl_get_focus_next :: MethodBind bindControl_get_focus_next = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_focus_next" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells Godot which node it should give keyboard focus to if the user presses Tab on a keyboard by default. You can change the key by editing the @ui_focus_next@ input action. -- If this property is not set, Godot will select a "best guess" based on surrounding nodes in the scene tree. get_focus_next :: (Control :< cls, Object :< cls) => cls -> IO NodePath get_focus_next cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_focus_next (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_focus_next" '[] (IO NodePath) where nodeMethod = Godot.Core.Control.get_focus_next {-# NOINLINE bindControl_get_focus_owner #-} -- | Returns the control that has the keyboard focus or @null@ if none. bindControl_get_focus_owner :: MethodBind bindControl_get_focus_owner = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_focus_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the control that has the keyboard focus or @null@ if none. get_focus_owner :: (Control :< cls, Object :< cls) => cls -> IO Control get_focus_owner cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_focus_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_focus_owner" '[] (IO Control) where nodeMethod = Godot.Core.Control.get_focus_owner {-# NOINLINE bindControl_get_focus_previous #-} -- | Tells Godot which node it should give keyboard focus to if the user presses Shift+Tab on a keyboard by default. You can change the key by editing the @ui_focus_prev@ input action. -- If this property is not set, Godot will select a "best guess" based on surrounding nodes in the scene tree. bindControl_get_focus_previous :: MethodBind bindControl_get_focus_previous = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_focus_previous" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells Godot which node it should give keyboard focus to if the user presses Shift+Tab on a keyboard by default. You can change the key by editing the @ui_focus_prev@ input action. -- If this property is not set, Godot will select a "best guess" based on surrounding nodes in the scene tree. get_focus_previous :: (Control :< cls, Object :< cls) => cls -> IO NodePath get_focus_previous cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_focus_previous (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_focus_previous" '[] (IO NodePath) where nodeMethod = Godot.Core.Control.get_focus_previous {-# NOINLINE bindControl_get_font #-} -- | Returns a font from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. bindControl_get_font :: MethodBind bindControl_get_font = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a font from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. get_font :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Font get_font cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_font" '[GodotString, Maybe GodotString] (IO Font) where nodeMethod = Godot.Core.Control.get_font {-# NOINLINE bindControl_get_global_position #-} -- | The node's global position, relative to the world (usually to the top-left corner of the window). bindControl_get_global_position :: MethodBind bindControl_get_global_position = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_global_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's global position, relative to the world (usually to the top-left corner of the window). get_global_position :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_global_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_global_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_global_position" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_global_position {-# NOINLINE bindControl_get_global_rect #-} -- | Returns the position and size of the control relative to the top-left corner of the screen. See @rect_position@ and @rect_size@. bindControl_get_global_rect :: MethodBind bindControl_get_global_rect = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_global_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position and size of the control relative to the top-left corner of the screen. See @rect_position@ and @rect_size@. get_global_rect :: (Control :< cls, Object :< cls) => cls -> IO Rect2 get_global_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_global_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_global_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Control.get_global_rect {-# NOINLINE bindControl_get_h_grow_direction #-} -- | Controls the direction on the horizontal axis in which the control should grow if its horizontal minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size. bindControl_get_h_grow_direction :: MethodBind bindControl_get_h_grow_direction = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_h_grow_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the direction on the horizontal axis in which the control should grow if its horizontal minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size. get_h_grow_direction :: (Control :< cls, Object :< cls) => cls -> IO Int get_h_grow_direction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_h_grow_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_h_grow_direction" '[] (IO Int) where nodeMethod = Godot.Core.Control.get_h_grow_direction {-# NOINLINE bindControl_get_h_size_flags #-} -- | Tells the parent @Container@ nodes how they should resize and place the node on the X axis. Use one of the @enum SizeFlags@ constants to change the flags. See the constants to learn what each does. bindControl_get_h_size_flags :: MethodBind bindControl_get_h_size_flags = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_h_size_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells the parent @Container@ nodes how they should resize and place the node on the X axis. Use one of the @enum SizeFlags@ constants to change the flags. See the constants to learn what each does. get_h_size_flags :: (Control :< cls, Object :< cls) => cls -> IO Int get_h_size_flags cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_h_size_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_h_size_flags" '[] (IO Int) where nodeMethod = Godot.Core.Control.get_h_size_flags {-# NOINLINE bindControl_get_icon #-} -- | Returns an icon from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. bindControl_get_icon :: MethodBind bindControl_get_icon = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an icon from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. get_icon :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Texture get_icon cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_icon" '[GodotString, Maybe GodotString] (IO Texture) where nodeMethod = Godot.Core.Control.get_icon {-# NOINLINE bindControl_get_margin #-} -- | Returns the anchor identified by @margin@ constant from @enum Margin@ enum. A getter method for @margin_bottom@, @margin_left@, @margin_right@ and @margin_top@. bindControl_get_margin :: MethodBind bindControl_get_margin = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the anchor identified by @margin@ constant from @enum Margin@ enum. A getter method for @margin_bottom@, @margin_left@, @margin_right@ and @margin_top@. get_margin :: (Control :< cls, Object :< cls) => cls -> Int -> IO Float get_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_margin" '[Int] (IO Float) where nodeMethod = Godot.Core.Control.get_margin {-# NOINLINE bindControl_get_minimum_size #-} -- | Returns the minimum size for this control. See @rect_min_size@. bindControl_get_minimum_size :: MethodBind bindControl_get_minimum_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_minimum_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the minimum size for this control. See @rect_min_size@. get_minimum_size :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_minimum_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_minimum_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_minimum_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_minimum_size {-# NOINLINE bindControl_get_mouse_filter #-} -- | Controls whether the control will be able to receive mouse button input events through @method _gui_input@ and how these events should be handled. Also controls whether the control can receive the @signal mouse_entered@, and @signal mouse_exited@ signals. See the constants to learn what each does. bindControl_get_mouse_filter :: MethodBind bindControl_get_mouse_filter = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_mouse_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls whether the control will be able to receive mouse button input events through @method _gui_input@ and how these events should be handled. Also controls whether the control can receive the @signal mouse_entered@, and @signal mouse_exited@ signals. See the constants to learn what each does. get_mouse_filter :: (Control :< cls, Object :< cls) => cls -> IO Int get_mouse_filter cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_mouse_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_mouse_filter" '[] (IO Int) where nodeMethod = Godot.Core.Control.get_mouse_filter {-# NOINLINE bindControl_get_parent_area_size #-} -- | Returns the width/height occupied in the parent control. bindControl_get_parent_area_size :: MethodBind bindControl_get_parent_area_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_parent_area_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the width/height occupied in the parent control. get_parent_area_size :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_parent_area_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_parent_area_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_parent_area_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_parent_area_size {-# NOINLINE bindControl_get_parent_control #-} -- | Returns the parent control node. bindControl_get_parent_control :: MethodBind bindControl_get_parent_control = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_parent_control" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parent control node. get_parent_control :: (Control :< cls, Object :< cls) => cls -> IO Control get_parent_control cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_parent_control (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_parent_control" '[] (IO Control) where nodeMethod = Godot.Core.Control.get_parent_control {-# NOINLINE bindControl_get_pivot_offset #-} -- | By default, the node's pivot is its top-left corner. When you change its @rect_scale@, it will scale around this pivot. Set this property to @rect_size@ / 2 to center the pivot in the node's rectangle. bindControl_get_pivot_offset :: MethodBind bindControl_get_pivot_offset = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_pivot_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | By default, the node's pivot is its top-left corner. When you change its @rect_scale@, it will scale around this pivot. Set this property to @rect_size@ / 2 to center the pivot in the node's rectangle. get_pivot_offset :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_pivot_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_pivot_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_pivot_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_pivot_offset {-# NOINLINE bindControl_get_position #-} -- | The node's position, relative to its parent. It corresponds to the rectangle's top-left corner. The property is not affected by @rect_pivot_offset@. bindControl_get_position :: MethodBind bindControl_get_position = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's position, relative to its parent. It corresponds to the rectangle's top-left corner. The property is not affected by @rect_pivot_offset@. get_position :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_position" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_position {-# NOINLINE bindControl_get_rect #-} -- | Returns the position and size of the control relative to the top-left corner of the parent Control. See @rect_position@ and @rect_size@. bindControl_get_rect :: MethodBind bindControl_get_rect = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position and size of the control relative to the top-left corner of the parent Control. See @rect_position@ and @rect_size@. get_rect :: (Control :< cls, Object :< cls) => cls -> IO Rect2 get_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Control.get_rect {-# NOINLINE bindControl_get_rotation #-} -- | Returns the rotation (in radians). bindControl_get_rotation :: MethodBind bindControl_get_rotation = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the rotation (in radians). get_rotation :: (Control :< cls, Object :< cls) => cls -> IO Float get_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_rotation" '[] (IO Float) where nodeMethod = Godot.Core.Control.get_rotation {-# NOINLINE bindControl_get_rotation_degrees #-} -- | The node's rotation around its pivot, in degrees. See @rect_pivot_offset@ to change the pivot's position. bindControl_get_rotation_degrees :: MethodBind bindControl_get_rotation_degrees = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's rotation around its pivot, in degrees. See @rect_pivot_offset@ to change the pivot's position. get_rotation_degrees :: (Control :< cls, Object :< cls) => cls -> IO Float get_rotation_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_rotation_degrees" '[] (IO Float) where nodeMethod = Godot.Core.Control.get_rotation_degrees {-# NOINLINE bindControl_get_scale #-} -- | The node's scale, relative to its @rect_size@. Change this property to scale the node around its @rect_pivot_offset@. The Control's @hint_tooltip@ will also scale according to this value. -- __Note:__ This property is mainly intended to be used for animation purposes. Text inside the Control will look pixelated or blurry when the Control is scaled. To support multiple resolutions in your project, use an appropriate viewport stretch mode as described in the @url=https://docs.godotengine.org/en/latest/tutorials/viewports/multiple_resolutions.html@documentation@/url@ instead of scaling Controls individually. -- __Note:__ If the Control node is a child of a @Container@ node, the scale will be reset to @Vector2(1, 1)@ when the scene is instanced. To set the Control's scale when it's instanced, wait for one frame using @yield(get_tree(), "idle_frame")@ then set its @rect_scale@ property. bindControl_get_scale :: MethodBind bindControl_get_scale = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's scale, relative to its @rect_size@. Change this property to scale the node around its @rect_pivot_offset@. The Control's @hint_tooltip@ will also scale according to this value. -- __Note:__ This property is mainly intended to be used for animation purposes. Text inside the Control will look pixelated or blurry when the Control is scaled. To support multiple resolutions in your project, use an appropriate viewport stretch mode as described in the @url=https://docs.godotengine.org/en/latest/tutorials/viewports/multiple_resolutions.html@documentation@/url@ instead of scaling Controls individually. -- __Note:__ If the Control node is a child of a @Container@ node, the scale will be reset to @Vector2(1, 1)@ when the scene is instanced. To set the Control's scale when it's instanced, wait for one frame using @yield(get_tree(), "idle_frame")@ then set its @rect_scale@ property. get_scale :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_scale" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_scale {-# NOINLINE bindControl_get_size #-} -- | The size of the node's bounding rectangle, in pixels. @Container@ nodes update this property automatically. bindControl_get_size :: MethodBind bindControl_get_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the node's bounding rectangle, in pixels. @Container@ nodes update this property automatically. get_size :: (Control :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Control.get_size {-# NOINLINE bindControl_get_stretch_ratio #-} -- | If the node and at least one of its neighbours uses the @SIZE_EXPAND@ size flag, the parent @Container@ will let it take more or less space depending on this property. If this node has a stretch ratio of 2 and its neighbour a ratio of 1, this node will take two thirds of the available space. bindControl_get_stretch_ratio :: MethodBind bindControl_get_stretch_ratio = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_stretch_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the node and at least one of its neighbours uses the @SIZE_EXPAND@ size flag, the parent @Container@ will let it take more or less space depending on this property. If this node has a stretch ratio of 2 and its neighbour a ratio of 1, this node will take two thirds of the available space. get_stretch_ratio :: (Control :< cls, Object :< cls) => cls -> IO Float get_stretch_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_stretch_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_stretch_ratio" '[] (IO Float) where nodeMethod = Godot.Core.Control.get_stretch_ratio {-# NOINLINE bindControl_get_stylebox #-} -- | Returns a @StyleBox@ from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. bindControl_get_stylebox :: MethodBind bindControl_get_stylebox = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_stylebox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @StyleBox@ from assigned @Theme@ with given @name@ and associated with @Control@ of given @type@. get_stylebox :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO StyleBox get_stylebox cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_stylebox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_stylebox" '[GodotString, Maybe GodotString] (IO StyleBox) where nodeMethod = Godot.Core.Control.get_stylebox {-# NOINLINE bindControl_get_theme #-} -- | Changing this property replaces the current @Theme@ resource this node and all its @Control@ children use. bindControl_get_theme :: MethodBind bindControl_get_theme = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_theme" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changing this property replaces the current @Theme@ resource this node and all its @Control@ children use. get_theme :: (Control :< cls, Object :< cls) => cls -> IO Theme get_theme cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_theme (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_theme" '[] (IO Theme) where nodeMethod = Godot.Core.Control.get_theme {-# NOINLINE bindControl_get_tooltip #-} -- | Returns the tooltip, which will appear when the cursor is resting over this control. See @hint_tooltip@. bindControl_get_tooltip :: MethodBind bindControl_get_tooltip = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tooltip, which will appear when the cursor is resting over this control. See @hint_tooltip@. get_tooltip :: (Control :< cls, Object :< cls) => cls -> Maybe Vector2 -> IO GodotString get_tooltip cls arg1 = withVariantArray [defaultedVariant VariantVector2 (V2 0 0) arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_tooltip" '[Maybe Vector2] (IO GodotString) where nodeMethod = Godot.Core.Control.get_tooltip {-# NOINLINE bindControl_get_v_grow_direction #-} -- | Controls the direction on the vertical axis in which the control should grow if its vertical minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size. bindControl_get_v_grow_direction :: MethodBind bindControl_get_v_grow_direction = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_v_grow_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the direction on the vertical axis in which the control should grow if its vertical minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size. get_v_grow_direction :: (Control :< cls, Object :< cls) => cls -> IO Int get_v_grow_direction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_v_grow_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_v_grow_direction" '[] (IO Int) where nodeMethod = Godot.Core.Control.get_v_grow_direction {-# NOINLINE bindControl_get_v_size_flags #-} -- | Tells the parent @Container@ nodes how they should resize and place the node on the Y axis. Use one of the @enum SizeFlags@ constants to change the flags. See the constants to learn what each does. bindControl_get_v_size_flags :: MethodBind bindControl_get_v_size_flags = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "get_v_size_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells the parent @Container@ nodes how they should resize and place the node on the Y axis. Use one of the @enum SizeFlags@ constants to change the flags. See the constants to learn what each does. get_v_size_flags :: (Control :< cls, Object :< cls) => cls -> IO Int get_v_size_flags cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_get_v_size_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "get_v_size_flags" '[] (IO Int) where nodeMethod = Godot.Core.Control.get_v_size_flags {-# NOINLINE bindControl_grab_click_focus #-} -- | Creates an @InputEventMouseButton@ that attempts to click the control. If the event is received, the control acquires focus. -- -- @ -- -- func _process(delta): -- grab_click_focus() #when clicking another Control node, this node will be clicked instead -- -- @ bindControl_grab_click_focus :: MethodBind bindControl_grab_click_focus = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "grab_click_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an @InputEventMouseButton@ that attempts to click the control. If the event is received, the control acquires focus. -- -- @ -- -- func _process(delta): -- grab_click_focus() #when clicking another Control node, this node will be clicked instead -- -- @ grab_click_focus :: (Control :< cls, Object :< cls) => cls -> IO () grab_click_focus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_grab_click_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "grab_click_focus" '[] (IO ()) where nodeMethod = Godot.Core.Control.grab_click_focus {-# NOINLINE bindControl_grab_focus #-} -- | Steal the focus from another control and become the focused control (see @focus_mode@). bindControl_grab_focus :: MethodBind bindControl_grab_focus = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "grab_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Steal the focus from another control and become the focused control (see @focus_mode@). grab_focus :: (Control :< cls, Object :< cls) => cls -> IO () grab_focus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_grab_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "grab_focus" '[] (IO ()) where nodeMethod = Godot.Core.Control.grab_focus {-# NOINLINE bindControl_has_color #-} -- | Returns @true@ if @Color@ with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. bindControl_has_color :: MethodBind bindControl_has_color = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @Color@ with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. has_color :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Bool has_color cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_color" '[GodotString, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_color {-# NOINLINE bindControl_has_color_override #-} -- | Returns @true@ if @Color@ with given @name@ has a valid override in this @Control@ node. bindControl_has_color_override :: MethodBind bindControl_has_color_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_color_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @Color@ with given @name@ has a valid override in this @Control@ node. has_color_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_color_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_color_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_color_override" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_color_override {-# NOINLINE bindControl_has_constant #-} -- | Returns @true@ if constant with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. bindControl_has_constant :: MethodBind bindControl_has_constant = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if constant with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. has_constant :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Bool has_constant cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_constant" '[GodotString, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_constant {-# NOINLINE bindControl_has_constant_override #-} -- | Returns @true@ if constant with given @name@ has a valid override in this @Control@ node. bindControl_has_constant_override :: MethodBind bindControl_has_constant_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_constant_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if constant with given @name@ has a valid override in this @Control@ node. has_constant_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_constant_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_constant_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_constant_override" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_constant_override {-# NOINLINE bindControl_has_focus #-} -- | Returns @true@ if this is the current focused control. See @focus_mode@. bindControl_has_focus :: MethodBind bindControl_has_focus = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this is the current focused control. See @focus_mode@. has_focus :: (Control :< cls, Object :< cls) => cls -> IO Bool has_focus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_focus" '[] (IO Bool) where nodeMethod = Godot.Core.Control.has_focus {-# NOINLINE bindControl_has_font #-} -- | Returns @true@ if font with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. bindControl_has_font :: MethodBind bindControl_has_font = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if font with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. has_font :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Bool has_font cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_font" '[GodotString, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_font {-# NOINLINE bindControl_has_font_override #-} -- | Returns @true@ if font with given @name@ has a valid override in this @Control@ node. bindControl_has_font_override :: MethodBind bindControl_has_font_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_font_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if font with given @name@ has a valid override in this @Control@ node. has_font_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_font_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_font_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_font_override" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_font_override {-# NOINLINE bindControl_has_icon #-} -- | Returns @true@ if icon with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. bindControl_has_icon :: MethodBind bindControl_has_icon = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if icon with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. has_icon :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Bool has_icon cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_icon" '[GodotString, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_icon {-# NOINLINE bindControl_has_icon_override #-} -- | Returns @true@ if icon with given @name@ has a valid override in this @Control@ node. bindControl_has_icon_override :: MethodBind bindControl_has_icon_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_icon_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if icon with given @name@ has a valid override in this @Control@ node. has_icon_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_icon_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_icon_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_icon_override" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_icon_override {-# NOINLINE bindControl_has_point #-} -- | Virtual method to be implemented by the user. Returns whether the given @point@ is inside this control. -- If not overridden, default behavior is checking if the point is within control's Rect. -- __Note:__ If you want to check if a point is inside the control, you can use @get_rect().has_point(point)@. bindControl_has_point :: MethodBind bindControl_has_point = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method to be implemented by the user. Returns whether the given @point@ is inside this control. -- If not overridden, default behavior is checking if the point is within control's Rect. -- __Note:__ If you want to check if a point is inside the control, you can use @get_rect().has_point(point)@. has_point :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO Bool has_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_point" '[Vector2] (IO Bool) where nodeMethod = Godot.Core.Control.has_point {-# NOINLINE bindControl_has_shader_override #-} -- | Returns @true@ if @Shader@ with given @name@ has a valid override in this @Control@ node. bindControl_has_shader_override :: MethodBind bindControl_has_shader_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_shader_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @Shader@ with given @name@ has a valid override in this @Control@ node. has_shader_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_shader_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_shader_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_shader_override" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_shader_override {-# NOINLINE bindControl_has_stylebox #-} -- | Returns @true@ if @StyleBox@ with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. bindControl_has_stylebox :: MethodBind bindControl_has_stylebox = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_stylebox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @StyleBox@ with given @name@ and associated with @Control@ of given @type@ exists in assigned @Theme@. has_stylebox :: (Control :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Bool has_stylebox cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_stylebox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_stylebox" '[GodotString, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_stylebox {-# NOINLINE bindControl_has_stylebox_override #-} -- | Returns @true@ if @StyleBox@ with given @name@ has a valid override in this @Control@ node. bindControl_has_stylebox_override :: MethodBind bindControl_has_stylebox_override = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "has_stylebox_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @StyleBox@ with given @name@ has a valid override in this @Control@ node. has_stylebox_override :: (Control :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_stylebox_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_has_stylebox_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "has_stylebox_override" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Control.has_stylebox_override {-# NOINLINE bindControl_is_clipping_contents #-} -- | Enables whether rendering of @CanvasItem@ based children should be clipped to this control's rectangle. If @true@, parts of a child which would be visibly outside of this control's rectangle will not be rendered. bindControl_is_clipping_contents :: MethodBind bindControl_is_clipping_contents = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "is_clipping_contents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables whether rendering of @CanvasItem@ based children should be clipped to this control's rectangle. If @true@, parts of a child which would be visibly outside of this control's rectangle will not be rendered. is_clipping_contents :: (Control :< cls, Object :< cls) => cls -> IO Bool is_clipping_contents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_is_clipping_contents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "is_clipping_contents" '[] (IO Bool) where nodeMethod = Godot.Core.Control.is_clipping_contents {-# NOINLINE bindControl_minimum_size_changed #-} -- | Invalidates the size cache in this node and in parent nodes up to toplevel. Intended to be used with @method get_minimum_size@ when the return value is changed. Setting @rect_min_size@ directly calls this method automatically. bindControl_minimum_size_changed :: MethodBind bindControl_minimum_size_changed = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "minimum_size_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Invalidates the size cache in this node and in parent nodes up to toplevel. Intended to be used with @method get_minimum_size@ when the return value is changed. Setting @rect_min_size@ directly calls this method automatically. minimum_size_changed :: (Control :< cls, Object :< cls) => cls -> IO () minimum_size_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_minimum_size_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "minimum_size_changed" '[] (IO ()) where nodeMethod = Godot.Core.Control.minimum_size_changed {-# NOINLINE bindControl_release_focus #-} -- | Give up the focus. No other control will be able to receive keyboard input. bindControl_release_focus :: MethodBind bindControl_release_focus = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "release_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Give up the focus. No other control will be able to receive keyboard input. release_focus :: (Control :< cls, Object :< cls) => cls -> IO () release_focus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindControl_release_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "release_focus" '[] (IO ()) where nodeMethod = Godot.Core.Control.release_focus {-# NOINLINE bindControl_set_anchor #-} -- | Sets the anchor identified by @margin@ constant from @enum Margin@ enum to value @anchor@. A setter method for @anchor_bottom@, @anchor_left@, @anchor_right@ and @anchor_top@. -- If @keep_margin@ is @true@, margins aren't updated after this operation. -- If @push_opposite_anchor@ is @true@ and the opposite anchor overlaps this anchor, the opposite one will have its value overridden. For example, when setting left anchor to 1 and the right anchor has value of 0.5, the right anchor will also get value of 1. If @push_opposite_anchor@ was @false@, the left anchor would get value 0.5. bindControl_set_anchor :: MethodBind bindControl_set_anchor = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_anchor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the anchor identified by @margin@ constant from @enum Margin@ enum to value @anchor@. A setter method for @anchor_bottom@, @anchor_left@, @anchor_right@ and @anchor_top@. -- If @keep_margin@ is @true@, margins aren't updated after this operation. -- If @push_opposite_anchor@ is @true@ and the opposite anchor overlaps this anchor, the opposite one will have its value overridden. For example, when setting left anchor to 1 and the right anchor has value of 0.5, the right anchor will also get value of 1. If @push_opposite_anchor@ was @false@, the left anchor would get value 0.5. set_anchor :: (Control :< cls, Object :< cls) => cls -> Int -> Float -> Maybe Bool -> Maybe Bool -> IO () set_anchor cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3, maybe (VariantBool True) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_anchor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_anchor" '[Int, Float, Maybe Bool, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Control.set_anchor {-# NOINLINE bindControl_set_anchor_and_margin #-} -- | Works the same as @method set_anchor@, but instead of @keep_margin@ argument and automatic update of margin, it allows to set the margin offset yourself (see @method set_margin@). bindControl_set_anchor_and_margin :: MethodBind bindControl_set_anchor_and_margin = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_anchor_and_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Works the same as @method set_anchor@, but instead of @keep_margin@ argument and automatic update of margin, it allows to set the margin offset yourself (see @method set_margin@). set_anchor_and_margin :: (Control :< cls, Object :< cls) => cls -> Int -> Float -> Float -> Maybe Bool -> IO () set_anchor_and_margin cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_anchor_and_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_anchor_and_margin" '[Int, Float, Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Control.set_anchor_and_margin {-# NOINLINE bindControl_set_anchors_and_margins_preset #-} -- | Sets both anchor preset and margin preset. See @method set_anchors_preset@ and @method set_margins_preset@. bindControl_set_anchors_and_margins_preset :: MethodBind bindControl_set_anchors_and_margins_preset = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_anchors_and_margins_preset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets both anchor preset and margin preset. See @method set_anchors_preset@ and @method set_margins_preset@. set_anchors_and_margins_preset :: (Control :< cls, Object :< cls) => cls -> Int -> Maybe Int -> Maybe Int -> IO () set_anchors_and_margins_preset cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_anchors_and_margins_preset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_anchors_and_margins_preset" '[Int, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.Control.set_anchors_and_margins_preset {-# NOINLINE bindControl_set_anchors_preset #-} -- | Sets the anchors to a @preset@ from @enum Control.LayoutPreset@ enum. This is code equivalent of using the Layout menu in 2D editor. -- If @keep_margins@ is @true@, control's position will also be updated. bindControl_set_anchors_preset :: MethodBind bindControl_set_anchors_preset = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_anchors_preset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the anchors to a @preset@ from @enum Control.LayoutPreset@ enum. This is code equivalent of using the Layout menu in 2D editor. -- If @keep_margins@ is @true@, control's position will also be updated. set_anchors_preset :: (Control :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO () set_anchors_preset cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_anchors_preset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_anchors_preset" '[Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Control.set_anchors_preset {-# NOINLINE bindControl_set_begin #-} -- | Sets @margin_left@ and @margin_top@ at the same time. Equivalent of changing @rect_position@. bindControl_set_begin :: MethodBind bindControl_set_begin = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets @margin_left@ and @margin_top@ at the same time. Equivalent of changing @rect_position@. set_begin :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () set_begin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_begin" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control.set_begin {-# NOINLINE bindControl_set_clip_contents #-} -- | Enables whether rendering of @CanvasItem@ based children should be clipped to this control's rectangle. If @true@, parts of a child which would be visibly outside of this control's rectangle will not be rendered. bindControl_set_clip_contents :: MethodBind bindControl_set_clip_contents = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_clip_contents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables whether rendering of @CanvasItem@ based children should be clipped to this control's rectangle. If @true@, parts of a child which would be visibly outside of this control's rectangle will not be rendered. set_clip_contents :: (Control :< cls, Object :< cls) => cls -> Bool -> IO () set_clip_contents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_clip_contents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_clip_contents" '[Bool] (IO ()) where nodeMethod = Godot.Core.Control.set_clip_contents {-# NOINLINE bindControl_set_custom_minimum_size #-} -- | The minimum size of the node's bounding rectangle. If you set it to a value greater than (0, 0), the node's bounding rectangle will always have at least this size, even if its content is smaller. If it's set to (0, 0), the node sizes automatically to fit its content, be it a texture or child nodes. bindControl_set_custom_minimum_size :: MethodBind bindControl_set_custom_minimum_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_custom_minimum_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum size of the node's bounding rectangle. If you set it to a value greater than (0, 0), the node's bounding rectangle will always have at least this size, even if its content is smaller. If it's set to (0, 0), the node sizes automatically to fit its content, be it a texture or child nodes. set_custom_minimum_size :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () set_custom_minimum_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_custom_minimum_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_custom_minimum_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control.set_custom_minimum_size {-# NOINLINE bindControl_set_default_cursor_shape #-} -- | The default cursor shape for this control. Useful for Godot plugins and applications or games that use the system's mouse cursors. -- __Note:__ On Linux, shapes may vary depending on the cursor theme of the system. bindControl_set_default_cursor_shape :: MethodBind bindControl_set_default_cursor_shape = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_default_cursor_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The default cursor shape for this control. Useful for Godot plugins and applications or games that use the system's mouse cursors. -- __Note:__ On Linux, shapes may vary depending on the cursor theme of the system. set_default_cursor_shape :: (Control :< cls, Object :< cls) => cls -> Int -> IO () set_default_cursor_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_default_cursor_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_default_cursor_shape" '[Int] (IO ()) where nodeMethod = Godot.Core.Control.set_default_cursor_shape {-# NOINLINE bindControl_set_drag_forwarding #-} -- | Forwards the handling of this control's drag and drop to @target@ control. -- Forwarding can be implemented in the target control similar to the methods @method get_drag_data@, @method can_drop_data@, and @method drop_data@ but with two differences: -- 1. The function name must be suffixed with ___fw__ -- 2. The function must take an extra argument that is the control doing the forwarding -- -- @ -- -- # ThisControl.gd -- extends Control -- func _ready(): -- set_drag_forwarding(target_control) -- -- # TargetControl.gd -- extends Control -- func can_drop_data_fw(position, data, from_control): -- return true -- -- func drop_data_fw(position, data, from_control): -- my_handle_data(data) -- -- func get_drag_data_fw(position, from_control): -- set_drag_preview(my_preview) -- return my_data() -- -- @ bindControl_set_drag_forwarding :: MethodBind bindControl_set_drag_forwarding = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_drag_forwarding" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Forwards the handling of this control's drag and drop to @target@ control. -- Forwarding can be implemented in the target control similar to the methods @method get_drag_data@, @method can_drop_data@, and @method drop_data@ but with two differences: -- 1. The function name must be suffixed with ___fw__ -- 2. The function must take an extra argument that is the control doing the forwarding -- -- @ -- -- # ThisControl.gd -- extends Control -- func _ready(): -- set_drag_forwarding(target_control) -- -- # TargetControl.gd -- extends Control -- func can_drop_data_fw(position, data, from_control): -- return true -- -- func drop_data_fw(position, data, from_control): -- my_handle_data(data) -- -- func get_drag_data_fw(position, from_control): -- set_drag_preview(my_preview) -- return my_data() -- -- @ set_drag_forwarding :: (Control :< cls, Object :< cls) => cls -> Control -> IO () set_drag_forwarding cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_drag_forwarding (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_drag_forwarding" '[Control] (IO ()) where nodeMethod = Godot.Core.Control.set_drag_forwarding {-# NOINLINE bindControl_set_drag_preview #-} -- | Shows the given control at the mouse pointer. A good time to call this method is in @method get_drag_data@. The control must not be in the scene tree. -- -- @ -- -- export (Color, RGBA) var color = Color(1, 0, 0, 1) -- -- func get_drag_data(position): -- # Use a control that is not in the tree -- var cpb = ColorPickerButton.new() -- cpb.color = color -- cpb.rect_size = Vector2(50, 50) -- set_drag_preview(cpb) -- return color -- -- @ bindControl_set_drag_preview :: MethodBind bindControl_set_drag_preview = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_drag_preview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shows the given control at the mouse pointer. A good time to call this method is in @method get_drag_data@. The control must not be in the scene tree. -- -- @ -- -- export (Color, RGBA) var color = Color(1, 0, 0, 1) -- -- func get_drag_data(position): -- # Use a control that is not in the tree -- var cpb = ColorPickerButton.new() -- cpb.color = color -- cpb.rect_size = Vector2(50, 50) -- set_drag_preview(cpb) -- return color -- -- @ set_drag_preview :: (Control :< cls, Object :< cls) => cls -> Control -> IO () set_drag_preview cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_drag_preview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_drag_preview" '[Control] (IO ()) where nodeMethod = Godot.Core.Control.set_drag_preview {-# NOINLINE bindControl_set_end #-} -- | Sets @margin_right@ and @margin_bottom@ at the same time. bindControl_set_end :: MethodBind bindControl_set_end = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets @margin_right@ and @margin_bottom@ at the same time. set_end :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () set_end cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_end" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control.set_end {-# NOINLINE bindControl_set_focus_mode #-} -- | The focus access mode for the control (None, Click or All). Only one Control can be focused at the same time, and it will receive keyboard signals. bindControl_set_focus_mode :: MethodBind bindControl_set_focus_mode = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_focus_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The focus access mode for the control (None, Click or All). Only one Control can be focused at the same time, and it will receive keyboard signals. set_focus_mode :: (Control :< cls, Object :< cls) => cls -> Int -> IO () set_focus_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_focus_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_focus_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Control.set_focus_mode {-# NOINLINE bindControl_set_focus_neighbour #-} -- | Sets the anchor identified by @margin@ constant from @enum Margin@ enum to @Control@ at @neighbor@ node path. A setter method for @focus_neighbour_bottom@, @focus_neighbour_left@, @focus_neighbour_right@ and @focus_neighbour_top@. bindControl_set_focus_neighbour :: MethodBind bindControl_set_focus_neighbour = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_focus_neighbour" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the anchor identified by @margin@ constant from @enum Margin@ enum to @Control@ at @neighbor@ node path. A setter method for @focus_neighbour_bottom@, @focus_neighbour_left@, @focus_neighbour_right@ and @focus_neighbour_top@. set_focus_neighbour :: (Control :< cls, Object :< cls) => cls -> Int -> NodePath -> IO () set_focus_neighbour cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_focus_neighbour (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_focus_neighbour" '[Int, NodePath] (IO ()) where nodeMethod = Godot.Core.Control.set_focus_neighbour {-# NOINLINE bindControl_set_focus_next #-} -- | Tells Godot which node it should give keyboard focus to if the user presses Tab on a keyboard by default. You can change the key by editing the @ui_focus_next@ input action. -- If this property is not set, Godot will select a "best guess" based on surrounding nodes in the scene tree. bindControl_set_focus_next :: MethodBind bindControl_set_focus_next = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_focus_next" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells Godot which node it should give keyboard focus to if the user presses Tab on a keyboard by default. You can change the key by editing the @ui_focus_next@ input action. -- If this property is not set, Godot will select a "best guess" based on surrounding nodes in the scene tree. set_focus_next :: (Control :< cls, Object :< cls) => cls -> NodePath -> IO () set_focus_next cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_focus_next (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_focus_next" '[NodePath] (IO ()) where nodeMethod = Godot.Core.Control.set_focus_next {-# NOINLINE bindControl_set_focus_previous #-} -- | Tells Godot which node it should give keyboard focus to if the user presses Shift+Tab on a keyboard by default. You can change the key by editing the @ui_focus_prev@ input action. -- If this property is not set, Godot will select a "best guess" based on surrounding nodes in the scene tree. bindControl_set_focus_previous :: MethodBind bindControl_set_focus_previous = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_focus_previous" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells Godot which node it should give keyboard focus to if the user presses Shift+Tab on a keyboard by default. You can change the key by editing the @ui_focus_prev@ input action. -- If this property is not set, Godot will select a "best guess" based on surrounding nodes in the scene tree. set_focus_previous :: (Control :< cls, Object :< cls) => cls -> NodePath -> IO () set_focus_previous cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_focus_previous (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_focus_previous" '[NodePath] (IO ()) where nodeMethod = Godot.Core.Control.set_focus_previous {-# NOINLINE bindControl_set_global_position #-} -- | Sets the @rect_global_position@ to given @position@. -- If @keep_margins@ is @true@, control's anchors will be updated instead of margins. bindControl_set_global_position :: MethodBind bindControl_set_global_position = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_global_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @rect_global_position@ to given @position@. -- If @keep_margins@ is @true@, control's anchors will be updated instead of margins. set_global_position :: (Control :< cls, Object :< cls) => cls -> Vector2 -> Maybe Bool -> IO () set_global_position cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_global_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_global_position" '[Vector2, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Control.set_global_position {-# NOINLINE bindControl_set_h_grow_direction #-} -- | Controls the direction on the horizontal axis in which the control should grow if its horizontal minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size. bindControl_set_h_grow_direction :: MethodBind bindControl_set_h_grow_direction = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_h_grow_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the direction on the horizontal axis in which the control should grow if its horizontal minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size. set_h_grow_direction :: (Control :< cls, Object :< cls) => cls -> Int -> IO () set_h_grow_direction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_h_grow_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_h_grow_direction" '[Int] (IO ()) where nodeMethod = Godot.Core.Control.set_h_grow_direction {-# NOINLINE bindControl_set_h_size_flags #-} -- | Tells the parent @Container@ nodes how they should resize and place the node on the X axis. Use one of the @enum SizeFlags@ constants to change the flags. See the constants to learn what each does. bindControl_set_h_size_flags :: MethodBind bindControl_set_h_size_flags = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_h_size_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells the parent @Container@ nodes how they should resize and place the node on the X axis. Use one of the @enum SizeFlags@ constants to change the flags. See the constants to learn what each does. set_h_size_flags :: (Control :< cls, Object :< cls) => cls -> Int -> IO () set_h_size_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_h_size_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_h_size_flags" '[Int] (IO ()) where nodeMethod = Godot.Core.Control.set_h_size_flags {-# NOINLINE bindControl_set_margin #-} -- | Sets the margin identified by @margin@ constant from @enum Margin@ enum to given @offset@. A setter method for @margin_bottom@, @margin_left@, @margin_right@ and @margin_top@. bindControl_set_margin :: MethodBind bindControl_set_margin = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the margin identified by @margin@ constant from @enum Margin@ enum to given @offset@. A setter method for @margin_bottom@, @margin_left@, @margin_right@ and @margin_top@. set_margin :: (Control :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_margin" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Control.set_margin {-# NOINLINE bindControl_set_margins_preset #-} -- | Sets the margins to a @preset@ from @enum Control.LayoutPreset@ enum. This is code equivalent of using the Layout menu in 2D editor. -- Use parameter @resize_mode@ with constants from @enum Control.LayoutPresetMode@ to better determine the resulting size of the @Control@. Constant size will be ignored if used with presets that change size, e.g. @PRESET_LEFT_WIDE@. -- Use parameter @margin@ to determine the gap between the @Control@ and the edges. bindControl_set_margins_preset :: MethodBind bindControl_set_margins_preset = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_margins_preset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the margins to a @preset@ from @enum Control.LayoutPreset@ enum. This is code equivalent of using the Layout menu in 2D editor. -- Use parameter @resize_mode@ with constants from @enum Control.LayoutPresetMode@ to better determine the resulting size of the @Control@. Constant size will be ignored if used with presets that change size, e.g. @PRESET_LEFT_WIDE@. -- Use parameter @margin@ to determine the gap between the @Control@ and the edges. set_margins_preset :: (Control :< cls, Object :< cls) => cls -> Int -> Maybe Int -> Maybe Int -> IO () set_margins_preset cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_margins_preset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_margins_preset" '[Int, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.Control.set_margins_preset {-# NOINLINE bindControl_set_mouse_filter #-} -- | Controls whether the control will be able to receive mouse button input events through @method _gui_input@ and how these events should be handled. Also controls whether the control can receive the @signal mouse_entered@, and @signal mouse_exited@ signals. See the constants to learn what each does. bindControl_set_mouse_filter :: MethodBind bindControl_set_mouse_filter = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_mouse_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls whether the control will be able to receive mouse button input events through @method _gui_input@ and how these events should be handled. Also controls whether the control can receive the @signal mouse_entered@, and @signal mouse_exited@ signals. See the constants to learn what each does. set_mouse_filter :: (Control :< cls, Object :< cls) => cls -> Int -> IO () set_mouse_filter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_mouse_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_mouse_filter" '[Int] (IO ()) where nodeMethod = Godot.Core.Control.set_mouse_filter {-# NOINLINE bindControl_set_pivot_offset #-} -- | By default, the node's pivot is its top-left corner. When you change its @rect_scale@, it will scale around this pivot. Set this property to @rect_size@ / 2 to center the pivot in the node's rectangle. bindControl_set_pivot_offset :: MethodBind bindControl_set_pivot_offset = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_pivot_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | By default, the node's pivot is its top-left corner. When you change its @rect_scale@, it will scale around this pivot. Set this property to @rect_size@ / 2 to center the pivot in the node's rectangle. set_pivot_offset :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () set_pivot_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_pivot_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_pivot_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control.set_pivot_offset {-# NOINLINE bindControl_set_position #-} -- | Sets the @rect_position@ to given @position@. -- If @keep_margins@ is @true@, control's anchors will be updated instead of margins. bindControl_set_position :: MethodBind bindControl_set_position = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @rect_position@ to given @position@. -- If @keep_margins@ is @true@, control's anchors will be updated instead of margins. set_position :: (Control :< cls, Object :< cls) => cls -> Vector2 -> Maybe Bool -> IO () set_position cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_position" '[Vector2, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Control.set_position {-# NOINLINE bindControl_set_rotation #-} -- | Sets the rotation (in radians). bindControl_set_rotation :: MethodBind bindControl_set_rotation = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the rotation (in radians). set_rotation :: (Control :< cls, Object :< cls) => cls -> Float -> IO () set_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_rotation" '[Float] (IO ()) where nodeMethod = Godot.Core.Control.set_rotation {-# NOINLINE bindControl_set_rotation_degrees #-} -- | The node's rotation around its pivot, in degrees. See @rect_pivot_offset@ to change the pivot's position. bindControl_set_rotation_degrees :: MethodBind bindControl_set_rotation_degrees = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's rotation around its pivot, in degrees. See @rect_pivot_offset@ to change the pivot's position. set_rotation_degrees :: (Control :< cls, Object :< cls) => cls -> Float -> IO () set_rotation_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_rotation_degrees" '[Float] (IO ()) where nodeMethod = Godot.Core.Control.set_rotation_degrees {-# NOINLINE bindControl_set_scale #-} -- | The node's scale, relative to its @rect_size@. Change this property to scale the node around its @rect_pivot_offset@. The Control's @hint_tooltip@ will also scale according to this value. -- __Note:__ This property is mainly intended to be used for animation purposes. Text inside the Control will look pixelated or blurry when the Control is scaled. To support multiple resolutions in your project, use an appropriate viewport stretch mode as described in the @url=https://docs.godotengine.org/en/latest/tutorials/viewports/multiple_resolutions.html@documentation@/url@ instead of scaling Controls individually. -- __Note:__ If the Control node is a child of a @Container@ node, the scale will be reset to @Vector2(1, 1)@ when the scene is instanced. To set the Control's scale when it's instanced, wait for one frame using @yield(get_tree(), "idle_frame")@ then set its @rect_scale@ property. bindControl_set_scale :: MethodBind bindControl_set_scale = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's scale, relative to its @rect_size@. Change this property to scale the node around its @rect_pivot_offset@. The Control's @hint_tooltip@ will also scale according to this value. -- __Note:__ This property is mainly intended to be used for animation purposes. Text inside the Control will look pixelated or blurry when the Control is scaled. To support multiple resolutions in your project, use an appropriate viewport stretch mode as described in the @url=https://docs.godotengine.org/en/latest/tutorials/viewports/multiple_resolutions.html@documentation@/url@ instead of scaling Controls individually. -- __Note:__ If the Control node is a child of a @Container@ node, the scale will be reset to @Vector2(1, 1)@ when the scene is instanced. To set the Control's scale when it's instanced, wait for one frame using @yield(get_tree(), "idle_frame")@ then set its @rect_scale@ property. set_scale :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () set_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control.set_scale {-# NOINLINE bindControl_set_size #-} -- | Sets the size (see @rect_size@). -- If @keep_margins@ is @true@, control's anchors will be updated instead of margins. bindControl_set_size :: MethodBind bindControl_set_size = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size (see @rect_size@). -- If @keep_margins@ is @true@, control's anchors will be updated instead of margins. set_size :: (Control :< cls, Object :< cls) => cls -> Vector2 -> Maybe Bool -> IO () set_size cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_size" '[Vector2, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Control.set_size {-# NOINLINE bindControl_set_stretch_ratio #-} -- | If the node and at least one of its neighbours uses the @SIZE_EXPAND@ size flag, the parent @Container@ will let it take more or less space depending on this property. If this node has a stretch ratio of 2 and its neighbour a ratio of 1, this node will take two thirds of the available space. bindControl_set_stretch_ratio :: MethodBind bindControl_set_stretch_ratio = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_stretch_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the node and at least one of its neighbours uses the @SIZE_EXPAND@ size flag, the parent @Container@ will let it take more or less space depending on this property. If this node has a stretch ratio of 2 and its neighbour a ratio of 1, this node will take two thirds of the available space. set_stretch_ratio :: (Control :< cls, Object :< cls) => cls -> Float -> IO () set_stretch_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_stretch_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_stretch_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.Control.set_stretch_ratio {-# NOINLINE bindControl_set_theme #-} -- | Changing this property replaces the current @Theme@ resource this node and all its @Control@ children use. bindControl_set_theme :: MethodBind bindControl_set_theme = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_theme" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changing this property replaces the current @Theme@ resource this node and all its @Control@ children use. set_theme :: (Control :< cls, Object :< cls) => cls -> Theme -> IO () set_theme cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_theme (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_theme" '[Theme] (IO ()) where nodeMethod = Godot.Core.Control.set_theme {-# NOINLINE bindControl_set_tooltip #-} -- | Changes the tooltip text. The tooltip appears when the user's mouse cursor stays idle over this control for a few moments, provided that the @mouse_filter@ property is not @MOUSE_FILTER_IGNORE@. You can change the time required for the tooltip to appear with @gui/timers/tooltip_delay_sec@ option in Project Settings. bindControl_set_tooltip :: MethodBind bindControl_set_tooltip = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the tooltip text. The tooltip appears when the user's mouse cursor stays idle over this control for a few moments, provided that the @mouse_filter@ property is not @MOUSE_FILTER_IGNORE@. You can change the time required for the tooltip to appear with @gui/timers/tooltip_delay_sec@ option in Project Settings. set_tooltip :: (Control :< cls, Object :< cls) => cls -> GodotString -> IO () set_tooltip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_tooltip" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Control.set_tooltip {-# NOINLINE bindControl_set_v_grow_direction #-} -- | Controls the direction on the vertical axis in which the control should grow if its vertical minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size. bindControl_set_v_grow_direction :: MethodBind bindControl_set_v_grow_direction = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_v_grow_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the direction on the vertical axis in which the control should grow if its vertical minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size. set_v_grow_direction :: (Control :< cls, Object :< cls) => cls -> Int -> IO () set_v_grow_direction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_v_grow_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_v_grow_direction" '[Int] (IO ()) where nodeMethod = Godot.Core.Control.set_v_grow_direction {-# NOINLINE bindControl_set_v_size_flags #-} -- | Tells the parent @Container@ nodes how they should resize and place the node on the Y axis. Use one of the @enum SizeFlags@ constants to change the flags. See the constants to learn what each does. bindControl_set_v_size_flags :: MethodBind bindControl_set_v_size_flags = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "set_v_size_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells the parent @Container@ nodes how they should resize and place the node on the Y axis. Use one of the @enum SizeFlags@ constants to change the flags. See the constants to learn what each does. set_v_size_flags :: (Control :< cls, Object :< cls) => cls -> Int -> IO () set_v_size_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_set_v_size_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "set_v_size_flags" '[Int] (IO ()) where nodeMethod = Godot.Core.Control.set_v_size_flags {-# NOINLINE bindControl_show_modal #-} -- | Displays a control as modal. Control must be a subwindow. Modal controls capture the input signals until closed or the area outside them is accessed. When a modal control loses focus, or the ESC key is pressed, they automatically hide. Modal controls are used extensively for popup dialogs and menus. -- If @exclusive@ is @true@, other controls will not receive input and clicking outside this control will not close it. bindControl_show_modal :: MethodBind bindControl_show_modal = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "show_modal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Displays a control as modal. Control must be a subwindow. Modal controls capture the input signals until closed or the area outside them is accessed. When a modal control loses focus, or the ESC key is pressed, they automatically hide. Modal controls are used extensively for popup dialogs and menus. -- If @exclusive@ is @true@, other controls will not receive input and clicking outside this control will not close it. show_modal :: (Control :< cls, Object :< cls) => cls -> Maybe Bool -> IO () show_modal cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_show_modal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "show_modal" '[Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Control.show_modal {-# NOINLINE bindControl_warp_mouse #-} -- | Moves the mouse cursor to @to_position@, relative to @rect_position@ of this @Control@. bindControl_warp_mouse :: MethodBind bindControl_warp_mouse = unsafePerformIO $ withCString "Control" $ \ clsNamePtr -> withCString "warp_mouse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the mouse cursor to @to_position@, relative to @rect_position@ of this @Control@. warp_mouse :: (Control :< cls, Object :< cls) => cls -> Vector2 -> IO () warp_mouse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindControl_warp_mouse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Control "warp_mouse" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Control.warp_mouse ================================================ FILE: src/Godot/Core/ConvexPolygonShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ConvexPolygonShape (Godot.Core.ConvexPolygonShape.get_points, Godot.Core.ConvexPolygonShape.set_points) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty ConvexPolygonShape "points" PoolVector3Array 'False where nodeProperty = (get_points, wrapDroppingSetter set_points, Nothing) {-# NOINLINE bindConvexPolygonShape_get_points #-} -- | The list of 3D points forming the convex polygon shape. bindConvexPolygonShape_get_points :: MethodBind bindConvexPolygonShape_get_points = unsafePerformIO $ withCString "ConvexPolygonShape" $ \ clsNamePtr -> withCString "get_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The list of 3D points forming the convex polygon shape. get_points :: (ConvexPolygonShape :< cls, Object :< cls) => cls -> IO PoolVector3Array get_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindConvexPolygonShape_get_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConvexPolygonShape "get_points" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.ConvexPolygonShape.get_points {-# NOINLINE bindConvexPolygonShape_set_points #-} -- | The list of 3D points forming the convex polygon shape. bindConvexPolygonShape_set_points :: MethodBind bindConvexPolygonShape_set_points = unsafePerformIO $ withCString "ConvexPolygonShape" $ \ clsNamePtr -> withCString "set_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The list of 3D points forming the convex polygon shape. set_points :: (ConvexPolygonShape :< cls, Object :< cls) => cls -> PoolVector3Array -> IO () set_points cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConvexPolygonShape_set_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConvexPolygonShape "set_points" '[PoolVector3Array] (IO ()) where nodeMethod = Godot.Core.ConvexPolygonShape.set_points ================================================ FILE: src/Godot/Core/ConvexPolygonShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ConvexPolygonShape2D (Godot.Core.ConvexPolygonShape2D.get_points, Godot.Core.ConvexPolygonShape2D.set_point_cloud, Godot.Core.ConvexPolygonShape2D.set_points) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape2D() instance NodeProperty ConvexPolygonShape2D "points" PoolVector2Array 'False where nodeProperty = (get_points, wrapDroppingSetter set_points, Nothing) {-# NOINLINE bindConvexPolygonShape2D_get_points #-} -- | The polygon's list of vertices. Can be in either clockwise or counterclockwise order. bindConvexPolygonShape2D_get_points :: MethodBind bindConvexPolygonShape2D_get_points = unsafePerformIO $ withCString "ConvexPolygonShape2D" $ \ clsNamePtr -> withCString "get_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's list of vertices. Can be in either clockwise or counterclockwise order. get_points :: (ConvexPolygonShape2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindConvexPolygonShape2D_get_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConvexPolygonShape2D "get_points" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.ConvexPolygonShape2D.get_points {-# NOINLINE bindConvexPolygonShape2D_set_point_cloud #-} -- | Based on the set of points provided, this creates and assigns the @points@ property using the convex hull algorithm. Removing all unneeded points. See @method Geometry.convex_hull_2d@ for details. bindConvexPolygonShape2D_set_point_cloud :: MethodBind bindConvexPolygonShape2D_set_point_cloud = unsafePerformIO $ withCString "ConvexPolygonShape2D" $ \ clsNamePtr -> withCString "set_point_cloud" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Based on the set of points provided, this creates and assigns the @points@ property using the convex hull algorithm. Removing all unneeded points. See @method Geometry.convex_hull_2d@ for details. set_point_cloud :: (ConvexPolygonShape2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_point_cloud cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConvexPolygonShape2D_set_point_cloud (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConvexPolygonShape2D "set_point_cloud" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.ConvexPolygonShape2D.set_point_cloud {-# NOINLINE bindConvexPolygonShape2D_set_points #-} -- | The polygon's list of vertices. Can be in either clockwise or counterclockwise order. bindConvexPolygonShape2D_set_points :: MethodBind bindConvexPolygonShape2D_set_points = unsafePerformIO $ withCString "ConvexPolygonShape2D" $ \ clsNamePtr -> withCString "set_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's list of vertices. Can be in either clockwise or counterclockwise order. set_points :: (ConvexPolygonShape2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_points cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindConvexPolygonShape2D_set_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ConvexPolygonShape2D "set_points" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.ConvexPolygonShape2D.set_points ================================================ FILE: src/Godot/Core/Crypto.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Crypto (Godot.Core.Crypto.generate_random_bytes, Godot.Core.Crypto.generate_rsa, Godot.Core.Crypto.generate_self_signed_certificate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindCrypto_generate_random_bytes #-} -- | Generates a @PoolByteArray@ of cryptographically secure random bytes with given @size@. bindCrypto_generate_random_bytes :: MethodBind bindCrypto_generate_random_bytes = unsafePerformIO $ withCString "Crypto" $ \ clsNamePtr -> withCString "generate_random_bytes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a @PoolByteArray@ of cryptographically secure random bytes with given @size@. generate_random_bytes :: (Crypto :< cls, Object :< cls) => cls -> Int -> IO PoolByteArray generate_random_bytes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCrypto_generate_random_bytes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Crypto "generate_random_bytes" '[Int] (IO PoolByteArray) where nodeMethod = Godot.Core.Crypto.generate_random_bytes {-# NOINLINE bindCrypto_generate_rsa #-} -- | Generates an RSA @CryptoKey@ that can be used for creating self-signed certificates and passed to @method StreamPeerSSL.accept_stream@. bindCrypto_generate_rsa :: MethodBind bindCrypto_generate_rsa = unsafePerformIO $ withCString "Crypto" $ \ clsNamePtr -> withCString "generate_rsa" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates an RSA @CryptoKey@ that can be used for creating self-signed certificates and passed to @method StreamPeerSSL.accept_stream@. generate_rsa :: (Crypto :< cls, Object :< cls) => cls -> Int -> IO CryptoKey generate_rsa cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCrypto_generate_rsa (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Crypto "generate_rsa" '[Int] (IO CryptoKey) where nodeMethod = Godot.Core.Crypto.generate_rsa {-# NOINLINE bindCrypto_generate_self_signed_certificate #-} -- | Generates a self-signed @X509Certificate@ from the given @CryptoKey@ and @issuer_name@. The certificate validity will be defined by @not_before@ and @not_after@ (first valid date and last valid date). The @issuer_name@ must contain at least "CN=" (common name, i.e. the domain name), "O=" (organization, i.e. your company name), "C=" (country, i.e. 2 lettered ISO-3166 code of the country the organization is based in). -- A small example to generate an RSA key and a X509 self-signed certificate. -- -- @ -- -- var crypto = Crypto.new() -- # Generate 4096 bits RSA key. -- var key = crypto.generate_rsa(4096) -- # Generate self-signed certificate using the given key. -- var cert = crypto.generate_self_signed_certificate(key, "CN=example.com,O=A Game Company,C=IT") -- -- @ bindCrypto_generate_self_signed_certificate :: MethodBind bindCrypto_generate_self_signed_certificate = unsafePerformIO $ withCString "Crypto" $ \ clsNamePtr -> withCString "generate_self_signed_certificate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a self-signed @X509Certificate@ from the given @CryptoKey@ and @issuer_name@. The certificate validity will be defined by @not_before@ and @not_after@ (first valid date and last valid date). The @issuer_name@ must contain at least "CN=" (common name, i.e. the domain name), "O=" (organization, i.e. your company name), "C=" (country, i.e. 2 lettered ISO-3166 code of the country the organization is based in). -- A small example to generate an RSA key and a X509 self-signed certificate. -- -- @ -- -- var crypto = Crypto.new() -- # Generate 4096 bits RSA key. -- var key = crypto.generate_rsa(4096) -- # Generate self-signed certificate using the given key. -- var cert = crypto.generate_self_signed_certificate(key, "CN=example.com,O=A Game Company,C=IT") -- -- @ generate_self_signed_certificate :: (Crypto :< cls, Object :< cls) => cls -> CryptoKey -> Maybe GodotString -> Maybe GodotString -> Maybe GodotString -> IO X509Certificate generate_self_signed_certificate cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, defaultedVariant VariantString "CN=myserver,O=myorganisation,C=IT" arg2, defaultedVariant VariantString "20140101000000" arg3, defaultedVariant VariantString "20340101000000" arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCrypto_generate_self_signed_certificate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Crypto "generate_self_signed_certificate" '[CryptoKey, Maybe GodotString, Maybe GodotString, Maybe GodotString] (IO X509Certificate) where nodeMethod = Godot.Core.Crypto.generate_self_signed_certificate ================================================ FILE: src/Godot/Core/CryptoKey.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CryptoKey (Godot.Core.CryptoKey.load, Godot.Core.CryptoKey.save) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindCryptoKey_load #-} -- | Loads a key from @path@ ("*.key" file). bindCryptoKey_load :: MethodBind bindCryptoKey_load = unsafePerformIO $ withCString "CryptoKey" $ \ clsNamePtr -> withCString "load" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads a key from @path@ ("*.key" file). load :: (CryptoKey :< cls, Object :< cls) => cls -> GodotString -> IO Int load cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCryptoKey_load (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CryptoKey "load" '[GodotString] (IO Int) where nodeMethod = Godot.Core.CryptoKey.load {-# NOINLINE bindCryptoKey_save #-} -- | Saves a key to the given @path@ (should be a "*.key" file). bindCryptoKey_save :: MethodBind bindCryptoKey_save = unsafePerformIO $ withCString "CryptoKey" $ \ clsNamePtr -> withCString "save" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves a key to the given @path@ (should be a "*.key" file). save :: (CryptoKey :< cls, Object :< cls) => cls -> GodotString -> IO Int save cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCryptoKey_save (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CryptoKey "save" '[GodotString] (IO Int) where nodeMethod = Godot.Core.CryptoKey.save ================================================ FILE: src/Godot/Core/CubeMap.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CubeMap (Godot.Core.CubeMap._SIDE_RIGHT, Godot.Core.CubeMap._SIDE_TOP, Godot.Core.CubeMap._SIDE_BACK, Godot.Core.CubeMap._STORAGE_RAW, Godot.Core.CubeMap._STORAGE_COMPRESS_LOSSLESS, Godot.Core.CubeMap._FLAGS_DEFAULT, Godot.Core.CubeMap._FLAG_REPEAT, Godot.Core.CubeMap._SIDE_LEFT, Godot.Core.CubeMap._SIDE_FRONT, Godot.Core.CubeMap._STORAGE_COMPRESS_LOSSY, Godot.Core.CubeMap._FLAG_MIPMAPS, Godot.Core.CubeMap._SIDE_BOTTOM, Godot.Core.CubeMap._FLAG_FILTER, Godot.Core.CubeMap.get_flags, Godot.Core.CubeMap.get_height, Godot.Core.CubeMap.get_lossy_storage_quality, Godot.Core.CubeMap.get_side, Godot.Core.CubeMap.get_storage, Godot.Core.CubeMap.get_width, Godot.Core.CubeMap.set_flags, Godot.Core.CubeMap.set_lossy_storage_quality, Godot.Core.CubeMap.set_side, Godot.Core.CubeMap.set_storage) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _SIDE_RIGHT :: Int _SIDE_RIGHT = 1 _SIDE_TOP :: Int _SIDE_TOP = 3 _SIDE_BACK :: Int _SIDE_BACK = 5 _STORAGE_RAW :: Int _STORAGE_RAW = 0 _STORAGE_COMPRESS_LOSSLESS :: Int _STORAGE_COMPRESS_LOSSLESS = 2 _FLAGS_DEFAULT :: Int _FLAGS_DEFAULT = 7 _FLAG_REPEAT :: Int _FLAG_REPEAT = 2 _SIDE_LEFT :: Int _SIDE_LEFT = 0 _SIDE_FRONT :: Int _SIDE_FRONT = 4 _STORAGE_COMPRESS_LOSSY :: Int _STORAGE_COMPRESS_LOSSY = 1 _FLAG_MIPMAPS :: Int _FLAG_MIPMAPS = 1 _SIDE_BOTTOM :: Int _SIDE_BOTTOM = 2 _FLAG_FILTER :: Int _FLAG_FILTER = 4 instance NodeProperty CubeMap "flags" Int 'False where nodeProperty = (get_flags, wrapDroppingSetter set_flags, Nothing) instance NodeProperty CubeMap "lossy_storage_quality" Float 'False where nodeProperty = (get_lossy_storage_quality, wrapDroppingSetter set_lossy_storage_quality, Nothing) instance NodeProperty CubeMap "storage_mode" Int 'False where nodeProperty = (get_storage, wrapDroppingSetter set_storage, Nothing) {-# NOINLINE bindCubeMap_get_flags #-} -- | The render flags for the @CubeMap@. See the @enum Flags@ constants for details. bindCubeMap_get_flags :: MethodBind bindCubeMap_get_flags = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "get_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The render flags for the @CubeMap@. See the @enum Flags@ constants for details. get_flags :: (CubeMap :< cls, Object :< cls) => cls -> IO Int get_flags cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_get_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "get_flags" '[] (IO Int) where nodeMethod = Godot.Core.CubeMap.get_flags {-# NOINLINE bindCubeMap_get_height #-} -- | Returns the @CubeMap@'s height. bindCubeMap_get_height :: MethodBind bindCubeMap_get_height = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @CubeMap@'s height. get_height :: (CubeMap :< cls, Object :< cls) => cls -> IO Int get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "get_height" '[] (IO Int) where nodeMethod = Godot.Core.CubeMap.get_height {-# NOINLINE bindCubeMap_get_lossy_storage_quality #-} -- | The lossy storage quality of the @CubeMap@ if the storage mode is set to @STORAGE_COMPRESS_LOSSY@. bindCubeMap_get_lossy_storage_quality :: MethodBind bindCubeMap_get_lossy_storage_quality = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "get_lossy_storage_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The lossy storage quality of the @CubeMap@ if the storage mode is set to @STORAGE_COMPRESS_LOSSY@. get_lossy_storage_quality :: (CubeMap :< cls, Object :< cls) => cls -> IO Float get_lossy_storage_quality cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_get_lossy_storage_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "get_lossy_storage_quality" '[] (IO Float) where nodeMethod = Godot.Core.CubeMap.get_lossy_storage_quality {-# NOINLINE bindCubeMap_get_side #-} -- | Returns an @Image@ for a side of the @CubeMap@ using one of the @enum Side@ constants. bindCubeMap_get_side :: MethodBind bindCubeMap_get_side = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "get_side" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Image@ for a side of the @CubeMap@ using one of the @enum Side@ constants. get_side :: (CubeMap :< cls, Object :< cls) => cls -> Int -> IO Image get_side cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_get_side (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "get_side" '[Int] (IO Image) where nodeMethod = Godot.Core.CubeMap.get_side {-# NOINLINE bindCubeMap_get_storage #-} -- | The @CubeMap@'s storage mode. See @enum Storage@ constants. bindCubeMap_get_storage :: MethodBind bindCubeMap_get_storage = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "get_storage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @CubeMap@'s storage mode. See @enum Storage@ constants. get_storage :: (CubeMap :< cls, Object :< cls) => cls -> IO Int get_storage cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_get_storage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "get_storage" '[] (IO Int) where nodeMethod = Godot.Core.CubeMap.get_storage {-# NOINLINE bindCubeMap_get_width #-} -- | Returns the @CubeMap@'s width. bindCubeMap_get_width :: MethodBind bindCubeMap_get_width = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @CubeMap@'s width. get_width :: (CubeMap :< cls, Object :< cls) => cls -> IO Int get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "get_width" '[] (IO Int) where nodeMethod = Godot.Core.CubeMap.get_width {-# NOINLINE bindCubeMap_set_flags #-} -- | The render flags for the @CubeMap@. See the @enum Flags@ constants for details. bindCubeMap_set_flags :: MethodBind bindCubeMap_set_flags = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "set_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The render flags for the @CubeMap@. See the @enum Flags@ constants for details. set_flags :: (CubeMap :< cls, Object :< cls) => cls -> Int -> IO () set_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_set_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "set_flags" '[Int] (IO ()) where nodeMethod = Godot.Core.CubeMap.set_flags {-# NOINLINE bindCubeMap_set_lossy_storage_quality #-} -- | The lossy storage quality of the @CubeMap@ if the storage mode is set to @STORAGE_COMPRESS_LOSSY@. bindCubeMap_set_lossy_storage_quality :: MethodBind bindCubeMap_set_lossy_storage_quality = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "set_lossy_storage_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The lossy storage quality of the @CubeMap@ if the storage mode is set to @STORAGE_COMPRESS_LOSSY@. set_lossy_storage_quality :: (CubeMap :< cls, Object :< cls) => cls -> Float -> IO () set_lossy_storage_quality cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_set_lossy_storage_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "set_lossy_storage_quality" '[Float] (IO ()) where nodeMethod = Godot.Core.CubeMap.set_lossy_storage_quality {-# NOINLINE bindCubeMap_set_side #-} -- | Sets an @Image@ for a side of the @CubeMap@ using one of the @enum Side@ constants. bindCubeMap_set_side :: MethodBind bindCubeMap_set_side = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "set_side" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an @Image@ for a side of the @CubeMap@ using one of the @enum Side@ constants. set_side :: (CubeMap :< cls, Object :< cls) => cls -> Int -> Image -> IO () set_side cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_set_side (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "set_side" '[Int, Image] (IO ()) where nodeMethod = Godot.Core.CubeMap.set_side {-# NOINLINE bindCubeMap_set_storage #-} -- | The @CubeMap@'s storage mode. See @enum Storage@ constants. bindCubeMap_set_storage :: MethodBind bindCubeMap_set_storage = unsafePerformIO $ withCString "CubeMap" $ \ clsNamePtr -> withCString "set_storage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @CubeMap@'s storage mode. See @enum Storage@ constants. set_storage :: (CubeMap :< cls, Object :< cls) => cls -> Int -> IO () set_storage cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMap_set_storage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMap "set_storage" '[Int] (IO ()) where nodeMethod = Godot.Core.CubeMap.set_storage ================================================ FILE: src/Godot/Core/CubeMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CubeMesh (Godot.Core.CubeMesh.get_size, Godot.Core.CubeMesh.get_subdivide_depth, Godot.Core.CubeMesh.get_subdivide_height, Godot.Core.CubeMesh.get_subdivide_width, Godot.Core.CubeMesh.set_size, Godot.Core.CubeMesh.set_subdivide_depth, Godot.Core.CubeMesh.set_subdivide_height, Godot.Core.CubeMesh.set_subdivide_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PrimitiveMesh() instance NodeProperty CubeMesh "size" Vector3 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) instance NodeProperty CubeMesh "subdivide_depth" Int 'False where nodeProperty = (get_subdivide_depth, wrapDroppingSetter set_subdivide_depth, Nothing) instance NodeProperty CubeMesh "subdivide_height" Int 'False where nodeProperty = (get_subdivide_height, wrapDroppingSetter set_subdivide_height, Nothing) instance NodeProperty CubeMesh "subdivide_width" Int 'False where nodeProperty = (get_subdivide_width, wrapDroppingSetter set_subdivide_width, Nothing) {-# NOINLINE bindCubeMesh_get_size #-} -- | Size of the cuboid mesh. bindCubeMesh_get_size :: MethodBind bindCubeMesh_get_size = unsafePerformIO $ withCString "CubeMesh" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size of the cuboid mesh. get_size :: (CubeMesh :< cls, Object :< cls) => cls -> IO Vector3 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMesh_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMesh "get_size" '[] (IO Vector3) where nodeMethod = Godot.Core.CubeMesh.get_size {-# NOINLINE bindCubeMesh_get_subdivide_depth #-} -- | Number of extra edge loops inserted along the Z axis. bindCubeMesh_get_subdivide_depth :: MethodBind bindCubeMesh_get_subdivide_depth = unsafePerformIO $ withCString "CubeMesh" $ \ clsNamePtr -> withCString "get_subdivide_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of extra edge loops inserted along the Z axis. get_subdivide_depth :: (CubeMesh :< cls, Object :< cls) => cls -> IO Int get_subdivide_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMesh_get_subdivide_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMesh "get_subdivide_depth" '[] (IO Int) where nodeMethod = Godot.Core.CubeMesh.get_subdivide_depth {-# NOINLINE bindCubeMesh_get_subdivide_height #-} -- | Number of extra edge loops inserted along the Y axis. bindCubeMesh_get_subdivide_height :: MethodBind bindCubeMesh_get_subdivide_height = unsafePerformIO $ withCString "CubeMesh" $ \ clsNamePtr -> withCString "get_subdivide_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of extra edge loops inserted along the Y axis. get_subdivide_height :: (CubeMesh :< cls, Object :< cls) => cls -> IO Int get_subdivide_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMesh_get_subdivide_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMesh "get_subdivide_height" '[] (IO Int) where nodeMethod = Godot.Core.CubeMesh.get_subdivide_height {-# NOINLINE bindCubeMesh_get_subdivide_width #-} -- | Number of extra edge loops inserted along the X axis. bindCubeMesh_get_subdivide_width :: MethodBind bindCubeMesh_get_subdivide_width = unsafePerformIO $ withCString "CubeMesh" $ \ clsNamePtr -> withCString "get_subdivide_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of extra edge loops inserted along the X axis. get_subdivide_width :: (CubeMesh :< cls, Object :< cls) => cls -> IO Int get_subdivide_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMesh_get_subdivide_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMesh "get_subdivide_width" '[] (IO Int) where nodeMethod = Godot.Core.CubeMesh.get_subdivide_width {-# NOINLINE bindCubeMesh_set_size #-} -- | Size of the cuboid mesh. bindCubeMesh_set_size :: MethodBind bindCubeMesh_set_size = unsafePerformIO $ withCString "CubeMesh" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size of the cuboid mesh. set_size :: (CubeMesh :< cls, Object :< cls) => cls -> Vector3 -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMesh_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMesh "set_size" '[Vector3] (IO ()) where nodeMethod = Godot.Core.CubeMesh.set_size {-# NOINLINE bindCubeMesh_set_subdivide_depth #-} -- | Number of extra edge loops inserted along the Z axis. bindCubeMesh_set_subdivide_depth :: MethodBind bindCubeMesh_set_subdivide_depth = unsafePerformIO $ withCString "CubeMesh" $ \ clsNamePtr -> withCString "set_subdivide_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of extra edge loops inserted along the Z axis. set_subdivide_depth :: (CubeMesh :< cls, Object :< cls) => cls -> Int -> IO () set_subdivide_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMesh_set_subdivide_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMesh "set_subdivide_depth" '[Int] (IO ()) where nodeMethod = Godot.Core.CubeMesh.set_subdivide_depth {-# NOINLINE bindCubeMesh_set_subdivide_height #-} -- | Number of extra edge loops inserted along the Y axis. bindCubeMesh_set_subdivide_height :: MethodBind bindCubeMesh_set_subdivide_height = unsafePerformIO $ withCString "CubeMesh" $ \ clsNamePtr -> withCString "set_subdivide_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of extra edge loops inserted along the Y axis. set_subdivide_height :: (CubeMesh :< cls, Object :< cls) => cls -> Int -> IO () set_subdivide_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMesh_set_subdivide_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMesh "set_subdivide_height" '[Int] (IO ()) where nodeMethod = Godot.Core.CubeMesh.set_subdivide_height {-# NOINLINE bindCubeMesh_set_subdivide_width #-} -- | Number of extra edge loops inserted along the X axis. bindCubeMesh_set_subdivide_width :: MethodBind bindCubeMesh_set_subdivide_width = unsafePerformIO $ withCString "CubeMesh" $ \ clsNamePtr -> withCString "set_subdivide_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of extra edge loops inserted along the X axis. set_subdivide_width :: (CubeMesh :< cls, Object :< cls) => cls -> Int -> IO () set_subdivide_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCubeMesh_set_subdivide_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CubeMesh "set_subdivide_width" '[Int] (IO ()) where nodeMethod = Godot.Core.CubeMesh.set_subdivide_width ================================================ FILE: src/Godot/Core/Curve.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Curve (Godot.Core.Curve._TANGENT_LINEAR, Godot.Core.Curve._TANGENT_FREE, Godot.Core.Curve._TANGENT_MODE_COUNT, Godot.Core.Curve.sig_range_changed, Godot.Core.Curve._get_data, Godot.Core.Curve._set_data, Godot.Core.Curve.add_point, Godot.Core.Curve.bake, Godot.Core.Curve.clean_dupes, Godot.Core.Curve.clear_points, Godot.Core.Curve.get_bake_resolution, Godot.Core.Curve.get_max_value, Godot.Core.Curve.get_min_value, Godot.Core.Curve.get_point_count, Godot.Core.Curve.get_point_left_mode, Godot.Core.Curve.get_point_left_tangent, Godot.Core.Curve.get_point_position, Godot.Core.Curve.get_point_right_mode, Godot.Core.Curve.get_point_right_tangent, Godot.Core.Curve.interpolate, Godot.Core.Curve.interpolate_baked, Godot.Core.Curve.remove_point, Godot.Core.Curve.set_bake_resolution, Godot.Core.Curve.set_max_value, Godot.Core.Curve.set_min_value, Godot.Core.Curve.set_point_left_mode, Godot.Core.Curve.set_point_left_tangent, Godot.Core.Curve.set_point_offset, Godot.Core.Curve.set_point_right_mode, Godot.Core.Curve.set_point_right_tangent, Godot.Core.Curve.set_point_value) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _TANGENT_LINEAR :: Int _TANGENT_LINEAR = 1 _TANGENT_FREE :: Int _TANGENT_FREE = 0 _TANGENT_MODE_COUNT :: Int _TANGENT_MODE_COUNT = 2 -- | Emitted when @max_value@ or @min_value@ is changed. sig_range_changed :: Godot.Internal.Dispatch.Signal Curve sig_range_changed = Godot.Internal.Dispatch.Signal "range_changed" instance NodeSignal Curve "range_changed" '[] instance NodeProperty Curve "_data" Array 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) instance NodeProperty Curve "bake_resolution" Int 'False where nodeProperty = (get_bake_resolution, wrapDroppingSetter set_bake_resolution, Nothing) instance NodeProperty Curve "max_value" Float 'False where nodeProperty = (get_max_value, wrapDroppingSetter set_max_value, Nothing) instance NodeProperty Curve "min_value" Float 'False where nodeProperty = (get_min_value, wrapDroppingSetter set_min_value, Nothing) {-# NOINLINE bindCurve__get_data #-} bindCurve__get_data :: MethodBind bindCurve__get_data = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_data :: (Curve :< cls, Object :< cls) => cls -> IO Array _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "_get_data" '[] (IO Array) where nodeMethod = Godot.Core.Curve._get_data {-# NOINLINE bindCurve__set_data #-} bindCurve__set_data :: MethodBind bindCurve__set_data = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_data :: (Curve :< cls, Object :< cls) => cls -> Array -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "_set_data" '[Array] (IO ()) where nodeMethod = Godot.Core.Curve._set_data {-# NOINLINE bindCurve_add_point #-} -- | Adds a point to the curve. For each side, if the @*_mode@ is @TANGENT_LINEAR@, the @*_tangent@ angle (in degrees) uses the slope of the curve halfway to the adjacent point. Allows custom assignments to the @*_tangent@ angle if @*_mode@ is set to @TANGENT_FREE@. bindCurve_add_point :: MethodBind bindCurve_add_point = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "add_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a point to the curve. For each side, if the @*_mode@ is @TANGENT_LINEAR@, the @*_tangent@ angle (in degrees) uses the slope of the curve halfway to the adjacent point. Allows custom assignments to the @*_tangent@ angle if @*_mode@ is set to @TANGENT_FREE@. add_point :: (Curve :< cls, Object :< cls) => cls -> Vector2 -> Maybe Float -> Maybe Float -> Maybe Int -> Maybe Int -> IO Int add_point cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, maybe (VariantReal (0)) toVariant arg2, maybe (VariantReal (0)) toVariant arg3, maybe (VariantInt (0)) toVariant arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_add_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "add_point" '[Vector2, Maybe Float, Maybe Float, Maybe Int, Maybe Int] (IO Int) where nodeMethod = Godot.Core.Curve.add_point {-# NOINLINE bindCurve_bake #-} -- | Recomputes the baked cache of points for the curve. bindCurve_bake :: MethodBind bindCurve_bake = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "bake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Recomputes the baked cache of points for the curve. bake :: (Curve :< cls, Object :< cls) => cls -> IO () bake cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_bake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "bake" '[] (IO ()) where nodeMethod = Godot.Core.Curve.bake {-# NOINLINE bindCurve_clean_dupes #-} -- | Removes points that are closer than @CMP_EPSILON@ (0.00001) units to their neighbor on the curve. bindCurve_clean_dupes :: MethodBind bindCurve_clean_dupes = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "clean_dupes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes points that are closer than @CMP_EPSILON@ (0.00001) units to their neighbor on the curve. clean_dupes :: (Curve :< cls, Object :< cls) => cls -> IO () clean_dupes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_clean_dupes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "clean_dupes" '[] (IO ()) where nodeMethod = Godot.Core.Curve.clean_dupes {-# NOINLINE bindCurve_clear_points #-} -- | Removes all points from the curve. bindCurve_clear_points :: MethodBind bindCurve_clear_points = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "clear_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all points from the curve. clear_points :: (Curve :< cls, Object :< cls) => cls -> IO () clear_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_clear_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "clear_points" '[] (IO ()) where nodeMethod = Godot.Core.Curve.clear_points {-# NOINLINE bindCurve_get_bake_resolution #-} -- | The number of points to include in the baked (i.e. cached) curve data. bindCurve_get_bake_resolution :: MethodBind bindCurve_get_bake_resolution = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_bake_resolution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of points to include in the baked (i.e. cached) curve data. get_bake_resolution :: (Curve :< cls, Object :< cls) => cls -> IO Int get_bake_resolution cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_bake_resolution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_bake_resolution" '[] (IO Int) where nodeMethod = Godot.Core.Curve.get_bake_resolution {-# NOINLINE bindCurve_get_max_value #-} -- | The maximum value the curve can reach. bindCurve_get_max_value :: MethodBind bindCurve_get_max_value = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_max_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum value the curve can reach. get_max_value :: (Curve :< cls, Object :< cls) => cls -> IO Float get_max_value cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_max_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_max_value" '[] (IO Float) where nodeMethod = Godot.Core.Curve.get_max_value {-# NOINLINE bindCurve_get_min_value #-} -- | The minimum value the curve can reach. bindCurve_get_min_value :: MethodBind bindCurve_get_min_value = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_min_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum value the curve can reach. get_min_value :: (Curve :< cls, Object :< cls) => cls -> IO Float get_min_value cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_min_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_min_value" '[] (IO Float) where nodeMethod = Godot.Core.Curve.get_min_value {-# NOINLINE bindCurve_get_point_count #-} -- | Returns the number of points describing the curve. bindCurve_get_point_count :: MethodBind bindCurve_get_point_count = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of points describing the curve. get_point_count :: (Curve :< cls, Object :< cls) => cls -> IO Int get_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_point_count" '[] (IO Int) where nodeMethod = Godot.Core.Curve.get_point_count {-# NOINLINE bindCurve_get_point_left_mode #-} -- | Returns the left @enum TangentMode@ for the point at @index@. bindCurve_get_point_left_mode :: MethodBind bindCurve_get_point_left_mode = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_point_left_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the left @enum TangentMode@ for the point at @index@. get_point_left_mode :: (Curve :< cls, Object :< cls) => cls -> Int -> IO Int get_point_left_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_point_left_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_point_left_mode" '[Int] (IO Int) where nodeMethod = Godot.Core.Curve.get_point_left_mode {-# NOINLINE bindCurve_get_point_left_tangent #-} -- | Returns the left tangent angle (in degrees) for the point at @index@. bindCurve_get_point_left_tangent :: MethodBind bindCurve_get_point_left_tangent = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_point_left_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the left tangent angle (in degrees) for the point at @index@. get_point_left_tangent :: (Curve :< cls, Object :< cls) => cls -> Int -> IO Float get_point_left_tangent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_point_left_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_point_left_tangent" '[Int] (IO Float) where nodeMethod = Godot.Core.Curve.get_point_left_tangent {-# NOINLINE bindCurve_get_point_position #-} -- | Returns the curve coordinates for the point at @index@. bindCurve_get_point_position :: MethodBind bindCurve_get_point_position = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the curve coordinates for the point at @index@. get_point_position :: (Curve :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_point_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_point_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Curve.get_point_position {-# NOINLINE bindCurve_get_point_right_mode #-} -- | Returns the right @enum TangentMode@ for the point at @index@. bindCurve_get_point_right_mode :: MethodBind bindCurve_get_point_right_mode = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_point_right_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the right @enum TangentMode@ for the point at @index@. get_point_right_mode :: (Curve :< cls, Object :< cls) => cls -> Int -> IO Int get_point_right_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_point_right_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_point_right_mode" '[Int] (IO Int) where nodeMethod = Godot.Core.Curve.get_point_right_mode {-# NOINLINE bindCurve_get_point_right_tangent #-} -- | Returns the right tangent angle (in degrees) for the point at @index@. bindCurve_get_point_right_tangent :: MethodBind bindCurve_get_point_right_tangent = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "get_point_right_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the right tangent angle (in degrees) for the point at @index@. get_point_right_tangent :: (Curve :< cls, Object :< cls) => cls -> Int -> IO Float get_point_right_tangent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_get_point_right_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "get_point_right_tangent" '[Int] (IO Float) where nodeMethod = Godot.Core.Curve.get_point_right_tangent {-# NOINLINE bindCurve_interpolate #-} -- | Returns the Y value for the point that would exist at the X position @offset@ along the curve. bindCurve_interpolate :: MethodBind bindCurve_interpolate = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "interpolate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the Y value for the point that would exist at the X position @offset@ along the curve. interpolate :: (Curve :< cls, Object :< cls) => cls -> Float -> IO Float interpolate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_interpolate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "interpolate" '[Float] (IO Float) where nodeMethod = Godot.Core.Curve.interpolate {-# NOINLINE bindCurve_interpolate_baked #-} -- | Returns the Y value for the point that would exist at the X position @offset@ along the curve using the baked cache. Bakes the curve's points if not already baked. bindCurve_interpolate_baked :: MethodBind bindCurve_interpolate_baked = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "interpolate_baked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the Y value for the point that would exist at the X position @offset@ along the curve using the baked cache. Bakes the curve's points if not already baked. interpolate_baked :: (Curve :< cls, Object :< cls) => cls -> Float -> IO Float interpolate_baked cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_interpolate_baked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "interpolate_baked" '[Float] (IO Float) where nodeMethod = Godot.Core.Curve.interpolate_baked {-# NOINLINE bindCurve_remove_point #-} -- | Removes the point at @index@ from the curve. bindCurve_remove_point :: MethodBind bindCurve_remove_point = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "remove_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the point at @index@ from the curve. remove_point :: (Curve :< cls, Object :< cls) => cls -> Int -> IO () remove_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_remove_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "remove_point" '[Int] (IO ()) where nodeMethod = Godot.Core.Curve.remove_point {-# NOINLINE bindCurve_set_bake_resolution #-} -- | The number of points to include in the baked (i.e. cached) curve data. bindCurve_set_bake_resolution :: MethodBind bindCurve_set_bake_resolution = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_bake_resolution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of points to include in the baked (i.e. cached) curve data. set_bake_resolution :: (Curve :< cls, Object :< cls) => cls -> Int -> IO () set_bake_resolution cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_bake_resolution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_bake_resolution" '[Int] (IO ()) where nodeMethod = Godot.Core.Curve.set_bake_resolution {-# NOINLINE bindCurve_set_max_value #-} -- | The maximum value the curve can reach. bindCurve_set_max_value :: MethodBind bindCurve_set_max_value = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_max_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum value the curve can reach. set_max_value :: (Curve :< cls, Object :< cls) => cls -> Float -> IO () set_max_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_max_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_max_value" '[Float] (IO ()) where nodeMethod = Godot.Core.Curve.set_max_value {-# NOINLINE bindCurve_set_min_value #-} -- | The minimum value the curve can reach. bindCurve_set_min_value :: MethodBind bindCurve_set_min_value = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_min_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum value the curve can reach. set_min_value :: (Curve :< cls, Object :< cls) => cls -> Float -> IO () set_min_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_min_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_min_value" '[Float] (IO ()) where nodeMethod = Godot.Core.Curve.set_min_value {-# NOINLINE bindCurve_set_point_left_mode #-} -- | Sets the left @enum TangentMode@ for the point at @index@ to @mode@. bindCurve_set_point_left_mode :: MethodBind bindCurve_set_point_left_mode = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_point_left_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the left @enum TangentMode@ for the point at @index@ to @mode@. set_point_left_mode :: (Curve :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_point_left_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_point_left_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_point_left_mode" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Curve.set_point_left_mode {-# NOINLINE bindCurve_set_point_left_tangent #-} -- | Sets the left tangent angle for the point at @index@ to @tangent@. bindCurve_set_point_left_tangent :: MethodBind bindCurve_set_point_left_tangent = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_point_left_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the left tangent angle for the point at @index@ to @tangent@. set_point_left_tangent :: (Curve :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_point_left_tangent cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_point_left_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_point_left_tangent" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Curve.set_point_left_tangent {-# NOINLINE bindCurve_set_point_offset #-} -- | Sets the offset from @0.5@. bindCurve_set_point_offset :: MethodBind bindCurve_set_point_offset = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_point_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the offset from @0.5@. set_point_offset :: (Curve :< cls, Object :< cls) => cls -> Int -> Float -> IO Int set_point_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_point_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_point_offset" '[Int, Float] (IO Int) where nodeMethod = Godot.Core.Curve.set_point_offset {-# NOINLINE bindCurve_set_point_right_mode #-} -- | Sets the right @enum TangentMode@ for the point at @index@ to @mode@. bindCurve_set_point_right_mode :: MethodBind bindCurve_set_point_right_mode = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_point_right_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the right @enum TangentMode@ for the point at @index@ to @mode@. set_point_right_mode :: (Curve :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_point_right_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_point_right_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_point_right_mode" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Curve.set_point_right_mode {-# NOINLINE bindCurve_set_point_right_tangent #-} -- | Sets the right tangent angle for the point at @index@ to @tangent@. bindCurve_set_point_right_tangent :: MethodBind bindCurve_set_point_right_tangent = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_point_right_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the right tangent angle for the point at @index@ to @tangent@. set_point_right_tangent :: (Curve :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_point_right_tangent cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_point_right_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_point_right_tangent" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Curve.set_point_right_tangent {-# NOINLINE bindCurve_set_point_value #-} -- | Assigns the vertical position @y@ to the point at @index@. bindCurve_set_point_value :: MethodBind bindCurve_set_point_value = unsafePerformIO $ withCString "Curve" $ \ clsNamePtr -> withCString "set_point_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns the vertical position @y@ to the point at @index@. set_point_value :: (Curve :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_point_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve_set_point_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve "set_point_value" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Curve.set_point_value ================================================ FILE: src/Godot/Core/Curve2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Curve2D (Godot.Core.Curve2D._get_data, Godot.Core.Curve2D._set_data, Godot.Core.Curve2D.add_point, Godot.Core.Curve2D.clear_points, Godot.Core.Curve2D.get_bake_interval, Godot.Core.Curve2D.get_baked_length, Godot.Core.Curve2D.get_baked_points, Godot.Core.Curve2D.get_closest_offset, Godot.Core.Curve2D.get_closest_point, Godot.Core.Curve2D.get_point_count, Godot.Core.Curve2D.get_point_in, Godot.Core.Curve2D.get_point_out, Godot.Core.Curve2D.get_point_position, Godot.Core.Curve2D.interpolate, Godot.Core.Curve2D.interpolate_baked, Godot.Core.Curve2D.interpolatef, Godot.Core.Curve2D.remove_point, Godot.Core.Curve2D.set_bake_interval, Godot.Core.Curve2D.set_point_in, Godot.Core.Curve2D.set_point_out, Godot.Core.Curve2D.set_point_position, Godot.Core.Curve2D.tessellate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty Curve2D "_data" Dictionary 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) instance NodeProperty Curve2D "bake_interval" Float 'False where nodeProperty = (get_bake_interval, wrapDroppingSetter set_bake_interval, Nothing) {-# NOINLINE bindCurve2D__get_data #-} bindCurve2D__get_data :: MethodBind bindCurve2D__get_data = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_data :: (Curve2D :< cls, Object :< cls) => cls -> IO Dictionary _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "_get_data" '[] (IO Dictionary) where nodeMethod = Godot.Core.Curve2D._get_data {-# NOINLINE bindCurve2D__set_data #-} bindCurve2D__set_data :: MethodBind bindCurve2D__set_data = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_data :: (Curve2D :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "_set_data" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.Curve2D._set_data {-# NOINLINE bindCurve2D_add_point #-} -- | Adds a point to a curve at @position@, with control points @in@ and @out@. -- If @at_position@ is given, the point is inserted before the point number @at_position@, moving that point (and every point after) after the inserted point. If @at_position@ is not given, or is an illegal value (@at_position <0@ or @at_position >= @method get_point_count@@), the point will be appended at the end of the point list. bindCurve2D_add_point :: MethodBind bindCurve2D_add_point = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "add_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a point to a curve at @position@, with control points @in@ and @out@. -- If @at_position@ is given, the point is inserted before the point number @at_position@, moving that point (and every point after) after the inserted point. If @at_position@ is not given, or is an illegal value (@at_position <0@ or @at_position >= @method get_point_count@@), the point will be appended at the end of the point list. add_point :: (Curve2D :< cls, Object :< cls) => cls -> Vector2 -> Maybe Vector2 -> Maybe Vector2 -> Maybe Int -> IO () add_point cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, defaultedVariant VariantVector2 (V2 0 0) arg2, defaultedVariant VariantVector2 (V2 0 0) arg3, maybe (VariantInt (-1)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_add_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "add_point" '[Vector2, Maybe Vector2, Maybe Vector2, Maybe Int] (IO ()) where nodeMethod = Godot.Core.Curve2D.add_point {-# NOINLINE bindCurve2D_clear_points #-} -- | Removes all points from the curve. bindCurve2D_clear_points :: MethodBind bindCurve2D_clear_points = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "clear_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all points from the curve. clear_points :: (Curve2D :< cls, Object :< cls) => cls -> IO () clear_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_clear_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "clear_points" '[] (IO ()) where nodeMethod = Godot.Core.Curve2D.clear_points {-# NOINLINE bindCurve2D_get_bake_interval #-} -- | The distance in pixels between two adjacent cached points. Changing it forces the cache to be recomputed the next time the @method get_baked_points@ or @method get_baked_length@ function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care. bindCurve2D_get_bake_interval :: MethodBind bindCurve2D_get_bake_interval = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_bake_interval" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance in pixels between two adjacent cached points. Changing it forces the cache to be recomputed the next time the @method get_baked_points@ or @method get_baked_length@ function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care. get_bake_interval :: (Curve2D :< cls, Object :< cls) => cls -> IO Float get_bake_interval cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_bake_interval (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_bake_interval" '[] (IO Float) where nodeMethod = Godot.Core.Curve2D.get_bake_interval {-# NOINLINE bindCurve2D_get_baked_length #-} -- | Returns the total length of the curve, based on the cached points. Given enough density (see @bake_interval@), it should be approximate enough. bindCurve2D_get_baked_length :: MethodBind bindCurve2D_get_baked_length = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_baked_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total length of the curve, based on the cached points. Given enough density (see @bake_interval@), it should be approximate enough. get_baked_length :: (Curve2D :< cls, Object :< cls) => cls -> IO Float get_baked_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_baked_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_baked_length" '[] (IO Float) where nodeMethod = Godot.Core.Curve2D.get_baked_length {-# NOINLINE bindCurve2D_get_baked_points #-} -- | Returns the cache of points as a @PoolVector2Array@. bindCurve2D_get_baked_points :: MethodBind bindCurve2D_get_baked_points = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_baked_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cache of points as a @PoolVector2Array@. get_baked_points :: (Curve2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_baked_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_baked_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_baked_points" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.Curve2D.get_baked_points {-# NOINLINE bindCurve2D_get_closest_offset #-} -- | Returns the closest offset to @to_point@. This offset is meant to be used in @method interpolate_baked@. -- @to_point@ must be in this curve's local space. bindCurve2D_get_closest_offset :: MethodBind bindCurve2D_get_closest_offset = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_closest_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the closest offset to @to_point@. This offset is meant to be used in @method interpolate_baked@. -- @to_point@ must be in this curve's local space. get_closest_offset :: (Curve2D :< cls, Object :< cls) => cls -> Vector2 -> IO Float get_closest_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_closest_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_closest_offset" '[Vector2] (IO Float) where nodeMethod = Godot.Core.Curve2D.get_closest_offset {-# NOINLINE bindCurve2D_get_closest_point #-} -- | Returns the closest point (in curve's local space) to @to_point@. -- @to_point@ must be in this curve's local space. bindCurve2D_get_closest_point :: MethodBind bindCurve2D_get_closest_point = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_closest_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the closest point (in curve's local space) to @to_point@. -- @to_point@ must be in this curve's local space. get_closest_point :: (Curve2D :< cls, Object :< cls) => cls -> Vector2 -> IO Vector2 get_closest_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_closest_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_closest_point" '[Vector2] (IO Vector2) where nodeMethod = Godot.Core.Curve2D.get_closest_point {-# NOINLINE bindCurve2D_get_point_count #-} -- | Returns the number of points describing the curve. bindCurve2D_get_point_count :: MethodBind bindCurve2D_get_point_count = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of points describing the curve. get_point_count :: (Curve2D :< cls, Object :< cls) => cls -> IO Int get_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_point_count" '[] (IO Int) where nodeMethod = Godot.Core.Curve2D.get_point_count {-# NOINLINE bindCurve2D_get_point_in #-} -- | Returns the position of the control point leading to the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0)@. bindCurve2D_get_point_in :: MethodBind bindCurve2D_get_point_in = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_point_in" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the control point leading to the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0)@. get_point_in :: (Curve2D :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_point_in cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_point_in (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_point_in" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Curve2D.get_point_in {-# NOINLINE bindCurve2D_get_point_out #-} -- | Returns the position of the control point leading out of the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0)@. bindCurve2D_get_point_out :: MethodBind bindCurve2D_get_point_out = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_point_out" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the control point leading out of the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0)@. get_point_out :: (Curve2D :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_point_out cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_point_out (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_point_out" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Curve2D.get_point_out {-# NOINLINE bindCurve2D_get_point_position #-} -- | Returns the position of the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0)@. bindCurve2D_get_point_position :: MethodBind bindCurve2D_get_point_position = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "get_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0)@. get_point_position :: (Curve2D :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_point_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_get_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "get_point_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Curve2D.get_point_position {-# NOINLINE bindCurve2D_interpolate #-} -- | Returns the position between the vertex @idx@ and the vertex @idx + 1@, where @t@ controls if the point is the first vertex (@t = 0.0@), the last vertex (@t = 1.0@), or in between. Values of @t@ outside the range (@0.0 >= t <=1@) give strange, but predictable results. -- If @idx@ is out of bounds it is truncated to the first or last vertex, and @t@ is ignored. If the curve has no points, the function sends an error to the console, and returns @(0, 0)@. bindCurve2D_interpolate :: MethodBind bindCurve2D_interpolate = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "interpolate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position between the vertex @idx@ and the vertex @idx + 1@, where @t@ controls if the point is the first vertex (@t = 0.0@), the last vertex (@t = 1.0@), or in between. Values of @t@ outside the range (@0.0 >= t <=1@) give strange, but predictable results. -- If @idx@ is out of bounds it is truncated to the first or last vertex, and @t@ is ignored. If the curve has no points, the function sends an error to the console, and returns @(0, 0)@. interpolate :: (Curve2D :< cls, Object :< cls) => cls -> Int -> Float -> IO Vector2 interpolate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_interpolate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "interpolate" '[Int, Float] (IO Vector2) where nodeMethod = Godot.Core.Curve2D.interpolate {-# NOINLINE bindCurve2D_interpolate_baked #-} -- | Returns a point within the curve at position @offset@, where @offset@ is measured as a pixel distance along the curve. -- To do that, it finds the two cached points where the @offset@ lies between, then interpolates the values. This interpolation is cubic if @cubic@ is set to @true@, or linear if set to @false@. -- Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough). bindCurve2D_interpolate_baked :: MethodBind bindCurve2D_interpolate_baked = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "interpolate_baked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a point within the curve at position @offset@, where @offset@ is measured as a pixel distance along the curve. -- To do that, it finds the two cached points where the @offset@ lies between, then interpolates the values. This interpolation is cubic if @cubic@ is set to @true@, or linear if set to @false@. -- Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough). interpolate_baked :: (Curve2D :< cls, Object :< cls) => cls -> Float -> Maybe Bool -> IO Vector2 interpolate_baked cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_interpolate_baked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "interpolate_baked" '[Float, Maybe Bool] (IO Vector2) where nodeMethod = Godot.Core.Curve2D.interpolate_baked {-# NOINLINE bindCurve2D_interpolatef #-} -- | Returns the position at the vertex @fofs@. It calls @method interpolate@ using the integer part of @fofs@ as @idx@, and its fractional part as @t@. bindCurve2D_interpolatef :: MethodBind bindCurve2D_interpolatef = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "interpolatef" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position at the vertex @fofs@. It calls @method interpolate@ using the integer part of @fofs@ as @idx@, and its fractional part as @t@. interpolatef :: (Curve2D :< cls, Object :< cls) => cls -> Float -> IO Vector2 interpolatef cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_interpolatef (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "interpolatef" '[Float] (IO Vector2) where nodeMethod = Godot.Core.Curve2D.interpolatef {-# NOINLINE bindCurve2D_remove_point #-} -- | Deletes the point @idx@ from the curve. Sends an error to the console if @idx@ is out of bounds. bindCurve2D_remove_point :: MethodBind bindCurve2D_remove_point = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "remove_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the point @idx@ from the curve. Sends an error to the console if @idx@ is out of bounds. remove_point :: (Curve2D :< cls, Object :< cls) => cls -> Int -> IO () remove_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_remove_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "remove_point" '[Int] (IO ()) where nodeMethod = Godot.Core.Curve2D.remove_point {-# NOINLINE bindCurve2D_set_bake_interval #-} -- | The distance in pixels between two adjacent cached points. Changing it forces the cache to be recomputed the next time the @method get_baked_points@ or @method get_baked_length@ function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care. bindCurve2D_set_bake_interval :: MethodBind bindCurve2D_set_bake_interval = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "set_bake_interval" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance in pixels between two adjacent cached points. Changing it forces the cache to be recomputed the next time the @method get_baked_points@ or @method get_baked_length@ function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care. set_bake_interval :: (Curve2D :< cls, Object :< cls) => cls -> Float -> IO () set_bake_interval cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_set_bake_interval (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "set_bake_interval" '[Float] (IO ()) where nodeMethod = Godot.Core.Curve2D.set_bake_interval {-# NOINLINE bindCurve2D_set_point_in #-} -- | Sets the position of the control point leading to the vertex @idx@. If the index is out of bounds, the function sends an error to the console. bindCurve2D_set_point_in :: MethodBind bindCurve2D_set_point_in = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "set_point_in" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position of the control point leading to the vertex @idx@. If the index is out of bounds, the function sends an error to the console. set_point_in :: (Curve2D :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_point_in cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_set_point_in (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "set_point_in" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.Curve2D.set_point_in {-# NOINLINE bindCurve2D_set_point_out #-} -- | Sets the position of the control point leading out of the vertex @idx@. If the index is out of bounds, the function sends an error to the console. bindCurve2D_set_point_out :: MethodBind bindCurve2D_set_point_out = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "set_point_out" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position of the control point leading out of the vertex @idx@. If the index is out of bounds, the function sends an error to the console. set_point_out :: (Curve2D :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_point_out cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_set_point_out (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "set_point_out" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.Curve2D.set_point_out {-# NOINLINE bindCurve2D_set_point_position #-} -- | Sets the position for the vertex @idx@. If the index is out of bounds, the function sends an error to the console. bindCurve2D_set_point_position :: MethodBind bindCurve2D_set_point_position = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "set_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position for the vertex @idx@. If the index is out of bounds, the function sends an error to the console. set_point_position :: (Curve2D :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_point_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_set_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "set_point_position" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.Curve2D.set_point_position {-# NOINLINE bindCurve2D_tessellate #-} -- | Returns a list of points along the curve, with a curvature controlled point density. That is, the curvier parts will have more points than the straighter parts. -- This approximation makes straight segments between each point, then subdivides those segments until the resulting shape is similar enough. -- @max_stages@ controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care! -- @tolerance_degrees@ controls how many degrees the midpoint of a segment may deviate from the real curve, before the segment has to be subdivided. bindCurve2D_tessellate :: MethodBind bindCurve2D_tessellate = unsafePerformIO $ withCString "Curve2D" $ \ clsNamePtr -> withCString "tessellate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of points along the curve, with a curvature controlled point density. That is, the curvier parts will have more points than the straighter parts. -- This approximation makes straight segments between each point, then subdivides those segments until the resulting shape is similar enough. -- @max_stages@ controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care! -- @tolerance_degrees@ controls how many degrees the midpoint of a segment may deviate from the real curve, before the segment has to be subdivided. tessellate :: (Curve2D :< cls, Object :< cls) => cls -> Maybe Int -> Maybe Float -> IO PoolVector2Array tessellate cls arg1 arg2 = withVariantArray [maybe (VariantInt (5)) toVariant arg1, maybe (VariantReal (4)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve2D_tessellate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve2D "tessellate" '[Maybe Int, Maybe Float] (IO PoolVector2Array) where nodeMethod = Godot.Core.Curve2D.tessellate ================================================ FILE: src/Godot/Core/Curve3D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Curve3D (Godot.Core.Curve3D._get_data, Godot.Core.Curve3D._set_data, Godot.Core.Curve3D.add_point, Godot.Core.Curve3D.clear_points, Godot.Core.Curve3D.get_bake_interval, Godot.Core.Curve3D.get_baked_length, Godot.Core.Curve3D.get_baked_points, Godot.Core.Curve3D.get_baked_tilts, Godot.Core.Curve3D.get_baked_up_vectors, Godot.Core.Curve3D.get_closest_offset, Godot.Core.Curve3D.get_closest_point, Godot.Core.Curve3D.get_point_count, Godot.Core.Curve3D.get_point_in, Godot.Core.Curve3D.get_point_out, Godot.Core.Curve3D.get_point_position, Godot.Core.Curve3D.get_point_tilt, Godot.Core.Curve3D.interpolate, Godot.Core.Curve3D.interpolate_baked, Godot.Core.Curve3D.interpolate_baked_up_vector, Godot.Core.Curve3D.interpolatef, Godot.Core.Curve3D.is_up_vector_enabled, Godot.Core.Curve3D.remove_point, Godot.Core.Curve3D.set_bake_interval, Godot.Core.Curve3D.set_point_in, Godot.Core.Curve3D.set_point_out, Godot.Core.Curve3D.set_point_position, Godot.Core.Curve3D.set_point_tilt, Godot.Core.Curve3D.set_up_vector_enabled, Godot.Core.Curve3D.tessellate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty Curve3D "_data" Dictionary 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) instance NodeProperty Curve3D "bake_interval" Float 'False where nodeProperty = (get_bake_interval, wrapDroppingSetter set_bake_interval, Nothing) instance NodeProperty Curve3D "up_vector_enabled" Bool 'False where nodeProperty = (is_up_vector_enabled, wrapDroppingSetter set_up_vector_enabled, Nothing) {-# NOINLINE bindCurve3D__get_data #-} bindCurve3D__get_data :: MethodBind bindCurve3D__get_data = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_data :: (Curve3D :< cls, Object :< cls) => cls -> IO Dictionary _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "_get_data" '[] (IO Dictionary) where nodeMethod = Godot.Core.Curve3D._get_data {-# NOINLINE bindCurve3D__set_data #-} bindCurve3D__set_data :: MethodBind bindCurve3D__set_data = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_data :: (Curve3D :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "_set_data" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.Curve3D._set_data {-# NOINLINE bindCurve3D_add_point #-} -- | Adds a point to a curve at @position@, with control points @in@ and @out@. -- If @at_position@ is given, the point is inserted before the point number @at_position@, moving that point (and every point after) after the inserted point. If @at_position@ is not given, or is an illegal value (@at_position <0@ or @at_position >= @method get_point_count@@), the point will be appended at the end of the point list. bindCurve3D_add_point :: MethodBind bindCurve3D_add_point = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "add_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a point to a curve at @position@, with control points @in@ and @out@. -- If @at_position@ is given, the point is inserted before the point number @at_position@, moving that point (and every point after) after the inserted point. If @at_position@ is not given, or is an illegal value (@at_position <0@ or @at_position >= @method get_point_count@@), the point will be appended at the end of the point list. add_point :: (Curve3D :< cls, Object :< cls) => cls -> Vector3 -> Maybe Vector3 -> Maybe Vector3 -> Maybe Int -> IO () add_point cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, defaultedVariant VariantVector3 (V3 0 0 0) arg2, defaultedVariant VariantVector3 (V3 0 0 0) arg3, maybe (VariantInt (-1)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_add_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "add_point" '[Vector3, Maybe Vector3, Maybe Vector3, Maybe Int] (IO ()) where nodeMethod = Godot.Core.Curve3D.add_point {-# NOINLINE bindCurve3D_clear_points #-} -- | Removes all points from the curve. bindCurve3D_clear_points :: MethodBind bindCurve3D_clear_points = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "clear_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all points from the curve. clear_points :: (Curve3D :< cls, Object :< cls) => cls -> IO () clear_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_clear_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "clear_points" '[] (IO ()) where nodeMethod = Godot.Core.Curve3D.clear_points {-# NOINLINE bindCurve3D_get_bake_interval #-} -- | The distance in meters between two adjacent cached points. Changing it forces the cache to be recomputed the next time the @method get_baked_points@ or @method get_baked_length@ function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care. bindCurve3D_get_bake_interval :: MethodBind bindCurve3D_get_bake_interval = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_bake_interval" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance in meters between two adjacent cached points. Changing it forces the cache to be recomputed the next time the @method get_baked_points@ or @method get_baked_length@ function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care. get_bake_interval :: (Curve3D :< cls, Object :< cls) => cls -> IO Float get_bake_interval cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_bake_interval (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_bake_interval" '[] (IO Float) where nodeMethod = Godot.Core.Curve3D.get_bake_interval {-# NOINLINE bindCurve3D_get_baked_length #-} -- | Returns the total length of the curve, based on the cached points. Given enough density (see @bake_interval@), it should be approximate enough. bindCurve3D_get_baked_length :: MethodBind bindCurve3D_get_baked_length = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_baked_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total length of the curve, based on the cached points. Given enough density (see @bake_interval@), it should be approximate enough. get_baked_length :: (Curve3D :< cls, Object :< cls) => cls -> IO Float get_baked_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_baked_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_baked_length" '[] (IO Float) where nodeMethod = Godot.Core.Curve3D.get_baked_length {-# NOINLINE bindCurve3D_get_baked_points #-} -- | Returns the cache of points as a @PoolVector3Array@. bindCurve3D_get_baked_points :: MethodBind bindCurve3D_get_baked_points = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_baked_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cache of points as a @PoolVector3Array@. get_baked_points :: (Curve3D :< cls, Object :< cls) => cls -> IO PoolVector3Array get_baked_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_baked_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_baked_points" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.Curve3D.get_baked_points {-# NOINLINE bindCurve3D_get_baked_tilts #-} -- | Returns the cache of tilts as a @PoolRealArray@. bindCurve3D_get_baked_tilts :: MethodBind bindCurve3D_get_baked_tilts = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_baked_tilts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cache of tilts as a @PoolRealArray@. get_baked_tilts :: (Curve3D :< cls, Object :< cls) => cls -> IO PoolRealArray get_baked_tilts cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_baked_tilts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_baked_tilts" '[] (IO PoolRealArray) where nodeMethod = Godot.Core.Curve3D.get_baked_tilts {-# NOINLINE bindCurve3D_get_baked_up_vectors #-} -- | Returns the cache of up vectors as a @PoolVector3Array@. -- If @up_vector_enabled@ is @false@, the cache will be empty. bindCurve3D_get_baked_up_vectors :: MethodBind bindCurve3D_get_baked_up_vectors = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_baked_up_vectors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cache of up vectors as a @PoolVector3Array@. -- If @up_vector_enabled@ is @false@, the cache will be empty. get_baked_up_vectors :: (Curve3D :< cls, Object :< cls) => cls -> IO PoolVector3Array get_baked_up_vectors cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_baked_up_vectors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_baked_up_vectors" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.Curve3D.get_baked_up_vectors {-# NOINLINE bindCurve3D_get_closest_offset #-} -- | Returns the closest offset to @to_point@. This offset is meant to be used in @method interpolate_baked@ or @method interpolate_baked_up_vector@. -- @to_point@ must be in this curve's local space. bindCurve3D_get_closest_offset :: MethodBind bindCurve3D_get_closest_offset = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_closest_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the closest offset to @to_point@. This offset is meant to be used in @method interpolate_baked@ or @method interpolate_baked_up_vector@. -- @to_point@ must be in this curve's local space. get_closest_offset :: (Curve3D :< cls, Object :< cls) => cls -> Vector3 -> IO Float get_closest_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_closest_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_closest_offset" '[Vector3] (IO Float) where nodeMethod = Godot.Core.Curve3D.get_closest_offset {-# NOINLINE bindCurve3D_get_closest_point #-} -- | Returns the closest point (in curve's local space) to @to_point@. -- @to_point@ must be in this curve's local space. bindCurve3D_get_closest_point :: MethodBind bindCurve3D_get_closest_point = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_closest_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the closest point (in curve's local space) to @to_point@. -- @to_point@ must be in this curve's local space. get_closest_point :: (Curve3D :< cls, Object :< cls) => cls -> Vector3 -> IO Vector3 get_closest_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_closest_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_closest_point" '[Vector3] (IO Vector3) where nodeMethod = Godot.Core.Curve3D.get_closest_point {-# NOINLINE bindCurve3D_get_point_count #-} -- | Returns the number of points describing the curve. bindCurve3D_get_point_count :: MethodBind bindCurve3D_get_point_count = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of points describing the curve. get_point_count :: (Curve3D :< cls, Object :< cls) => cls -> IO Int get_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_point_count" '[] (IO Int) where nodeMethod = Godot.Core.Curve3D.get_point_count {-# NOINLINE bindCurve3D_get_point_in #-} -- | Returns the position of the control point leading to the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0, 0)@. bindCurve3D_get_point_in :: MethodBind bindCurve3D_get_point_in = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_point_in" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the control point leading to the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0, 0)@. get_point_in :: (Curve3D :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_point_in cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_point_in (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_point_in" '[Int] (IO Vector3) where nodeMethod = Godot.Core.Curve3D.get_point_in {-# NOINLINE bindCurve3D_get_point_out #-} -- | Returns the position of the control point leading out of the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0, 0)@. bindCurve3D_get_point_out :: MethodBind bindCurve3D_get_point_out = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_point_out" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the control point leading out of the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0, 0)@. get_point_out :: (Curve3D :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_point_out cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_point_out (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_point_out" '[Int] (IO Vector3) where nodeMethod = Godot.Core.Curve3D.get_point_out {-# NOINLINE bindCurve3D_get_point_position #-} -- | Returns the position of the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0, 0)@. bindCurve3D_get_point_position :: MethodBind bindCurve3D_get_point_position = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the vertex @idx@. If the index is out of bounds, the function sends an error to the console, and returns @(0, 0, 0)@. get_point_position :: (Curve3D :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_point_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_point_position" '[Int] (IO Vector3) where nodeMethod = Godot.Core.Curve3D.get_point_position {-# NOINLINE bindCurve3D_get_point_tilt #-} -- | Returns the tilt angle in radians for the point @idx@. If the index is out of bounds, the function sends an error to the console, and returns @0@. bindCurve3D_get_point_tilt :: MethodBind bindCurve3D_get_point_tilt = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "get_point_tilt" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tilt angle in radians for the point @idx@. If the index is out of bounds, the function sends an error to the console, and returns @0@. get_point_tilt :: (Curve3D :< cls, Object :< cls) => cls -> Int -> IO Float get_point_tilt cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_get_point_tilt (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "get_point_tilt" '[Int] (IO Float) where nodeMethod = Godot.Core.Curve3D.get_point_tilt {-# NOINLINE bindCurve3D_interpolate #-} -- | Returns the position between the vertex @idx@ and the vertex @idx + 1@, where @t@ controls if the point is the first vertex (@t = 0.0@), the last vertex (@t = 1.0@), or in between. Values of @t@ outside the range (@0.0 >= t <=1@) give strange, but predictable results. -- If @idx@ is out of bounds it is truncated to the first or last vertex, and @t@ is ignored. If the curve has no points, the function sends an error to the console, and returns @(0, 0, 0)@. bindCurve3D_interpolate :: MethodBind bindCurve3D_interpolate = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "interpolate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position between the vertex @idx@ and the vertex @idx + 1@, where @t@ controls if the point is the first vertex (@t = 0.0@), the last vertex (@t = 1.0@), or in between. Values of @t@ outside the range (@0.0 >= t <=1@) give strange, but predictable results. -- If @idx@ is out of bounds it is truncated to the first or last vertex, and @t@ is ignored. If the curve has no points, the function sends an error to the console, and returns @(0, 0, 0)@. interpolate :: (Curve3D :< cls, Object :< cls) => cls -> Int -> Float -> IO Vector3 interpolate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_interpolate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "interpolate" '[Int, Float] (IO Vector3) where nodeMethod = Godot.Core.Curve3D.interpolate {-# NOINLINE bindCurve3D_interpolate_baked #-} -- | Returns a point within the curve at position @offset@, where @offset@ is measured as a pixel distance along the curve. -- To do that, it finds the two cached points where the @offset@ lies between, then interpolates the values. This interpolation is cubic if @cubic@ is set to @true@, or linear if set to @false@. -- Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough). bindCurve3D_interpolate_baked :: MethodBind bindCurve3D_interpolate_baked = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "interpolate_baked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a point within the curve at position @offset@, where @offset@ is measured as a pixel distance along the curve. -- To do that, it finds the two cached points where the @offset@ lies between, then interpolates the values. This interpolation is cubic if @cubic@ is set to @true@, or linear if set to @false@. -- Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough). interpolate_baked :: (Curve3D :< cls, Object :< cls) => cls -> Float -> Maybe Bool -> IO Vector3 interpolate_baked cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_interpolate_baked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "interpolate_baked" '[Float, Maybe Bool] (IO Vector3) where nodeMethod = Godot.Core.Curve3D.interpolate_baked {-# NOINLINE bindCurve3D_interpolate_baked_up_vector #-} -- | Returns an up vector within the curve at position @offset@, where @offset@ is measured as a distance in 3D units along the curve. -- To do that, it finds the two cached up vectors where the @offset@ lies between, then interpolates the values. If @apply_tilt@ is @true@, an interpolated tilt is applied to the interpolated up vector. -- If the curve has no up vectors, the function sends an error to the console, and returns @(0, 1, 0)@. bindCurve3D_interpolate_baked_up_vector :: MethodBind bindCurve3D_interpolate_baked_up_vector = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "interpolate_baked_up_vector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an up vector within the curve at position @offset@, where @offset@ is measured as a distance in 3D units along the curve. -- To do that, it finds the two cached up vectors where the @offset@ lies between, then interpolates the values. If @apply_tilt@ is @true@, an interpolated tilt is applied to the interpolated up vector. -- If the curve has no up vectors, the function sends an error to the console, and returns @(0, 1, 0)@. interpolate_baked_up_vector :: (Curve3D :< cls, Object :< cls) => cls -> Float -> Maybe Bool -> IO Vector3 interpolate_baked_up_vector cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_interpolate_baked_up_vector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "interpolate_baked_up_vector" '[Float, Maybe Bool] (IO Vector3) where nodeMethod = Godot.Core.Curve3D.interpolate_baked_up_vector {-# NOINLINE bindCurve3D_interpolatef #-} -- | Returns the position at the vertex @fofs@. It calls @method interpolate@ using the integer part of @fofs@ as @idx@, and its fractional part as @t@. bindCurve3D_interpolatef :: MethodBind bindCurve3D_interpolatef = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "interpolatef" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position at the vertex @fofs@. It calls @method interpolate@ using the integer part of @fofs@ as @idx@, and its fractional part as @t@. interpolatef :: (Curve3D :< cls, Object :< cls) => cls -> Float -> IO Vector3 interpolatef cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_interpolatef (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "interpolatef" '[Float] (IO Vector3) where nodeMethod = Godot.Core.Curve3D.interpolatef {-# NOINLINE bindCurve3D_is_up_vector_enabled #-} -- | If @true@, the curve will bake up vectors used for orientation. This is used when @PathFollow.rotation_mode@ is set to @PathFollow.ROTATION_ORIENTED@. Changing it forces the cache to be recomputed. bindCurve3D_is_up_vector_enabled :: MethodBind bindCurve3D_is_up_vector_enabled = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "is_up_vector_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the curve will bake up vectors used for orientation. This is used when @PathFollow.rotation_mode@ is set to @PathFollow.ROTATION_ORIENTED@. Changing it forces the cache to be recomputed. is_up_vector_enabled :: (Curve3D :< cls, Object :< cls) => cls -> IO Bool is_up_vector_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_is_up_vector_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "is_up_vector_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Curve3D.is_up_vector_enabled {-# NOINLINE bindCurve3D_remove_point #-} -- | Deletes the point @idx@ from the curve. Sends an error to the console if @idx@ is out of bounds. bindCurve3D_remove_point :: MethodBind bindCurve3D_remove_point = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "remove_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the point @idx@ from the curve. Sends an error to the console if @idx@ is out of bounds. remove_point :: (Curve3D :< cls, Object :< cls) => cls -> Int -> IO () remove_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_remove_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "remove_point" '[Int] (IO ()) where nodeMethod = Godot.Core.Curve3D.remove_point {-# NOINLINE bindCurve3D_set_bake_interval #-} -- | The distance in meters between two adjacent cached points. Changing it forces the cache to be recomputed the next time the @method get_baked_points@ or @method get_baked_length@ function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care. bindCurve3D_set_bake_interval :: MethodBind bindCurve3D_set_bake_interval = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "set_bake_interval" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance in meters between two adjacent cached points. Changing it forces the cache to be recomputed the next time the @method get_baked_points@ or @method get_baked_length@ function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care. set_bake_interval :: (Curve3D :< cls, Object :< cls) => cls -> Float -> IO () set_bake_interval cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_set_bake_interval (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "set_bake_interval" '[Float] (IO ()) where nodeMethod = Godot.Core.Curve3D.set_bake_interval {-# NOINLINE bindCurve3D_set_point_in #-} -- | Sets the position of the control point leading to the vertex @idx@. If the index is out of bounds, the function sends an error to the console. bindCurve3D_set_point_in :: MethodBind bindCurve3D_set_point_in = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "set_point_in" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position of the control point leading to the vertex @idx@. If the index is out of bounds, the function sends an error to the console. set_point_in :: (Curve3D :< cls, Object :< cls) => cls -> Int -> Vector3 -> IO () set_point_in cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_set_point_in (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "set_point_in" '[Int, Vector3] (IO ()) where nodeMethod = Godot.Core.Curve3D.set_point_in {-# NOINLINE bindCurve3D_set_point_out #-} -- | Sets the position of the control point leading out of the vertex @idx@. If the index is out of bounds, the function sends an error to the console. bindCurve3D_set_point_out :: MethodBind bindCurve3D_set_point_out = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "set_point_out" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position of the control point leading out of the vertex @idx@. If the index is out of bounds, the function sends an error to the console. set_point_out :: (Curve3D :< cls, Object :< cls) => cls -> Int -> Vector3 -> IO () set_point_out cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_set_point_out (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "set_point_out" '[Int, Vector3] (IO ()) where nodeMethod = Godot.Core.Curve3D.set_point_out {-# NOINLINE bindCurve3D_set_point_position #-} -- | Sets the position for the vertex @idx@. If the index is out of bounds, the function sends an error to the console. bindCurve3D_set_point_position :: MethodBind bindCurve3D_set_point_position = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "set_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position for the vertex @idx@. If the index is out of bounds, the function sends an error to the console. set_point_position :: (Curve3D :< cls, Object :< cls) => cls -> Int -> Vector3 -> IO () set_point_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_set_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "set_point_position" '[Int, Vector3] (IO ()) where nodeMethod = Godot.Core.Curve3D.set_point_position {-# NOINLINE bindCurve3D_set_point_tilt #-} -- | Sets the tilt angle in radians for the point @idx@. If the index is out of bounds, the function sends an error to the console. -- The tilt controls the rotation along the look-at axis an object traveling the path would have. In the case of a curve controlling a @PathFollow@, this tilt is an offset over the natural tilt the @PathFollow@ calculates. bindCurve3D_set_point_tilt :: MethodBind bindCurve3D_set_point_tilt = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "set_point_tilt" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tilt angle in radians for the point @idx@. If the index is out of bounds, the function sends an error to the console. -- The tilt controls the rotation along the look-at axis an object traveling the path would have. In the case of a curve controlling a @PathFollow@, this tilt is an offset over the natural tilt the @PathFollow@ calculates. set_point_tilt :: (Curve3D :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_point_tilt cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_set_point_tilt (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "set_point_tilt" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Curve3D.set_point_tilt {-# NOINLINE bindCurve3D_set_up_vector_enabled #-} -- | If @true@, the curve will bake up vectors used for orientation. This is used when @PathFollow.rotation_mode@ is set to @PathFollow.ROTATION_ORIENTED@. Changing it forces the cache to be recomputed. bindCurve3D_set_up_vector_enabled :: MethodBind bindCurve3D_set_up_vector_enabled = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "set_up_vector_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the curve will bake up vectors used for orientation. This is used when @PathFollow.rotation_mode@ is set to @PathFollow.ROTATION_ORIENTED@. Changing it forces the cache to be recomputed. set_up_vector_enabled :: (Curve3D :< cls, Object :< cls) => cls -> Bool -> IO () set_up_vector_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_set_up_vector_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "set_up_vector_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Curve3D.set_up_vector_enabled {-# NOINLINE bindCurve3D_tessellate #-} -- | Returns a list of points along the curve, with a curvature controlled point density. That is, the curvier parts will have more points than the straighter parts. -- This approximation makes straight segments between each point, then subdivides those segments until the resulting shape is similar enough. -- @max_stages@ controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care! -- @tolerance_degrees@ controls how many degrees the midpoint of a segment may deviate from the real curve, before the segment has to be subdivided. bindCurve3D_tessellate :: MethodBind bindCurve3D_tessellate = unsafePerformIO $ withCString "Curve3D" $ \ clsNamePtr -> withCString "tessellate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of points along the curve, with a curvature controlled point density. That is, the curvier parts will have more points than the straighter parts. -- This approximation makes straight segments between each point, then subdivides those segments until the resulting shape is similar enough. -- @max_stages@ controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care! -- @tolerance_degrees@ controls how many degrees the midpoint of a segment may deviate from the real curve, before the segment has to be subdivided. tessellate :: (Curve3D :< cls, Object :< cls) => cls -> Maybe Int -> Maybe Float -> IO PoolVector3Array tessellate cls arg1 arg2 = withVariantArray [maybe (VariantInt (5)) toVariant arg1, maybe (VariantReal (4)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindCurve3D_tessellate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Curve3D "tessellate" '[Maybe Int, Maybe Float] (IO PoolVector3Array) where nodeMethod = Godot.Core.Curve3D.tessellate ================================================ FILE: src/Godot/Core/CurveTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CurveTexture (Godot.Core.CurveTexture.get_width, Godot.Core.CurveTexture._update, Godot.Core.CurveTexture.get_curve, Godot.Core.CurveTexture.set_curve, Godot.Core.CurveTexture.set_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty CurveTexture "curve" Curve 'False where nodeProperty = (get_curve, wrapDroppingSetter set_curve, Nothing) {-# NOINLINE bindCurveTexture_get_width #-} -- | The width of the texture. bindCurveTexture_get_width :: MethodBind bindCurveTexture_get_width = unsafePerformIO $ withCString "CurveTexture" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The width of the texture. get_width :: (CurveTexture :< cls, Object :< cls) => cls -> IO Int get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurveTexture_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CurveTexture "get_width" '[] (IO Int) where nodeMethod = Godot.Core.CurveTexture.get_width instance NodeProperty CurveTexture "width" Int 'False where nodeProperty = (get_width, wrapDroppingSetter set_width, Nothing) {-# NOINLINE bindCurveTexture__update #-} bindCurveTexture__update :: MethodBind bindCurveTexture__update = unsafePerformIO $ withCString "CurveTexture" $ \ clsNamePtr -> withCString "_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update :: (CurveTexture :< cls, Object :< cls) => cls -> IO () _update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurveTexture__update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CurveTexture "_update" '[] (IO ()) where nodeMethod = Godot.Core.CurveTexture._update {-# NOINLINE bindCurveTexture_get_curve #-} -- | The @curve@ rendered onto the texture. bindCurveTexture_get_curve :: MethodBind bindCurveTexture_get_curve = unsafePerformIO $ withCString "CurveTexture" $ \ clsNamePtr -> withCString "get_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @curve@ rendered onto the texture. get_curve :: (CurveTexture :< cls, Object :< cls) => cls -> IO Curve get_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCurveTexture_get_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CurveTexture "get_curve" '[] (IO Curve) where nodeMethod = Godot.Core.CurveTexture.get_curve {-# NOINLINE bindCurveTexture_set_curve #-} -- | The @curve@ rendered onto the texture. bindCurveTexture_set_curve :: MethodBind bindCurveTexture_set_curve = unsafePerformIO $ withCString "CurveTexture" $ \ clsNamePtr -> withCString "set_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @curve@ rendered onto the texture. set_curve :: (CurveTexture :< cls, Object :< cls) => cls -> Curve -> IO () set_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurveTexture_set_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CurveTexture "set_curve" '[Curve] (IO ()) where nodeMethod = Godot.Core.CurveTexture.set_curve {-# NOINLINE bindCurveTexture_set_width #-} -- | The width of the texture. bindCurveTexture_set_width :: MethodBind bindCurveTexture_set_width = unsafePerformIO $ withCString "CurveTexture" $ \ clsNamePtr -> withCString "set_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The width of the texture. set_width :: (CurveTexture :< cls, Object :< cls) => cls -> Int -> IO () set_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCurveTexture_set_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CurveTexture "set_width" '[Int] (IO ()) where nodeMethod = Godot.Core.CurveTexture.set_width ================================================ FILE: src/Godot/Core/CylinderMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CylinderMesh (Godot.Core.CylinderMesh.get_bottom_radius, Godot.Core.CylinderMesh.get_height, Godot.Core.CylinderMesh.get_radial_segments, Godot.Core.CylinderMesh.get_rings, Godot.Core.CylinderMesh.get_top_radius, Godot.Core.CylinderMesh.set_bottom_radius, Godot.Core.CylinderMesh.set_height, Godot.Core.CylinderMesh.set_radial_segments, Godot.Core.CylinderMesh.set_rings, Godot.Core.CylinderMesh.set_top_radius) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PrimitiveMesh() instance NodeProperty CylinderMesh "bottom_radius" Float 'False where nodeProperty = (get_bottom_radius, wrapDroppingSetter set_bottom_radius, Nothing) instance NodeProperty CylinderMesh "height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty CylinderMesh "radial_segments" Int 'False where nodeProperty = (get_radial_segments, wrapDroppingSetter set_radial_segments, Nothing) instance NodeProperty CylinderMesh "rings" Int 'False where nodeProperty = (get_rings, wrapDroppingSetter set_rings, Nothing) instance NodeProperty CylinderMesh "top_radius" Float 'False where nodeProperty = (get_top_radius, wrapDroppingSetter set_top_radius, Nothing) {-# NOINLINE bindCylinderMesh_get_bottom_radius #-} -- | Bottom radius of the cylinder. bindCylinderMesh_get_bottom_radius :: MethodBind bindCylinderMesh_get_bottom_radius = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "get_bottom_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bottom radius of the cylinder. get_bottom_radius :: (CylinderMesh :< cls, Object :< cls) => cls -> IO Float get_bottom_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_get_bottom_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "get_bottom_radius" '[] (IO Float) where nodeMethod = Godot.Core.CylinderMesh.get_bottom_radius {-# NOINLINE bindCylinderMesh_get_height #-} -- | Full height of the cylinder. bindCylinderMesh_get_height :: MethodBind bindCylinderMesh_get_height = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Full height of the cylinder. get_height :: (CylinderMesh :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "get_height" '[] (IO Float) where nodeMethod = Godot.Core.CylinderMesh.get_height {-# NOINLINE bindCylinderMesh_get_radial_segments #-} -- | Number of radial segments on the cylinder. bindCylinderMesh_get_radial_segments :: MethodBind bindCylinderMesh_get_radial_segments = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "get_radial_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of radial segments on the cylinder. get_radial_segments :: (CylinderMesh :< cls, Object :< cls) => cls -> IO Int get_radial_segments cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_get_radial_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "get_radial_segments" '[] (IO Int) where nodeMethod = Godot.Core.CylinderMesh.get_radial_segments {-# NOINLINE bindCylinderMesh_get_rings #-} -- | Number of edge rings along the height of the cylinder. bindCylinderMesh_get_rings :: MethodBind bindCylinderMesh_get_rings = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "get_rings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of edge rings along the height of the cylinder. get_rings :: (CylinderMesh :< cls, Object :< cls) => cls -> IO Int get_rings cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_get_rings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "get_rings" '[] (IO Int) where nodeMethod = Godot.Core.CylinderMesh.get_rings {-# NOINLINE bindCylinderMesh_get_top_radius #-} -- | Top radius of the cylinder. bindCylinderMesh_get_top_radius :: MethodBind bindCylinderMesh_get_top_radius = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "get_top_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Top radius of the cylinder. get_top_radius :: (CylinderMesh :< cls, Object :< cls) => cls -> IO Float get_top_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_get_top_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "get_top_radius" '[] (IO Float) where nodeMethod = Godot.Core.CylinderMesh.get_top_radius {-# NOINLINE bindCylinderMesh_set_bottom_radius #-} -- | Bottom radius of the cylinder. bindCylinderMesh_set_bottom_radius :: MethodBind bindCylinderMesh_set_bottom_radius = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "set_bottom_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bottom radius of the cylinder. set_bottom_radius :: (CylinderMesh :< cls, Object :< cls) => cls -> Float -> IO () set_bottom_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_set_bottom_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "set_bottom_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CylinderMesh.set_bottom_radius {-# NOINLINE bindCylinderMesh_set_height #-} -- | Full height of the cylinder. bindCylinderMesh_set_height :: MethodBind bindCylinderMesh_set_height = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Full height of the cylinder. set_height :: (CylinderMesh :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.CylinderMesh.set_height {-# NOINLINE bindCylinderMesh_set_radial_segments #-} -- | Number of radial segments on the cylinder. bindCylinderMesh_set_radial_segments :: MethodBind bindCylinderMesh_set_radial_segments = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "set_radial_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of radial segments on the cylinder. set_radial_segments :: (CylinderMesh :< cls, Object :< cls) => cls -> Int -> IO () set_radial_segments cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_set_radial_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "set_radial_segments" '[Int] (IO ()) where nodeMethod = Godot.Core.CylinderMesh.set_radial_segments {-# NOINLINE bindCylinderMesh_set_rings #-} -- | Number of edge rings along the height of the cylinder. bindCylinderMesh_set_rings :: MethodBind bindCylinderMesh_set_rings = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "set_rings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of edge rings along the height of the cylinder. set_rings :: (CylinderMesh :< cls, Object :< cls) => cls -> Int -> IO () set_rings cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_set_rings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "set_rings" '[Int] (IO ()) where nodeMethod = Godot.Core.CylinderMesh.set_rings {-# NOINLINE bindCylinderMesh_set_top_radius #-} -- | Top radius of the cylinder. bindCylinderMesh_set_top_radius :: MethodBind bindCylinderMesh_set_top_radius = unsafePerformIO $ withCString "CylinderMesh" $ \ clsNamePtr -> withCString "set_top_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Top radius of the cylinder. set_top_radius :: (CylinderMesh :< cls, Object :< cls) => cls -> Float -> IO () set_top_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderMesh_set_top_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderMesh "set_top_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CylinderMesh.set_top_radius ================================================ FILE: src/Godot/Core/CylinderShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.CylinderShape (Godot.Core.CylinderShape.get_height, Godot.Core.CylinderShape.get_radius, Godot.Core.CylinderShape.set_height, Godot.Core.CylinderShape.set_radius) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty CylinderShape "height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty CylinderShape "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) {-# NOINLINE bindCylinderShape_get_height #-} -- | The cylinder's height. bindCylinderShape_get_height :: MethodBind bindCylinderShape_get_height = unsafePerformIO $ withCString "CylinderShape" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The cylinder's height. get_height :: (CylinderShape :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderShape_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderShape "get_height" '[] (IO Float) where nodeMethod = Godot.Core.CylinderShape.get_height {-# NOINLINE bindCylinderShape_get_radius #-} -- | The cylinder's radius. bindCylinderShape_get_radius :: MethodBind bindCylinderShape_get_radius = unsafePerformIO $ withCString "CylinderShape" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The cylinder's radius. get_radius :: (CylinderShape :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderShape_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderShape "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.CylinderShape.get_radius {-# NOINLINE bindCylinderShape_set_height #-} -- | The cylinder's height. bindCylinderShape_set_height :: MethodBind bindCylinderShape_set_height = unsafePerformIO $ withCString "CylinderShape" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The cylinder's height. set_height :: (CylinderShape :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderShape_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderShape "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.CylinderShape.set_height {-# NOINLINE bindCylinderShape_set_radius #-} -- | The cylinder's radius. bindCylinderShape_set_radius :: MethodBind bindCylinderShape_set_radius = unsafePerformIO $ withCString "CylinderShape" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The cylinder's radius. set_radius :: (CylinderShape :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindCylinderShape_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod CylinderShape "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.CylinderShape.set_radius ================================================ FILE: src/Godot/Core/DampedSpringJoint2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.DampedSpringJoint2D (Godot.Core.DampedSpringJoint2D.get_damping, Godot.Core.DampedSpringJoint2D.get_length, Godot.Core.DampedSpringJoint2D.get_rest_length, Godot.Core.DampedSpringJoint2D.get_stiffness, Godot.Core.DampedSpringJoint2D.set_damping, Godot.Core.DampedSpringJoint2D.set_length, Godot.Core.DampedSpringJoint2D.set_rest_length, Godot.Core.DampedSpringJoint2D.set_stiffness) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Joint2D() instance NodeProperty DampedSpringJoint2D "damping" Float 'False where nodeProperty = (get_damping, wrapDroppingSetter set_damping, Nothing) instance NodeProperty DampedSpringJoint2D "length" Float 'False where nodeProperty = (get_length, wrapDroppingSetter set_length, Nothing) instance NodeProperty DampedSpringJoint2D "rest_length" Float 'False where nodeProperty = (get_rest_length, wrapDroppingSetter set_rest_length, Nothing) instance NodeProperty DampedSpringJoint2D "stiffness" Float 'False where nodeProperty = (get_stiffness, wrapDroppingSetter set_stiffness, Nothing) {-# NOINLINE bindDampedSpringJoint2D_get_damping #-} -- | The spring joint's damping ratio. A value between @0@ and @1@. When the two bodies move into different directions the system tries to align them to the spring axis again. A high @damping@ value forces the attached bodies to align faster. bindDampedSpringJoint2D_get_damping :: MethodBind bindDampedSpringJoint2D_get_damping = unsafePerformIO $ withCString "DampedSpringJoint2D" $ \ clsNamePtr -> withCString "get_damping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The spring joint's damping ratio. A value between @0@ and @1@. When the two bodies move into different directions the system tries to align them to the spring axis again. A high @damping@ value forces the attached bodies to align faster. get_damping :: (DampedSpringJoint2D :< cls, Object :< cls) => cls -> IO Float get_damping cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDampedSpringJoint2D_get_damping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DampedSpringJoint2D "get_damping" '[] (IO Float) where nodeMethod = Godot.Core.DampedSpringJoint2D.get_damping {-# NOINLINE bindDampedSpringJoint2D_get_length #-} -- | The spring joint's maximum length. The two attached bodies cannot stretch it past this value. bindDampedSpringJoint2D_get_length :: MethodBind bindDampedSpringJoint2D_get_length = unsafePerformIO $ withCString "DampedSpringJoint2D" $ \ clsNamePtr -> withCString "get_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The spring joint's maximum length. The two attached bodies cannot stretch it past this value. get_length :: (DampedSpringJoint2D :< cls, Object :< cls) => cls -> IO Float get_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDampedSpringJoint2D_get_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DampedSpringJoint2D "get_length" '[] (IO Float) where nodeMethod = Godot.Core.DampedSpringJoint2D.get_length {-# NOINLINE bindDampedSpringJoint2D_get_rest_length #-} -- | When the bodies attached to the spring joint move they stretch or squash it. The joint always tries to resize towards this length. bindDampedSpringJoint2D_get_rest_length :: MethodBind bindDampedSpringJoint2D_get_rest_length = unsafePerformIO $ withCString "DampedSpringJoint2D" $ \ clsNamePtr -> withCString "get_rest_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When the bodies attached to the spring joint move they stretch or squash it. The joint always tries to resize towards this length. get_rest_length :: (DampedSpringJoint2D :< cls, Object :< cls) => cls -> IO Float get_rest_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDampedSpringJoint2D_get_rest_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DampedSpringJoint2D "get_rest_length" '[] (IO Float) where nodeMethod = Godot.Core.DampedSpringJoint2D.get_rest_length {-# NOINLINE bindDampedSpringJoint2D_get_stiffness #-} -- | The higher the value, the less the bodies attached to the joint will deform it. The joint applies an opposing force to the bodies, the product of the stiffness multiplied by the size difference from its resting length. bindDampedSpringJoint2D_get_stiffness :: MethodBind bindDampedSpringJoint2D_get_stiffness = unsafePerformIO $ withCString "DampedSpringJoint2D" $ \ clsNamePtr -> withCString "get_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The higher the value, the less the bodies attached to the joint will deform it. The joint applies an opposing force to the bodies, the product of the stiffness multiplied by the size difference from its resting length. get_stiffness :: (DampedSpringJoint2D :< cls, Object :< cls) => cls -> IO Float get_stiffness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDampedSpringJoint2D_get_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DampedSpringJoint2D "get_stiffness" '[] (IO Float) where nodeMethod = Godot.Core.DampedSpringJoint2D.get_stiffness {-# NOINLINE bindDampedSpringJoint2D_set_damping #-} -- | The spring joint's damping ratio. A value between @0@ and @1@. When the two bodies move into different directions the system tries to align them to the spring axis again. A high @damping@ value forces the attached bodies to align faster. bindDampedSpringJoint2D_set_damping :: MethodBind bindDampedSpringJoint2D_set_damping = unsafePerformIO $ withCString "DampedSpringJoint2D" $ \ clsNamePtr -> withCString "set_damping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The spring joint's damping ratio. A value between @0@ and @1@. When the two bodies move into different directions the system tries to align them to the spring axis again. A high @damping@ value forces the attached bodies to align faster. set_damping :: (DampedSpringJoint2D :< cls, Object :< cls) => cls -> Float -> IO () set_damping cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDampedSpringJoint2D_set_damping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DampedSpringJoint2D "set_damping" '[Float] (IO ()) where nodeMethod = Godot.Core.DampedSpringJoint2D.set_damping {-# NOINLINE bindDampedSpringJoint2D_set_length #-} -- | The spring joint's maximum length. The two attached bodies cannot stretch it past this value. bindDampedSpringJoint2D_set_length :: MethodBind bindDampedSpringJoint2D_set_length = unsafePerformIO $ withCString "DampedSpringJoint2D" $ \ clsNamePtr -> withCString "set_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The spring joint's maximum length. The two attached bodies cannot stretch it past this value. set_length :: (DampedSpringJoint2D :< cls, Object :< cls) => cls -> Float -> IO () set_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDampedSpringJoint2D_set_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DampedSpringJoint2D "set_length" '[Float] (IO ()) where nodeMethod = Godot.Core.DampedSpringJoint2D.set_length {-# NOINLINE bindDampedSpringJoint2D_set_rest_length #-} -- | When the bodies attached to the spring joint move they stretch or squash it. The joint always tries to resize towards this length. bindDampedSpringJoint2D_set_rest_length :: MethodBind bindDampedSpringJoint2D_set_rest_length = unsafePerformIO $ withCString "DampedSpringJoint2D" $ \ clsNamePtr -> withCString "set_rest_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When the bodies attached to the spring joint move they stretch or squash it. The joint always tries to resize towards this length. set_rest_length :: (DampedSpringJoint2D :< cls, Object :< cls) => cls -> Float -> IO () set_rest_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDampedSpringJoint2D_set_rest_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DampedSpringJoint2D "set_rest_length" '[Float] (IO ()) where nodeMethod = Godot.Core.DampedSpringJoint2D.set_rest_length {-# NOINLINE bindDampedSpringJoint2D_set_stiffness #-} -- | The higher the value, the less the bodies attached to the joint will deform it. The joint applies an opposing force to the bodies, the product of the stiffness multiplied by the size difference from its resting length. bindDampedSpringJoint2D_set_stiffness :: MethodBind bindDampedSpringJoint2D_set_stiffness = unsafePerformIO $ withCString "DampedSpringJoint2D" $ \ clsNamePtr -> withCString "set_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The higher the value, the less the bodies attached to the joint will deform it. The joint applies an opposing force to the bodies, the product of the stiffness multiplied by the size difference from its resting length. set_stiffness :: (DampedSpringJoint2D :< cls, Object :< cls) => cls -> Float -> IO () set_stiffness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDampedSpringJoint2D_set_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DampedSpringJoint2D "set_stiffness" '[Float] (IO ()) where nodeMethod = Godot.Core.DampedSpringJoint2D.set_stiffness ================================================ FILE: src/Godot/Core/DirectionalLight.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.DirectionalLight (Godot.Core.DirectionalLight._SHADOW_ORTHOGONAL, Godot.Core.DirectionalLight._SHADOW_PARALLEL_4_SPLITS, Godot.Core.DirectionalLight._SHADOW_DEPTH_RANGE_STABLE, Godot.Core.DirectionalLight._SHADOW_DEPTH_RANGE_OPTIMIZED, Godot.Core.DirectionalLight._SHADOW_PARALLEL_2_SPLITS, Godot.Core.DirectionalLight.get_param, Godot.Core.DirectionalLight.set_param, Godot.Core.DirectionalLight.get_shadow_depth_range, Godot.Core.DirectionalLight.get_shadow_mode, Godot.Core.DirectionalLight.is_blend_splits_enabled, Godot.Core.DirectionalLight.set_blend_splits, Godot.Core.DirectionalLight.set_shadow_depth_range, Godot.Core.DirectionalLight.set_shadow_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Light() _SHADOW_ORTHOGONAL :: Int _SHADOW_ORTHOGONAL = 0 _SHADOW_PARALLEL_4_SPLITS :: Int _SHADOW_PARALLEL_4_SPLITS = 2 _SHADOW_DEPTH_RANGE_STABLE :: Int _SHADOW_DEPTH_RANGE_STABLE = 0 _SHADOW_DEPTH_RANGE_OPTIMIZED :: Int _SHADOW_DEPTH_RANGE_OPTIMIZED = 1 _SHADOW_PARALLEL_2_SPLITS :: Int _SHADOW_PARALLEL_2_SPLITS = 1 {-# NOINLINE bindDirectionalLight_get_param #-} -- | Amount of extra bias for shadow splits that are far away. If self-shadowing occurs only on the splits far away, increasing this value can fix them. bindDirectionalLight_get_param :: MethodBind bindDirectionalLight_get_param = unsafePerformIO $ withCString "DirectionalLight" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of extra bias for shadow splits that are far away. If self-shadowing occurs only on the splits far away, increasing this value can fix them. get_param :: (DirectionalLight :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectionalLight_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DirectionalLight "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.DirectionalLight.get_param {-# NOINLINE bindDirectionalLight_set_param #-} -- | Amount of extra bias for shadow splits that are far away. If self-shadowing occurs only on the splits far away, increasing this value can fix them. bindDirectionalLight_set_param :: MethodBind bindDirectionalLight_set_param = unsafePerformIO $ withCString "DirectionalLight" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of extra bias for shadow splits that are far away. If self-shadowing occurs only on the splits far away, increasing this value can fix them. set_param :: (DirectionalLight :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindDirectionalLight_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DirectionalLight "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.DirectionalLight.set_param instance NodeProperty DirectionalLight "directional_shadow_bias_split_scale" Float 'False where nodeProperty = (wrapIndexedGetter 14 get_param, wrapIndexedSetter 14 set_param, Nothing) instance NodeProperty DirectionalLight "directional_shadow_blend_splits" Bool 'False where nodeProperty = (is_blend_splits_enabled, wrapDroppingSetter set_blend_splits, Nothing) instance NodeProperty DirectionalLight "directional_shadow_depth_range" Int 'False where nodeProperty = (get_shadow_depth_range, wrapDroppingSetter set_shadow_depth_range, Nothing) instance NodeProperty DirectionalLight "directional_shadow_max_distance" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param, wrapIndexedSetter 8 set_param, Nothing) instance NodeProperty DirectionalLight "directional_shadow_mode" Int 'False where nodeProperty = (get_shadow_mode, wrapDroppingSetter set_shadow_mode, Nothing) instance NodeProperty DirectionalLight "directional_shadow_normal_bias" Float 'False where nodeProperty = (wrapIndexedGetter 12 get_param, wrapIndexedSetter 12 set_param, Nothing) instance NodeProperty DirectionalLight "directional_shadow_split_1" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param, wrapIndexedSetter 9 set_param, Nothing) instance NodeProperty DirectionalLight "directional_shadow_split_2" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_param, wrapIndexedSetter 10 set_param, Nothing) instance NodeProperty DirectionalLight "directional_shadow_split_3" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_param, wrapIndexedSetter 11 set_param, Nothing) {-# NOINLINE bindDirectionalLight_get_shadow_depth_range #-} -- | Optimizes shadow rendering for detail versus movement. See @enum ShadowDepthRange@. bindDirectionalLight_get_shadow_depth_range :: MethodBind bindDirectionalLight_get_shadow_depth_range = unsafePerformIO $ withCString "DirectionalLight" $ \ clsNamePtr -> withCString "get_shadow_depth_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Optimizes shadow rendering for detail versus movement. See @enum ShadowDepthRange@. get_shadow_depth_range :: (DirectionalLight :< cls, Object :< cls) => cls -> IO Int get_shadow_depth_range cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectionalLight_get_shadow_depth_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DirectionalLight "get_shadow_depth_range" '[] (IO Int) where nodeMethod = Godot.Core.DirectionalLight.get_shadow_depth_range {-# NOINLINE bindDirectionalLight_get_shadow_mode #-} -- | The light's shadow rendering algorithm. See @enum ShadowMode@. bindDirectionalLight_get_shadow_mode :: MethodBind bindDirectionalLight_get_shadow_mode = unsafePerformIO $ withCString "DirectionalLight" $ \ clsNamePtr -> withCString "get_shadow_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light's shadow rendering algorithm. See @enum ShadowMode@. get_shadow_mode :: (DirectionalLight :< cls, Object :< cls) => cls -> IO Int get_shadow_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectionalLight_get_shadow_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DirectionalLight "get_shadow_mode" '[] (IO Int) where nodeMethod = Godot.Core.DirectionalLight.get_shadow_mode {-# NOINLINE bindDirectionalLight_is_blend_splits_enabled #-} -- | If @true@, shadow detail is sacrificed in exchange for smoother transitions between splits. bindDirectionalLight_is_blend_splits_enabled :: MethodBind bindDirectionalLight_is_blend_splits_enabled = unsafePerformIO $ withCString "DirectionalLight" $ \ clsNamePtr -> withCString "is_blend_splits_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, shadow detail is sacrificed in exchange for smoother transitions between splits. is_blend_splits_enabled :: (DirectionalLight :< cls, Object :< cls) => cls -> IO Bool is_blend_splits_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectionalLight_is_blend_splits_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DirectionalLight "is_blend_splits_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.DirectionalLight.is_blend_splits_enabled {-# NOINLINE bindDirectionalLight_set_blend_splits #-} -- | If @true@, shadow detail is sacrificed in exchange for smoother transitions between splits. bindDirectionalLight_set_blend_splits :: MethodBind bindDirectionalLight_set_blend_splits = unsafePerformIO $ withCString "DirectionalLight" $ \ clsNamePtr -> withCString "set_blend_splits" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, shadow detail is sacrificed in exchange for smoother transitions between splits. set_blend_splits :: (DirectionalLight :< cls, Object :< cls) => cls -> Bool -> IO () set_blend_splits cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectionalLight_set_blend_splits (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DirectionalLight "set_blend_splits" '[Bool] (IO ()) where nodeMethod = Godot.Core.DirectionalLight.set_blend_splits {-# NOINLINE bindDirectionalLight_set_shadow_depth_range #-} -- | Optimizes shadow rendering for detail versus movement. See @enum ShadowDepthRange@. bindDirectionalLight_set_shadow_depth_range :: MethodBind bindDirectionalLight_set_shadow_depth_range = unsafePerformIO $ withCString "DirectionalLight" $ \ clsNamePtr -> withCString "set_shadow_depth_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Optimizes shadow rendering for detail versus movement. See @enum ShadowDepthRange@. set_shadow_depth_range :: (DirectionalLight :< cls, Object :< cls) => cls -> Int -> IO () set_shadow_depth_range cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectionalLight_set_shadow_depth_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DirectionalLight "set_shadow_depth_range" '[Int] (IO ()) where nodeMethod = Godot.Core.DirectionalLight.set_shadow_depth_range {-# NOINLINE bindDirectionalLight_set_shadow_mode #-} -- | The light's shadow rendering algorithm. See @enum ShadowMode@. bindDirectionalLight_set_shadow_mode :: MethodBind bindDirectionalLight_set_shadow_mode = unsafePerformIO $ withCString "DirectionalLight" $ \ clsNamePtr -> withCString "set_shadow_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light's shadow rendering algorithm. See @enum ShadowMode@. set_shadow_mode :: (DirectionalLight :< cls, Object :< cls) => cls -> Int -> IO () set_shadow_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectionalLight_set_shadow_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DirectionalLight "set_shadow_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.DirectionalLight.set_shadow_mode ================================================ FILE: src/Godot/Core/Directory.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Directory (Godot.Core.Directory.change_dir, Godot.Core.Directory.copy, Godot.Core.Directory.current_is_dir, Godot.Core.Directory.dir_exists, Godot.Core.Directory.file_exists, Godot.Core.Directory.get_current_dir, Godot.Core.Directory.get_current_drive, Godot.Core.Directory.get_drive, Godot.Core.Directory.get_drive_count, Godot.Core.Directory.get_next, Godot.Core.Directory.get_space_left, Godot.Core.Directory.list_dir_begin, Godot.Core.Directory.list_dir_end, Godot.Core.Directory.make_dir, Godot.Core.Directory.make_dir_recursive, Godot.Core.Directory.open, Godot.Core.Directory.remove, Godot.Core.Directory.rename) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindDirectory_change_dir #-} -- | Changes the currently opened directory to the one passed as an argument. The argument can be relative to the current directory (e.g. @newdir@ or @../newdir@), or an absolute path (e.g. @/tmp/newdir@ or @res://somedir/newdir@). -- Returns one of the @enum Error@ code constants (@OK@ on success). bindDirectory_change_dir :: MethodBind bindDirectory_change_dir = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "change_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the currently opened directory to the one passed as an argument. The argument can be relative to the current directory (e.g. @newdir@ or @../newdir@), or an absolute path (e.g. @/tmp/newdir@ or @res://somedir/newdir@). -- Returns one of the @enum Error@ code constants (@OK@ on success). change_dir :: (Directory :< cls, Object :< cls) => cls -> GodotString -> IO Int change_dir cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_change_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "change_dir" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Directory.change_dir {-# NOINLINE bindDirectory_copy #-} -- | Copies the @from@ file to the @to@ destination. Both arguments should be paths to files, either relative or absolute. If the destination file exists and is not access-protected, it will be overwritten. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindDirectory_copy :: MethodBind bindDirectory_copy = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "copy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Copies the @from@ file to the @to@ destination. Both arguments should be paths to files, either relative or absolute. If the destination file exists and is not access-protected, it will be overwritten. -- Returns one of the @enum Error@ code constants (@OK@ on success). copy :: (Directory :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int copy cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_copy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "copy" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.Directory.copy {-# NOINLINE bindDirectory_current_is_dir #-} -- | Returns whether the current item processed with the last @method get_next@ call is a directory (@.@ and @..@ are considered directories). bindDirectory_current_is_dir :: MethodBind bindDirectory_current_is_dir = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "current_is_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the current item processed with the last @method get_next@ call is a directory (@.@ and @..@ are considered directories). current_is_dir :: (Directory :< cls, Object :< cls) => cls -> IO Bool current_is_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_current_is_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "current_is_dir" '[] (IO Bool) where nodeMethod = Godot.Core.Directory.current_is_dir {-# NOINLINE bindDirectory_dir_exists #-} -- | Returns whether the target directory exists. The argument can be relative to the current directory, or an absolute path. bindDirectory_dir_exists :: MethodBind bindDirectory_dir_exists = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "dir_exists" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the target directory exists. The argument can be relative to the current directory, or an absolute path. dir_exists :: (Directory :< cls, Object :< cls) => cls -> GodotString -> IO Bool dir_exists cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_dir_exists (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "dir_exists" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Directory.dir_exists {-# NOINLINE bindDirectory_file_exists #-} -- | Returns whether the target file exists. The argument can be relative to the current directory, or an absolute path. bindDirectory_file_exists :: MethodBind bindDirectory_file_exists = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "file_exists" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the target file exists. The argument can be relative to the current directory, or an absolute path. file_exists :: (Directory :< cls, Object :< cls) => cls -> GodotString -> IO Bool file_exists cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_file_exists (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "file_exists" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Directory.file_exists {-# NOINLINE bindDirectory_get_current_dir #-} -- | Returns the absolute path to the currently opened directory (e.g. @res://folder@ or @C:\tmp\folder@). bindDirectory_get_current_dir :: MethodBind bindDirectory_get_current_dir = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "get_current_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the absolute path to the currently opened directory (e.g. @res://folder@ or @C:\tmp\folder@). get_current_dir :: (Directory :< cls, Object :< cls) => cls -> IO GodotString get_current_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_get_current_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "get_current_dir" '[] (IO GodotString) where nodeMethod = Godot.Core.Directory.get_current_dir {-# NOINLINE bindDirectory_get_current_drive #-} -- | Returns the currently opened directory's drive index. See @method get_drive@ to convert returned index to the name of the drive. bindDirectory_get_current_drive :: MethodBind bindDirectory_get_current_drive = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "get_current_drive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the currently opened directory's drive index. See @method get_drive@ to convert returned index to the name of the drive. get_current_drive :: (Directory :< cls, Object :< cls) => cls -> IO Int get_current_drive cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_get_current_drive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "get_current_drive" '[] (IO Int) where nodeMethod = Godot.Core.Directory.get_current_drive {-# NOINLINE bindDirectory_get_drive #-} -- | On Windows, returns the name of the drive (partition) passed as an argument (e.g. @C:@). On other platforms, or if the requested drive does not existed, the method returns an empty String. bindDirectory_get_drive :: MethodBind bindDirectory_get_drive = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "get_drive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | On Windows, returns the name of the drive (partition) passed as an argument (e.g. @C:@). On other platforms, or if the requested drive does not existed, the method returns an empty String. get_drive :: (Directory :< cls, Object :< cls) => cls -> Int -> IO GodotString get_drive cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_get_drive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "get_drive" '[Int] (IO GodotString) where nodeMethod = Godot.Core.Directory.get_drive {-# NOINLINE bindDirectory_get_drive_count #-} -- | On Windows, returns the number of drives (partitions) mounted on the current filesystem. On other platforms, the method returns 0. bindDirectory_get_drive_count :: MethodBind bindDirectory_get_drive_count = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "get_drive_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | On Windows, returns the number of drives (partitions) mounted on the current filesystem. On other platforms, the method returns 0. get_drive_count :: (Directory :< cls, Object :< cls) => cls -> IO Int get_drive_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_get_drive_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "get_drive_count" '[] (IO Int) where nodeMethod = Godot.Core.Directory.get_drive_count {-# NOINLINE bindDirectory_get_next #-} -- | Returns the next element (file or directory) in the current directory (including @.@ and @..@, unless @skip_navigational@ was given to @method list_dir_begin@). -- The name of the file or directory is returned (and not its full path). Once the stream has been fully processed, the method returns an empty String and closes the stream automatically (i.e. @method list_dir_end@ would not be mandatory in such a case). bindDirectory_get_next :: MethodBind bindDirectory_get_next = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "get_next" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next element (file or directory) in the current directory (including @.@ and @..@, unless @skip_navigational@ was given to @method list_dir_begin@). -- The name of the file or directory is returned (and not its full path). Once the stream has been fully processed, the method returns an empty String and closes the stream automatically (i.e. @method list_dir_end@ would not be mandatory in such a case). get_next :: (Directory :< cls, Object :< cls) => cls -> IO GodotString get_next cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_get_next (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "get_next" '[] (IO GodotString) where nodeMethod = Godot.Core.Directory.get_next {-# NOINLINE bindDirectory_get_space_left #-} -- | On UNIX desktop systems, returns the available space on the current directory's disk. On other platforms, this information is not available and the method returns 0 or -1. bindDirectory_get_space_left :: MethodBind bindDirectory_get_space_left = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "get_space_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | On UNIX desktop systems, returns the available space on the current directory's disk. On other platforms, this information is not available and the method returns 0 or -1. get_space_left :: (Directory :< cls, Object :< cls) => cls -> IO Int get_space_left cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_get_space_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "get_space_left" '[] (IO Int) where nodeMethod = Godot.Core.Directory.get_space_left {-# NOINLINE bindDirectory_list_dir_begin #-} -- | Initializes the stream used to list all files and directories using the @method get_next@ function, closing the current opened stream if needed. Once the stream has been processed, it should typically be closed with @method list_dir_end@. -- If @skip_navigational@ is @true@, @.@ and @..@ are filtered out. -- If @skip_hidden@ is @true@, hidden files are filtered out. bindDirectory_list_dir_begin :: MethodBind bindDirectory_list_dir_begin = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "list_dir_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Initializes the stream used to list all files and directories using the @method get_next@ function, closing the current opened stream if needed. Once the stream has been processed, it should typically be closed with @method list_dir_end@. -- If @skip_navigational@ is @true@, @.@ and @..@ are filtered out. -- If @skip_hidden@ is @true@, hidden files are filtered out. list_dir_begin :: (Directory :< cls, Object :< cls) => cls -> Maybe Bool -> Maybe Bool -> IO Int list_dir_begin cls arg1 arg2 = withVariantArray [maybe (VariantBool False) toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_list_dir_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "list_dir_begin" '[Maybe Bool, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.Directory.list_dir_begin {-# NOINLINE bindDirectory_list_dir_end #-} -- | Closes the current stream opened with @method list_dir_begin@ (whether it has been fully processed with @method get_next@ or not does not matter). bindDirectory_list_dir_end :: MethodBind bindDirectory_list_dir_end = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "list_dir_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Closes the current stream opened with @method list_dir_begin@ (whether it has been fully processed with @method get_next@ or not does not matter). list_dir_end :: (Directory :< cls, Object :< cls) => cls -> IO () list_dir_end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_list_dir_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "list_dir_end" '[] (IO ()) where nodeMethod = Godot.Core.Directory.list_dir_end {-# NOINLINE bindDirectory_make_dir #-} -- | Creates a directory. The argument can be relative to the current directory, or an absolute path. The target directory should be placed in an already existing directory (to create the full path recursively, see @method make_dir_recursive@). -- Returns one of the @enum Error@ code constants (@OK@ on success). bindDirectory_make_dir :: MethodBind bindDirectory_make_dir = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "make_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a directory. The argument can be relative to the current directory, or an absolute path. The target directory should be placed in an already existing directory (to create the full path recursively, see @method make_dir_recursive@). -- Returns one of the @enum Error@ code constants (@OK@ on success). make_dir :: (Directory :< cls, Object :< cls) => cls -> GodotString -> IO Int make_dir cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_make_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "make_dir" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Directory.make_dir {-# NOINLINE bindDirectory_make_dir_recursive #-} -- | Creates a target directory and all necessary intermediate directories in its path, by calling @method make_dir@ recursively. The argument can be relative to the current directory, or an absolute path. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindDirectory_make_dir_recursive :: MethodBind bindDirectory_make_dir_recursive = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "make_dir_recursive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a target directory and all necessary intermediate directories in its path, by calling @method make_dir@ recursively. The argument can be relative to the current directory, or an absolute path. -- Returns one of the @enum Error@ code constants (@OK@ on success). make_dir_recursive :: (Directory :< cls, Object :< cls) => cls -> GodotString -> IO Int make_dir_recursive cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_make_dir_recursive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "make_dir_recursive" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Directory.make_dir_recursive {-# NOINLINE bindDirectory_open #-} -- | Opens an existing directory of the filesystem. The @path@ argument can be within the project tree (@res://folder@), the user directory (@user://folder@) or an absolute path of the user filesystem (e.g. @/tmp/folder@ or @C:\tmp\folder@). -- Returns one of the @enum Error@ code constants (@OK@ on success). bindDirectory_open :: MethodBind bindDirectory_open = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "open" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opens an existing directory of the filesystem. The @path@ argument can be within the project tree (@res://folder@), the user directory (@user://folder@) or an absolute path of the user filesystem (e.g. @/tmp/folder@ or @C:\tmp\folder@). -- Returns one of the @enum Error@ code constants (@OK@ on success). open :: (Directory :< cls, Object :< cls) => cls -> GodotString -> IO Int open cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_open (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "open" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Directory.open {-# NOINLINE bindDirectory_remove #-} -- | Deletes the target file or an empty directory. The argument can be relative to the current directory, or an absolute path. If the target directory is not empty, the operation will fail. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindDirectory_remove :: MethodBind bindDirectory_remove = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "remove" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the target file or an empty directory. The argument can be relative to the current directory, or an absolute path. If the target directory is not empty, the operation will fail. -- Returns one of the @enum Error@ code constants (@OK@ on success). remove :: (Directory :< cls, Object :< cls) => cls -> GodotString -> IO Int remove cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_remove (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "remove" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Directory.remove {-# NOINLINE bindDirectory_rename #-} -- | Renames (move) the @from@ file to the @to@ destination. Both arguments should be paths to files, either relative or absolute. If the destination file exists and is not access-protected, it will be overwritten. -- Returns one of the @enum Error@ code constants (@OK@ on success). bindDirectory_rename :: MethodBind bindDirectory_rename = unsafePerformIO $ withCString "_Directory" $ \ clsNamePtr -> withCString "rename" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Renames (move) the @from@ file to the @to@ destination. Both arguments should be paths to files, either relative or absolute. If the destination file exists and is not access-protected, it will be overwritten. -- Returns one of the @enum Error@ code constants (@OK@ on success). rename :: (Directory :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int rename cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindDirectory_rename (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Directory "rename" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.Directory.rename ================================================ FILE: src/Godot/Core/DynamicFont.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.DynamicFont (Godot.Core.DynamicFont._SPACING_TOP, Godot.Core.DynamicFont._SPACING_SPACE, Godot.Core.DynamicFont._SPACING_CHAR, Godot.Core.DynamicFont._SPACING_BOTTOM, Godot.Core.DynamicFont.add_fallback, Godot.Core.DynamicFont.get_fallback, Godot.Core.DynamicFont.get_fallback_count, Godot.Core.DynamicFont.get_font_data, Godot.Core.DynamicFont.get_outline_color, Godot.Core.DynamicFont.get_outline_size, Godot.Core.DynamicFont.get_size, Godot.Core.DynamicFont.get_spacing, Godot.Core.DynamicFont.get_use_filter, Godot.Core.DynamicFont.get_use_mipmaps, Godot.Core.DynamicFont.remove_fallback, Godot.Core.DynamicFont.set_fallback, Godot.Core.DynamicFont.set_font_data, Godot.Core.DynamicFont.set_outline_color, Godot.Core.DynamicFont.set_outline_size, Godot.Core.DynamicFont.set_size, Godot.Core.DynamicFont.set_spacing, Godot.Core.DynamicFont.set_use_filter, Godot.Core.DynamicFont.set_use_mipmaps) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Font() _SPACING_TOP :: Int _SPACING_TOP = 0 _SPACING_SPACE :: Int _SPACING_SPACE = 3 _SPACING_CHAR :: Int _SPACING_CHAR = 2 _SPACING_BOTTOM :: Int _SPACING_BOTTOM = 1 instance NodeProperty DynamicFont "extra_spacing_bottom" Int 'False where nodeProperty = (wrapIndexedGetter 1 get_spacing, wrapIndexedSetter 1 set_spacing, Nothing) instance NodeProperty DynamicFont "extra_spacing_char" Int 'False where nodeProperty = (wrapIndexedGetter 2 get_spacing, wrapIndexedSetter 2 set_spacing, Nothing) instance NodeProperty DynamicFont "extra_spacing_space" Int 'False where nodeProperty = (wrapIndexedGetter 3 get_spacing, wrapIndexedSetter 3 set_spacing, Nothing) instance NodeProperty DynamicFont "extra_spacing_top" Int 'False where nodeProperty = (wrapIndexedGetter 0 get_spacing, wrapIndexedSetter 0 set_spacing, Nothing) instance NodeProperty DynamicFont "font_data" DynamicFontData 'False where nodeProperty = (get_font_data, wrapDroppingSetter set_font_data, Nothing) instance NodeProperty DynamicFont "outline_color" Color 'False where nodeProperty = (get_outline_color, wrapDroppingSetter set_outline_color, Nothing) instance NodeProperty DynamicFont "outline_size" Int 'False where nodeProperty = (get_outline_size, wrapDroppingSetter set_outline_size, Nothing) instance NodeProperty DynamicFont "size" Int 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) instance NodeProperty DynamicFont "use_filter" Bool 'False where nodeProperty = (get_use_filter, wrapDroppingSetter set_use_filter, Nothing) instance NodeProperty DynamicFont "use_mipmaps" Bool 'False where nodeProperty = (get_use_mipmaps, wrapDroppingSetter set_use_mipmaps, Nothing) {-# NOINLINE bindDynamicFont_add_fallback #-} -- | Adds a fallback font. bindDynamicFont_add_fallback :: MethodBind bindDynamicFont_add_fallback = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "add_fallback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a fallback font. add_fallback :: (DynamicFont :< cls, Object :< cls) => cls -> DynamicFontData -> IO () add_fallback cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_add_fallback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "add_fallback" '[DynamicFontData] (IO ()) where nodeMethod = Godot.Core.DynamicFont.add_fallback {-# NOINLINE bindDynamicFont_get_fallback #-} -- | Returns the fallback font at index @idx@. bindDynamicFont_get_fallback :: MethodBind bindDynamicFont_get_fallback = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_fallback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the fallback font at index @idx@. get_fallback :: (DynamicFont :< cls, Object :< cls) => cls -> Int -> IO DynamicFontData get_fallback cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_fallback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_fallback" '[Int] (IO DynamicFontData) where nodeMethod = Godot.Core.DynamicFont.get_fallback {-# NOINLINE bindDynamicFont_get_fallback_count #-} -- | Returns the number of fallback fonts. bindDynamicFont_get_fallback_count :: MethodBind bindDynamicFont_get_fallback_count = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_fallback_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of fallback fonts. get_fallback_count :: (DynamicFont :< cls, Object :< cls) => cls -> IO Int get_fallback_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_fallback_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_fallback_count" '[] (IO Int) where nodeMethod = Godot.Core.DynamicFont.get_fallback_count {-# NOINLINE bindDynamicFont_get_font_data #-} -- | The font data. bindDynamicFont_get_font_data :: MethodBind bindDynamicFont_get_font_data = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_font_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font data. get_font_data :: (DynamicFont :< cls, Object :< cls) => cls -> IO DynamicFontData get_font_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_font_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_font_data" '[] (IO DynamicFontData) where nodeMethod = Godot.Core.DynamicFont.get_font_data {-# NOINLINE bindDynamicFont_get_outline_color #-} -- | The font outline's color. -- __Note:__ It's recommended to leave this at the default value so that you can adjust it in individual controls. For example, if the outline is made black here, it won't be possible to change its color using a Label's font outline modulate theme item. bindDynamicFont_get_outline_color :: MethodBind bindDynamicFont_get_outline_color = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_outline_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font outline's color. -- __Note:__ It's recommended to leave this at the default value so that you can adjust it in individual controls. For example, if the outline is made black here, it won't be possible to change its color using a Label's font outline modulate theme item. get_outline_color :: (DynamicFont :< cls, Object :< cls) => cls -> IO Color get_outline_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_outline_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_outline_color" '[] (IO Color) where nodeMethod = Godot.Core.DynamicFont.get_outline_color {-# NOINLINE bindDynamicFont_get_outline_size #-} -- | The font outline's thickness in pixels (not relative to the font size). bindDynamicFont_get_outline_size :: MethodBind bindDynamicFont_get_outline_size = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_outline_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font outline's thickness in pixels (not relative to the font size). get_outline_size :: (DynamicFont :< cls, Object :< cls) => cls -> IO Int get_outline_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_outline_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_outline_size" '[] (IO Int) where nodeMethod = Godot.Core.DynamicFont.get_outline_size {-# NOINLINE bindDynamicFont_get_size #-} -- | The font size in pixels. bindDynamicFont_get_size :: MethodBind bindDynamicFont_get_size = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font size in pixels. get_size :: (DynamicFont :< cls, Object :< cls) => cls -> IO Int get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_size" '[] (IO Int) where nodeMethod = Godot.Core.DynamicFont.get_size {-# NOINLINE bindDynamicFont_get_spacing #-} -- | Returns the spacing for the given @type@ (see @enum SpacingType@). bindDynamicFont_get_spacing :: MethodBind bindDynamicFont_get_spacing = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_spacing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the spacing for the given @type@ (see @enum SpacingType@). get_spacing :: (DynamicFont :< cls, Object :< cls) => cls -> Int -> IO Int get_spacing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_spacing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_spacing" '[Int] (IO Int) where nodeMethod = Godot.Core.DynamicFont.get_spacing {-# NOINLINE bindDynamicFont_get_use_filter #-} -- | If @true@, filtering is used. This makes the font blurry instead of pixelated when scaling it if font oversampling is disabled or ineffective. It's recommended to enable this when using the font in a control whose size changes over time, unless a pixel art aesthetic is desired. bindDynamicFont_get_use_filter :: MethodBind bindDynamicFont_get_use_filter = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_use_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, filtering is used. This makes the font blurry instead of pixelated when scaling it if font oversampling is disabled or ineffective. It's recommended to enable this when using the font in a control whose size changes over time, unless a pixel art aesthetic is desired. get_use_filter :: (DynamicFont :< cls, Object :< cls) => cls -> IO Bool get_use_filter cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_use_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_use_filter" '[] (IO Bool) where nodeMethod = Godot.Core.DynamicFont.get_use_filter {-# NOINLINE bindDynamicFont_get_use_mipmaps #-} -- | If @true@, mipmapping is used. This improves the font's appearance when downscaling it if font oversampling is disabled or ineffective. bindDynamicFont_get_use_mipmaps :: MethodBind bindDynamicFont_get_use_mipmaps = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "get_use_mipmaps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, mipmapping is used. This improves the font's appearance when downscaling it if font oversampling is disabled or ineffective. get_use_mipmaps :: (DynamicFont :< cls, Object :< cls) => cls -> IO Bool get_use_mipmaps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_get_use_mipmaps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "get_use_mipmaps" '[] (IO Bool) where nodeMethod = Godot.Core.DynamicFont.get_use_mipmaps {-# NOINLINE bindDynamicFont_remove_fallback #-} -- | Removes the fallback font at index @idx@. bindDynamicFont_remove_fallback :: MethodBind bindDynamicFont_remove_fallback = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "remove_fallback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the fallback font at index @idx@. remove_fallback :: (DynamicFont :< cls, Object :< cls) => cls -> Int -> IO () remove_fallback cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_remove_fallback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "remove_fallback" '[Int] (IO ()) where nodeMethod = Godot.Core.DynamicFont.remove_fallback {-# NOINLINE bindDynamicFont_set_fallback #-} -- | Sets the fallback font at index @idx@. bindDynamicFont_set_fallback :: MethodBind bindDynamicFont_set_fallback = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "set_fallback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the fallback font at index @idx@. set_fallback :: (DynamicFont :< cls, Object :< cls) => cls -> Int -> DynamicFontData -> IO () set_fallback cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_set_fallback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "set_fallback" '[Int, DynamicFontData] (IO ()) where nodeMethod = Godot.Core.DynamicFont.set_fallback {-# NOINLINE bindDynamicFont_set_font_data #-} -- | The font data. bindDynamicFont_set_font_data :: MethodBind bindDynamicFont_set_font_data = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "set_font_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font data. set_font_data :: (DynamicFont :< cls, Object :< cls) => cls -> DynamicFontData -> IO () set_font_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_set_font_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "set_font_data" '[DynamicFontData] (IO ()) where nodeMethod = Godot.Core.DynamicFont.set_font_data {-# NOINLINE bindDynamicFont_set_outline_color #-} -- | The font outline's color. -- __Note:__ It's recommended to leave this at the default value so that you can adjust it in individual controls. For example, if the outline is made black here, it won't be possible to change its color using a Label's font outline modulate theme item. bindDynamicFont_set_outline_color :: MethodBind bindDynamicFont_set_outline_color = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "set_outline_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font outline's color. -- __Note:__ It's recommended to leave this at the default value so that you can adjust it in individual controls. For example, if the outline is made black here, it won't be possible to change its color using a Label's font outline modulate theme item. set_outline_color :: (DynamicFont :< cls, Object :< cls) => cls -> Color -> IO () set_outline_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_set_outline_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "set_outline_color" '[Color] (IO ()) where nodeMethod = Godot.Core.DynamicFont.set_outline_color {-# NOINLINE bindDynamicFont_set_outline_size #-} -- | The font outline's thickness in pixels (not relative to the font size). bindDynamicFont_set_outline_size :: MethodBind bindDynamicFont_set_outline_size = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "set_outline_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font outline's thickness in pixels (not relative to the font size). set_outline_size :: (DynamicFont :< cls, Object :< cls) => cls -> Int -> IO () set_outline_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_set_outline_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "set_outline_size" '[Int] (IO ()) where nodeMethod = Godot.Core.DynamicFont.set_outline_size {-# NOINLINE bindDynamicFont_set_size #-} -- | The font size in pixels. bindDynamicFont_set_size :: MethodBind bindDynamicFont_set_size = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font size in pixels. set_size :: (DynamicFont :< cls, Object :< cls) => cls -> Int -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "set_size" '[Int] (IO ()) where nodeMethod = Godot.Core.DynamicFont.set_size {-# NOINLINE bindDynamicFont_set_spacing #-} -- | Sets the spacing for @type@ (see @enum SpacingType@) to @value@ in pixels (not relative to the font size). bindDynamicFont_set_spacing :: MethodBind bindDynamicFont_set_spacing = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "set_spacing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the spacing for @type@ (see @enum SpacingType@) to @value@ in pixels (not relative to the font size). set_spacing :: (DynamicFont :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_spacing cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_set_spacing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "set_spacing" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.DynamicFont.set_spacing {-# NOINLINE bindDynamicFont_set_use_filter #-} -- | If @true@, filtering is used. This makes the font blurry instead of pixelated when scaling it if font oversampling is disabled or ineffective. It's recommended to enable this when using the font in a control whose size changes over time, unless a pixel art aesthetic is desired. bindDynamicFont_set_use_filter :: MethodBind bindDynamicFont_set_use_filter = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "set_use_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, filtering is used. This makes the font blurry instead of pixelated when scaling it if font oversampling is disabled or ineffective. It's recommended to enable this when using the font in a control whose size changes over time, unless a pixel art aesthetic is desired. set_use_filter :: (DynamicFont :< cls, Object :< cls) => cls -> Bool -> IO () set_use_filter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_set_use_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "set_use_filter" '[Bool] (IO ()) where nodeMethod = Godot.Core.DynamicFont.set_use_filter {-# NOINLINE bindDynamicFont_set_use_mipmaps #-} -- | If @true@, mipmapping is used. This improves the font's appearance when downscaling it if font oversampling is disabled or ineffective. bindDynamicFont_set_use_mipmaps :: MethodBind bindDynamicFont_set_use_mipmaps = unsafePerformIO $ withCString "DynamicFont" $ \ clsNamePtr -> withCString "set_use_mipmaps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, mipmapping is used. This improves the font's appearance when downscaling it if font oversampling is disabled or ineffective. set_use_mipmaps :: (DynamicFont :< cls, Object :< cls) => cls -> Bool -> IO () set_use_mipmaps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFont_set_use_mipmaps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFont "set_use_mipmaps" '[Bool] (IO ()) where nodeMethod = Godot.Core.DynamicFont.set_use_mipmaps ================================================ FILE: src/Godot/Core/DynamicFontData.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.DynamicFontData (Godot.Core.DynamicFontData._HINTING_NONE, Godot.Core.DynamicFontData._HINTING_NORMAL, Godot.Core.DynamicFontData._HINTING_LIGHT, Godot.Core.DynamicFontData.get_font_path, Godot.Core.DynamicFontData.get_hinting, Godot.Core.DynamicFontData.is_antialiased, Godot.Core.DynamicFontData.set_antialiased, Godot.Core.DynamicFontData.set_font_path, Godot.Core.DynamicFontData.set_hinting) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _HINTING_NONE :: Int _HINTING_NONE = 0 _HINTING_NORMAL :: Int _HINTING_NORMAL = 2 _HINTING_LIGHT :: Int _HINTING_LIGHT = 1 instance NodeProperty DynamicFontData "antialiased" Bool 'False where nodeProperty = (is_antialiased, wrapDroppingSetter set_antialiased, Nothing) instance NodeProperty DynamicFontData "font_path" GodotString 'False where nodeProperty = (get_font_path, wrapDroppingSetter set_font_path, Nothing) instance NodeProperty DynamicFontData "hinting" Int 'False where nodeProperty = (get_hinting, wrapDroppingSetter set_hinting, Nothing) {-# NOINLINE bindDynamicFontData_get_font_path #-} -- | The path to the vector font file. bindDynamicFontData_get_font_path :: MethodBind bindDynamicFontData_get_font_path = unsafePerformIO $ withCString "DynamicFontData" $ \ clsNamePtr -> withCString "get_font_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the vector font file. get_font_path :: (DynamicFontData :< cls, Object :< cls) => cls -> IO GodotString get_font_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFontData_get_font_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFontData "get_font_path" '[] (IO GodotString) where nodeMethod = Godot.Core.DynamicFontData.get_font_path {-# NOINLINE bindDynamicFontData_get_hinting #-} -- | The font hinting mode used by FreeType. See @enum Hinting@ for options. bindDynamicFontData_get_hinting :: MethodBind bindDynamicFontData_get_hinting = unsafePerformIO $ withCString "DynamicFontData" $ \ clsNamePtr -> withCString "get_hinting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font hinting mode used by FreeType. See @enum Hinting@ for options. get_hinting :: (DynamicFontData :< cls, Object :< cls) => cls -> IO Int get_hinting cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFontData_get_hinting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFontData "get_hinting" '[] (IO Int) where nodeMethod = Godot.Core.DynamicFontData.get_hinting {-# NOINLINE bindDynamicFontData_is_antialiased #-} -- | If @true@, the font is rendered with anti-aliasing. This property applies both to the main font and its outline (if it has one). bindDynamicFontData_is_antialiased :: MethodBind bindDynamicFontData_is_antialiased = unsafePerformIO $ withCString "DynamicFontData" $ \ clsNamePtr -> withCString "is_antialiased" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the font is rendered with anti-aliasing. This property applies both to the main font and its outline (if it has one). is_antialiased :: (DynamicFontData :< cls, Object :< cls) => cls -> IO Bool is_antialiased cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFontData_is_antialiased (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFontData "is_antialiased" '[] (IO Bool) where nodeMethod = Godot.Core.DynamicFontData.is_antialiased {-# NOINLINE bindDynamicFontData_set_antialiased #-} -- | If @true@, the font is rendered with anti-aliasing. This property applies both to the main font and its outline (if it has one). bindDynamicFontData_set_antialiased :: MethodBind bindDynamicFontData_set_antialiased = unsafePerformIO $ withCString "DynamicFontData" $ \ clsNamePtr -> withCString "set_antialiased" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the font is rendered with anti-aliasing. This property applies both to the main font and its outline (if it has one). set_antialiased :: (DynamicFontData :< cls, Object :< cls) => cls -> Bool -> IO () set_antialiased cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFontData_set_antialiased (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFontData "set_antialiased" '[Bool] (IO ()) where nodeMethod = Godot.Core.DynamicFontData.set_antialiased {-# NOINLINE bindDynamicFontData_set_font_path #-} -- | The path to the vector font file. bindDynamicFontData_set_font_path :: MethodBind bindDynamicFontData_set_font_path = unsafePerformIO $ withCString "DynamicFontData" $ \ clsNamePtr -> withCString "set_font_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the vector font file. set_font_path :: (DynamicFontData :< cls, Object :< cls) => cls -> GodotString -> IO () set_font_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFontData_set_font_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFontData "set_font_path" '[GodotString] (IO ()) where nodeMethod = Godot.Core.DynamicFontData.set_font_path {-# NOINLINE bindDynamicFontData_set_hinting #-} -- | The font hinting mode used by FreeType. See @enum Hinting@ for options. bindDynamicFontData_set_hinting :: MethodBind bindDynamicFontData_set_hinting = unsafePerformIO $ withCString "DynamicFontData" $ \ clsNamePtr -> withCString "set_hinting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The font hinting mode used by FreeType. See @enum Hinting@ for options. set_hinting :: (DynamicFontData :< cls, Object :< cls) => cls -> Int -> IO () set_hinting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindDynamicFontData_set_hinting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod DynamicFontData "set_hinting" '[Int] (IO ()) where nodeMethod = Godot.Core.DynamicFontData.set_hinting ================================================ FILE: src/Godot/Core/EncodedObjectAsID.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.EncodedObjectAsID (Godot.Core.EncodedObjectAsID.get_object_id, Godot.Core.EncodedObjectAsID.set_object_id) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty EncodedObjectAsID "object_id" Int 'False where nodeProperty = (get_object_id, wrapDroppingSetter set_object_id, Nothing) {-# NOINLINE bindEncodedObjectAsID_get_object_id #-} -- | The @Object@ identifier stored in this @EncodedObjectAsID@ instance. The object instance can be retrieved with @method @GDScript.instance_from_id@. bindEncodedObjectAsID_get_object_id :: MethodBind bindEncodedObjectAsID_get_object_id = unsafePerformIO $ withCString "EncodedObjectAsID" $ \ clsNamePtr -> withCString "get_object_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Object@ identifier stored in this @EncodedObjectAsID@ instance. The object instance can be retrieved with @method @GDScript.instance_from_id@. get_object_id :: (EncodedObjectAsID :< cls, Object :< cls) => cls -> IO Int get_object_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEncodedObjectAsID_get_object_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EncodedObjectAsID "get_object_id" '[] (IO Int) where nodeMethod = Godot.Core.EncodedObjectAsID.get_object_id {-# NOINLINE bindEncodedObjectAsID_set_object_id #-} -- | The @Object@ identifier stored in this @EncodedObjectAsID@ instance. The object instance can be retrieved with @method @GDScript.instance_from_id@. bindEncodedObjectAsID_set_object_id :: MethodBind bindEncodedObjectAsID_set_object_id = unsafePerformIO $ withCString "EncodedObjectAsID" $ \ clsNamePtr -> withCString "set_object_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Object@ identifier stored in this @EncodedObjectAsID@ instance. The object instance can be retrieved with @method @GDScript.instance_from_id@. set_object_id :: (EncodedObjectAsID :< cls, Object :< cls) => cls -> Int -> IO () set_object_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEncodedObjectAsID_set_object_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EncodedObjectAsID "set_object_id" '[Int] (IO ()) where nodeMethod = Godot.Core.EncodedObjectAsID.set_object_id ================================================ FILE: src/Godot/Core/Engine.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Engine (Godot.Core.Engine.is_editor_hint, Godot.Core.Engine.set_editor_hint, Godot.Core.Engine.get_iterations_per_second, Godot.Core.Engine.set_iterations_per_second, Godot.Core.Engine.get_physics_jitter_fix, Godot.Core.Engine.set_physics_jitter_fix, Godot.Core.Engine.get_target_fps, Godot.Core.Engine.set_target_fps, Godot.Core.Engine.get_time_scale, Godot.Core.Engine.set_time_scale, Godot.Core.Engine.get_author_info, Godot.Core.Engine.get_copyright_info, Godot.Core.Engine.get_donor_info, Godot.Core.Engine.get_frames_drawn, Godot.Core.Engine.get_frames_per_second, Godot.Core.Engine.get_idle_frames, Godot.Core.Engine.get_license_info, Godot.Core.Engine.get_license_text, Godot.Core.Engine.get_main_loop, Godot.Core.Engine.get_physics_frames, Godot.Core.Engine.get_physics_interpolation_fraction, Godot.Core.Engine.get_singleton, Godot.Core.Engine.get_version_info, Godot.Core.Engine.has_singleton, Godot.Core.Engine.is_in_physics_frame) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindEngine_is_editor_hint #-} -- | If @true@, it is running inside the editor. Useful for tool scripts. bindEngine_is_editor_hint :: MethodBind bindEngine_is_editor_hint = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "is_editor_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, it is running inside the editor. Useful for tool scripts. is_editor_hint :: (Engine :< cls, Object :< cls) => cls -> IO Bool is_editor_hint cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_is_editor_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "is_editor_hint" '[] (IO Bool) where nodeMethod = Godot.Core.Engine.is_editor_hint {-# NOINLINE bindEngine_set_editor_hint #-} -- | If @true@, it is running inside the editor. Useful for tool scripts. bindEngine_set_editor_hint :: MethodBind bindEngine_set_editor_hint = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "set_editor_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, it is running inside the editor. Useful for tool scripts. set_editor_hint :: (Engine :< cls, Object :< cls) => cls -> Bool -> IO () set_editor_hint cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_set_editor_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "set_editor_hint" '[Bool] (IO ()) where nodeMethod = Godot.Core.Engine.set_editor_hint instance NodeProperty Engine "editor_hint" Bool 'False where nodeProperty = (is_editor_hint, wrapDroppingSetter set_editor_hint, Nothing) {-# NOINLINE bindEngine_get_iterations_per_second #-} -- | The number of fixed iterations per second. This controls how often physics simulation and @method Node._physics_process@ methods are run. This value should generally always be set to @60@ or above, as Godot doesn't interpolate the physics step. As a result, values lower than @60@ will look stuttery. This value can be increased to make input more reactive or work around tunneling issues, but keep in mind doing so will increase CPU usage. bindEngine_get_iterations_per_second :: MethodBind bindEngine_get_iterations_per_second = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_iterations_per_second" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of fixed iterations per second. This controls how often physics simulation and @method Node._physics_process@ methods are run. This value should generally always be set to @60@ or above, as Godot doesn't interpolate the physics step. As a result, values lower than @60@ will look stuttery. This value can be increased to make input more reactive or work around tunneling issues, but keep in mind doing so will increase CPU usage. get_iterations_per_second :: (Engine :< cls, Object :< cls) => cls -> IO Int get_iterations_per_second cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_iterations_per_second (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_iterations_per_second" '[] (IO Int) where nodeMethod = Godot.Core.Engine.get_iterations_per_second {-# NOINLINE bindEngine_set_iterations_per_second #-} -- | The number of fixed iterations per second. This controls how often physics simulation and @method Node._physics_process@ methods are run. This value should generally always be set to @60@ or above, as Godot doesn't interpolate the physics step. As a result, values lower than @60@ will look stuttery. This value can be increased to make input more reactive or work around tunneling issues, but keep in mind doing so will increase CPU usage. bindEngine_set_iterations_per_second :: MethodBind bindEngine_set_iterations_per_second = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "set_iterations_per_second" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of fixed iterations per second. This controls how often physics simulation and @method Node._physics_process@ methods are run. This value should generally always be set to @60@ or above, as Godot doesn't interpolate the physics step. As a result, values lower than @60@ will look stuttery. This value can be increased to make input more reactive or work around tunneling issues, but keep in mind doing so will increase CPU usage. set_iterations_per_second :: (Engine :< cls, Object :< cls) => cls -> Int -> IO () set_iterations_per_second cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_set_iterations_per_second (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "set_iterations_per_second" '[Int] (IO ()) where nodeMethod = Godot.Core.Engine.set_iterations_per_second instance NodeProperty Engine "iterations_per_second" Int 'False where nodeProperty = (get_iterations_per_second, wrapDroppingSetter set_iterations_per_second, Nothing) {-# NOINLINE bindEngine_get_physics_jitter_fix #-} -- | Controls how much physics ticks are synchronized with real time. For 0 or less, the ticks are synchronized. Such values are recommended for network games, where clock synchronization matters. Higher values cause higher deviation of in-game clock and real clock, but allows to smooth out framerate jitters. The default value of 0.5 should be fine for most; values above 2 could cause the game to react to dropped frames with a noticeable delay and are not recommended. bindEngine_get_physics_jitter_fix :: MethodBind bindEngine_get_physics_jitter_fix = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_physics_jitter_fix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how much physics ticks are synchronized with real time. For 0 or less, the ticks are synchronized. Such values are recommended for network games, where clock synchronization matters. Higher values cause higher deviation of in-game clock and real clock, but allows to smooth out framerate jitters. The default value of 0.5 should be fine for most; values above 2 could cause the game to react to dropped frames with a noticeable delay and are not recommended. get_physics_jitter_fix :: (Engine :< cls, Object :< cls) => cls -> IO Float get_physics_jitter_fix cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_physics_jitter_fix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_physics_jitter_fix" '[] (IO Float) where nodeMethod = Godot.Core.Engine.get_physics_jitter_fix {-# NOINLINE bindEngine_set_physics_jitter_fix #-} -- | Controls how much physics ticks are synchronized with real time. For 0 or less, the ticks are synchronized. Such values are recommended for network games, where clock synchronization matters. Higher values cause higher deviation of in-game clock and real clock, but allows to smooth out framerate jitters. The default value of 0.5 should be fine for most; values above 2 could cause the game to react to dropped frames with a noticeable delay and are not recommended. bindEngine_set_physics_jitter_fix :: MethodBind bindEngine_set_physics_jitter_fix = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "set_physics_jitter_fix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how much physics ticks are synchronized with real time. For 0 or less, the ticks are synchronized. Such values are recommended for network games, where clock synchronization matters. Higher values cause higher deviation of in-game clock and real clock, but allows to smooth out framerate jitters. The default value of 0.5 should be fine for most; values above 2 could cause the game to react to dropped frames with a noticeable delay and are not recommended. set_physics_jitter_fix :: (Engine :< cls, Object :< cls) => cls -> Float -> IO () set_physics_jitter_fix cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_set_physics_jitter_fix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "set_physics_jitter_fix" '[Float] (IO ()) where nodeMethod = Godot.Core.Engine.set_physics_jitter_fix instance NodeProperty Engine "physics_jitter_fix" Float 'False where nodeProperty = (get_physics_jitter_fix, wrapDroppingSetter set_physics_jitter_fix, Nothing) {-# NOINLINE bindEngine_get_target_fps #-} -- | The desired frames per second. If the hardware cannot keep up, this setting may not be respected. A value of 0 means no limit. bindEngine_get_target_fps :: MethodBind bindEngine_get_target_fps = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_target_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The desired frames per second. If the hardware cannot keep up, this setting may not be respected. A value of 0 means no limit. get_target_fps :: (Engine :< cls, Object :< cls) => cls -> IO Int get_target_fps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_target_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_target_fps" '[] (IO Int) where nodeMethod = Godot.Core.Engine.get_target_fps {-# NOINLINE bindEngine_set_target_fps #-} -- | The desired frames per second. If the hardware cannot keep up, this setting may not be respected. A value of 0 means no limit. bindEngine_set_target_fps :: MethodBind bindEngine_set_target_fps = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "set_target_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The desired frames per second. If the hardware cannot keep up, this setting may not be respected. A value of 0 means no limit. set_target_fps :: (Engine :< cls, Object :< cls) => cls -> Int -> IO () set_target_fps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_set_target_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "set_target_fps" '[Int] (IO ()) where nodeMethod = Godot.Core.Engine.set_target_fps instance NodeProperty Engine "target_fps" Int 'False where nodeProperty = (get_target_fps, wrapDroppingSetter set_target_fps, Nothing) {-# NOINLINE bindEngine_get_time_scale #-} -- | Controls how fast or slow the in-game clock ticks versus the real life one. It defaults to 1.0. A value of 2.0 means the game moves twice as fast as real life, whilst a value of 0.5 means the game moves at half the regular speed. bindEngine_get_time_scale :: MethodBind bindEngine_get_time_scale = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_time_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how fast or slow the in-game clock ticks versus the real life one. It defaults to 1.0. A value of 2.0 means the game moves twice as fast as real life, whilst a value of 0.5 means the game moves at half the regular speed. get_time_scale :: (Engine :< cls, Object :< cls) => cls -> IO Float get_time_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_time_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_time_scale" '[] (IO Float) where nodeMethod = Godot.Core.Engine.get_time_scale {-# NOINLINE bindEngine_set_time_scale #-} -- | Controls how fast or slow the in-game clock ticks versus the real life one. It defaults to 1.0. A value of 2.0 means the game moves twice as fast as real life, whilst a value of 0.5 means the game moves at half the regular speed. bindEngine_set_time_scale :: MethodBind bindEngine_set_time_scale = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "set_time_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how fast or slow the in-game clock ticks versus the real life one. It defaults to 1.0. A value of 2.0 means the game moves twice as fast as real life, whilst a value of 0.5 means the game moves at half the regular speed. set_time_scale :: (Engine :< cls, Object :< cls) => cls -> Float -> IO () set_time_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_set_time_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "set_time_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.Engine.set_time_scale instance NodeProperty Engine "time_scale" Float 'False where nodeProperty = (get_time_scale, wrapDroppingSetter set_time_scale, Nothing) {-# NOINLINE bindEngine_get_author_info #-} -- | Returns engine author information in a Dictionary. -- @lead_developers@ - Array of Strings, lead developer names -- @founders@ - Array of Strings, founder names -- @project_managers@ - Array of Strings, project manager names -- @developers@ - Array of Strings, developer names bindEngine_get_author_info :: MethodBind bindEngine_get_author_info = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_author_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns engine author information in a Dictionary. -- @lead_developers@ - Array of Strings, lead developer names -- @founders@ - Array of Strings, founder names -- @project_managers@ - Array of Strings, project manager names -- @developers@ - Array of Strings, developer names get_author_info :: (Engine :< cls, Object :< cls) => cls -> IO Dictionary get_author_info cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_author_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_author_info" '[] (IO Dictionary) where nodeMethod = Godot.Core.Engine.get_author_info {-# NOINLINE bindEngine_get_copyright_info #-} -- | Returns an Array of copyright information Dictionaries. -- @name@ - String, component name -- @parts@ - Array of Dictionaries {@files@, @copyright@, @license@} describing subsections of the component bindEngine_get_copyright_info :: MethodBind bindEngine_get_copyright_info = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_copyright_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an Array of copyright information Dictionaries. -- @name@ - String, component name -- @parts@ - Array of Dictionaries {@files@, @copyright@, @license@} describing subsections of the component get_copyright_info :: (Engine :< cls, Object :< cls) => cls -> IO Array get_copyright_info cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_copyright_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_copyright_info" '[] (IO Array) where nodeMethod = Godot.Core.Engine.get_copyright_info {-# NOINLINE bindEngine_get_donor_info #-} -- | Returns a Dictionary of Arrays of donor names. -- {@platinum_sponsors@, @gold_sponsors@, @silver_sponsors@, @bronze_sponsors@, @mini_sponsors@, @gold_donors@, @silver_donors@, @bronze_donors@} bindEngine_get_donor_info :: MethodBind bindEngine_get_donor_info = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_donor_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a Dictionary of Arrays of donor names. -- {@platinum_sponsors@, @gold_sponsors@, @silver_sponsors@, @bronze_sponsors@, @mini_sponsors@, @gold_donors@, @silver_donors@, @bronze_donors@} get_donor_info :: (Engine :< cls, Object :< cls) => cls -> IO Dictionary get_donor_info cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_donor_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_donor_info" '[] (IO Dictionary) where nodeMethod = Godot.Core.Engine.get_donor_info {-# NOINLINE bindEngine_get_frames_drawn #-} -- | Returns the total number of frames drawn. If the render loop is disabled with @--disable-render-loop@ via command line, this returns @0@. See also @method get_idle_frames@. bindEngine_get_frames_drawn :: MethodBind bindEngine_get_frames_drawn = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_frames_drawn" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total number of frames drawn. If the render loop is disabled with @--disable-render-loop@ via command line, this returns @0@. See also @method get_idle_frames@. get_frames_drawn :: (Engine :< cls, Object :< cls) => cls -> IO Int get_frames_drawn cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_frames_drawn (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_frames_drawn" '[] (IO Int) where nodeMethod = Godot.Core.Engine.get_frames_drawn {-# NOINLINE bindEngine_get_frames_per_second #-} -- | Returns the frames per second of the running game. bindEngine_get_frames_per_second :: MethodBind bindEngine_get_frames_per_second = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_frames_per_second" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the frames per second of the running game. get_frames_per_second :: (Engine :< cls, Object :< cls) => cls -> IO Float get_frames_per_second cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_frames_per_second (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_frames_per_second" '[] (IO Float) where nodeMethod = Godot.Core.Engine.get_frames_per_second {-# NOINLINE bindEngine_get_idle_frames #-} -- | Returns the total number of frames passed since engine initialization which is advanced on each __idle frame__, regardless of whether the render loop is enabled. See also @method get_frames_drawn@. bindEngine_get_idle_frames :: MethodBind bindEngine_get_idle_frames = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_idle_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total number of frames passed since engine initialization which is advanced on each __idle frame__, regardless of whether the render loop is enabled. See also @method get_frames_drawn@. get_idle_frames :: (Engine :< cls, Object :< cls) => cls -> IO Int get_idle_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_idle_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_idle_frames" '[] (IO Int) where nodeMethod = Godot.Core.Engine.get_idle_frames {-# NOINLINE bindEngine_get_license_info #-} -- | Returns Dictionary of licenses used by Godot and included third party components. bindEngine_get_license_info :: MethodBind bindEngine_get_license_info = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_license_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns Dictionary of licenses used by Godot and included third party components. get_license_info :: (Engine :< cls, Object :< cls) => cls -> IO Dictionary get_license_info cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_license_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_license_info" '[] (IO Dictionary) where nodeMethod = Godot.Core.Engine.get_license_info {-# NOINLINE bindEngine_get_license_text #-} -- | Returns Godot license text. bindEngine_get_license_text :: MethodBind bindEngine_get_license_text = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_license_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns Godot license text. get_license_text :: (Engine :< cls, Object :< cls) => cls -> IO GodotString get_license_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_license_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_license_text" '[] (IO GodotString) where nodeMethod = Godot.Core.Engine.get_license_text {-# NOINLINE bindEngine_get_main_loop #-} -- | Returns the main loop object (see @MainLoop@ and @SceneTree@). bindEngine_get_main_loop :: MethodBind bindEngine_get_main_loop = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_main_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the main loop object (see @MainLoop@ and @SceneTree@). get_main_loop :: (Engine :< cls, Object :< cls) => cls -> IO MainLoop get_main_loop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_main_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_main_loop" '[] (IO MainLoop) where nodeMethod = Godot.Core.Engine.get_main_loop {-# NOINLINE bindEngine_get_physics_frames #-} -- | Returns the total number of frames passed since engine initialization which is advanced on each __physics frame__. bindEngine_get_physics_frames :: MethodBind bindEngine_get_physics_frames = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_physics_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total number of frames passed since engine initialization which is advanced on each __physics frame__. get_physics_frames :: (Engine :< cls, Object :< cls) => cls -> IO Int get_physics_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_physics_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_physics_frames" '[] (IO Int) where nodeMethod = Godot.Core.Engine.get_physics_frames {-# NOINLINE bindEngine_get_physics_interpolation_fraction #-} -- | Returns the fraction through the current physics tick we are at the time of rendering the frame. This can be used to implement fixed timestep interpolation. bindEngine_get_physics_interpolation_fraction :: MethodBind bindEngine_get_physics_interpolation_fraction = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_physics_interpolation_fraction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the fraction through the current physics tick we are at the time of rendering the frame. This can be used to implement fixed timestep interpolation. get_physics_interpolation_fraction :: (Engine :< cls, Object :< cls) => cls -> IO Float get_physics_interpolation_fraction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_physics_interpolation_fraction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_physics_interpolation_fraction" '[] (IO Float) where nodeMethod = Godot.Core.Engine.get_physics_interpolation_fraction {-# NOINLINE bindEngine_get_singleton #-} -- | Returns a global singleton with given @name@. Often used for plugins, e.g. @GodotPayment@ on Android. bindEngine_get_singleton :: MethodBind bindEngine_get_singleton = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a global singleton with given @name@. Often used for plugins, e.g. @GodotPayment@ on Android. get_singleton :: (Engine :< cls, Object :< cls) => cls -> GodotString -> IO Object get_singleton cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_singleton" '[GodotString] (IO Object) where nodeMethod = Godot.Core.Engine.get_singleton {-# NOINLINE bindEngine_get_version_info #-} -- | Returns the current engine version information in a Dictionary. -- @major@ - Holds the major version number as an int -- @minor@ - Holds the minor version number as an int -- @patch@ - Holds the patch version number as an int -- @hex@ - Holds the full version number encoded as a hexadecimal int with one byte (2 places) per number (see example below) -- @status@ - Holds the status (e.g. "beta", "rc1", "rc2", ... "stable") as a String -- @build@ - Holds the build name (e.g. "custom_build") as a String -- @hash@ - Holds the full Git commit hash as a String -- @year@ - Holds the year the version was released in as an int -- @string@ - @major@ + @minor@ + @patch@ + @status@ + @build@ in a single String -- The @hex@ value is encoded as follows, from left to right: one byte for the major, one byte for the minor, one byte for the patch version. For example, "3.1.12" would be @0x03010C@. __Note:__ It's still an int internally, and printing it will give you its decimal representation, which is not particularly meaningful. Use hexadecimal literals for easy version comparisons from code: -- -- @ -- -- if Engine.get_version_info().hex >= 0x030200: -- # Do things specific to version 3.2 or later -- else: -- # Do things specific to versions before 3.2 -- -- @ bindEngine_get_version_info :: MethodBind bindEngine_get_version_info = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "get_version_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current engine version information in a Dictionary. -- @major@ - Holds the major version number as an int -- @minor@ - Holds the minor version number as an int -- @patch@ - Holds the patch version number as an int -- @hex@ - Holds the full version number encoded as a hexadecimal int with one byte (2 places) per number (see example below) -- @status@ - Holds the status (e.g. "beta", "rc1", "rc2", ... "stable") as a String -- @build@ - Holds the build name (e.g. "custom_build") as a String -- @hash@ - Holds the full Git commit hash as a String -- @year@ - Holds the year the version was released in as an int -- @string@ - @major@ + @minor@ + @patch@ + @status@ + @build@ in a single String -- The @hex@ value is encoded as follows, from left to right: one byte for the major, one byte for the minor, one byte for the patch version. For example, "3.1.12" would be @0x03010C@. __Note:__ It's still an int internally, and printing it will give you its decimal representation, which is not particularly meaningful. Use hexadecimal literals for easy version comparisons from code: -- -- @ -- -- if Engine.get_version_info().hex >= 0x030200: -- # Do things specific to version 3.2 or later -- else: -- # Do things specific to versions before 3.2 -- -- @ get_version_info :: (Engine :< cls, Object :< cls) => cls -> IO Dictionary get_version_info cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_get_version_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "get_version_info" '[] (IO Dictionary) where nodeMethod = Godot.Core.Engine.get_version_info {-# NOINLINE bindEngine_has_singleton #-} -- | Returns @true@ if a singleton with given @name@ exists in global scope. bindEngine_has_singleton :: MethodBind bindEngine_has_singleton = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "has_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a singleton with given @name@ exists in global scope. has_singleton :: (Engine :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_singleton cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_has_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "has_singleton" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Engine.has_singleton {-# NOINLINE bindEngine_is_in_physics_frame #-} -- | Returns @true@ if the game is inside the fixed process and physics phase of the game loop. bindEngine_is_in_physics_frame :: MethodBind bindEngine_is_in_physics_frame = unsafePerformIO $ withCString "_Engine" $ \ clsNamePtr -> withCString "is_in_physics_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the game is inside the fixed process and physics phase of the game loop. is_in_physics_frame :: (Engine :< cls, Object :< cls) => cls -> IO Bool is_in_physics_frame cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEngine_is_in_physics_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Engine "is_in_physics_frame" '[] (IO Bool) where nodeMethod = Godot.Core.Engine.is_in_physics_frame ================================================ FILE: src/Godot/Core/Environment.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Environment (Godot.Core.Environment._TONE_MAPPER_FILMIC, Godot.Core.Environment._SSAO_QUALITY_LOW, Godot.Core.Environment._BG_CANVAS, Godot.Core.Environment._DOF_BLUR_QUALITY_LOW, Godot.Core.Environment._GLOW_BLEND_MODE_ADDITIVE, Godot.Core.Environment._DOF_BLUR_QUALITY_HIGH, Godot.Core.Environment._DOF_BLUR_QUALITY_MEDIUM, Godot.Core.Environment._BG_SKY, Godot.Core.Environment._SSAO_QUALITY_MEDIUM, Godot.Core.Environment._GLOW_BLEND_MODE_SOFTLIGHT, Godot.Core.Environment._TONE_MAPPER_LINEAR, Godot.Core.Environment._BG_MAX, Godot.Core.Environment._BG_COLOR_SKY, Godot.Core.Environment._SSAO_BLUR_DISABLED, Godot.Core.Environment._SSAO_BLUR_2x2, Godot.Core.Environment._TONE_MAPPER_ACES, Godot.Core.Environment._SSAO_BLUR_1x1, Godot.Core.Environment._BG_COLOR, Godot.Core.Environment._SSAO_BLUR_3x3, Godot.Core.Environment._GLOW_BLEND_MODE_REPLACE, Godot.Core.Environment._GLOW_BLEND_MODE_SCREEN, Godot.Core.Environment._SSAO_QUALITY_HIGH, Godot.Core.Environment._TONE_MAPPER_REINHARDT, Godot.Core.Environment._BG_CAMERA_FEED, Godot.Core.Environment._BG_CLEAR_COLOR, Godot.Core.Environment._BG_KEEP, Godot.Core.Environment.get_adjustment_brightness, Godot.Core.Environment.get_adjustment_color_correction, Godot.Core.Environment.get_adjustment_contrast, Godot.Core.Environment.get_adjustment_saturation, Godot.Core.Environment.get_ambient_light_color, Godot.Core.Environment.get_ambient_light_energy, Godot.Core.Environment.get_ambient_light_sky_contribution, Godot.Core.Environment.get_background, Godot.Core.Environment.get_bg_color, Godot.Core.Environment.get_bg_energy, Godot.Core.Environment.get_camera_feed_id, Godot.Core.Environment.get_canvas_max_layer, Godot.Core.Environment.get_dof_blur_far_amount, Godot.Core.Environment.get_dof_blur_far_distance, Godot.Core.Environment.get_dof_blur_far_quality, Godot.Core.Environment.get_dof_blur_far_transition, Godot.Core.Environment.get_dof_blur_near_amount, Godot.Core.Environment.get_dof_blur_near_distance, Godot.Core.Environment.get_dof_blur_near_quality, Godot.Core.Environment.get_dof_blur_near_transition, Godot.Core.Environment.get_fog_color, Godot.Core.Environment.get_fog_depth_begin, Godot.Core.Environment.get_fog_depth_curve, Godot.Core.Environment.get_fog_depth_end, Godot.Core.Environment.get_fog_height_curve, Godot.Core.Environment.get_fog_height_max, Godot.Core.Environment.get_fog_height_min, Godot.Core.Environment.get_fog_sun_amount, Godot.Core.Environment.get_fog_sun_color, Godot.Core.Environment.get_fog_transmit_curve, Godot.Core.Environment.get_glow_blend_mode, Godot.Core.Environment.get_glow_bloom, Godot.Core.Environment.get_glow_hdr_bleed_scale, Godot.Core.Environment.get_glow_hdr_bleed_threshold, Godot.Core.Environment.get_glow_hdr_luminance_cap, Godot.Core.Environment.get_glow_intensity, Godot.Core.Environment.get_glow_strength, Godot.Core.Environment.get_sky, Godot.Core.Environment.get_sky_custom_fov, Godot.Core.Environment.get_sky_orientation, Godot.Core.Environment.get_sky_rotation, Godot.Core.Environment.get_sky_rotation_degrees, Godot.Core.Environment.get_ssao_ao_channel_affect, Godot.Core.Environment.get_ssao_bias, Godot.Core.Environment.get_ssao_blur, Godot.Core.Environment.get_ssao_color, Godot.Core.Environment.get_ssao_direct_light_affect, Godot.Core.Environment.get_ssao_edge_sharpness, Godot.Core.Environment.get_ssao_intensity, Godot.Core.Environment.get_ssao_intensity2, Godot.Core.Environment.get_ssao_quality, Godot.Core.Environment.get_ssao_radius, Godot.Core.Environment.get_ssao_radius2, Godot.Core.Environment.get_ssr_depth_tolerance, Godot.Core.Environment.get_ssr_fade_in, Godot.Core.Environment.get_ssr_fade_out, Godot.Core.Environment.get_ssr_max_steps, Godot.Core.Environment.get_tonemap_auto_exposure, Godot.Core.Environment.get_tonemap_auto_exposure_grey, Godot.Core.Environment.get_tonemap_auto_exposure_max, Godot.Core.Environment.get_tonemap_auto_exposure_min, Godot.Core.Environment.get_tonemap_auto_exposure_speed, Godot.Core.Environment.get_tonemap_exposure, Godot.Core.Environment.get_tonemap_white, Godot.Core.Environment.get_tonemapper, Godot.Core.Environment.is_adjustment_enabled, Godot.Core.Environment.is_dof_blur_far_enabled, Godot.Core.Environment.is_dof_blur_near_enabled, Godot.Core.Environment.is_fog_depth_enabled, Godot.Core.Environment.is_fog_enabled, Godot.Core.Environment.is_fog_height_enabled, Godot.Core.Environment.is_fog_transmit_enabled, Godot.Core.Environment.is_glow_bicubic_upscale_enabled, Godot.Core.Environment.is_glow_enabled, Godot.Core.Environment.is_glow_level_enabled, Godot.Core.Environment.is_ssao_enabled, Godot.Core.Environment.is_ssr_enabled, Godot.Core.Environment.is_ssr_rough, Godot.Core.Environment.set_adjustment_brightness, Godot.Core.Environment.set_adjustment_color_correction, Godot.Core.Environment.set_adjustment_contrast, Godot.Core.Environment.set_adjustment_enable, Godot.Core.Environment.set_adjustment_saturation, Godot.Core.Environment.set_ambient_light_color, Godot.Core.Environment.set_ambient_light_energy, Godot.Core.Environment.set_ambient_light_sky_contribution, Godot.Core.Environment.set_background, Godot.Core.Environment.set_bg_color, Godot.Core.Environment.set_bg_energy, Godot.Core.Environment.set_camera_feed_id, Godot.Core.Environment.set_canvas_max_layer, Godot.Core.Environment.set_dof_blur_far_amount, Godot.Core.Environment.set_dof_blur_far_distance, Godot.Core.Environment.set_dof_blur_far_enabled, Godot.Core.Environment.set_dof_blur_far_quality, Godot.Core.Environment.set_dof_blur_far_transition, Godot.Core.Environment.set_dof_blur_near_amount, Godot.Core.Environment.set_dof_blur_near_distance, Godot.Core.Environment.set_dof_blur_near_enabled, Godot.Core.Environment.set_dof_blur_near_quality, Godot.Core.Environment.set_dof_blur_near_transition, Godot.Core.Environment.set_fog_color, Godot.Core.Environment.set_fog_depth_begin, Godot.Core.Environment.set_fog_depth_curve, Godot.Core.Environment.set_fog_depth_enabled, Godot.Core.Environment.set_fog_depth_end, Godot.Core.Environment.set_fog_enabled, Godot.Core.Environment.set_fog_height_curve, Godot.Core.Environment.set_fog_height_enabled, Godot.Core.Environment.set_fog_height_max, Godot.Core.Environment.set_fog_height_min, Godot.Core.Environment.set_fog_sun_amount, Godot.Core.Environment.set_fog_sun_color, Godot.Core.Environment.set_fog_transmit_curve, Godot.Core.Environment.set_fog_transmit_enabled, Godot.Core.Environment.set_glow_bicubic_upscale, Godot.Core.Environment.set_glow_blend_mode, Godot.Core.Environment.set_glow_bloom, Godot.Core.Environment.set_glow_enabled, Godot.Core.Environment.set_glow_hdr_bleed_scale, Godot.Core.Environment.set_glow_hdr_bleed_threshold, Godot.Core.Environment.set_glow_hdr_luminance_cap, Godot.Core.Environment.set_glow_intensity, Godot.Core.Environment.set_glow_level, Godot.Core.Environment.set_glow_strength, Godot.Core.Environment.set_sky, Godot.Core.Environment.set_sky_custom_fov, Godot.Core.Environment.set_sky_orientation, Godot.Core.Environment.set_sky_rotation, Godot.Core.Environment.set_sky_rotation_degrees, Godot.Core.Environment.set_ssao_ao_channel_affect, Godot.Core.Environment.set_ssao_bias, Godot.Core.Environment.set_ssao_blur, Godot.Core.Environment.set_ssao_color, Godot.Core.Environment.set_ssao_direct_light_affect, Godot.Core.Environment.set_ssao_edge_sharpness, Godot.Core.Environment.set_ssao_enabled, Godot.Core.Environment.set_ssao_intensity, Godot.Core.Environment.set_ssao_intensity2, Godot.Core.Environment.set_ssao_quality, Godot.Core.Environment.set_ssao_radius, Godot.Core.Environment.set_ssao_radius2, Godot.Core.Environment.set_ssr_depth_tolerance, Godot.Core.Environment.set_ssr_enabled, Godot.Core.Environment.set_ssr_fade_in, Godot.Core.Environment.set_ssr_fade_out, Godot.Core.Environment.set_ssr_max_steps, Godot.Core.Environment.set_ssr_rough, Godot.Core.Environment.set_tonemap_auto_exposure, Godot.Core.Environment.set_tonemap_auto_exposure_grey, Godot.Core.Environment.set_tonemap_auto_exposure_max, Godot.Core.Environment.set_tonemap_auto_exposure_min, Godot.Core.Environment.set_tonemap_auto_exposure_speed, Godot.Core.Environment.set_tonemap_exposure, Godot.Core.Environment.set_tonemap_white, Godot.Core.Environment.set_tonemapper) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _TONE_MAPPER_FILMIC :: Int _TONE_MAPPER_FILMIC = 2 _SSAO_QUALITY_LOW :: Int _SSAO_QUALITY_LOW = 0 _BG_CANVAS :: Int _BG_CANVAS = 4 _DOF_BLUR_QUALITY_LOW :: Int _DOF_BLUR_QUALITY_LOW = 0 _GLOW_BLEND_MODE_ADDITIVE :: Int _GLOW_BLEND_MODE_ADDITIVE = 0 _DOF_BLUR_QUALITY_HIGH :: Int _DOF_BLUR_QUALITY_HIGH = 2 _DOF_BLUR_QUALITY_MEDIUM :: Int _DOF_BLUR_QUALITY_MEDIUM = 1 _BG_SKY :: Int _BG_SKY = 2 _SSAO_QUALITY_MEDIUM :: Int _SSAO_QUALITY_MEDIUM = 1 _GLOW_BLEND_MODE_SOFTLIGHT :: Int _GLOW_BLEND_MODE_SOFTLIGHT = 2 _TONE_MAPPER_LINEAR :: Int _TONE_MAPPER_LINEAR = 0 _BG_MAX :: Int _BG_MAX = 7 _BG_COLOR_SKY :: Int _BG_COLOR_SKY = 3 _SSAO_BLUR_DISABLED :: Int _SSAO_BLUR_DISABLED = 0 _SSAO_BLUR_2x2 :: Int _SSAO_BLUR_2x2 = 2 _TONE_MAPPER_ACES :: Int _TONE_MAPPER_ACES = 3 _SSAO_BLUR_1x1 :: Int _SSAO_BLUR_1x1 = 1 _BG_COLOR :: Int _BG_COLOR = 1 _SSAO_BLUR_3x3 :: Int _SSAO_BLUR_3x3 = 3 _GLOW_BLEND_MODE_REPLACE :: Int _GLOW_BLEND_MODE_REPLACE = 3 _GLOW_BLEND_MODE_SCREEN :: Int _GLOW_BLEND_MODE_SCREEN = 1 _SSAO_QUALITY_HIGH :: Int _SSAO_QUALITY_HIGH = 2 _TONE_MAPPER_REINHARDT :: Int _TONE_MAPPER_REINHARDT = 1 _BG_CAMERA_FEED :: Int _BG_CAMERA_FEED = 6 _BG_CLEAR_COLOR :: Int _BG_CLEAR_COLOR = 0 _BG_KEEP :: Int _BG_KEEP = 5 instance NodeProperty Environment "adjustment_brightness" Float 'False where nodeProperty = (get_adjustment_brightness, wrapDroppingSetter set_adjustment_brightness, Nothing) instance NodeProperty Environment "adjustment_color_correction" Texture 'False where nodeProperty = (get_adjustment_color_correction, wrapDroppingSetter set_adjustment_color_correction, Nothing) instance NodeProperty Environment "adjustment_contrast" Float 'False where nodeProperty = (get_adjustment_contrast, wrapDroppingSetter set_adjustment_contrast, Nothing) instance NodeProperty Environment "adjustment_enabled" Bool 'False where nodeProperty = (is_adjustment_enabled, wrapDroppingSetter set_adjustment_enable, Nothing) instance NodeProperty Environment "adjustment_saturation" Float 'False where nodeProperty = (get_adjustment_saturation, wrapDroppingSetter set_adjustment_saturation, Nothing) instance NodeProperty Environment "ambient_light_color" Color 'False where nodeProperty = (get_ambient_light_color, wrapDroppingSetter set_ambient_light_color, Nothing) instance NodeProperty Environment "ambient_light_energy" Float 'False where nodeProperty = (get_ambient_light_energy, wrapDroppingSetter set_ambient_light_energy, Nothing) instance NodeProperty Environment "ambient_light_sky_contribution" Float 'False where nodeProperty = (get_ambient_light_sky_contribution, wrapDroppingSetter set_ambient_light_sky_contribution, Nothing) instance NodeProperty Environment "auto_exposure_enabled" Bool 'False where nodeProperty = (get_tonemap_auto_exposure, wrapDroppingSetter set_tonemap_auto_exposure, Nothing) instance NodeProperty Environment "auto_exposure_max_luma" Float 'False where nodeProperty = (get_tonemap_auto_exposure_max, wrapDroppingSetter set_tonemap_auto_exposure_max, Nothing) instance NodeProperty Environment "auto_exposure_min_luma" Float 'False where nodeProperty = (get_tonemap_auto_exposure_min, wrapDroppingSetter set_tonemap_auto_exposure_min, Nothing) instance NodeProperty Environment "auto_exposure_scale" Float 'False where nodeProperty = (get_tonemap_auto_exposure_grey, wrapDroppingSetter set_tonemap_auto_exposure_grey, Nothing) instance NodeProperty Environment "auto_exposure_speed" Float 'False where nodeProperty = (get_tonemap_auto_exposure_speed, wrapDroppingSetter set_tonemap_auto_exposure_speed, Nothing) instance NodeProperty Environment "background_camera_feed_id" Int 'False where nodeProperty = (get_camera_feed_id, wrapDroppingSetter set_camera_feed_id, Nothing) instance NodeProperty Environment "background_canvas_max_layer" Int 'False where nodeProperty = (get_canvas_max_layer, wrapDroppingSetter set_canvas_max_layer, Nothing) instance NodeProperty Environment "background_color" Color 'False where nodeProperty = (get_bg_color, wrapDroppingSetter set_bg_color, Nothing) instance NodeProperty Environment "background_energy" Float 'False where nodeProperty = (get_bg_energy, wrapDroppingSetter set_bg_energy, Nothing) instance NodeProperty Environment "background_mode" Int 'False where nodeProperty = (get_background, wrapDroppingSetter set_background, Nothing) instance NodeProperty Environment "background_sky" Sky 'False where nodeProperty = (get_sky, wrapDroppingSetter set_sky, Nothing) instance NodeProperty Environment "background_sky_custom_fov" Float 'False where nodeProperty = (get_sky_custom_fov, wrapDroppingSetter set_sky_custom_fov, Nothing) instance NodeProperty Environment "background_sky_orientation" Basis 'False where nodeProperty = (get_sky_orientation, wrapDroppingSetter set_sky_orientation, Nothing) instance NodeProperty Environment "background_sky_rotation" Vector3 'False where nodeProperty = (get_sky_rotation, wrapDroppingSetter set_sky_rotation, Nothing) instance NodeProperty Environment "background_sky_rotation_degrees" Vector3 'False where nodeProperty = (get_sky_rotation_degrees, wrapDroppingSetter set_sky_rotation_degrees, Nothing) instance NodeProperty Environment "dof_blur_far_amount" Float 'False where nodeProperty = (get_dof_blur_far_amount, wrapDroppingSetter set_dof_blur_far_amount, Nothing) instance NodeProperty Environment "dof_blur_far_distance" Float 'False where nodeProperty = (get_dof_blur_far_distance, wrapDroppingSetter set_dof_blur_far_distance, Nothing) instance NodeProperty Environment "dof_blur_far_enabled" Bool 'False where nodeProperty = (is_dof_blur_far_enabled, wrapDroppingSetter set_dof_blur_far_enabled, Nothing) instance NodeProperty Environment "dof_blur_far_quality" Int 'False where nodeProperty = (get_dof_blur_far_quality, wrapDroppingSetter set_dof_blur_far_quality, Nothing) instance NodeProperty Environment "dof_blur_far_transition" Float 'False where nodeProperty = (get_dof_blur_far_transition, wrapDroppingSetter set_dof_blur_far_transition, Nothing) instance NodeProperty Environment "dof_blur_near_amount" Float 'False where nodeProperty = (get_dof_blur_near_amount, wrapDroppingSetter set_dof_blur_near_amount, Nothing) instance NodeProperty Environment "dof_blur_near_distance" Float 'False where nodeProperty = (get_dof_blur_near_distance, wrapDroppingSetter set_dof_blur_near_distance, Nothing) instance NodeProperty Environment "dof_blur_near_enabled" Bool 'False where nodeProperty = (is_dof_blur_near_enabled, wrapDroppingSetter set_dof_blur_near_enabled, Nothing) instance NodeProperty Environment "dof_blur_near_quality" Int 'False where nodeProperty = (get_dof_blur_near_quality, wrapDroppingSetter set_dof_blur_near_quality, Nothing) instance NodeProperty Environment "dof_blur_near_transition" Float 'False where nodeProperty = (get_dof_blur_near_transition, wrapDroppingSetter set_dof_blur_near_transition, Nothing) instance NodeProperty Environment "fog_color" Color 'False where nodeProperty = (get_fog_color, wrapDroppingSetter set_fog_color, Nothing) instance NodeProperty Environment "fog_depth_begin" Float 'False where nodeProperty = (get_fog_depth_begin, wrapDroppingSetter set_fog_depth_begin, Nothing) instance NodeProperty Environment "fog_depth_curve" Float 'False where nodeProperty = (get_fog_depth_curve, wrapDroppingSetter set_fog_depth_curve, Nothing) instance NodeProperty Environment "fog_depth_enabled" Bool 'False where nodeProperty = (is_fog_depth_enabled, wrapDroppingSetter set_fog_depth_enabled, Nothing) instance NodeProperty Environment "fog_depth_end" Float 'False where nodeProperty = (get_fog_depth_end, wrapDroppingSetter set_fog_depth_end, Nothing) instance NodeProperty Environment "fog_enabled" Bool 'False where nodeProperty = (is_fog_enabled, wrapDroppingSetter set_fog_enabled, Nothing) instance NodeProperty Environment "fog_height_curve" Float 'False where nodeProperty = (get_fog_height_curve, wrapDroppingSetter set_fog_height_curve, Nothing) instance NodeProperty Environment "fog_height_enabled" Bool 'False where nodeProperty = (is_fog_height_enabled, wrapDroppingSetter set_fog_height_enabled, Nothing) instance NodeProperty Environment "fog_height_max" Float 'False where nodeProperty = (get_fog_height_max, wrapDroppingSetter set_fog_height_max, Nothing) instance NodeProperty Environment "fog_height_min" Float 'False where nodeProperty = (get_fog_height_min, wrapDroppingSetter set_fog_height_min, Nothing) instance NodeProperty Environment "fog_sun_amount" Float 'False where nodeProperty = (get_fog_sun_amount, wrapDroppingSetter set_fog_sun_amount, Nothing) instance NodeProperty Environment "fog_sun_color" Color 'False where nodeProperty = (get_fog_sun_color, wrapDroppingSetter set_fog_sun_color, Nothing) instance NodeProperty Environment "fog_transmit_curve" Float 'False where nodeProperty = (get_fog_transmit_curve, wrapDroppingSetter set_fog_transmit_curve, Nothing) instance NodeProperty Environment "fog_transmit_enabled" Bool 'False where nodeProperty = (is_fog_transmit_enabled, wrapDroppingSetter set_fog_transmit_enabled, Nothing) instance NodeProperty Environment "glow_bicubic_upscale" Bool 'False where nodeProperty = (is_glow_bicubic_upscale_enabled, wrapDroppingSetter set_glow_bicubic_upscale, Nothing) instance NodeProperty Environment "glow_blend_mode" Int 'False where nodeProperty = (get_glow_blend_mode, wrapDroppingSetter set_glow_blend_mode, Nothing) instance NodeProperty Environment "glow_bloom" Float 'False where nodeProperty = (get_glow_bloom, wrapDroppingSetter set_glow_bloom, Nothing) instance NodeProperty Environment "glow_enabled" Bool 'False where nodeProperty = (is_glow_enabled, wrapDroppingSetter set_glow_enabled, Nothing) instance NodeProperty Environment "glow_hdr_luminance_cap" Float 'False where nodeProperty = (get_glow_hdr_luminance_cap, wrapDroppingSetter set_glow_hdr_luminance_cap, Nothing) instance NodeProperty Environment "glow_hdr_scale" Float 'False where nodeProperty = (get_glow_hdr_bleed_scale, wrapDroppingSetter set_glow_hdr_bleed_scale, Nothing) instance NodeProperty Environment "glow_hdr_threshold" Float 'False where nodeProperty = (get_glow_hdr_bleed_threshold, wrapDroppingSetter set_glow_hdr_bleed_threshold, Nothing) instance NodeProperty Environment "glow_intensity" Float 'False where nodeProperty = (get_glow_intensity, wrapDroppingSetter set_glow_intensity, Nothing) instance NodeProperty Environment "glow_levels/1" Bool 'False where nodeProperty = (wrapIndexedGetter 0 is_glow_level_enabled, wrapIndexedSetter 0 set_glow_level, Nothing) instance NodeProperty Environment "glow_levels/2" Bool 'False where nodeProperty = (wrapIndexedGetter 1 is_glow_level_enabled, wrapIndexedSetter 1 set_glow_level, Nothing) instance NodeProperty Environment "glow_levels/3" Bool 'False where nodeProperty = (wrapIndexedGetter 2 is_glow_level_enabled, wrapIndexedSetter 2 set_glow_level, Nothing) instance NodeProperty Environment "glow_levels/4" Bool 'False where nodeProperty = (wrapIndexedGetter 3 is_glow_level_enabled, wrapIndexedSetter 3 set_glow_level, Nothing) instance NodeProperty Environment "glow_levels/5" Bool 'False where nodeProperty = (wrapIndexedGetter 4 is_glow_level_enabled, wrapIndexedSetter 4 set_glow_level, Nothing) instance NodeProperty Environment "glow_levels/6" Bool 'False where nodeProperty = (wrapIndexedGetter 5 is_glow_level_enabled, wrapIndexedSetter 5 set_glow_level, Nothing) instance NodeProperty Environment "glow_levels/7" Bool 'False where nodeProperty = (wrapIndexedGetter 6 is_glow_level_enabled, wrapIndexedSetter 6 set_glow_level, Nothing) instance NodeProperty Environment "glow_strength" Float 'False where nodeProperty = (get_glow_strength, wrapDroppingSetter set_glow_strength, Nothing) instance NodeProperty Environment "ss_reflections_depth_tolerance" Float 'False where nodeProperty = (get_ssr_depth_tolerance, wrapDroppingSetter set_ssr_depth_tolerance, Nothing) instance NodeProperty Environment "ss_reflections_enabled" Bool 'False where nodeProperty = (is_ssr_enabled, wrapDroppingSetter set_ssr_enabled, Nothing) instance NodeProperty Environment "ss_reflections_fade_in" Float 'False where nodeProperty = (get_ssr_fade_in, wrapDroppingSetter set_ssr_fade_in, Nothing) instance NodeProperty Environment "ss_reflections_fade_out" Float 'False where nodeProperty = (get_ssr_fade_out, wrapDroppingSetter set_ssr_fade_out, Nothing) instance NodeProperty Environment "ss_reflections_max_steps" Int 'False where nodeProperty = (get_ssr_max_steps, wrapDroppingSetter set_ssr_max_steps, Nothing) instance NodeProperty Environment "ss_reflections_roughness" Bool 'False where nodeProperty = (is_ssr_rough, wrapDroppingSetter set_ssr_rough, Nothing) instance NodeProperty Environment "ssao_ao_channel_affect" Float 'False where nodeProperty = (get_ssao_ao_channel_affect, wrapDroppingSetter set_ssao_ao_channel_affect, Nothing) instance NodeProperty Environment "ssao_bias" Float 'False where nodeProperty = (get_ssao_bias, wrapDroppingSetter set_ssao_bias, Nothing) instance NodeProperty Environment "ssao_blur" Int 'False where nodeProperty = (get_ssao_blur, wrapDroppingSetter set_ssao_blur, Nothing) instance NodeProperty Environment "ssao_color" Color 'False where nodeProperty = (get_ssao_color, wrapDroppingSetter set_ssao_color, Nothing) instance NodeProperty Environment "ssao_edge_sharpness" Float 'False where nodeProperty = (get_ssao_edge_sharpness, wrapDroppingSetter set_ssao_edge_sharpness, Nothing) instance NodeProperty Environment "ssao_enabled" Bool 'False where nodeProperty = (is_ssao_enabled, wrapDroppingSetter set_ssao_enabled, Nothing) instance NodeProperty Environment "ssao_intensity" Float 'False where nodeProperty = (get_ssao_intensity, wrapDroppingSetter set_ssao_intensity, Nothing) instance NodeProperty Environment "ssao_intensity2" Float 'False where nodeProperty = (get_ssao_intensity2, wrapDroppingSetter set_ssao_intensity2, Nothing) instance NodeProperty Environment "ssao_light_affect" Float 'False where nodeProperty = (get_ssao_direct_light_affect, wrapDroppingSetter set_ssao_direct_light_affect, Nothing) instance NodeProperty Environment "ssao_quality" Int 'False where nodeProperty = (get_ssao_quality, wrapDroppingSetter set_ssao_quality, Nothing) instance NodeProperty Environment "ssao_radius" Float 'False where nodeProperty = (get_ssao_radius, wrapDroppingSetter set_ssao_radius, Nothing) instance NodeProperty Environment "ssao_radius2" Float 'False where nodeProperty = (get_ssao_radius2, wrapDroppingSetter set_ssao_radius2, Nothing) instance NodeProperty Environment "tonemap_exposure" Float 'False where nodeProperty = (get_tonemap_exposure, wrapDroppingSetter set_tonemap_exposure, Nothing) instance NodeProperty Environment "tonemap_mode" Int 'False where nodeProperty = (get_tonemapper, wrapDroppingSetter set_tonemapper, Nothing) instance NodeProperty Environment "tonemap_white" Float 'False where nodeProperty = (get_tonemap_white, wrapDroppingSetter set_tonemap_white, Nothing) {-# NOINLINE bindEnvironment_get_adjustment_brightness #-} -- | The global brightness value of the rendered scene. Effective only if @adjustment_enabled@ is @true@. bindEnvironment_get_adjustment_brightness :: MethodBind bindEnvironment_get_adjustment_brightness = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_adjustment_brightness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global brightness value of the rendered scene. Effective only if @adjustment_enabled@ is @true@. get_adjustment_brightness :: (Environment :< cls, Object :< cls) => cls -> IO Float get_adjustment_brightness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_adjustment_brightness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_adjustment_brightness" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_adjustment_brightness {-# NOINLINE bindEnvironment_get_adjustment_color_correction #-} -- | Applies the provided @Texture@ resource to affect the global color aspect of the rendered scene. Effective only if @adjustment_enabled@ is @true@. bindEnvironment_get_adjustment_color_correction :: MethodBind bindEnvironment_get_adjustment_color_correction = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_adjustment_color_correction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies the provided @Texture@ resource to affect the global color aspect of the rendered scene. Effective only if @adjustment_enabled@ is @true@. get_adjustment_color_correction :: (Environment :< cls, Object :< cls) => cls -> IO Texture get_adjustment_color_correction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_adjustment_color_correction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_adjustment_color_correction" '[] (IO Texture) where nodeMethod = Godot.Core.Environment.get_adjustment_color_correction {-# NOINLINE bindEnvironment_get_adjustment_contrast #-} -- | The global contrast value of the rendered scene (default value is 1). Effective only if @adjustment_enabled@ is @true@. bindEnvironment_get_adjustment_contrast :: MethodBind bindEnvironment_get_adjustment_contrast = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_adjustment_contrast" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global contrast value of the rendered scene (default value is 1). Effective only if @adjustment_enabled@ is @true@. get_adjustment_contrast :: (Environment :< cls, Object :< cls) => cls -> IO Float get_adjustment_contrast cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_adjustment_contrast (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_adjustment_contrast" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_adjustment_contrast {-# NOINLINE bindEnvironment_get_adjustment_saturation #-} -- | The global color saturation value of the rendered scene (default value is 1). Effective only if @adjustment_enabled@ is @true@. bindEnvironment_get_adjustment_saturation :: MethodBind bindEnvironment_get_adjustment_saturation = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_adjustment_saturation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global color saturation value of the rendered scene (default value is 1). Effective only if @adjustment_enabled@ is @true@. get_adjustment_saturation :: (Environment :< cls, Object :< cls) => cls -> IO Float get_adjustment_saturation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_adjustment_saturation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_adjustment_saturation" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_adjustment_saturation {-# NOINLINE bindEnvironment_get_ambient_light_color #-} -- | The ambient light's @Color@. bindEnvironment_get_ambient_light_color :: MethodBind bindEnvironment_get_ambient_light_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ambient_light_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ambient light's @Color@. get_ambient_light_color :: (Environment :< cls, Object :< cls) => cls -> IO Color get_ambient_light_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ambient_light_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ambient_light_color" '[] (IO Color) where nodeMethod = Godot.Core.Environment.get_ambient_light_color {-# NOINLINE bindEnvironment_get_ambient_light_energy #-} -- | The ambient light's energy. The higher the value, the stronger the light. bindEnvironment_get_ambient_light_energy :: MethodBind bindEnvironment_get_ambient_light_energy = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ambient_light_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ambient light's energy. The higher the value, the stronger the light. get_ambient_light_energy :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ambient_light_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ambient_light_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ambient_light_energy" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ambient_light_energy {-# NOINLINE bindEnvironment_get_ambient_light_sky_contribution #-} -- | Defines the amount of light that the sky brings on the scene. A value of 0 means that the sky's light emission has no effect on the scene illumination, thus all ambient illumination is provided by the ambient light. On the contrary, a value of 1 means that all the light that affects the scene is provided by the sky, thus the ambient light parameter has no effect on the scene. bindEnvironment_get_ambient_light_sky_contribution :: MethodBind bindEnvironment_get_ambient_light_sky_contribution = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ambient_light_sky_contribution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the amount of light that the sky brings on the scene. A value of 0 means that the sky's light emission has no effect on the scene illumination, thus all ambient illumination is provided by the ambient light. On the contrary, a value of 1 means that all the light that affects the scene is provided by the sky, thus the ambient light parameter has no effect on the scene. get_ambient_light_sky_contribution :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ambient_light_sky_contribution cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ambient_light_sky_contribution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ambient_light_sky_contribution" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ambient_light_sky_contribution {-# NOINLINE bindEnvironment_get_background #-} -- | The background mode. See @enum BGMode@ for possible values. bindEnvironment_get_background :: MethodBind bindEnvironment_get_background = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_background" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The background mode. See @enum BGMode@ for possible values. get_background :: (Environment :< cls, Object :< cls) => cls -> IO Int get_background cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_background (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_background" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_background {-# NOINLINE bindEnvironment_get_bg_color #-} -- | The @Color@ displayed for clear areas of the scene. Only effective when using the @BG_COLOR@ or @BG_COLOR_SKY@ background modes). bindEnvironment_get_bg_color :: MethodBind bindEnvironment_get_bg_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Color@ displayed for clear areas of the scene. Only effective when using the @BG_COLOR@ or @BG_COLOR_SKY@ background modes). get_bg_color :: (Environment :< cls, Object :< cls) => cls -> IO Color get_bg_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_bg_color" '[] (IO Color) where nodeMethod = Godot.Core.Environment.get_bg_color {-# NOINLINE bindEnvironment_get_bg_energy #-} -- | The power of the light emitted by the background. bindEnvironment_get_bg_energy :: MethodBind bindEnvironment_get_bg_energy = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_bg_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The power of the light emitted by the background. get_bg_energy :: (Environment :< cls, Object :< cls) => cls -> IO Float get_bg_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_bg_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_bg_energy" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_bg_energy {-# NOINLINE bindEnvironment_get_camera_feed_id #-} -- | The ID of the camera feed to show in the background. bindEnvironment_get_camera_feed_id :: MethodBind bindEnvironment_get_camera_feed_id = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_camera_feed_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ID of the camera feed to show in the background. get_camera_feed_id :: (Environment :< cls, Object :< cls) => cls -> IO Int get_camera_feed_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_camera_feed_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_camera_feed_id" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_camera_feed_id {-# NOINLINE bindEnvironment_get_canvas_max_layer #-} -- | The maximum layer ID to display. Only effective when using the @BG_CANVAS@ background mode. bindEnvironment_get_canvas_max_layer :: MethodBind bindEnvironment_get_canvas_max_layer = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_canvas_max_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum layer ID to display. Only effective when using the @BG_CANVAS@ background mode. get_canvas_max_layer :: (Environment :< cls, Object :< cls) => cls -> IO Int get_canvas_max_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_canvas_max_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_canvas_max_layer" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_canvas_max_layer {-# NOINLINE bindEnvironment_get_dof_blur_far_amount #-} -- | The amount of far blur for the depth-of-field effect. bindEnvironment_get_dof_blur_far_amount :: MethodBind bindEnvironment_get_dof_blur_far_amount = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_dof_blur_far_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of far blur for the depth-of-field effect. get_dof_blur_far_amount :: (Environment :< cls, Object :< cls) => cls -> IO Float get_dof_blur_far_amount cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_dof_blur_far_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_dof_blur_far_amount" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_dof_blur_far_amount {-# NOINLINE bindEnvironment_get_dof_blur_far_distance #-} -- | The distance from the camera where the far blur effect affects the rendering. bindEnvironment_get_dof_blur_far_distance :: MethodBind bindEnvironment_get_dof_blur_far_distance = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_dof_blur_far_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance from the camera where the far blur effect affects the rendering. get_dof_blur_far_distance :: (Environment :< cls, Object :< cls) => cls -> IO Float get_dof_blur_far_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_dof_blur_far_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_dof_blur_far_distance" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_dof_blur_far_distance {-# NOINLINE bindEnvironment_get_dof_blur_far_quality #-} -- | The depth-of-field far blur's quality. Higher values can mitigate the visible banding effect seen at higher strengths, but are much slower. bindEnvironment_get_dof_blur_far_quality :: MethodBind bindEnvironment_get_dof_blur_far_quality = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_dof_blur_far_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The depth-of-field far blur's quality. Higher values can mitigate the visible banding effect seen at higher strengths, but are much slower. get_dof_blur_far_quality :: (Environment :< cls, Object :< cls) => cls -> IO Int get_dof_blur_far_quality cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_dof_blur_far_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_dof_blur_far_quality" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_dof_blur_far_quality {-# NOINLINE bindEnvironment_get_dof_blur_far_transition #-} -- | The length of the transition between the no-blur area and far blur. bindEnvironment_get_dof_blur_far_transition :: MethodBind bindEnvironment_get_dof_blur_far_transition = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_dof_blur_far_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The length of the transition between the no-blur area and far blur. get_dof_blur_far_transition :: (Environment :< cls, Object :< cls) => cls -> IO Float get_dof_blur_far_transition cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_dof_blur_far_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_dof_blur_far_transition" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_dof_blur_far_transition {-# NOINLINE bindEnvironment_get_dof_blur_near_amount #-} -- | The amount of near blur for the depth-of-field effect. bindEnvironment_get_dof_blur_near_amount :: MethodBind bindEnvironment_get_dof_blur_near_amount = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_dof_blur_near_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of near blur for the depth-of-field effect. get_dof_blur_near_amount :: (Environment :< cls, Object :< cls) => cls -> IO Float get_dof_blur_near_amount cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_dof_blur_near_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_dof_blur_near_amount" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_dof_blur_near_amount {-# NOINLINE bindEnvironment_get_dof_blur_near_distance #-} -- | Distance from the camera where the near blur effect affects the rendering. bindEnvironment_get_dof_blur_near_distance :: MethodBind bindEnvironment_get_dof_blur_near_distance = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_dof_blur_near_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance from the camera where the near blur effect affects the rendering. get_dof_blur_near_distance :: (Environment :< cls, Object :< cls) => cls -> IO Float get_dof_blur_near_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_dof_blur_near_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_dof_blur_near_distance" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_dof_blur_near_distance {-# NOINLINE bindEnvironment_get_dof_blur_near_quality #-} -- | The depth-of-field near blur's quality. Higher values can mitigate the visible banding effect seen at higher strengths, but are much slower. bindEnvironment_get_dof_blur_near_quality :: MethodBind bindEnvironment_get_dof_blur_near_quality = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_dof_blur_near_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The depth-of-field near blur's quality. Higher values can mitigate the visible banding effect seen at higher strengths, but are much slower. get_dof_blur_near_quality :: (Environment :< cls, Object :< cls) => cls -> IO Int get_dof_blur_near_quality cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_dof_blur_near_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_dof_blur_near_quality" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_dof_blur_near_quality {-# NOINLINE bindEnvironment_get_dof_blur_near_transition #-} -- | The length of the transition between the near blur and no-blur area. bindEnvironment_get_dof_blur_near_transition :: MethodBind bindEnvironment_get_dof_blur_near_transition = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_dof_blur_near_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The length of the transition between the near blur and no-blur area. get_dof_blur_near_transition :: (Environment :< cls, Object :< cls) => cls -> IO Float get_dof_blur_near_transition cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_dof_blur_near_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_dof_blur_near_transition" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_dof_blur_near_transition {-# NOINLINE bindEnvironment_get_fog_color #-} -- | The fog's @Color@. bindEnvironment_get_fog_color :: MethodBind bindEnvironment_get_fog_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fog's @Color@. get_fog_color :: (Environment :< cls, Object :< cls) => cls -> IO Color get_fog_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_color" '[] (IO Color) where nodeMethod = Godot.Core.Environment.get_fog_color {-# NOINLINE bindEnvironment_get_fog_depth_begin #-} -- | The fog's depth starting distance from the camera. bindEnvironment_get_fog_depth_begin :: MethodBind bindEnvironment_get_fog_depth_begin = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_depth_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fog's depth starting distance from the camera. get_fog_depth_begin :: (Environment :< cls, Object :< cls) => cls -> IO Float get_fog_depth_begin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_depth_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_depth_begin" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_fog_depth_begin {-# NOINLINE bindEnvironment_get_fog_depth_curve #-} -- | The fog depth's intensity curve. A number of presets are available in the __Inspector__ by right-clicking the curve. bindEnvironment_get_fog_depth_curve :: MethodBind bindEnvironment_get_fog_depth_curve = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_depth_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fog depth's intensity curve. A number of presets are available in the __Inspector__ by right-clicking the curve. get_fog_depth_curve :: (Environment :< cls, Object :< cls) => cls -> IO Float get_fog_depth_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_depth_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_depth_curve" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_fog_depth_curve {-# NOINLINE bindEnvironment_get_fog_depth_end #-} -- | The fog's depth end distance from the camera. If this value is set to 0, it will be equal to the current camera's @Camera.far@ value. bindEnvironment_get_fog_depth_end :: MethodBind bindEnvironment_get_fog_depth_end = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_depth_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fog's depth end distance from the camera. If this value is set to 0, it will be equal to the current camera's @Camera.far@ value. get_fog_depth_end :: (Environment :< cls, Object :< cls) => cls -> IO Float get_fog_depth_end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_depth_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_depth_end" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_fog_depth_end {-# NOINLINE bindEnvironment_get_fog_height_curve #-} -- | The height fog's intensity. A number of presets are available in the __Inspector__ by right-clicking the curve. bindEnvironment_get_fog_height_curve :: MethodBind bindEnvironment_get_fog_height_curve = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_height_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The height fog's intensity. A number of presets are available in the __Inspector__ by right-clicking the curve. get_fog_height_curve :: (Environment :< cls, Object :< cls) => cls -> IO Float get_fog_height_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_height_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_height_curve" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_fog_height_curve {-# NOINLINE bindEnvironment_get_fog_height_max #-} -- | The Y coordinate where the height fog will be the most intense. If this value is greater than @fog_height_min@, fog will be displayed from bottom to top. Otherwise, it will be displayed from top to bottom. bindEnvironment_get_fog_height_max :: MethodBind bindEnvironment_get_fog_height_max = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_height_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Y coordinate where the height fog will be the most intense. If this value is greater than @fog_height_min@, fog will be displayed from bottom to top. Otherwise, it will be displayed from top to bottom. get_fog_height_max :: (Environment :< cls, Object :< cls) => cls -> IO Float get_fog_height_max cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_height_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_height_max" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_fog_height_max {-# NOINLINE bindEnvironment_get_fog_height_min #-} -- | The Y coordinate where the height fog will be the least intense. If this value is greater than @fog_height_max@, fog will be displayed from top to bottom. Otherwise, it will be displayed from bottom to top. bindEnvironment_get_fog_height_min :: MethodBind bindEnvironment_get_fog_height_min = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_height_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Y coordinate where the height fog will be the least intense. If this value is greater than @fog_height_max@, fog will be displayed from top to bottom. Otherwise, it will be displayed from bottom to top. get_fog_height_min :: (Environment :< cls, Object :< cls) => cls -> IO Float get_fog_height_min cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_height_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_height_min" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_fog_height_min {-# NOINLINE bindEnvironment_get_fog_sun_amount #-} -- | The intensity of the depth fog color transition when looking towards the sun. The sun's direction is determined automatically using the DirectionalLight node in the scene. bindEnvironment_get_fog_sun_amount :: MethodBind bindEnvironment_get_fog_sun_amount = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_sun_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The intensity of the depth fog color transition when looking towards the sun. The sun's direction is determined automatically using the DirectionalLight node in the scene. get_fog_sun_amount :: (Environment :< cls, Object :< cls) => cls -> IO Float get_fog_sun_amount cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_sun_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_sun_amount" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_fog_sun_amount {-# NOINLINE bindEnvironment_get_fog_sun_color #-} -- | The depth fog's @Color@ when looking towards the sun. bindEnvironment_get_fog_sun_color :: MethodBind bindEnvironment_get_fog_sun_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_sun_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The depth fog's @Color@ when looking towards the sun. get_fog_sun_color :: (Environment :< cls, Object :< cls) => cls -> IO Color get_fog_sun_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_sun_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_sun_color" '[] (IO Color) where nodeMethod = Godot.Core.Environment.get_fog_sun_color {-# NOINLINE bindEnvironment_get_fog_transmit_curve #-} -- | The intensity of the fog light transmittance effect. Amount of light that the fog transmits. bindEnvironment_get_fog_transmit_curve :: MethodBind bindEnvironment_get_fog_transmit_curve = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_fog_transmit_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The intensity of the fog light transmittance effect. Amount of light that the fog transmits. get_fog_transmit_curve :: (Environment :< cls, Object :< cls) => cls -> IO Float get_fog_transmit_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_fog_transmit_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_fog_transmit_curve" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_fog_transmit_curve {-# NOINLINE bindEnvironment_get_glow_blend_mode #-} -- | The glow blending mode. bindEnvironment_get_glow_blend_mode :: MethodBind bindEnvironment_get_glow_blend_mode = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_glow_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The glow blending mode. get_glow_blend_mode :: (Environment :< cls, Object :< cls) => cls -> IO Int get_glow_blend_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_glow_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_glow_blend_mode" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_glow_blend_mode {-# NOINLINE bindEnvironment_get_glow_bloom #-} -- | The bloom's intensity. If set to a value higher than @0@, this will make glow visible in areas darker than the @glow_hdr_threshold@. bindEnvironment_get_glow_bloom :: MethodBind bindEnvironment_get_glow_bloom = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_glow_bloom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The bloom's intensity. If set to a value higher than @0@, this will make glow visible in areas darker than the @glow_hdr_threshold@. get_glow_bloom :: (Environment :< cls, Object :< cls) => cls -> IO Float get_glow_bloom cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_glow_bloom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_glow_bloom" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_glow_bloom {-# NOINLINE bindEnvironment_get_glow_hdr_bleed_scale #-} -- | The bleed scale of the HDR glow. bindEnvironment_get_glow_hdr_bleed_scale :: MethodBind bindEnvironment_get_glow_hdr_bleed_scale = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_glow_hdr_bleed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The bleed scale of the HDR glow. get_glow_hdr_bleed_scale :: (Environment :< cls, Object :< cls) => cls -> IO Float get_glow_hdr_bleed_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_glow_hdr_bleed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_glow_hdr_bleed_scale" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_glow_hdr_bleed_scale {-# NOINLINE bindEnvironment_get_glow_hdr_bleed_threshold #-} -- | The lower threshold of the HDR glow. When using the GLES2 renderer (which doesn't support HDR), this needs to be below @1.0@ for glow to be visible. A value of @0.9@ works well in this case. bindEnvironment_get_glow_hdr_bleed_threshold :: MethodBind bindEnvironment_get_glow_hdr_bleed_threshold = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_glow_hdr_bleed_threshold" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The lower threshold of the HDR glow. When using the GLES2 renderer (which doesn't support HDR), this needs to be below @1.0@ for glow to be visible. A value of @0.9@ works well in this case. get_glow_hdr_bleed_threshold :: (Environment :< cls, Object :< cls) => cls -> IO Float get_glow_hdr_bleed_threshold cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_glow_hdr_bleed_threshold (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_glow_hdr_bleed_threshold" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_glow_hdr_bleed_threshold {-# NOINLINE bindEnvironment_get_glow_hdr_luminance_cap #-} -- | The higher threshold of the HDR glow. Areas brighter than this threshold will be clamped for the purposes of the glow effect. bindEnvironment_get_glow_hdr_luminance_cap :: MethodBind bindEnvironment_get_glow_hdr_luminance_cap = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_glow_hdr_luminance_cap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The higher threshold of the HDR glow. Areas brighter than this threshold will be clamped for the purposes of the glow effect. get_glow_hdr_luminance_cap :: (Environment :< cls, Object :< cls) => cls -> IO Float get_glow_hdr_luminance_cap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_glow_hdr_luminance_cap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_glow_hdr_luminance_cap" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_glow_hdr_luminance_cap {-# NOINLINE bindEnvironment_get_glow_intensity #-} -- | The glow intensity. When using the GLES2 renderer, this should be increased to 1.5 to compensate for the lack of HDR rendering. bindEnvironment_get_glow_intensity :: MethodBind bindEnvironment_get_glow_intensity = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_glow_intensity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The glow intensity. When using the GLES2 renderer, this should be increased to 1.5 to compensate for the lack of HDR rendering. get_glow_intensity :: (Environment :< cls, Object :< cls) => cls -> IO Float get_glow_intensity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_glow_intensity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_glow_intensity" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_glow_intensity {-# NOINLINE bindEnvironment_get_glow_strength #-} -- | The glow strength. When using the GLES2 renderer, this should be increased to 1.3 to compensate for the lack of HDR rendering. bindEnvironment_get_glow_strength :: MethodBind bindEnvironment_get_glow_strength = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_glow_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The glow strength. When using the GLES2 renderer, this should be increased to 1.3 to compensate for the lack of HDR rendering. get_glow_strength :: (Environment :< cls, Object :< cls) => cls -> IO Float get_glow_strength cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_glow_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_glow_strength" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_glow_strength {-# NOINLINE bindEnvironment_get_sky #-} -- | The @Sky@ resource defined as background. bindEnvironment_get_sky :: MethodBind bindEnvironment_get_sky = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_sky" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource defined as background. get_sky :: (Environment :< cls, Object :< cls) => cls -> IO Sky get_sky cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_sky (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_sky" '[] (IO Sky) where nodeMethod = Godot.Core.Environment.get_sky {-# NOINLINE bindEnvironment_get_sky_custom_fov #-} -- | The @Sky@ resource's custom field of view. bindEnvironment_get_sky_custom_fov :: MethodBind bindEnvironment_get_sky_custom_fov = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_sky_custom_fov" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource's custom field of view. get_sky_custom_fov :: (Environment :< cls, Object :< cls) => cls -> IO Float get_sky_custom_fov cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_sky_custom_fov (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_sky_custom_fov" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_sky_custom_fov {-# NOINLINE bindEnvironment_get_sky_orientation #-} -- | The @Sky@ resource's rotation expressed as a @Basis@. bindEnvironment_get_sky_orientation :: MethodBind bindEnvironment_get_sky_orientation = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_sky_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource's rotation expressed as a @Basis@. get_sky_orientation :: (Environment :< cls, Object :< cls) => cls -> IO Basis get_sky_orientation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_sky_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_sky_orientation" '[] (IO Basis) where nodeMethod = Godot.Core.Environment.get_sky_orientation {-# NOINLINE bindEnvironment_get_sky_rotation #-} -- | The @Sky@ resource's rotation expressed as Euler angles in radians. bindEnvironment_get_sky_rotation :: MethodBind bindEnvironment_get_sky_rotation = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_sky_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource's rotation expressed as Euler angles in radians. get_sky_rotation :: (Environment :< cls, Object :< cls) => cls -> IO Vector3 get_sky_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_sky_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_sky_rotation" '[] (IO Vector3) where nodeMethod = Godot.Core.Environment.get_sky_rotation {-# NOINLINE bindEnvironment_get_sky_rotation_degrees #-} -- | The @Sky@ resource's rotation expressed as Euler angles in degrees. bindEnvironment_get_sky_rotation_degrees :: MethodBind bindEnvironment_get_sky_rotation_degrees = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_sky_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource's rotation expressed as Euler angles in degrees. get_sky_rotation_degrees :: (Environment :< cls, Object :< cls) => cls -> IO Vector3 get_sky_rotation_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_sky_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_sky_rotation_degrees" '[] (IO Vector3) where nodeMethod = Godot.Core.Environment.get_sky_rotation_degrees {-# NOINLINE bindEnvironment_get_ssao_ao_channel_affect #-} -- | The screen-space ambient occlusion intensity on materials that have an AO texture defined. Values higher than @0@ will make the SSAO effect visible in areas darkened by AO textures. bindEnvironment_get_ssao_ao_channel_affect :: MethodBind bindEnvironment_get_ssao_ao_channel_affect = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_ao_channel_affect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion intensity on materials that have an AO texture defined. Values higher than @0@ will make the SSAO effect visible in areas darkened by AO textures. get_ssao_ao_channel_affect :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssao_ao_channel_affect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_ao_channel_affect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_ao_channel_affect" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssao_ao_channel_affect {-# NOINLINE bindEnvironment_get_ssao_bias #-} -- | The screen-space ambient occlusion bias. This should be kept high enough to prevent "smooth" curves from being affected by ambient occlusion. bindEnvironment_get_ssao_bias :: MethodBind bindEnvironment_get_ssao_bias = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion bias. This should be kept high enough to prevent "smooth" curves from being affected by ambient occlusion. get_ssao_bias :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssao_bias cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_bias" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssao_bias {-# NOINLINE bindEnvironment_get_ssao_blur #-} -- | The screen-space ambient occlusion blur quality. See @enum SSAOBlur@ for possible values. bindEnvironment_get_ssao_blur :: MethodBind bindEnvironment_get_ssao_blur = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_blur" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion blur quality. See @enum SSAOBlur@ for possible values. get_ssao_blur :: (Environment :< cls, Object :< cls) => cls -> IO Int get_ssao_blur cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_blur (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_blur" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_ssao_blur {-# NOINLINE bindEnvironment_get_ssao_color #-} -- | The screen-space ambient occlusion color. bindEnvironment_get_ssao_color :: MethodBind bindEnvironment_get_ssao_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion color. get_ssao_color :: (Environment :< cls, Object :< cls) => cls -> IO Color get_ssao_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_color" '[] (IO Color) where nodeMethod = Godot.Core.Environment.get_ssao_color {-# NOINLINE bindEnvironment_get_ssao_direct_light_affect #-} -- | The screen-space ambient occlusion intensity in direct light. In real life, ambient occlusion only applies to indirect light, which means its effects can't be seen in direct light. Values higher than @0@ will make the SSAO effect visible in direct light. bindEnvironment_get_ssao_direct_light_affect :: MethodBind bindEnvironment_get_ssao_direct_light_affect = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_direct_light_affect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion intensity in direct light. In real life, ambient occlusion only applies to indirect light, which means its effects can't be seen in direct light. Values higher than @0@ will make the SSAO effect visible in direct light. get_ssao_direct_light_affect :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssao_direct_light_affect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_direct_light_affect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_direct_light_affect" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssao_direct_light_affect {-# NOINLINE bindEnvironment_get_ssao_edge_sharpness #-} -- | The screen-space ambient occlusion edge sharpness. bindEnvironment_get_ssao_edge_sharpness :: MethodBind bindEnvironment_get_ssao_edge_sharpness = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_edge_sharpness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion edge sharpness. get_ssao_edge_sharpness :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssao_edge_sharpness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_edge_sharpness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_edge_sharpness" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssao_edge_sharpness {-# NOINLINE bindEnvironment_get_ssao_intensity #-} -- | The primary screen-space ambient occlusion intensity. See also @ssao_radius@. bindEnvironment_get_ssao_intensity :: MethodBind bindEnvironment_get_ssao_intensity = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_intensity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The primary screen-space ambient occlusion intensity. See also @ssao_radius@. get_ssao_intensity :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssao_intensity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_intensity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_intensity" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssao_intensity {-# NOINLINE bindEnvironment_get_ssao_intensity2 #-} -- | The secondary screen-space ambient occlusion intensity. See also @ssao_radius2@. bindEnvironment_get_ssao_intensity2 :: MethodBind bindEnvironment_get_ssao_intensity2 = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_intensity2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The secondary screen-space ambient occlusion intensity. See also @ssao_radius2@. get_ssao_intensity2 :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssao_intensity2 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_intensity2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_intensity2" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssao_intensity2 {-# NOINLINE bindEnvironment_get_ssao_quality #-} -- | The screen-space ambient occlusion quality. Higher qualities will make better use of small objects for ambient occlusion, but are slower. bindEnvironment_get_ssao_quality :: MethodBind bindEnvironment_get_ssao_quality = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion quality. Higher qualities will make better use of small objects for ambient occlusion, but are slower. get_ssao_quality :: (Environment :< cls, Object :< cls) => cls -> IO Int get_ssao_quality cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_quality" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_ssao_quality {-# NOINLINE bindEnvironment_get_ssao_radius #-} -- | The primary screen-space ambient occlusion radius. bindEnvironment_get_ssao_radius :: MethodBind bindEnvironment_get_ssao_radius = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The primary screen-space ambient occlusion radius. get_ssao_radius :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssao_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_radius" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssao_radius {-# NOINLINE bindEnvironment_get_ssao_radius2 #-} -- | The secondary screen-space ambient occlusion radius. If set to a value higher than @0@, enables the secondary screen-space ambient occlusion effect which can be used to improve the effect's appearance (at the cost of performance). bindEnvironment_get_ssao_radius2 :: MethodBind bindEnvironment_get_ssao_radius2 = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssao_radius2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The secondary screen-space ambient occlusion radius. If set to a value higher than @0@, enables the secondary screen-space ambient occlusion effect which can be used to improve the effect's appearance (at the cost of performance). get_ssao_radius2 :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssao_radius2 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssao_radius2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssao_radius2" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssao_radius2 {-# NOINLINE bindEnvironment_get_ssr_depth_tolerance #-} -- | The depth tolerance for screen-space reflections. bindEnvironment_get_ssr_depth_tolerance :: MethodBind bindEnvironment_get_ssr_depth_tolerance = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssr_depth_tolerance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The depth tolerance for screen-space reflections. get_ssr_depth_tolerance :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssr_depth_tolerance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssr_depth_tolerance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssr_depth_tolerance" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssr_depth_tolerance {-# NOINLINE bindEnvironment_get_ssr_fade_in #-} -- | The fade-in distance for screen-space reflections. Affects the area from the reflected material to the screen-space reflection). bindEnvironment_get_ssr_fade_in :: MethodBind bindEnvironment_get_ssr_fade_in = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssr_fade_in" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fade-in distance for screen-space reflections. Affects the area from the reflected material to the screen-space reflection). get_ssr_fade_in :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssr_fade_in cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssr_fade_in (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssr_fade_in" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssr_fade_in {-# NOINLINE bindEnvironment_get_ssr_fade_out #-} -- | The fade-out distance for screen-space reflections. Affects the area from the screen-space reflection to the "global" reflection. bindEnvironment_get_ssr_fade_out :: MethodBind bindEnvironment_get_ssr_fade_out = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssr_fade_out" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fade-out distance for screen-space reflections. Affects the area from the screen-space reflection to the "global" reflection. get_ssr_fade_out :: (Environment :< cls, Object :< cls) => cls -> IO Float get_ssr_fade_out cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssr_fade_out (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssr_fade_out" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_ssr_fade_out {-# NOINLINE bindEnvironment_get_ssr_max_steps #-} -- | The maximum number of steps for screen-space reflections. Higher values are slower. bindEnvironment_get_ssr_max_steps :: MethodBind bindEnvironment_get_ssr_max_steps = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_ssr_max_steps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum number of steps for screen-space reflections. Higher values are slower. get_ssr_max_steps :: (Environment :< cls, Object :< cls) => cls -> IO Int get_ssr_max_steps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_ssr_max_steps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_ssr_max_steps" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_ssr_max_steps {-# NOINLINE bindEnvironment_get_tonemap_auto_exposure #-} -- | If @true@, enables the tonemapping auto exposure mode of the scene renderer. If @true@, the renderer will automatically determine the exposure setting to adapt to the scene's illumination and the observed light. bindEnvironment_get_tonemap_auto_exposure :: MethodBind bindEnvironment_get_tonemap_auto_exposure = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_tonemap_auto_exposure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the tonemapping auto exposure mode of the scene renderer. If @true@, the renderer will automatically determine the exposure setting to adapt to the scene's illumination and the observed light. get_tonemap_auto_exposure :: (Environment :< cls, Object :< cls) => cls -> IO Bool get_tonemap_auto_exposure cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_tonemap_auto_exposure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_tonemap_auto_exposure" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.get_tonemap_auto_exposure {-# NOINLINE bindEnvironment_get_tonemap_auto_exposure_grey #-} -- | The scale of the auto exposure effect. Affects the intensity of auto exposure. bindEnvironment_get_tonemap_auto_exposure_grey :: MethodBind bindEnvironment_get_tonemap_auto_exposure_grey = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_tonemap_auto_exposure_grey" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The scale of the auto exposure effect. Affects the intensity of auto exposure. get_tonemap_auto_exposure_grey :: (Environment :< cls, Object :< cls) => cls -> IO Float get_tonemap_auto_exposure_grey cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_tonemap_auto_exposure_grey (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_tonemap_auto_exposure_grey" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_tonemap_auto_exposure_grey {-# NOINLINE bindEnvironment_get_tonemap_auto_exposure_max #-} -- | The maximum luminance value for the auto exposure. bindEnvironment_get_tonemap_auto_exposure_max :: MethodBind bindEnvironment_get_tonemap_auto_exposure_max = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_tonemap_auto_exposure_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum luminance value for the auto exposure. get_tonemap_auto_exposure_max :: (Environment :< cls, Object :< cls) => cls -> IO Float get_tonemap_auto_exposure_max cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_tonemap_auto_exposure_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_tonemap_auto_exposure_max" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_tonemap_auto_exposure_max {-# NOINLINE bindEnvironment_get_tonemap_auto_exposure_min #-} -- | The minimum luminance value for the auto exposure. bindEnvironment_get_tonemap_auto_exposure_min :: MethodBind bindEnvironment_get_tonemap_auto_exposure_min = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_tonemap_auto_exposure_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum luminance value for the auto exposure. get_tonemap_auto_exposure_min :: (Environment :< cls, Object :< cls) => cls -> IO Float get_tonemap_auto_exposure_min cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_tonemap_auto_exposure_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_tonemap_auto_exposure_min" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_tonemap_auto_exposure_min {-# NOINLINE bindEnvironment_get_tonemap_auto_exposure_speed #-} -- | The speed of the auto exposure effect. Affects the time needed for the camera to perform auto exposure. bindEnvironment_get_tonemap_auto_exposure_speed :: MethodBind bindEnvironment_get_tonemap_auto_exposure_speed = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_tonemap_auto_exposure_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The speed of the auto exposure effect. Affects the time needed for the camera to perform auto exposure. get_tonemap_auto_exposure_speed :: (Environment :< cls, Object :< cls) => cls -> IO Float get_tonemap_auto_exposure_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_tonemap_auto_exposure_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_tonemap_auto_exposure_speed" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_tonemap_auto_exposure_speed {-# NOINLINE bindEnvironment_get_tonemap_exposure #-} -- | The default exposure used for tonemapping. bindEnvironment_get_tonemap_exposure :: MethodBind bindEnvironment_get_tonemap_exposure = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_tonemap_exposure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The default exposure used for tonemapping. get_tonemap_exposure :: (Environment :< cls, Object :< cls) => cls -> IO Float get_tonemap_exposure cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_tonemap_exposure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_tonemap_exposure" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_tonemap_exposure {-# NOINLINE bindEnvironment_get_tonemap_white #-} -- | The white reference value for tonemapping. Only effective if the @tonemap_mode@ isn't set to @TONE_MAPPER_LINEAR@. bindEnvironment_get_tonemap_white :: MethodBind bindEnvironment_get_tonemap_white = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_tonemap_white" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The white reference value for tonemapping. Only effective if the @tonemap_mode@ isn't set to @TONE_MAPPER_LINEAR@. get_tonemap_white :: (Environment :< cls, Object :< cls) => cls -> IO Float get_tonemap_white cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_tonemap_white (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_tonemap_white" '[] (IO Float) where nodeMethod = Godot.Core.Environment.get_tonemap_white {-# NOINLINE bindEnvironment_get_tonemapper #-} -- | The tonemapping mode to use. Tonemapping is the process that "converts" HDR values to be suitable for rendering on a LDR display. (Godot doesn't support rendering on HDR displays yet.) bindEnvironment_get_tonemapper :: MethodBind bindEnvironment_get_tonemapper = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "get_tonemapper" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The tonemapping mode to use. Tonemapping is the process that "converts" HDR values to be suitable for rendering on a LDR display. (Godot doesn't support rendering on HDR displays yet.) get_tonemapper :: (Environment :< cls, Object :< cls) => cls -> IO Int get_tonemapper cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_get_tonemapper (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "get_tonemapper" '[] (IO Int) where nodeMethod = Godot.Core.Environment.get_tonemapper {-# NOINLINE bindEnvironment_is_adjustment_enabled #-} -- | If @true@, enables the @adjustment_*@ properties provided by this resource. If @false@, modifications to the @adjustment_*@ properties will have no effect on the rendered scene. bindEnvironment_is_adjustment_enabled :: MethodBind bindEnvironment_is_adjustment_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_adjustment_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the @adjustment_*@ properties provided by this resource. If @false@, modifications to the @adjustment_*@ properties will have no effect on the rendered scene. is_adjustment_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_adjustment_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_adjustment_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_adjustment_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_adjustment_enabled {-# NOINLINE bindEnvironment_is_dof_blur_far_enabled #-} -- | If @true@, enables the depth-of-field far blur effect. bindEnvironment_is_dof_blur_far_enabled :: MethodBind bindEnvironment_is_dof_blur_far_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_dof_blur_far_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the depth-of-field far blur effect. is_dof_blur_far_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_dof_blur_far_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_dof_blur_far_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_dof_blur_far_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_dof_blur_far_enabled {-# NOINLINE bindEnvironment_is_dof_blur_near_enabled #-} -- | If @true@, enables the depth-of-field near blur effect. bindEnvironment_is_dof_blur_near_enabled :: MethodBind bindEnvironment_is_dof_blur_near_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_dof_blur_near_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the depth-of-field near blur effect. is_dof_blur_near_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_dof_blur_near_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_dof_blur_near_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_dof_blur_near_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_dof_blur_near_enabled {-# NOINLINE bindEnvironment_is_fog_depth_enabled #-} -- | If @true@, the depth fog effect is enabled. When enabled, fog will appear in the distance (relative to the camera). bindEnvironment_is_fog_depth_enabled :: MethodBind bindEnvironment_is_fog_depth_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_fog_depth_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the depth fog effect is enabled. When enabled, fog will appear in the distance (relative to the camera). is_fog_depth_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_fog_depth_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_fog_depth_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_fog_depth_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_fog_depth_enabled {-# NOINLINE bindEnvironment_is_fog_enabled #-} -- | If @true@, fog effects are enabled. @fog_height_enabled@ and/or @fog_depth_enabled@ must be set to @true@ to actually display fog. bindEnvironment_is_fog_enabled :: MethodBind bindEnvironment_is_fog_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_fog_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, fog effects are enabled. @fog_height_enabled@ and/or @fog_depth_enabled@ must be set to @true@ to actually display fog. is_fog_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_fog_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_fog_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_fog_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_fog_enabled {-# NOINLINE bindEnvironment_is_fog_height_enabled #-} -- | If @true@, the height fog effect is enabled. When enabled, fog will appear in a defined height range, regardless of the distance from the camera. This can be used to simulate "deep water" effects with a lower performance cost compared to a dedicated shader. bindEnvironment_is_fog_height_enabled :: MethodBind bindEnvironment_is_fog_height_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_fog_height_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the height fog effect is enabled. When enabled, fog will appear in a defined height range, regardless of the distance from the camera. This can be used to simulate "deep water" effects with a lower performance cost compared to a dedicated shader. is_fog_height_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_fog_height_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_fog_height_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_fog_height_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_fog_height_enabled {-# NOINLINE bindEnvironment_is_fog_transmit_enabled #-} -- | Enables fog's light transmission effect. If @true@, light will be more visible in the fog to simulate light scattering as in real life. bindEnvironment_is_fog_transmit_enabled :: MethodBind bindEnvironment_is_fog_transmit_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_fog_transmit_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables fog's light transmission effect. If @true@, light will be more visible in the fog to simulate light scattering as in real life. is_fog_transmit_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_fog_transmit_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_fog_transmit_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_fog_transmit_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_fog_transmit_enabled {-# NOINLINE bindEnvironment_is_glow_bicubic_upscale_enabled #-} -- | Smooths out the blockiness created by sampling higher levels, at the cost of performance. -- __Note:__ When using the GLES2 renderer, this is only available if the GPU supports the @GL_EXT_gpu_shader4@ extension. bindEnvironment_is_glow_bicubic_upscale_enabled :: MethodBind bindEnvironment_is_glow_bicubic_upscale_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_glow_bicubic_upscale_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Smooths out the blockiness created by sampling higher levels, at the cost of performance. -- __Note:__ When using the GLES2 renderer, this is only available if the GPU supports the @GL_EXT_gpu_shader4@ extension. is_glow_bicubic_upscale_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_glow_bicubic_upscale_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_glow_bicubic_upscale_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_glow_bicubic_upscale_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_glow_bicubic_upscale_enabled {-# NOINLINE bindEnvironment_is_glow_enabled #-} -- | If @true@, the glow effect is enabled. bindEnvironment_is_glow_enabled :: MethodBind bindEnvironment_is_glow_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_glow_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the glow effect is enabled. is_glow_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_glow_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_glow_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_glow_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_glow_enabled {-# NOINLINE bindEnvironment_is_glow_level_enabled #-} -- | Returns @true@ if the glow level @idx@ is specified, @false@ otherwise. bindEnvironment_is_glow_level_enabled :: MethodBind bindEnvironment_is_glow_level_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_glow_level_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the glow level @idx@ is specified, @false@ otherwise. is_glow_level_enabled :: (Environment :< cls, Object :< cls) => cls -> Int -> IO Bool is_glow_level_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_glow_level_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_glow_level_enabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.Environment.is_glow_level_enabled {-# NOINLINE bindEnvironment_is_ssao_enabled #-} -- | If @true@, the screen-space ambient occlusion effect is enabled. This darkens objects' corners and cavities to simulate ambient light not reaching the entire object as in real life. This works well for small, dynamic objects, but baked lighting or ambient occlusion textures will do a better job at displaying ambient occlusion on large static objects. This is a costly effect and should be disabled first when running into performance issues. bindEnvironment_is_ssao_enabled :: MethodBind bindEnvironment_is_ssao_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_ssao_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the screen-space ambient occlusion effect is enabled. This darkens objects' corners and cavities to simulate ambient light not reaching the entire object as in real life. This works well for small, dynamic objects, but baked lighting or ambient occlusion textures will do a better job at displaying ambient occlusion on large static objects. This is a costly effect and should be disabled first when running into performance issues. is_ssao_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_ssao_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_ssao_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_ssao_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_ssao_enabled {-# NOINLINE bindEnvironment_is_ssr_enabled #-} -- | If @true@, screen-space reflections are enabled. Screen-space reflections are more accurate than reflections from @GIProbe@s or @ReflectionProbe@s, but are slower and can't reflect surfaces occluded by others. bindEnvironment_is_ssr_enabled :: MethodBind bindEnvironment_is_ssr_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_ssr_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, screen-space reflections are enabled. Screen-space reflections are more accurate than reflections from @GIProbe@s or @ReflectionProbe@s, but are slower and can't reflect surfaces occluded by others. is_ssr_enabled :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_ssr_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_ssr_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_ssr_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_ssr_enabled {-# NOINLINE bindEnvironment_is_ssr_rough #-} -- | If @true@, screen-space reflections will take the material roughness into account. bindEnvironment_is_ssr_rough :: MethodBind bindEnvironment_is_ssr_rough = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "is_ssr_rough" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, screen-space reflections will take the material roughness into account. is_ssr_rough :: (Environment :< cls, Object :< cls) => cls -> IO Bool is_ssr_rough cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_is_ssr_rough (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "is_ssr_rough" '[] (IO Bool) where nodeMethod = Godot.Core.Environment.is_ssr_rough {-# NOINLINE bindEnvironment_set_adjustment_brightness #-} -- | The global brightness value of the rendered scene. Effective only if @adjustment_enabled@ is @true@. bindEnvironment_set_adjustment_brightness :: MethodBind bindEnvironment_set_adjustment_brightness = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_adjustment_brightness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global brightness value of the rendered scene. Effective only if @adjustment_enabled@ is @true@. set_adjustment_brightness :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_adjustment_brightness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_adjustment_brightness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_adjustment_brightness" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_adjustment_brightness {-# NOINLINE bindEnvironment_set_adjustment_color_correction #-} -- | Applies the provided @Texture@ resource to affect the global color aspect of the rendered scene. Effective only if @adjustment_enabled@ is @true@. bindEnvironment_set_adjustment_color_correction :: MethodBind bindEnvironment_set_adjustment_color_correction = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_adjustment_color_correction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies the provided @Texture@ resource to affect the global color aspect of the rendered scene. Effective only if @adjustment_enabled@ is @true@. set_adjustment_color_correction :: (Environment :< cls, Object :< cls) => cls -> Texture -> IO () set_adjustment_color_correction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_adjustment_color_correction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_adjustment_color_correction" '[Texture] (IO ()) where nodeMethod = Godot.Core.Environment.set_adjustment_color_correction {-# NOINLINE bindEnvironment_set_adjustment_contrast #-} -- | The global contrast value of the rendered scene (default value is 1). Effective only if @adjustment_enabled@ is @true@. bindEnvironment_set_adjustment_contrast :: MethodBind bindEnvironment_set_adjustment_contrast = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_adjustment_contrast" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global contrast value of the rendered scene (default value is 1). Effective only if @adjustment_enabled@ is @true@. set_adjustment_contrast :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_adjustment_contrast cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_adjustment_contrast (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_adjustment_contrast" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_adjustment_contrast {-# NOINLINE bindEnvironment_set_adjustment_enable #-} -- | If @true@, enables the @adjustment_*@ properties provided by this resource. If @false@, modifications to the @adjustment_*@ properties will have no effect on the rendered scene. bindEnvironment_set_adjustment_enable :: MethodBind bindEnvironment_set_adjustment_enable = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_adjustment_enable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the @adjustment_*@ properties provided by this resource. If @false@, modifications to the @adjustment_*@ properties will have no effect on the rendered scene. set_adjustment_enable :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_adjustment_enable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_adjustment_enable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_adjustment_enable" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_adjustment_enable {-# NOINLINE bindEnvironment_set_adjustment_saturation #-} -- | The global color saturation value of the rendered scene (default value is 1). Effective only if @adjustment_enabled@ is @true@. bindEnvironment_set_adjustment_saturation :: MethodBind bindEnvironment_set_adjustment_saturation = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_adjustment_saturation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global color saturation value of the rendered scene (default value is 1). Effective only if @adjustment_enabled@ is @true@. set_adjustment_saturation :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_adjustment_saturation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_adjustment_saturation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_adjustment_saturation" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_adjustment_saturation {-# NOINLINE bindEnvironment_set_ambient_light_color #-} -- | The ambient light's @Color@. bindEnvironment_set_ambient_light_color :: MethodBind bindEnvironment_set_ambient_light_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ambient_light_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ambient light's @Color@. set_ambient_light_color :: (Environment :< cls, Object :< cls) => cls -> Color -> IO () set_ambient_light_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ambient_light_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ambient_light_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Environment.set_ambient_light_color {-# NOINLINE bindEnvironment_set_ambient_light_energy #-} -- | The ambient light's energy. The higher the value, the stronger the light. bindEnvironment_set_ambient_light_energy :: MethodBind bindEnvironment_set_ambient_light_energy = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ambient_light_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ambient light's energy. The higher the value, the stronger the light. set_ambient_light_energy :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ambient_light_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ambient_light_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ambient_light_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ambient_light_energy {-# NOINLINE bindEnvironment_set_ambient_light_sky_contribution #-} -- | Defines the amount of light that the sky brings on the scene. A value of 0 means that the sky's light emission has no effect on the scene illumination, thus all ambient illumination is provided by the ambient light. On the contrary, a value of 1 means that all the light that affects the scene is provided by the sky, thus the ambient light parameter has no effect on the scene. bindEnvironment_set_ambient_light_sky_contribution :: MethodBind bindEnvironment_set_ambient_light_sky_contribution = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ambient_light_sky_contribution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the amount of light that the sky brings on the scene. A value of 0 means that the sky's light emission has no effect on the scene illumination, thus all ambient illumination is provided by the ambient light. On the contrary, a value of 1 means that all the light that affects the scene is provided by the sky, thus the ambient light parameter has no effect on the scene. set_ambient_light_sky_contribution :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ambient_light_sky_contribution cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ambient_light_sky_contribution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ambient_light_sky_contribution" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ambient_light_sky_contribution {-# NOINLINE bindEnvironment_set_background #-} -- | The background mode. See @enum BGMode@ for possible values. bindEnvironment_set_background :: MethodBind bindEnvironment_set_background = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_background" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The background mode. See @enum BGMode@ for possible values. set_background :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_background cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_background (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_background" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_background {-# NOINLINE bindEnvironment_set_bg_color #-} -- | The @Color@ displayed for clear areas of the scene. Only effective when using the @BG_COLOR@ or @BG_COLOR_SKY@ background modes). bindEnvironment_set_bg_color :: MethodBind bindEnvironment_set_bg_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Color@ displayed for clear areas of the scene. Only effective when using the @BG_COLOR@ or @BG_COLOR_SKY@ background modes). set_bg_color :: (Environment :< cls, Object :< cls) => cls -> Color -> IO () set_bg_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_bg_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Environment.set_bg_color {-# NOINLINE bindEnvironment_set_bg_energy #-} -- | The power of the light emitted by the background. bindEnvironment_set_bg_energy :: MethodBind bindEnvironment_set_bg_energy = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_bg_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The power of the light emitted by the background. set_bg_energy :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_bg_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_bg_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_bg_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_bg_energy {-# NOINLINE bindEnvironment_set_camera_feed_id #-} -- | The ID of the camera feed to show in the background. bindEnvironment_set_camera_feed_id :: MethodBind bindEnvironment_set_camera_feed_id = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_camera_feed_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ID of the camera feed to show in the background. set_camera_feed_id :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_camera_feed_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_camera_feed_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_camera_feed_id" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_camera_feed_id {-# NOINLINE bindEnvironment_set_canvas_max_layer #-} -- | The maximum layer ID to display. Only effective when using the @BG_CANVAS@ background mode. bindEnvironment_set_canvas_max_layer :: MethodBind bindEnvironment_set_canvas_max_layer = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_canvas_max_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum layer ID to display. Only effective when using the @BG_CANVAS@ background mode. set_canvas_max_layer :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_canvas_max_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_canvas_max_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_canvas_max_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_canvas_max_layer {-# NOINLINE bindEnvironment_set_dof_blur_far_amount #-} -- | The amount of far blur for the depth-of-field effect. bindEnvironment_set_dof_blur_far_amount :: MethodBind bindEnvironment_set_dof_blur_far_amount = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_far_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of far blur for the depth-of-field effect. set_dof_blur_far_amount :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_dof_blur_far_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_far_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_far_amount" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_far_amount {-# NOINLINE bindEnvironment_set_dof_blur_far_distance #-} -- | The distance from the camera where the far blur effect affects the rendering. bindEnvironment_set_dof_blur_far_distance :: MethodBind bindEnvironment_set_dof_blur_far_distance = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_far_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance from the camera where the far blur effect affects the rendering. set_dof_blur_far_distance :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_dof_blur_far_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_far_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_far_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_far_distance {-# NOINLINE bindEnvironment_set_dof_blur_far_enabled #-} -- | If @true@, enables the depth-of-field far blur effect. bindEnvironment_set_dof_blur_far_enabled :: MethodBind bindEnvironment_set_dof_blur_far_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_far_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the depth-of-field far blur effect. set_dof_blur_far_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_dof_blur_far_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_far_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_far_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_far_enabled {-# NOINLINE bindEnvironment_set_dof_blur_far_quality #-} -- | The depth-of-field far blur's quality. Higher values can mitigate the visible banding effect seen at higher strengths, but are much slower. bindEnvironment_set_dof_blur_far_quality :: MethodBind bindEnvironment_set_dof_blur_far_quality = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_far_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The depth-of-field far blur's quality. Higher values can mitigate the visible banding effect seen at higher strengths, but are much slower. set_dof_blur_far_quality :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_dof_blur_far_quality cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_far_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_far_quality" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_far_quality {-# NOINLINE bindEnvironment_set_dof_blur_far_transition #-} -- | The length of the transition between the no-blur area and far blur. bindEnvironment_set_dof_blur_far_transition :: MethodBind bindEnvironment_set_dof_blur_far_transition = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_far_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The length of the transition between the no-blur area and far blur. set_dof_blur_far_transition :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_dof_blur_far_transition cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_far_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_far_transition" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_far_transition {-# NOINLINE bindEnvironment_set_dof_blur_near_amount #-} -- | The amount of near blur for the depth-of-field effect. bindEnvironment_set_dof_blur_near_amount :: MethodBind bindEnvironment_set_dof_blur_near_amount = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_near_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of near blur for the depth-of-field effect. set_dof_blur_near_amount :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_dof_blur_near_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_near_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_near_amount" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_near_amount {-# NOINLINE bindEnvironment_set_dof_blur_near_distance #-} -- | Distance from the camera where the near blur effect affects the rendering. bindEnvironment_set_dof_blur_near_distance :: MethodBind bindEnvironment_set_dof_blur_near_distance = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_near_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance from the camera where the near blur effect affects the rendering. set_dof_blur_near_distance :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_dof_blur_near_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_near_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_near_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_near_distance {-# NOINLINE bindEnvironment_set_dof_blur_near_enabled #-} -- | If @true@, enables the depth-of-field near blur effect. bindEnvironment_set_dof_blur_near_enabled :: MethodBind bindEnvironment_set_dof_blur_near_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_near_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the depth-of-field near blur effect. set_dof_blur_near_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_dof_blur_near_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_near_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_near_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_near_enabled {-# NOINLINE bindEnvironment_set_dof_blur_near_quality #-} -- | The depth-of-field near blur's quality. Higher values can mitigate the visible banding effect seen at higher strengths, but are much slower. bindEnvironment_set_dof_blur_near_quality :: MethodBind bindEnvironment_set_dof_blur_near_quality = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_near_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The depth-of-field near blur's quality. Higher values can mitigate the visible banding effect seen at higher strengths, but are much slower. set_dof_blur_near_quality :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_dof_blur_near_quality cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_near_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_near_quality" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_near_quality {-# NOINLINE bindEnvironment_set_dof_blur_near_transition #-} -- | The length of the transition between the near blur and no-blur area. bindEnvironment_set_dof_blur_near_transition :: MethodBind bindEnvironment_set_dof_blur_near_transition = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_dof_blur_near_transition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The length of the transition between the near blur and no-blur area. set_dof_blur_near_transition :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_dof_blur_near_transition cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_dof_blur_near_transition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_dof_blur_near_transition" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_dof_blur_near_transition {-# NOINLINE bindEnvironment_set_fog_color #-} -- | The fog's @Color@. bindEnvironment_set_fog_color :: MethodBind bindEnvironment_set_fog_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fog's @Color@. set_fog_color :: (Environment :< cls, Object :< cls) => cls -> Color -> IO () set_fog_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_color {-# NOINLINE bindEnvironment_set_fog_depth_begin #-} -- | The fog's depth starting distance from the camera. bindEnvironment_set_fog_depth_begin :: MethodBind bindEnvironment_set_fog_depth_begin = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_depth_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fog's depth starting distance from the camera. set_fog_depth_begin :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_fog_depth_begin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_depth_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_depth_begin" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_depth_begin {-# NOINLINE bindEnvironment_set_fog_depth_curve #-} -- | The fog depth's intensity curve. A number of presets are available in the __Inspector__ by right-clicking the curve. bindEnvironment_set_fog_depth_curve :: MethodBind bindEnvironment_set_fog_depth_curve = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_depth_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fog depth's intensity curve. A number of presets are available in the __Inspector__ by right-clicking the curve. set_fog_depth_curve :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_fog_depth_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_depth_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_depth_curve" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_depth_curve {-# NOINLINE bindEnvironment_set_fog_depth_enabled #-} -- | If @true@, the depth fog effect is enabled. When enabled, fog will appear in the distance (relative to the camera). bindEnvironment_set_fog_depth_enabled :: MethodBind bindEnvironment_set_fog_depth_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_depth_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the depth fog effect is enabled. When enabled, fog will appear in the distance (relative to the camera). set_fog_depth_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_fog_depth_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_depth_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_depth_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_depth_enabled {-# NOINLINE bindEnvironment_set_fog_depth_end #-} -- | The fog's depth end distance from the camera. If this value is set to 0, it will be equal to the current camera's @Camera.far@ value. bindEnvironment_set_fog_depth_end :: MethodBind bindEnvironment_set_fog_depth_end = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_depth_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fog's depth end distance from the camera. If this value is set to 0, it will be equal to the current camera's @Camera.far@ value. set_fog_depth_end :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_fog_depth_end cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_depth_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_depth_end" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_depth_end {-# NOINLINE bindEnvironment_set_fog_enabled #-} -- | If @true@, fog effects are enabled. @fog_height_enabled@ and/or @fog_depth_enabled@ must be set to @true@ to actually display fog. bindEnvironment_set_fog_enabled :: MethodBind bindEnvironment_set_fog_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, fog effects are enabled. @fog_height_enabled@ and/or @fog_depth_enabled@ must be set to @true@ to actually display fog. set_fog_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_fog_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_enabled {-# NOINLINE bindEnvironment_set_fog_height_curve #-} -- | The height fog's intensity. A number of presets are available in the __Inspector__ by right-clicking the curve. bindEnvironment_set_fog_height_curve :: MethodBind bindEnvironment_set_fog_height_curve = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_height_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The height fog's intensity. A number of presets are available in the __Inspector__ by right-clicking the curve. set_fog_height_curve :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_fog_height_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_height_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_height_curve" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_height_curve {-# NOINLINE bindEnvironment_set_fog_height_enabled #-} -- | If @true@, the height fog effect is enabled. When enabled, fog will appear in a defined height range, regardless of the distance from the camera. This can be used to simulate "deep water" effects with a lower performance cost compared to a dedicated shader. bindEnvironment_set_fog_height_enabled :: MethodBind bindEnvironment_set_fog_height_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_height_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the height fog effect is enabled. When enabled, fog will appear in a defined height range, regardless of the distance from the camera. This can be used to simulate "deep water" effects with a lower performance cost compared to a dedicated shader. set_fog_height_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_fog_height_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_height_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_height_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_height_enabled {-# NOINLINE bindEnvironment_set_fog_height_max #-} -- | The Y coordinate where the height fog will be the most intense. If this value is greater than @fog_height_min@, fog will be displayed from bottom to top. Otherwise, it will be displayed from top to bottom. bindEnvironment_set_fog_height_max :: MethodBind bindEnvironment_set_fog_height_max = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_height_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Y coordinate where the height fog will be the most intense. If this value is greater than @fog_height_min@, fog will be displayed from bottom to top. Otherwise, it will be displayed from top to bottom. set_fog_height_max :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_fog_height_max cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_height_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_height_max" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_height_max {-# NOINLINE bindEnvironment_set_fog_height_min #-} -- | The Y coordinate where the height fog will be the least intense. If this value is greater than @fog_height_max@, fog will be displayed from top to bottom. Otherwise, it will be displayed from bottom to top. bindEnvironment_set_fog_height_min :: MethodBind bindEnvironment_set_fog_height_min = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_height_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Y coordinate where the height fog will be the least intense. If this value is greater than @fog_height_max@, fog will be displayed from top to bottom. Otherwise, it will be displayed from bottom to top. set_fog_height_min :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_fog_height_min cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_height_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_height_min" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_height_min {-# NOINLINE bindEnvironment_set_fog_sun_amount #-} -- | The intensity of the depth fog color transition when looking towards the sun. The sun's direction is determined automatically using the DirectionalLight node in the scene. bindEnvironment_set_fog_sun_amount :: MethodBind bindEnvironment_set_fog_sun_amount = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_sun_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The intensity of the depth fog color transition when looking towards the sun. The sun's direction is determined automatically using the DirectionalLight node in the scene. set_fog_sun_amount :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_fog_sun_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_sun_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_sun_amount" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_sun_amount {-# NOINLINE bindEnvironment_set_fog_sun_color #-} -- | The depth fog's @Color@ when looking towards the sun. bindEnvironment_set_fog_sun_color :: MethodBind bindEnvironment_set_fog_sun_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_sun_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The depth fog's @Color@ when looking towards the sun. set_fog_sun_color :: (Environment :< cls, Object :< cls) => cls -> Color -> IO () set_fog_sun_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_sun_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_sun_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_sun_color {-# NOINLINE bindEnvironment_set_fog_transmit_curve #-} -- | The intensity of the fog light transmittance effect. Amount of light that the fog transmits. bindEnvironment_set_fog_transmit_curve :: MethodBind bindEnvironment_set_fog_transmit_curve = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_transmit_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The intensity of the fog light transmittance effect. Amount of light that the fog transmits. set_fog_transmit_curve :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_fog_transmit_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_transmit_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_transmit_curve" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_transmit_curve {-# NOINLINE bindEnvironment_set_fog_transmit_enabled #-} -- | Enables fog's light transmission effect. If @true@, light will be more visible in the fog to simulate light scattering as in real life. bindEnvironment_set_fog_transmit_enabled :: MethodBind bindEnvironment_set_fog_transmit_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_fog_transmit_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables fog's light transmission effect. If @true@, light will be more visible in the fog to simulate light scattering as in real life. set_fog_transmit_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_fog_transmit_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_fog_transmit_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_fog_transmit_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_fog_transmit_enabled {-# NOINLINE bindEnvironment_set_glow_bicubic_upscale #-} -- | Smooths out the blockiness created by sampling higher levels, at the cost of performance. -- __Note:__ When using the GLES2 renderer, this is only available if the GPU supports the @GL_EXT_gpu_shader4@ extension. bindEnvironment_set_glow_bicubic_upscale :: MethodBind bindEnvironment_set_glow_bicubic_upscale = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_bicubic_upscale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Smooths out the blockiness created by sampling higher levels, at the cost of performance. -- __Note:__ When using the GLES2 renderer, this is only available if the GPU supports the @GL_EXT_gpu_shader4@ extension. set_glow_bicubic_upscale :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_glow_bicubic_upscale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_bicubic_upscale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_bicubic_upscale" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_bicubic_upscale {-# NOINLINE bindEnvironment_set_glow_blend_mode #-} -- | The glow blending mode. bindEnvironment_set_glow_blend_mode :: MethodBind bindEnvironment_set_glow_blend_mode = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The glow blending mode. set_glow_blend_mode :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_glow_blend_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_blend_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_blend_mode {-# NOINLINE bindEnvironment_set_glow_bloom #-} -- | The bloom's intensity. If set to a value higher than @0@, this will make glow visible in areas darker than the @glow_hdr_threshold@. bindEnvironment_set_glow_bloom :: MethodBind bindEnvironment_set_glow_bloom = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_bloom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The bloom's intensity. If set to a value higher than @0@, this will make glow visible in areas darker than the @glow_hdr_threshold@. set_glow_bloom :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_glow_bloom cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_bloom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_bloom" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_bloom {-# NOINLINE bindEnvironment_set_glow_enabled #-} -- | If @true@, the glow effect is enabled. bindEnvironment_set_glow_enabled :: MethodBind bindEnvironment_set_glow_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the glow effect is enabled. set_glow_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_glow_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_enabled {-# NOINLINE bindEnvironment_set_glow_hdr_bleed_scale #-} -- | The bleed scale of the HDR glow. bindEnvironment_set_glow_hdr_bleed_scale :: MethodBind bindEnvironment_set_glow_hdr_bleed_scale = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_hdr_bleed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The bleed scale of the HDR glow. set_glow_hdr_bleed_scale :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_glow_hdr_bleed_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_hdr_bleed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_hdr_bleed_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_hdr_bleed_scale {-# NOINLINE bindEnvironment_set_glow_hdr_bleed_threshold #-} -- | The lower threshold of the HDR glow. When using the GLES2 renderer (which doesn't support HDR), this needs to be below @1.0@ for glow to be visible. A value of @0.9@ works well in this case. bindEnvironment_set_glow_hdr_bleed_threshold :: MethodBind bindEnvironment_set_glow_hdr_bleed_threshold = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_hdr_bleed_threshold" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The lower threshold of the HDR glow. When using the GLES2 renderer (which doesn't support HDR), this needs to be below @1.0@ for glow to be visible. A value of @0.9@ works well in this case. set_glow_hdr_bleed_threshold :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_glow_hdr_bleed_threshold cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_hdr_bleed_threshold (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_hdr_bleed_threshold" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_hdr_bleed_threshold {-# NOINLINE bindEnvironment_set_glow_hdr_luminance_cap #-} -- | The higher threshold of the HDR glow. Areas brighter than this threshold will be clamped for the purposes of the glow effect. bindEnvironment_set_glow_hdr_luminance_cap :: MethodBind bindEnvironment_set_glow_hdr_luminance_cap = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_hdr_luminance_cap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The higher threshold of the HDR glow. Areas brighter than this threshold will be clamped for the purposes of the glow effect. set_glow_hdr_luminance_cap :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_glow_hdr_luminance_cap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_hdr_luminance_cap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_hdr_luminance_cap" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_hdr_luminance_cap {-# NOINLINE bindEnvironment_set_glow_intensity #-} -- | The glow intensity. When using the GLES2 renderer, this should be increased to 1.5 to compensate for the lack of HDR rendering. bindEnvironment_set_glow_intensity :: MethodBind bindEnvironment_set_glow_intensity = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_intensity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The glow intensity. When using the GLES2 renderer, this should be increased to 1.5 to compensate for the lack of HDR rendering. set_glow_intensity :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_glow_intensity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_intensity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_intensity" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_intensity {-# NOINLINE bindEnvironment_set_glow_level #-} -- | Enables or disables the glow level at index @idx@. Each level relies on the previous level. This means that enabling higher glow levels will slow down the glow effect rendering, even if previous levels aren't enabled. bindEnvironment_set_glow_level :: MethodBind bindEnvironment_set_glow_level = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_level" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables the glow level at index @idx@. Each level relies on the previous level. This means that enabling higher glow levels will slow down the glow effect rendering, even if previous levels aren't enabled. set_glow_level :: (Environment :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_glow_level cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_level (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_level" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_level {-# NOINLINE bindEnvironment_set_glow_strength #-} -- | The glow strength. When using the GLES2 renderer, this should be increased to 1.3 to compensate for the lack of HDR rendering. bindEnvironment_set_glow_strength :: MethodBind bindEnvironment_set_glow_strength = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_glow_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The glow strength. When using the GLES2 renderer, this should be increased to 1.3 to compensate for the lack of HDR rendering. set_glow_strength :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_glow_strength cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_glow_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_glow_strength" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_glow_strength {-# NOINLINE bindEnvironment_set_sky #-} -- | The @Sky@ resource defined as background. bindEnvironment_set_sky :: MethodBind bindEnvironment_set_sky = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_sky" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource defined as background. set_sky :: (Environment :< cls, Object :< cls) => cls -> Sky -> IO () set_sky cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_sky (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_sky" '[Sky] (IO ()) where nodeMethod = Godot.Core.Environment.set_sky {-# NOINLINE bindEnvironment_set_sky_custom_fov #-} -- | The @Sky@ resource's custom field of view. bindEnvironment_set_sky_custom_fov :: MethodBind bindEnvironment_set_sky_custom_fov = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_sky_custom_fov" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource's custom field of view. set_sky_custom_fov :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_sky_custom_fov cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_sky_custom_fov (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_sky_custom_fov" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_sky_custom_fov {-# NOINLINE bindEnvironment_set_sky_orientation #-} -- | The @Sky@ resource's rotation expressed as a @Basis@. bindEnvironment_set_sky_orientation :: MethodBind bindEnvironment_set_sky_orientation = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_sky_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource's rotation expressed as a @Basis@. set_sky_orientation :: (Environment :< cls, Object :< cls) => cls -> Basis -> IO () set_sky_orientation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_sky_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_sky_orientation" '[Basis] (IO ()) where nodeMethod = Godot.Core.Environment.set_sky_orientation {-# NOINLINE bindEnvironment_set_sky_rotation #-} -- | The @Sky@ resource's rotation expressed as Euler angles in radians. bindEnvironment_set_sky_rotation :: MethodBind bindEnvironment_set_sky_rotation = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_sky_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource's rotation expressed as Euler angles in radians. set_sky_rotation :: (Environment :< cls, Object :< cls) => cls -> Vector3 -> IO () set_sky_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_sky_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_sky_rotation" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Environment.set_sky_rotation {-# NOINLINE bindEnvironment_set_sky_rotation_degrees #-} -- | The @Sky@ resource's rotation expressed as Euler angles in degrees. bindEnvironment_set_sky_rotation_degrees :: MethodBind bindEnvironment_set_sky_rotation_degrees = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_sky_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@ resource's rotation expressed as Euler angles in degrees. set_sky_rotation_degrees :: (Environment :< cls, Object :< cls) => cls -> Vector3 -> IO () set_sky_rotation_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_sky_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_sky_rotation_degrees" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Environment.set_sky_rotation_degrees {-# NOINLINE bindEnvironment_set_ssao_ao_channel_affect #-} -- | The screen-space ambient occlusion intensity on materials that have an AO texture defined. Values higher than @0@ will make the SSAO effect visible in areas darkened by AO textures. bindEnvironment_set_ssao_ao_channel_affect :: MethodBind bindEnvironment_set_ssao_ao_channel_affect = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_ao_channel_affect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion intensity on materials that have an AO texture defined. Values higher than @0@ will make the SSAO effect visible in areas darkened by AO textures. set_ssao_ao_channel_affect :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssao_ao_channel_affect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_ao_channel_affect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_ao_channel_affect" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_ao_channel_affect {-# NOINLINE bindEnvironment_set_ssao_bias #-} -- | The screen-space ambient occlusion bias. This should be kept high enough to prevent "smooth" curves from being affected by ambient occlusion. bindEnvironment_set_ssao_bias :: MethodBind bindEnvironment_set_ssao_bias = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion bias. This should be kept high enough to prevent "smooth" curves from being affected by ambient occlusion. set_ssao_bias :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssao_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_bias" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_bias {-# NOINLINE bindEnvironment_set_ssao_blur #-} -- | The screen-space ambient occlusion blur quality. See @enum SSAOBlur@ for possible values. bindEnvironment_set_ssao_blur :: MethodBind bindEnvironment_set_ssao_blur = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_blur" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion blur quality. See @enum SSAOBlur@ for possible values. set_ssao_blur :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_ssao_blur cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_blur (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_blur" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_blur {-# NOINLINE bindEnvironment_set_ssao_color #-} -- | The screen-space ambient occlusion color. bindEnvironment_set_ssao_color :: MethodBind bindEnvironment_set_ssao_color = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion color. set_ssao_color :: (Environment :< cls, Object :< cls) => cls -> Color -> IO () set_ssao_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_color {-# NOINLINE bindEnvironment_set_ssao_direct_light_affect #-} -- | The screen-space ambient occlusion intensity in direct light. In real life, ambient occlusion only applies to indirect light, which means its effects can't be seen in direct light. Values higher than @0@ will make the SSAO effect visible in direct light. bindEnvironment_set_ssao_direct_light_affect :: MethodBind bindEnvironment_set_ssao_direct_light_affect = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_direct_light_affect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion intensity in direct light. In real life, ambient occlusion only applies to indirect light, which means its effects can't be seen in direct light. Values higher than @0@ will make the SSAO effect visible in direct light. set_ssao_direct_light_affect :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssao_direct_light_affect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_direct_light_affect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_direct_light_affect" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_direct_light_affect {-# NOINLINE bindEnvironment_set_ssao_edge_sharpness #-} -- | The screen-space ambient occlusion edge sharpness. bindEnvironment_set_ssao_edge_sharpness :: MethodBind bindEnvironment_set_ssao_edge_sharpness = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_edge_sharpness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion edge sharpness. set_ssao_edge_sharpness :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssao_edge_sharpness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_edge_sharpness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_edge_sharpness" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_edge_sharpness {-# NOINLINE bindEnvironment_set_ssao_enabled #-} -- | If @true@, the screen-space ambient occlusion effect is enabled. This darkens objects' corners and cavities to simulate ambient light not reaching the entire object as in real life. This works well for small, dynamic objects, but baked lighting or ambient occlusion textures will do a better job at displaying ambient occlusion on large static objects. This is a costly effect and should be disabled first when running into performance issues. bindEnvironment_set_ssao_enabled :: MethodBind bindEnvironment_set_ssao_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the screen-space ambient occlusion effect is enabled. This darkens objects' corners and cavities to simulate ambient light not reaching the entire object as in real life. This works well for small, dynamic objects, but baked lighting or ambient occlusion textures will do a better job at displaying ambient occlusion on large static objects. This is a costly effect and should be disabled first when running into performance issues. set_ssao_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_ssao_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_enabled {-# NOINLINE bindEnvironment_set_ssao_intensity #-} -- | The primary screen-space ambient occlusion intensity. See also @ssao_radius@. bindEnvironment_set_ssao_intensity :: MethodBind bindEnvironment_set_ssao_intensity = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_intensity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The primary screen-space ambient occlusion intensity. See also @ssao_radius@. set_ssao_intensity :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssao_intensity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_intensity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_intensity" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_intensity {-# NOINLINE bindEnvironment_set_ssao_intensity2 #-} -- | The secondary screen-space ambient occlusion intensity. See also @ssao_radius2@. bindEnvironment_set_ssao_intensity2 :: MethodBind bindEnvironment_set_ssao_intensity2 = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_intensity2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The secondary screen-space ambient occlusion intensity. See also @ssao_radius2@. set_ssao_intensity2 :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssao_intensity2 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_intensity2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_intensity2" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_intensity2 {-# NOINLINE bindEnvironment_set_ssao_quality #-} -- | The screen-space ambient occlusion quality. Higher qualities will make better use of small objects for ambient occlusion, but are slower. bindEnvironment_set_ssao_quality :: MethodBind bindEnvironment_set_ssao_quality = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The screen-space ambient occlusion quality. Higher qualities will make better use of small objects for ambient occlusion, but are slower. set_ssao_quality :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_ssao_quality cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_quality" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_quality {-# NOINLINE bindEnvironment_set_ssao_radius #-} -- | The primary screen-space ambient occlusion radius. bindEnvironment_set_ssao_radius :: MethodBind bindEnvironment_set_ssao_radius = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The primary screen-space ambient occlusion radius. set_ssao_radius :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssao_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_radius {-# NOINLINE bindEnvironment_set_ssao_radius2 #-} -- | The secondary screen-space ambient occlusion radius. If set to a value higher than @0@, enables the secondary screen-space ambient occlusion effect which can be used to improve the effect's appearance (at the cost of performance). bindEnvironment_set_ssao_radius2 :: MethodBind bindEnvironment_set_ssao_radius2 = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssao_radius2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The secondary screen-space ambient occlusion radius. If set to a value higher than @0@, enables the secondary screen-space ambient occlusion effect which can be used to improve the effect's appearance (at the cost of performance). set_ssao_radius2 :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssao_radius2 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssao_radius2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssao_radius2" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssao_radius2 {-# NOINLINE bindEnvironment_set_ssr_depth_tolerance #-} -- | The depth tolerance for screen-space reflections. bindEnvironment_set_ssr_depth_tolerance :: MethodBind bindEnvironment_set_ssr_depth_tolerance = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssr_depth_tolerance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The depth tolerance for screen-space reflections. set_ssr_depth_tolerance :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssr_depth_tolerance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssr_depth_tolerance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssr_depth_tolerance" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssr_depth_tolerance {-# NOINLINE bindEnvironment_set_ssr_enabled #-} -- | If @true@, screen-space reflections are enabled. Screen-space reflections are more accurate than reflections from @GIProbe@s or @ReflectionProbe@s, but are slower and can't reflect surfaces occluded by others. bindEnvironment_set_ssr_enabled :: MethodBind bindEnvironment_set_ssr_enabled = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssr_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, screen-space reflections are enabled. Screen-space reflections are more accurate than reflections from @GIProbe@s or @ReflectionProbe@s, but are slower and can't reflect surfaces occluded by others. set_ssr_enabled :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_ssr_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssr_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssr_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssr_enabled {-# NOINLINE bindEnvironment_set_ssr_fade_in #-} -- | The fade-in distance for screen-space reflections. Affects the area from the reflected material to the screen-space reflection). bindEnvironment_set_ssr_fade_in :: MethodBind bindEnvironment_set_ssr_fade_in = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssr_fade_in" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fade-in distance for screen-space reflections. Affects the area from the reflected material to the screen-space reflection). set_ssr_fade_in :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssr_fade_in cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssr_fade_in (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssr_fade_in" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssr_fade_in {-# NOINLINE bindEnvironment_set_ssr_fade_out #-} -- | The fade-out distance for screen-space reflections. Affects the area from the screen-space reflection to the "global" reflection. bindEnvironment_set_ssr_fade_out :: MethodBind bindEnvironment_set_ssr_fade_out = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssr_fade_out" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fade-out distance for screen-space reflections. Affects the area from the screen-space reflection to the "global" reflection. set_ssr_fade_out :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_ssr_fade_out cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssr_fade_out (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssr_fade_out" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssr_fade_out {-# NOINLINE bindEnvironment_set_ssr_max_steps #-} -- | The maximum number of steps for screen-space reflections. Higher values are slower. bindEnvironment_set_ssr_max_steps :: MethodBind bindEnvironment_set_ssr_max_steps = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssr_max_steps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum number of steps for screen-space reflections. Higher values are slower. set_ssr_max_steps :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_ssr_max_steps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssr_max_steps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssr_max_steps" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssr_max_steps {-# NOINLINE bindEnvironment_set_ssr_rough #-} -- | If @true@, screen-space reflections will take the material roughness into account. bindEnvironment_set_ssr_rough :: MethodBind bindEnvironment_set_ssr_rough = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_ssr_rough" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, screen-space reflections will take the material roughness into account. set_ssr_rough :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_ssr_rough cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_ssr_rough (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_ssr_rough" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_ssr_rough {-# NOINLINE bindEnvironment_set_tonemap_auto_exposure #-} -- | If @true@, enables the tonemapping auto exposure mode of the scene renderer. If @true@, the renderer will automatically determine the exposure setting to adapt to the scene's illumination and the observed light. bindEnvironment_set_tonemap_auto_exposure :: MethodBind bindEnvironment_set_tonemap_auto_exposure = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_tonemap_auto_exposure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the tonemapping auto exposure mode of the scene renderer. If @true@, the renderer will automatically determine the exposure setting to adapt to the scene's illumination and the observed light. set_tonemap_auto_exposure :: (Environment :< cls, Object :< cls) => cls -> Bool -> IO () set_tonemap_auto_exposure cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_tonemap_auto_exposure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_tonemap_auto_exposure" '[Bool] (IO ()) where nodeMethod = Godot.Core.Environment.set_tonemap_auto_exposure {-# NOINLINE bindEnvironment_set_tonemap_auto_exposure_grey #-} -- | The scale of the auto exposure effect. Affects the intensity of auto exposure. bindEnvironment_set_tonemap_auto_exposure_grey :: MethodBind bindEnvironment_set_tonemap_auto_exposure_grey = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_tonemap_auto_exposure_grey" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The scale of the auto exposure effect. Affects the intensity of auto exposure. set_tonemap_auto_exposure_grey :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_tonemap_auto_exposure_grey cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_tonemap_auto_exposure_grey (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_tonemap_auto_exposure_grey" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_tonemap_auto_exposure_grey {-# NOINLINE bindEnvironment_set_tonemap_auto_exposure_max #-} -- | The maximum luminance value for the auto exposure. bindEnvironment_set_tonemap_auto_exposure_max :: MethodBind bindEnvironment_set_tonemap_auto_exposure_max = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_tonemap_auto_exposure_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum luminance value for the auto exposure. set_tonemap_auto_exposure_max :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_tonemap_auto_exposure_max cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_tonemap_auto_exposure_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_tonemap_auto_exposure_max" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_tonemap_auto_exposure_max {-# NOINLINE bindEnvironment_set_tonemap_auto_exposure_min #-} -- | The minimum luminance value for the auto exposure. bindEnvironment_set_tonemap_auto_exposure_min :: MethodBind bindEnvironment_set_tonemap_auto_exposure_min = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_tonemap_auto_exposure_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum luminance value for the auto exposure. set_tonemap_auto_exposure_min :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_tonemap_auto_exposure_min cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_tonemap_auto_exposure_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_tonemap_auto_exposure_min" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_tonemap_auto_exposure_min {-# NOINLINE bindEnvironment_set_tonemap_auto_exposure_speed #-} -- | The speed of the auto exposure effect. Affects the time needed for the camera to perform auto exposure. bindEnvironment_set_tonemap_auto_exposure_speed :: MethodBind bindEnvironment_set_tonemap_auto_exposure_speed = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_tonemap_auto_exposure_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The speed of the auto exposure effect. Affects the time needed for the camera to perform auto exposure. set_tonemap_auto_exposure_speed :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_tonemap_auto_exposure_speed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_tonemap_auto_exposure_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_tonemap_auto_exposure_speed" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_tonemap_auto_exposure_speed {-# NOINLINE bindEnvironment_set_tonemap_exposure #-} -- | The default exposure used for tonemapping. bindEnvironment_set_tonemap_exposure :: MethodBind bindEnvironment_set_tonemap_exposure = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_tonemap_exposure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The default exposure used for tonemapping. set_tonemap_exposure :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_tonemap_exposure cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_tonemap_exposure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_tonemap_exposure" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_tonemap_exposure {-# NOINLINE bindEnvironment_set_tonemap_white #-} -- | The white reference value for tonemapping. Only effective if the @tonemap_mode@ isn't set to @TONE_MAPPER_LINEAR@. bindEnvironment_set_tonemap_white :: MethodBind bindEnvironment_set_tonemap_white = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_tonemap_white" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The white reference value for tonemapping. Only effective if the @tonemap_mode@ isn't set to @TONE_MAPPER_LINEAR@. set_tonemap_white :: (Environment :< cls, Object :< cls) => cls -> Float -> IO () set_tonemap_white cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_tonemap_white (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_tonemap_white" '[Float] (IO ()) where nodeMethod = Godot.Core.Environment.set_tonemap_white {-# NOINLINE bindEnvironment_set_tonemapper #-} -- | The tonemapping mode to use. Tonemapping is the process that "converts" HDR values to be suitable for rendering on a LDR display. (Godot doesn't support rendering on HDR displays yet.) bindEnvironment_set_tonemapper :: MethodBind bindEnvironment_set_tonemapper = unsafePerformIO $ withCString "Environment" $ \ clsNamePtr -> withCString "set_tonemapper" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The tonemapping mode to use. Tonemapping is the process that "converts" HDR values to be suitable for rendering on a LDR display. (Godot doesn't support rendering on HDR displays yet.) set_tonemapper :: (Environment :< cls, Object :< cls) => cls -> Int -> IO () set_tonemapper cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEnvironment_set_tonemapper (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Environment "set_tonemapper" '[Int] (IO ()) where nodeMethod = Godot.Core.Environment.set_tonemapper ================================================ FILE: src/Godot/Core/Expression.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Expression (Godot.Core.Expression.execute, Godot.Core.Expression.get_error_text, Godot.Core.Expression.has_execute_failed, Godot.Core.Expression.parse) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindExpression_execute #-} -- | Executes the expression that was previously parsed by @method parse@ and returns the result. Before you use the returned object, you should check if the method failed by calling @method has_execute_failed@. -- If you defined input variables in @method parse@, you can specify their values in the inputs array, in the same order. bindExpression_execute :: MethodBind bindExpression_execute = unsafePerformIO $ withCString "Expression" $ \ clsNamePtr -> withCString "execute" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Executes the expression that was previously parsed by @method parse@ and returns the result. Before you use the returned object, you should check if the method failed by calling @method has_execute_failed@. -- If you defined input variables in @method parse@, you can specify their values in the inputs array, in the same order. execute :: (Expression :< cls, Object :< cls) => cls -> Maybe Array -> Maybe Object -> Maybe Bool -> IO GodotVariant execute cls arg1 arg2 arg3 = withVariantArray [defaultedVariant VariantArray V.empty arg1, maybe VariantNil toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindExpression_execute (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Expression "execute" '[Maybe Array, Maybe Object, Maybe Bool] (IO GodotVariant) where nodeMethod = Godot.Core.Expression.execute {-# NOINLINE bindExpression_get_error_text #-} -- | Returns the error text if @method parse@ has failed. bindExpression_get_error_text :: MethodBind bindExpression_get_error_text = unsafePerformIO $ withCString "Expression" $ \ clsNamePtr -> withCString "get_error_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the error text if @method parse@ has failed. get_error_text :: (Expression :< cls, Object :< cls) => cls -> IO GodotString get_error_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindExpression_get_error_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Expression "get_error_text" '[] (IO GodotString) where nodeMethod = Godot.Core.Expression.get_error_text {-# NOINLINE bindExpression_has_execute_failed #-} -- | Returns @true@ if @method execute@ has failed. bindExpression_has_execute_failed :: MethodBind bindExpression_has_execute_failed = unsafePerformIO $ withCString "Expression" $ \ clsNamePtr -> withCString "has_execute_failed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @method execute@ has failed. has_execute_failed :: (Expression :< cls, Object :< cls) => cls -> IO Bool has_execute_failed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindExpression_has_execute_failed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Expression "has_execute_failed" '[] (IO Bool) where nodeMethod = Godot.Core.Expression.has_execute_failed {-# NOINLINE bindExpression_parse #-} -- | Parses the expression and returns an @enum Error@ code. -- You can optionally specify names of variables that may appear in the expression with @input_names@, so that you can bind them when it gets executed. bindExpression_parse :: MethodBind bindExpression_parse = unsafePerformIO $ withCString "Expression" $ \ clsNamePtr -> withCString "parse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Parses the expression and returns an @enum Error@ code. -- You can optionally specify names of variables that may appear in the expression with @input_names@, so that you can bind them when it gets executed. parse :: (Expression :< cls, Object :< cls) => cls -> GodotString -> Maybe PoolStringArray -> IO Int parse cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantPoolStringArray V.empty arg2] (\ (arrPtr, len) -> godot_method_bind_call bindExpression_parse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Expression "parse" '[GodotString, Maybe PoolStringArray] (IO Int) where nodeMethod = Godot.Core.Expression.parse ================================================ FILE: src/Godot/Core/File.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.File (Godot.Core.File._COMPRESSION_DEFLATE, Godot.Core.File._READ, Godot.Core.File._WRITE, Godot.Core.File._WRITE_READ, Godot.Core.File._READ_WRITE, Godot.Core.File._COMPRESSION_FASTLZ, Godot.Core.File._COMPRESSION_GZIP, Godot.Core.File._COMPRESSION_ZSTD, Godot.Core.File.get_endian_swap, Godot.Core.File.set_endian_swap, Godot.Core.File.close, Godot.Core.File.eof_reached, Godot.Core.File.file_exists, Godot.Core.File.get_16, Godot.Core.File.get_32, Godot.Core.File.get_64, Godot.Core.File.get_8, Godot.Core.File.get_as_text, Godot.Core.File.get_buffer, Godot.Core.File.get_csv_line, Godot.Core.File.get_double, Godot.Core.File.get_error, Godot.Core.File.get_float, Godot.Core.File.get_len, Godot.Core.File.get_line, Godot.Core.File.get_md5, Godot.Core.File.get_modified_time, Godot.Core.File.get_pascal_string, Godot.Core.File.get_path, Godot.Core.File.get_path_absolute, Godot.Core.File.get_position, Godot.Core.File.get_real, Godot.Core.File.get_sha256, Godot.Core.File.get_var, Godot.Core.File.is_open, Godot.Core.File.open, Godot.Core.File.open_compressed, Godot.Core.File.open_encrypted, Godot.Core.File.open_encrypted_with_pass, Godot.Core.File.seek, Godot.Core.File.seek_end, Godot.Core.File.store_16, Godot.Core.File.store_32, Godot.Core.File.store_64, Godot.Core.File.store_8, Godot.Core.File.store_buffer, Godot.Core.File.store_csv_line, Godot.Core.File.store_double, Godot.Core.File.store_float, Godot.Core.File.store_line, Godot.Core.File.store_pascal_string, Godot.Core.File.store_real, Godot.Core.File.store_string, Godot.Core.File.store_var) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _COMPRESSION_DEFLATE :: Int _COMPRESSION_DEFLATE = 1 _READ :: Int _READ = 1 _WRITE :: Int _WRITE = 2 _WRITE_READ :: Int _WRITE_READ = 7 _READ_WRITE :: Int _READ_WRITE = 3 _COMPRESSION_FASTLZ :: Int _COMPRESSION_FASTLZ = 0 _COMPRESSION_GZIP :: Int _COMPRESSION_GZIP = 3 _COMPRESSION_ZSTD :: Int _COMPRESSION_ZSTD = 2 {-# NOINLINE bindFile_get_endian_swap #-} -- | If @true@, the file's endianness is swapped. Use this if you're dealing with files written on big-endian machines. -- __Note:__ This is about the file format, not CPU type. This is always reset to @false@ whenever you open the file. bindFile_get_endian_swap :: MethodBind bindFile_get_endian_swap = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_endian_swap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the file's endianness is swapped. Use this if you're dealing with files written on big-endian machines. -- __Note:__ This is about the file format, not CPU type. This is always reset to @false@ whenever you open the file. get_endian_swap :: (File :< cls, Object :< cls) => cls -> IO Bool get_endian_swap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_endian_swap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_endian_swap" '[] (IO Bool) where nodeMethod = Godot.Core.File.get_endian_swap {-# NOINLINE bindFile_set_endian_swap #-} -- | If @true@, the file's endianness is swapped. Use this if you're dealing with files written on big-endian machines. -- __Note:__ This is about the file format, not CPU type. This is always reset to @false@ whenever you open the file. bindFile_set_endian_swap :: MethodBind bindFile_set_endian_swap = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "set_endian_swap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the file's endianness is swapped. Use this if you're dealing with files written on big-endian machines. -- __Note:__ This is about the file format, not CPU type. This is always reset to @false@ whenever you open the file. set_endian_swap :: (File :< cls, Object :< cls) => cls -> Bool -> IO () set_endian_swap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_set_endian_swap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "set_endian_swap" '[Bool] (IO ()) where nodeMethod = Godot.Core.File.set_endian_swap instance NodeProperty File "endian_swap" Bool 'False where nodeProperty = (get_endian_swap, wrapDroppingSetter set_endian_swap, Nothing) {-# NOINLINE bindFile_close #-} -- | Closes the currently opened file. bindFile_close :: MethodBind bindFile_close = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "close" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Closes the currently opened file. close :: (File :< cls, Object :< cls) => cls -> IO () close cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_close (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "close" '[] (IO ()) where nodeMethod = Godot.Core.File.close {-# NOINLINE bindFile_eof_reached #-} -- | Returns @true@ if the file cursor has read past the end of the file. -- __Note:__ This function will still return @false@ while at the end of the file and only activates when reading past it. This can be confusing but it conforms to how low-level file access works in all operating systems. There is always @method get_len@ and @method get_position@ to implement a custom logic. bindFile_eof_reached :: MethodBind bindFile_eof_reached = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "eof_reached" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the file cursor has read past the end of the file. -- __Note:__ This function will still return @false@ while at the end of the file and only activates when reading past it. This can be confusing but it conforms to how low-level file access works in all operating systems. There is always @method get_len@ and @method get_position@ to implement a custom logic. eof_reached :: (File :< cls, Object :< cls) => cls -> IO Bool eof_reached cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_eof_reached (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "eof_reached" '[] (IO Bool) where nodeMethod = Godot.Core.File.eof_reached {-# NOINLINE bindFile_file_exists #-} -- | Returns @true@ if the file exists in the given path. -- __Note:__ Many resources types are imported (e.g. textures or sound files), and that their source asset will not be included in the exported game, as only the imported version is used (in the @res://.import@ folder). To check for the existence of such resources while taking into account the remapping to their imported location, use @method ResourceLoader.exists@. Typically, using @File.file_exists@ on an imported resource would work while you are developing in the editor (the source asset is present in @res://@, but fail when exported). bindFile_file_exists :: MethodBind bindFile_file_exists = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "file_exists" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the file exists in the given path. -- __Note:__ Many resources types are imported (e.g. textures or sound files), and that their source asset will not be included in the exported game, as only the imported version is used (in the @res://.import@ folder). To check for the existence of such resources while taking into account the remapping to their imported location, use @method ResourceLoader.exists@. Typically, using @File.file_exists@ on an imported resource would work while you are developing in the editor (the source asset is present in @res://@, but fail when exported). file_exists :: (File :< cls, Object :< cls) => cls -> GodotString -> IO Bool file_exists cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_file_exists (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "file_exists" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.File.file_exists {-# NOINLINE bindFile_get_16 #-} -- | Returns the next 16 bits from the file as an integer. See @method store_16@ for details on what values can be stored and retrieved this way. bindFile_get_16 :: MethodBind bindFile_get_16 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_16" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next 16 bits from the file as an integer. See @method store_16@ for details on what values can be stored and retrieved this way. get_16 :: (File :< cls, Object :< cls) => cls -> IO Int get_16 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_16 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_16" '[] (IO Int) where nodeMethod = Godot.Core.File.get_16 {-# NOINLINE bindFile_get_32 #-} -- | Returns the next 32 bits from the file as an integer. See @method store_32@ for details on what values can be stored and retrieved this way. bindFile_get_32 :: MethodBind bindFile_get_32 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_32" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next 32 bits from the file as an integer. See @method store_32@ for details on what values can be stored and retrieved this way. get_32 :: (File :< cls, Object :< cls) => cls -> IO Int get_32 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_32 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_32" '[] (IO Int) where nodeMethod = Godot.Core.File.get_32 {-# NOINLINE bindFile_get_64 #-} -- | Returns the next 64 bits from the file as an integer. See @method store_64@ for details on what values can be stored and retrieved this way. bindFile_get_64 :: MethodBind bindFile_get_64 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next 64 bits from the file as an integer. See @method store_64@ for details on what values can be stored and retrieved this way. get_64 :: (File :< cls, Object :< cls) => cls -> IO Int get_64 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_64" '[] (IO Int) where nodeMethod = Godot.Core.File.get_64 {-# NOINLINE bindFile_get_8 #-} -- | Returns the next 8 bits from the file as an integer. See @method store_8@ for details on what values can be stored and retrieved this way. bindFile_get_8 :: MethodBind bindFile_get_8 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_8" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next 8 bits from the file as an integer. See @method store_8@ for details on what values can be stored and retrieved this way. get_8 :: (File :< cls, Object :< cls) => cls -> IO Int get_8 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_8 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_8" '[] (IO Int) where nodeMethod = Godot.Core.File.get_8 {-# NOINLINE bindFile_get_as_text #-} -- | Returns the whole file as a @String@. -- Text is interpreted as being UTF-8 encoded. bindFile_get_as_text :: MethodBind bindFile_get_as_text = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_as_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the whole file as a @String@. -- Text is interpreted as being UTF-8 encoded. get_as_text :: (File :< cls, Object :< cls) => cls -> IO GodotString get_as_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_as_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_as_text" '[] (IO GodotString) where nodeMethod = Godot.Core.File.get_as_text {-# NOINLINE bindFile_get_buffer #-} -- | Returns next @len@ bytes of the file as a @PoolByteArray@. bindFile_get_buffer :: MethodBind bindFile_get_buffer = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns next @len@ bytes of the file as a @PoolByteArray@. get_buffer :: (File :< cls, Object :< cls) => cls -> Int -> IO PoolByteArray get_buffer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_buffer" '[Int] (IO PoolByteArray) where nodeMethod = Godot.Core.File.get_buffer {-# NOINLINE bindFile_get_csv_line #-} -- | Returns the next value of the file in CSV (Comma-Separated Values) format. You can pass a different delimiter @delim@ to use other than the default @","@ (comma). This delimiter must be one-character long. -- Text is interpreted as being UTF-8 encoded. bindFile_get_csv_line :: MethodBind bindFile_get_csv_line = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_csv_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next value of the file in CSV (Comma-Separated Values) format. You can pass a different delimiter @delim@ to use other than the default @","@ (comma). This delimiter must be one-character long. -- Text is interpreted as being UTF-8 encoded. get_csv_line :: (File :< cls, Object :< cls) => cls -> Maybe GodotString -> IO PoolStringArray get_csv_line cls arg1 = withVariantArray [defaultedVariant VariantString "," arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_csv_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_csv_line" '[Maybe GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.File.get_csv_line {-# NOINLINE bindFile_get_double #-} -- | Returns the next 64 bits from the file as a floating-point number. bindFile_get_double :: MethodBind bindFile_get_double = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_double" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next 64 bits from the file as a floating-point number. get_double :: (File :< cls, Object :< cls) => cls -> IO Float get_double cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_double (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_double" '[] (IO Float) where nodeMethod = Godot.Core.File.get_double {-# NOINLINE bindFile_get_error #-} -- | Returns the last error that happened when trying to perform operations. Compare with the @ERR_FILE_*@ constants from @enum Error@. bindFile_get_error :: MethodBind bindFile_get_error = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the last error that happened when trying to perform operations. Compare with the @ERR_FILE_*@ constants from @enum Error@. get_error :: (File :< cls, Object :< cls) => cls -> IO Int get_error cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_error" '[] (IO Int) where nodeMethod = Godot.Core.File.get_error {-# NOINLINE bindFile_get_float #-} -- | Returns the next 32 bits from the file as a floating-point number. bindFile_get_float :: MethodBind bindFile_get_float = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_float" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next 32 bits from the file as a floating-point number. get_float :: (File :< cls, Object :< cls) => cls -> IO Float get_float cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_float (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_float" '[] (IO Float) where nodeMethod = Godot.Core.File.get_float {-# NOINLINE bindFile_get_len #-} -- | Returns the size of the file in bytes. bindFile_get_len :: MethodBind bindFile_get_len = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_len" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of the file in bytes. get_len :: (File :< cls, Object :< cls) => cls -> IO Int get_len cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_len (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_len" '[] (IO Int) where nodeMethod = Godot.Core.File.get_len {-# NOINLINE bindFile_get_line #-} -- | Returns the next line of the file as a @String@. -- Text is interpreted as being UTF-8 encoded. bindFile_get_line :: MethodBind bindFile_get_line = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next line of the file as a @String@. -- Text is interpreted as being UTF-8 encoded. get_line :: (File :< cls, Object :< cls) => cls -> IO GodotString get_line cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_line" '[] (IO GodotString) where nodeMethod = Godot.Core.File.get_line {-# NOINLINE bindFile_get_md5 #-} -- | Returns an MD5 String representing the file at the given path or an empty @String@ on failure. bindFile_get_md5 :: MethodBind bindFile_get_md5 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_md5" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an MD5 String representing the file at the given path or an empty @String@ on failure. get_md5 :: (File :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_md5 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_md5 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_md5" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.File.get_md5 {-# NOINLINE bindFile_get_modified_time #-} -- | Returns the last time the @file@ was modified in unix timestamp format or returns a @String@ "ERROR IN @file@". This unix timestamp can be converted to datetime by using @method OS.get_datetime_from_unix_time@. bindFile_get_modified_time :: MethodBind bindFile_get_modified_time = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_modified_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the last time the @file@ was modified in unix timestamp format or returns a @String@ "ERROR IN @file@". This unix timestamp can be converted to datetime by using @method OS.get_datetime_from_unix_time@. get_modified_time :: (File :< cls, Object :< cls) => cls -> GodotString -> IO Int get_modified_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_modified_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_modified_time" '[GodotString] (IO Int) where nodeMethod = Godot.Core.File.get_modified_time {-# NOINLINE bindFile_get_pascal_string #-} -- | Returns a @String@ saved in Pascal format from the file. -- Text is interpreted as being UTF-8 encoded. bindFile_get_pascal_string :: MethodBind bindFile_get_pascal_string = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_pascal_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @String@ saved in Pascal format from the file. -- Text is interpreted as being UTF-8 encoded. get_pascal_string :: (File :< cls, Object :< cls) => cls -> IO GodotString get_pascal_string cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_pascal_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_pascal_string" '[] (IO GodotString) where nodeMethod = Godot.Core.File.get_pascal_string {-# NOINLINE bindFile_get_path #-} -- | Returns the path as a @String@ for the current open file. bindFile_get_path :: MethodBind bindFile_get_path = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path as a @String@ for the current open file. get_path :: (File :< cls, Object :< cls) => cls -> IO GodotString get_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_path" '[] (IO GodotString) where nodeMethod = Godot.Core.File.get_path {-# NOINLINE bindFile_get_path_absolute #-} -- | Returns the absolute path as a @String@ for the current open file. bindFile_get_path_absolute :: MethodBind bindFile_get_path_absolute = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_path_absolute" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the absolute path as a @String@ for the current open file. get_path_absolute :: (File :< cls, Object :< cls) => cls -> IO GodotString get_path_absolute cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_path_absolute (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_path_absolute" '[] (IO GodotString) where nodeMethod = Godot.Core.File.get_path_absolute {-# NOINLINE bindFile_get_position #-} -- | Returns the file cursor's position. bindFile_get_position :: MethodBind bindFile_get_position = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the file cursor's position. get_position :: (File :< cls, Object :< cls) => cls -> IO Int get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_position" '[] (IO Int) where nodeMethod = Godot.Core.File.get_position {-# NOINLINE bindFile_get_real #-} -- | Returns the next bits from the file as a floating-point number. bindFile_get_real :: MethodBind bindFile_get_real = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_real" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next bits from the file as a floating-point number. get_real :: (File :< cls, Object :< cls) => cls -> IO Float get_real cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_real (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_real" '[] (IO Float) where nodeMethod = Godot.Core.File.get_real {-# NOINLINE bindFile_get_sha256 #-} -- | Returns a SHA-256 @String@ representing the file at the given path or an empty @String@ on failure. bindFile_get_sha256 :: MethodBind bindFile_get_sha256 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_sha256" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a SHA-256 @String@ representing the file at the given path or an empty @String@ on failure. get_sha256 :: (File :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_sha256 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_sha256 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_sha256" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.File.get_sha256 {-# NOINLINE bindFile_get_var #-} -- | Returns the next @Variant@ value from the file. If @allow_objects@ is @true@, decoding objects is allowed. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. bindFile_get_var :: MethodBind bindFile_get_var = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "get_var" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next @Variant@ value from the file. If @allow_objects@ is @true@, decoding objects is allowed. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. get_var :: (File :< cls, Object :< cls) => cls -> Maybe Bool -> IO GodotVariant get_var cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_get_var (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "get_var" '[Maybe Bool] (IO GodotVariant) where nodeMethod = Godot.Core.File.get_var {-# NOINLINE bindFile_is_open #-} -- | Returns @true@ if the file is currently opened. bindFile_is_open :: MethodBind bindFile_is_open = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "is_open" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the file is currently opened. is_open :: (File :< cls, Object :< cls) => cls -> IO Bool is_open cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFile_is_open (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "is_open" '[] (IO Bool) where nodeMethod = Godot.Core.File.is_open {-# NOINLINE bindFile_open #-} -- | Opens the file for writing or reading, depending on the flags. bindFile_open :: MethodBind bindFile_open = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "open" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opens the file for writing or reading, depending on the flags. open :: (File :< cls, Object :< cls) => cls -> GodotString -> Int -> IO Int open cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindFile_open (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "open" '[GodotString, Int] (IO Int) where nodeMethod = Godot.Core.File.open {-# NOINLINE bindFile_open_compressed #-} -- | Opens a compressed file for reading or writing. bindFile_open_compressed :: MethodBind bindFile_open_compressed = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "open_compressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opens a compressed file for reading or writing. open_compressed :: (File :< cls, Object :< cls) => cls -> GodotString -> Int -> Maybe Int -> IO Int open_compressed cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindFile_open_compressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "open_compressed" '[GodotString, Int, Maybe Int] (IO Int) where nodeMethod = Godot.Core.File.open_compressed {-# NOINLINE bindFile_open_encrypted #-} -- | Opens an encrypted file in write or read mode. You need to pass a binary key to encrypt/decrypt it. -- __Note:__ The provided key must be 32 bytes long. bindFile_open_encrypted :: MethodBind bindFile_open_encrypted = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "open_encrypted" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opens an encrypted file in write or read mode. You need to pass a binary key to encrypt/decrypt it. -- __Note:__ The provided key must be 32 bytes long. open_encrypted :: (File :< cls, Object :< cls) => cls -> GodotString -> Int -> PoolByteArray -> IO Int open_encrypted cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindFile_open_encrypted (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "open_encrypted" '[GodotString, Int, PoolByteArray] (IO Int) where nodeMethod = Godot.Core.File.open_encrypted {-# NOINLINE bindFile_open_encrypted_with_pass #-} -- | Opens an encrypted file in write or read mode. You need to pass a password to encrypt/decrypt it. bindFile_open_encrypted_with_pass :: MethodBind bindFile_open_encrypted_with_pass = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "open_encrypted_with_pass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opens an encrypted file in write or read mode. You need to pass a password to encrypt/decrypt it. open_encrypted_with_pass :: (File :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> IO Int open_encrypted_with_pass cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindFile_open_encrypted_with_pass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "open_encrypted_with_pass" '[GodotString, Int, GodotString] (IO Int) where nodeMethod = Godot.Core.File.open_encrypted_with_pass {-# NOINLINE bindFile_seek #-} -- | Changes the file reading/writing cursor to the specified position (in bytes from the beginning of the file). bindFile_seek :: MethodBind bindFile_seek = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the file reading/writing cursor to the specified position (in bytes from the beginning of the file). seek :: (File :< cls, Object :< cls) => cls -> Int -> IO () seek cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "seek" '[Int] (IO ()) where nodeMethod = Godot.Core.File.seek {-# NOINLINE bindFile_seek_end #-} -- | Changes the file reading/writing cursor to the specified position (in bytes from the end of the file). -- __Note:__ This is an offset, so you should use negative numbers or the cursor will be at the end of the file. bindFile_seek_end :: MethodBind bindFile_seek_end = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "seek_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the file reading/writing cursor to the specified position (in bytes from the end of the file). -- __Note:__ This is an offset, so you should use negative numbers or the cursor will be at the end of the file. seek_end :: (File :< cls, Object :< cls) => cls -> Maybe Int -> IO () seek_end cls arg1 = withVariantArray [maybe (VariantInt (0)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_seek_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "seek_end" '[Maybe Int] (IO ()) where nodeMethod = Godot.Core.File.seek_end {-# NOINLINE bindFile_store_16 #-} -- | Stores an integer as 16 bits in the file. -- __Note:__ The @value@ should lie in the interval @@0, 2^16 - 1@@. Any other value will overflow and wrap around. -- To store a signed integer, use @method store_64@ or store a signed integer from the interval @@-2^15, 2^15 - 1@@ (i.e. keeping one bit for the signedness) and compute its sign manually when reading. For example: -- -- @ -- -- const MAX_15B = 1 << 15 -- const MAX_16B = 1 << 16 -- -- func unsigned16_to_signed(unsigned): -- return (unsigned + MAX_15B) % MAX_16B - MAX_15B -- -- func _ready(): -- var f = File.new() -- f.open("user://file.dat", File.WRITE_READ) -- f.store_16(-42) # This wraps around and stores 65494 (2^16 - 42). -- f.store_16(121) # In bounds, will store 121. -- f.seek(0) # Go back to start to read the stored value. -- var read1 = f.get_16() # 65494 -- var read2 = f.get_16() # 121 -- var converted1 = unsigned16_to_signed(read1) # -42 -- var converted2 = unsigned16_to_signed(read2) # 121 -- -- @ bindFile_store_16 :: MethodBind bindFile_store_16 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_16" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores an integer as 16 bits in the file. -- __Note:__ The @value@ should lie in the interval @@0, 2^16 - 1@@. Any other value will overflow and wrap around. -- To store a signed integer, use @method store_64@ or store a signed integer from the interval @@-2^15, 2^15 - 1@@ (i.e. keeping one bit for the signedness) and compute its sign manually when reading. For example: -- -- @ -- -- const MAX_15B = 1 << 15 -- const MAX_16B = 1 << 16 -- -- func unsigned16_to_signed(unsigned): -- return (unsigned + MAX_15B) % MAX_16B - MAX_15B -- -- func _ready(): -- var f = File.new() -- f.open("user://file.dat", File.WRITE_READ) -- f.store_16(-42) # This wraps around and stores 65494 (2^16 - 42). -- f.store_16(121) # In bounds, will store 121. -- f.seek(0) # Go back to start to read the stored value. -- var read1 = f.get_16() # 65494 -- var read2 = f.get_16() # 121 -- var converted1 = unsigned16_to_signed(read1) # -42 -- var converted2 = unsigned16_to_signed(read2) # 121 -- -- @ store_16 :: (File :< cls, Object :< cls) => cls -> Int -> IO () store_16 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_16 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_16" '[Int] (IO ()) where nodeMethod = Godot.Core.File.store_16 {-# NOINLINE bindFile_store_32 #-} -- | Stores an integer as 32 bits in the file. -- __Note:__ The @value@ should lie in the interval @@0, 2^32 - 1@@. Any other value will overflow and wrap around. -- To store a signed integer, use @method store_64@, or convert it manually (see @method store_16@ for an example). bindFile_store_32 :: MethodBind bindFile_store_32 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_32" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores an integer as 32 bits in the file. -- __Note:__ The @value@ should lie in the interval @@0, 2^32 - 1@@. Any other value will overflow and wrap around. -- To store a signed integer, use @method store_64@, or convert it manually (see @method store_16@ for an example). store_32 :: (File :< cls, Object :< cls) => cls -> Int -> IO () store_32 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_32 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_32" '[Int] (IO ()) where nodeMethod = Godot.Core.File.store_32 {-# NOINLINE bindFile_store_64 #-} -- | Stores an integer as 64 bits in the file. -- __Note:__ The @value@ must lie in the interval @@-2^63, 2^63 - 1@@ (i.e. be a valid @int@ value). bindFile_store_64 :: MethodBind bindFile_store_64 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores an integer as 64 bits in the file. -- __Note:__ The @value@ must lie in the interval @@-2^63, 2^63 - 1@@ (i.e. be a valid @int@ value). store_64 :: (File :< cls, Object :< cls) => cls -> Int -> IO () store_64 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_64" '[Int] (IO ()) where nodeMethod = Godot.Core.File.store_64 {-# NOINLINE bindFile_store_8 #-} -- | Stores an integer as 8 bits in the file. -- __Note:__ The @value@ should lie in the interval @@0, 255@@. Any other value will overflow and wrap around. -- To store a signed integer, use @method store_64@, or convert it manually (see @method store_16@ for an example). bindFile_store_8 :: MethodBind bindFile_store_8 = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_8" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores an integer as 8 bits in the file. -- __Note:__ The @value@ should lie in the interval @@0, 255@@. Any other value will overflow and wrap around. -- To store a signed integer, use @method store_64@, or convert it manually (see @method store_16@ for an example). store_8 :: (File :< cls, Object :< cls) => cls -> Int -> IO () store_8 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_8 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_8" '[Int] (IO ()) where nodeMethod = Godot.Core.File.store_8 {-# NOINLINE bindFile_store_buffer #-} -- | Stores the given array of bytes in the file. bindFile_store_buffer :: MethodBind bindFile_store_buffer = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores the given array of bytes in the file. store_buffer :: (File :< cls, Object :< cls) => cls -> PoolByteArray -> IO () store_buffer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_buffer" '[PoolByteArray] (IO ()) where nodeMethod = Godot.Core.File.store_buffer {-# NOINLINE bindFile_store_csv_line #-} -- | Store the given @PoolStringArray@ in the file as a line formatted in the CSV (Comma-Separated Values) format. You can pass a different delimiter @delim@ to use other than the default @","@ (comma). This delimiter must be one-character long. -- Text will be encoded as UTF-8. bindFile_store_csv_line :: MethodBind bindFile_store_csv_line = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_csv_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Store the given @PoolStringArray@ in the file as a line formatted in the CSV (Comma-Separated Values) format. You can pass a different delimiter @delim@ to use other than the default @","@ (comma). This delimiter must be one-character long. -- Text will be encoded as UTF-8. store_csv_line :: (File :< cls, Object :< cls) => cls -> PoolStringArray -> Maybe GodotString -> IO () store_csv_line cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "," arg2] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_csv_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_csv_line" '[PoolStringArray, Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.File.store_csv_line {-# NOINLINE bindFile_store_double #-} -- | Stores a floating-point number as 64 bits in the file. bindFile_store_double :: MethodBind bindFile_store_double = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_double" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores a floating-point number as 64 bits in the file. store_double :: (File :< cls, Object :< cls) => cls -> Float -> IO () store_double cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_double (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_double" '[Float] (IO ()) where nodeMethod = Godot.Core.File.store_double {-# NOINLINE bindFile_store_float #-} -- | Stores a floating-point number as 32 bits in the file. bindFile_store_float :: MethodBind bindFile_store_float = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_float" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores a floating-point number as 32 bits in the file. store_float :: (File :< cls, Object :< cls) => cls -> Float -> IO () store_float cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_float (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_float" '[Float] (IO ()) where nodeMethod = Godot.Core.File.store_float {-# NOINLINE bindFile_store_line #-} -- | Stores the given @String@ as a line in the file. -- Text will be encoded as UTF-8. bindFile_store_line :: MethodBind bindFile_store_line = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores the given @String@ as a line in the file. -- Text will be encoded as UTF-8. store_line :: (File :< cls, Object :< cls) => cls -> GodotString -> IO () store_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_line" '[GodotString] (IO ()) where nodeMethod = Godot.Core.File.store_line {-# NOINLINE bindFile_store_pascal_string #-} -- | Stores the given @String@ as a line in the file in Pascal format (i.e. also store the length of the string). -- Text will be encoded as UTF-8. bindFile_store_pascal_string :: MethodBind bindFile_store_pascal_string = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_pascal_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores the given @String@ as a line in the file in Pascal format (i.e. also store the length of the string). -- Text will be encoded as UTF-8. store_pascal_string :: (File :< cls, Object :< cls) => cls -> GodotString -> IO () store_pascal_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_pascal_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_pascal_string" '[GodotString] (IO ()) where nodeMethod = Godot.Core.File.store_pascal_string {-# NOINLINE bindFile_store_real #-} -- | Stores a floating-point number in the file. bindFile_store_real :: MethodBind bindFile_store_real = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_real" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores a floating-point number in the file. store_real :: (File :< cls, Object :< cls) => cls -> Float -> IO () store_real cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_real (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_real" '[Float] (IO ()) where nodeMethod = Godot.Core.File.store_real {-# NOINLINE bindFile_store_string #-} -- | Stores the given @String@ in the file. -- Text will be encoded as UTF-8. bindFile_store_string :: MethodBind bindFile_store_string = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores the given @String@ in the file. -- Text will be encoded as UTF-8. store_string :: (File :< cls, Object :< cls) => cls -> GodotString -> IO () store_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_string" '[GodotString] (IO ()) where nodeMethod = Godot.Core.File.store_string {-# NOINLINE bindFile_store_var #-} -- | Stores any Variant value in the file. If @full_objects@ is @true@, encoding objects is allowed (and can potentially include code). bindFile_store_var :: MethodBind bindFile_store_var = unsafePerformIO $ withCString "_File" $ \ clsNamePtr -> withCString "store_var" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stores any Variant value in the file. If @full_objects@ is @true@, encoding objects is allowed (and can potentially include code). store_var :: (File :< cls, Object :< cls) => cls -> GodotVariant -> Maybe Bool -> IO () store_var cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindFile_store_var (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod File "store_var" '[GodotVariant, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.File.store_var ================================================ FILE: src/Godot/Core/FileDialog.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.FileDialog (Godot.Core.FileDialog._ACCESS_RESOURCES, Godot.Core.FileDialog._MODE_OPEN_FILES, Godot.Core.FileDialog._MODE_OPEN_FILE, Godot.Core.FileDialog._MODE_SAVE_FILE, Godot.Core.FileDialog._ACCESS_USERDATA, Godot.Core.FileDialog._ACCESS_FILESYSTEM, Godot.Core.FileDialog._MODE_OPEN_DIR, Godot.Core.FileDialog._MODE_OPEN_ANY, Godot.Core.FileDialog.sig_dir_selected, Godot.Core.FileDialog.sig_file_selected, Godot.Core.FileDialog.sig_files_selected, Godot.Core.FileDialog._action_pressed, Godot.Core.FileDialog._cancel_pressed, Godot.Core.FileDialog._dir_entered, Godot.Core.FileDialog._file_entered, Godot.Core.FileDialog._filter_selected, Godot.Core.FileDialog._go_up, Godot.Core.FileDialog._make_dir, Godot.Core.FileDialog._make_dir_confirm, Godot.Core.FileDialog._save_confirm_pressed, Godot.Core.FileDialog._select_drive, Godot.Core.FileDialog._tree_item_activated, Godot.Core.FileDialog._tree_multi_selected, Godot.Core.FileDialog._tree_selected, Godot.Core.FileDialog._unhandled_input, Godot.Core.FileDialog._update_dir, Godot.Core.FileDialog._update_file_list, Godot.Core.FileDialog._update_file_name, Godot.Core.FileDialog.add_filter, Godot.Core.FileDialog.clear_filters, Godot.Core.FileDialog.deselect_items, Godot.Core.FileDialog.get_access, Godot.Core.FileDialog.get_current_dir, Godot.Core.FileDialog.get_current_file, Godot.Core.FileDialog.get_current_path, Godot.Core.FileDialog.get_filters, Godot.Core.FileDialog.get_line_edit, Godot.Core.FileDialog.get_mode, Godot.Core.FileDialog.get_vbox, Godot.Core.FileDialog.invalidate, Godot.Core.FileDialog.is_mode_overriding_title, Godot.Core.FileDialog.is_showing_hidden_files, Godot.Core.FileDialog.set_access, Godot.Core.FileDialog.set_current_dir, Godot.Core.FileDialog.set_current_file, Godot.Core.FileDialog.set_current_path, Godot.Core.FileDialog.set_filters, Godot.Core.FileDialog.set_mode, Godot.Core.FileDialog.set_mode_overrides_title, Godot.Core.FileDialog.set_show_hidden_files) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ConfirmationDialog() _ACCESS_RESOURCES :: Int _ACCESS_RESOURCES = 0 _MODE_OPEN_FILES :: Int _MODE_OPEN_FILES = 1 _MODE_OPEN_FILE :: Int _MODE_OPEN_FILE = 0 _MODE_SAVE_FILE :: Int _MODE_SAVE_FILE = 4 _ACCESS_USERDATA :: Int _ACCESS_USERDATA = 1 _ACCESS_FILESYSTEM :: Int _ACCESS_FILESYSTEM = 2 _MODE_OPEN_DIR :: Int _MODE_OPEN_DIR = 2 _MODE_OPEN_ANY :: Int _MODE_OPEN_ANY = 3 -- | Emitted when the user selects a directory. sig_dir_selected :: Godot.Internal.Dispatch.Signal FileDialog sig_dir_selected = Godot.Internal.Dispatch.Signal "dir_selected" instance NodeSignal FileDialog "dir_selected" '[GodotString] -- | Emitted when the user selects a file by double-clicking it or pressing the __OK__ button. sig_file_selected :: Godot.Internal.Dispatch.Signal FileDialog sig_file_selected = Godot.Internal.Dispatch.Signal "file_selected" instance NodeSignal FileDialog "file_selected" '[GodotString] -- | Emitted when the user selects multiple files. sig_files_selected :: Godot.Internal.Dispatch.Signal FileDialog sig_files_selected = Godot.Internal.Dispatch.Signal "files_selected" instance NodeSignal FileDialog "files_selected" '[PoolStringArray] instance NodeProperty FileDialog "access" Int 'False where nodeProperty = (get_access, wrapDroppingSetter set_access, Nothing) instance NodeProperty FileDialog "current_dir" GodotString 'False where nodeProperty = (get_current_dir, wrapDroppingSetter set_current_dir, Nothing) instance NodeProperty FileDialog "current_file" GodotString 'False where nodeProperty = (get_current_file, wrapDroppingSetter set_current_file, Nothing) instance NodeProperty FileDialog "current_path" GodotString 'False where nodeProperty = (get_current_path, wrapDroppingSetter set_current_path, Nothing) instance NodeProperty FileDialog "filters" PoolStringArray 'False where nodeProperty = (get_filters, wrapDroppingSetter set_filters, Nothing) instance NodeProperty FileDialog "mode" Int 'False where nodeProperty = (get_mode, wrapDroppingSetter set_mode, Nothing) instance NodeProperty FileDialog "mode_overrides_title" Bool 'False where nodeProperty = (is_mode_overriding_title, wrapDroppingSetter set_mode_overrides_title, Nothing) instance NodeProperty FileDialog "show_hidden_files" Bool 'False where nodeProperty = (is_showing_hidden_files, wrapDroppingSetter set_show_hidden_files, Nothing) {-# NOINLINE bindFileDialog__action_pressed #-} bindFileDialog__action_pressed :: MethodBind bindFileDialog__action_pressed = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_action_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _action_pressed :: (FileDialog :< cls, Object :< cls) => cls -> IO () _action_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__action_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_action_pressed" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._action_pressed {-# NOINLINE bindFileDialog__cancel_pressed #-} bindFileDialog__cancel_pressed :: MethodBind bindFileDialog__cancel_pressed = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_cancel_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _cancel_pressed :: (FileDialog :< cls, Object :< cls) => cls -> IO () _cancel_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__cancel_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_cancel_pressed" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._cancel_pressed {-# NOINLINE bindFileDialog__dir_entered #-} bindFileDialog__dir_entered :: MethodBind bindFileDialog__dir_entered = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_dir_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _dir_entered :: (FileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _dir_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__dir_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_dir_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Core.FileDialog._dir_entered {-# NOINLINE bindFileDialog__file_entered #-} bindFileDialog__file_entered :: MethodBind bindFileDialog__file_entered = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_file_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _file_entered :: (FileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _file_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__file_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_file_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Core.FileDialog._file_entered {-# NOINLINE bindFileDialog__filter_selected #-} bindFileDialog__filter_selected :: MethodBind bindFileDialog__filter_selected = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_filter_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _filter_selected :: (FileDialog :< cls, Object :< cls) => cls -> Int -> IO () _filter_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__filter_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_filter_selected" '[Int] (IO ()) where nodeMethod = Godot.Core.FileDialog._filter_selected {-# NOINLINE bindFileDialog__go_up #-} bindFileDialog__go_up :: MethodBind bindFileDialog__go_up = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_go_up" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _go_up :: (FileDialog :< cls, Object :< cls) => cls -> IO () _go_up cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__go_up (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_go_up" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._go_up {-# NOINLINE bindFileDialog__make_dir #-} bindFileDialog__make_dir :: MethodBind bindFileDialog__make_dir = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_make_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _make_dir :: (FileDialog :< cls, Object :< cls) => cls -> IO () _make_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__make_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_make_dir" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._make_dir {-# NOINLINE bindFileDialog__make_dir_confirm #-} bindFileDialog__make_dir_confirm :: MethodBind bindFileDialog__make_dir_confirm = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_make_dir_confirm" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _make_dir_confirm :: (FileDialog :< cls, Object :< cls) => cls -> IO () _make_dir_confirm cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__make_dir_confirm (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_make_dir_confirm" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._make_dir_confirm {-# NOINLINE bindFileDialog__save_confirm_pressed #-} bindFileDialog__save_confirm_pressed :: MethodBind bindFileDialog__save_confirm_pressed = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_save_confirm_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _save_confirm_pressed :: (FileDialog :< cls, Object :< cls) => cls -> IO () _save_confirm_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__save_confirm_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_save_confirm_pressed" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._save_confirm_pressed {-# NOINLINE bindFileDialog__select_drive #-} bindFileDialog__select_drive :: MethodBind bindFileDialog__select_drive = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_select_drive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _select_drive :: (FileDialog :< cls, Object :< cls) => cls -> Int -> IO () _select_drive cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__select_drive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_select_drive" '[Int] (IO ()) where nodeMethod = Godot.Core.FileDialog._select_drive {-# NOINLINE bindFileDialog__tree_item_activated #-} bindFileDialog__tree_item_activated :: MethodBind bindFileDialog__tree_item_activated = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_tree_item_activated" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_item_activated :: (FileDialog :< cls, Object :< cls) => cls -> IO () _tree_item_activated cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__tree_item_activated (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_tree_item_activated" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._tree_item_activated {-# NOINLINE bindFileDialog__tree_multi_selected #-} bindFileDialog__tree_multi_selected :: MethodBind bindFileDialog__tree_multi_selected = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_tree_multi_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_multi_selected :: (FileDialog :< cls, Object :< cls) => cls -> Object -> Int -> Bool -> IO () _tree_multi_selected cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__tree_multi_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_tree_multi_selected" '[Object, Int, Bool] (IO ()) where nodeMethod = Godot.Core.FileDialog._tree_multi_selected {-# NOINLINE bindFileDialog__tree_selected #-} bindFileDialog__tree_selected :: MethodBind bindFileDialog__tree_selected = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_tree_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_selected :: (FileDialog :< cls, Object :< cls) => cls -> IO () _tree_selected cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__tree_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_tree_selected" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._tree_selected {-# NOINLINE bindFileDialog__unhandled_input #-} bindFileDialog__unhandled_input :: MethodBind bindFileDialog__unhandled_input = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _unhandled_input :: (FileDialog :< cls, Object :< cls) => cls -> InputEvent -> IO () _unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_unhandled_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.FileDialog._unhandled_input {-# NOINLINE bindFileDialog__update_dir #-} bindFileDialog__update_dir :: MethodBind bindFileDialog__update_dir = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_update_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_dir :: (FileDialog :< cls, Object :< cls) => cls -> IO () _update_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__update_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_update_dir" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._update_dir {-# NOINLINE bindFileDialog__update_file_list #-} bindFileDialog__update_file_list :: MethodBind bindFileDialog__update_file_list = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_update_file_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_file_list :: (FileDialog :< cls, Object :< cls) => cls -> IO () _update_file_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__update_file_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_update_file_list" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._update_file_list {-# NOINLINE bindFileDialog__update_file_name #-} bindFileDialog__update_file_name :: MethodBind bindFileDialog__update_file_name = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "_update_file_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_file_name :: (FileDialog :< cls, Object :< cls) => cls -> IO () _update_file_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog__update_file_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "_update_file_name" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog._update_file_name {-# NOINLINE bindFileDialog_add_filter #-} -- | Adds @filter@ as a custom filter; @filter@ should be of the form @"filename.extension ; Description"@. For example, @"*.png ; PNG Images"@. bindFileDialog_add_filter :: MethodBind bindFileDialog_add_filter = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "add_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds @filter@ as a custom filter; @filter@ should be of the form @"filename.extension ; Description"@. For example, @"*.png ; PNG Images"@. add_filter :: (FileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () add_filter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_add_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "add_filter" '[GodotString] (IO ()) where nodeMethod = Godot.Core.FileDialog.add_filter {-# NOINLINE bindFileDialog_clear_filters #-} -- | Clear all the added filters in the dialog. bindFileDialog_clear_filters :: MethodBind bindFileDialog_clear_filters = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "clear_filters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear all the added filters in the dialog. clear_filters :: (FileDialog :< cls, Object :< cls) => cls -> IO () clear_filters cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_clear_filters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "clear_filters" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog.clear_filters {-# NOINLINE bindFileDialog_deselect_items #-} -- | Clear currently selected items in the dialog. bindFileDialog_deselect_items :: MethodBind bindFileDialog_deselect_items = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "deselect_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear currently selected items in the dialog. deselect_items :: (FileDialog :< cls, Object :< cls) => cls -> IO () deselect_items cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_deselect_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "deselect_items" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog.deselect_items {-# NOINLINE bindFileDialog_get_access #-} -- | The file system access scope. See enum @Access@ constants. -- __Warning:__ Currently, in sandboxed environments such as HTML5 builds or sandboxed macOS apps, FileDialog cannot access the host file system. See @url=https://github.com/godotengine/godot-proposals/issues/1123@godot-proposals#1123@/url@. bindFileDialog_get_access :: MethodBind bindFileDialog_get_access = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "get_access" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The file system access scope. See enum @Access@ constants. -- __Warning:__ Currently, in sandboxed environments such as HTML5 builds or sandboxed macOS apps, FileDialog cannot access the host file system. See @url=https://github.com/godotengine/godot-proposals/issues/1123@godot-proposals#1123@/url@. get_access :: (FileDialog :< cls, Object :< cls) => cls -> IO Int get_access cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_get_access (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "get_access" '[] (IO Int) where nodeMethod = Godot.Core.FileDialog.get_access {-# NOINLINE bindFileDialog_get_current_dir #-} -- | The current working directory of the file dialog. bindFileDialog_get_current_dir :: MethodBind bindFileDialog_get_current_dir = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "get_current_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current working directory of the file dialog. get_current_dir :: (FileDialog :< cls, Object :< cls) => cls -> IO GodotString get_current_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_get_current_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "get_current_dir" '[] (IO GodotString) where nodeMethod = Godot.Core.FileDialog.get_current_dir {-# NOINLINE bindFileDialog_get_current_file #-} -- | The currently selected file of the file dialog. bindFileDialog_get_current_file :: MethodBind bindFileDialog_get_current_file = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "get_current_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected file of the file dialog. get_current_file :: (FileDialog :< cls, Object :< cls) => cls -> IO GodotString get_current_file cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_get_current_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "get_current_file" '[] (IO GodotString) where nodeMethod = Godot.Core.FileDialog.get_current_file {-# NOINLINE bindFileDialog_get_current_path #-} -- | The currently selected file path of the file dialog. bindFileDialog_get_current_path :: MethodBind bindFileDialog_get_current_path = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "get_current_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected file path of the file dialog. get_current_path :: (FileDialog :< cls, Object :< cls) => cls -> IO GodotString get_current_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_get_current_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "get_current_path" '[] (IO GodotString) where nodeMethod = Godot.Core.FileDialog.get_current_path {-# NOINLINE bindFileDialog_get_filters #-} -- | The available file type filters. For example, this shows only @.png@ and @.gd@ files: @set_filters(PoolStringArray(@"*.png ; PNG Images","*.gd ; GDScript Files"@))@. bindFileDialog_get_filters :: MethodBind bindFileDialog_get_filters = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "get_filters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The available file type filters. For example, this shows only @.png@ and @.gd@ files: @set_filters(PoolStringArray(@"*.png ; PNG Images","*.gd ; GDScript Files"@))@. get_filters :: (FileDialog :< cls, Object :< cls) => cls -> IO PoolStringArray get_filters cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_get_filters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "get_filters" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.FileDialog.get_filters {-# NOINLINE bindFileDialog_get_line_edit #-} -- | Returns the LineEdit for the selected file. bindFileDialog_get_line_edit :: MethodBind bindFileDialog_get_line_edit = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "get_line_edit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the LineEdit for the selected file. get_line_edit :: (FileDialog :< cls, Object :< cls) => cls -> IO LineEdit get_line_edit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_get_line_edit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "get_line_edit" '[] (IO LineEdit) where nodeMethod = Godot.Core.FileDialog.get_line_edit {-# NOINLINE bindFileDialog_get_mode #-} -- | The dialog's open or save mode, which affects the selection behavior. See enum @Mode@ constants. bindFileDialog_get_mode :: MethodBind bindFileDialog_get_mode = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The dialog's open or save mode, which affects the selection behavior. See enum @Mode@ constants. get_mode :: (FileDialog :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "get_mode" '[] (IO Int) where nodeMethod = Godot.Core.FileDialog.get_mode {-# NOINLINE bindFileDialog_get_vbox #-} -- | Returns the vertical box container of the dialog, custom controls can be added to it. bindFileDialog_get_vbox :: MethodBind bindFileDialog_get_vbox = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "get_vbox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the vertical box container of the dialog, custom controls can be added to it. get_vbox :: (FileDialog :< cls, Object :< cls) => cls -> IO VBoxContainer get_vbox cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_get_vbox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "get_vbox" '[] (IO VBoxContainer) where nodeMethod = Godot.Core.FileDialog.get_vbox {-# NOINLINE bindFileDialog_invalidate #-} -- | Invalidate and update the current dialog content list. bindFileDialog_invalidate :: MethodBind bindFileDialog_invalidate = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "invalidate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Invalidate and update the current dialog content list. invalidate :: (FileDialog :< cls, Object :< cls) => cls -> IO () invalidate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_invalidate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "invalidate" '[] (IO ()) where nodeMethod = Godot.Core.FileDialog.invalidate {-# NOINLINE bindFileDialog_is_mode_overriding_title #-} -- | If @true@, changing the @Mode@ property will set the window title accordingly (e.g. setting mode to @MODE_OPEN_FILE@ will change the window title to "Open a File"). bindFileDialog_is_mode_overriding_title :: MethodBind bindFileDialog_is_mode_overriding_title = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "is_mode_overriding_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, changing the @Mode@ property will set the window title accordingly (e.g. setting mode to @MODE_OPEN_FILE@ will change the window title to "Open a File"). is_mode_overriding_title :: (FileDialog :< cls, Object :< cls) => cls -> IO Bool is_mode_overriding_title cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_is_mode_overriding_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "is_mode_overriding_title" '[] (IO Bool) where nodeMethod = Godot.Core.FileDialog.is_mode_overriding_title {-# NOINLINE bindFileDialog_is_showing_hidden_files #-} -- | If @true@, the dialog will show hidden files. bindFileDialog_is_showing_hidden_files :: MethodBind bindFileDialog_is_showing_hidden_files = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "is_showing_hidden_files" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the dialog will show hidden files. is_showing_hidden_files :: (FileDialog :< cls, Object :< cls) => cls -> IO Bool is_showing_hidden_files cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_is_showing_hidden_files (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "is_showing_hidden_files" '[] (IO Bool) where nodeMethod = Godot.Core.FileDialog.is_showing_hidden_files {-# NOINLINE bindFileDialog_set_access #-} -- | The file system access scope. See enum @Access@ constants. -- __Warning:__ Currently, in sandboxed environments such as HTML5 builds or sandboxed macOS apps, FileDialog cannot access the host file system. See @url=https://github.com/godotengine/godot-proposals/issues/1123@godot-proposals#1123@/url@. bindFileDialog_set_access :: MethodBind bindFileDialog_set_access = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "set_access" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The file system access scope. See enum @Access@ constants. -- __Warning:__ Currently, in sandboxed environments such as HTML5 builds or sandboxed macOS apps, FileDialog cannot access the host file system. See @url=https://github.com/godotengine/godot-proposals/issues/1123@godot-proposals#1123@/url@. set_access :: (FileDialog :< cls, Object :< cls) => cls -> Int -> IO () set_access cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_set_access (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "set_access" '[Int] (IO ()) where nodeMethod = Godot.Core.FileDialog.set_access {-# NOINLINE bindFileDialog_set_current_dir #-} -- | The current working directory of the file dialog. bindFileDialog_set_current_dir :: MethodBind bindFileDialog_set_current_dir = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "set_current_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current working directory of the file dialog. set_current_dir :: (FileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () set_current_dir cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_set_current_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "set_current_dir" '[GodotString] (IO ()) where nodeMethod = Godot.Core.FileDialog.set_current_dir {-# NOINLINE bindFileDialog_set_current_file #-} -- | The currently selected file of the file dialog. bindFileDialog_set_current_file :: MethodBind bindFileDialog_set_current_file = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "set_current_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected file of the file dialog. set_current_file :: (FileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () set_current_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_set_current_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "set_current_file" '[GodotString] (IO ()) where nodeMethod = Godot.Core.FileDialog.set_current_file {-# NOINLINE bindFileDialog_set_current_path #-} -- | The currently selected file path of the file dialog. bindFileDialog_set_current_path :: MethodBind bindFileDialog_set_current_path = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "set_current_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected file path of the file dialog. set_current_path :: (FileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () set_current_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_set_current_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "set_current_path" '[GodotString] (IO ()) where nodeMethod = Godot.Core.FileDialog.set_current_path {-# NOINLINE bindFileDialog_set_filters #-} -- | The available file type filters. For example, this shows only @.png@ and @.gd@ files: @set_filters(PoolStringArray(@"*.png ; PNG Images","*.gd ; GDScript Files"@))@. bindFileDialog_set_filters :: MethodBind bindFileDialog_set_filters = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "set_filters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The available file type filters. For example, this shows only @.png@ and @.gd@ files: @set_filters(PoolStringArray(@"*.png ; PNG Images","*.gd ; GDScript Files"@))@. set_filters :: (FileDialog :< cls, Object :< cls) => cls -> PoolStringArray -> IO () set_filters cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_set_filters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "set_filters" '[PoolStringArray] (IO ()) where nodeMethod = Godot.Core.FileDialog.set_filters {-# NOINLINE bindFileDialog_set_mode #-} -- | The dialog's open or save mode, which affects the selection behavior. See enum @Mode@ constants. bindFileDialog_set_mode :: MethodBind bindFileDialog_set_mode = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The dialog's open or save mode, which affects the selection behavior. See enum @Mode@ constants. set_mode :: (FileDialog :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.FileDialog.set_mode {-# NOINLINE bindFileDialog_set_mode_overrides_title #-} -- | If @true@, changing the @Mode@ property will set the window title accordingly (e.g. setting mode to @MODE_OPEN_FILE@ will change the window title to "Open a File"). bindFileDialog_set_mode_overrides_title :: MethodBind bindFileDialog_set_mode_overrides_title = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "set_mode_overrides_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, changing the @Mode@ property will set the window title accordingly (e.g. setting mode to @MODE_OPEN_FILE@ will change the window title to "Open a File"). set_mode_overrides_title :: (FileDialog :< cls, Object :< cls) => cls -> Bool -> IO () set_mode_overrides_title cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_set_mode_overrides_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "set_mode_overrides_title" '[Bool] (IO ()) where nodeMethod = Godot.Core.FileDialog.set_mode_overrides_title {-# NOINLINE bindFileDialog_set_show_hidden_files #-} -- | If @true@, the dialog will show hidden files. bindFileDialog_set_show_hidden_files :: MethodBind bindFileDialog_set_show_hidden_files = unsafePerformIO $ withCString "FileDialog" $ \ clsNamePtr -> withCString "set_show_hidden_files" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the dialog will show hidden files. set_show_hidden_files :: (FileDialog :< cls, Object :< cls) => cls -> Bool -> IO () set_show_hidden_files cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFileDialog_set_show_hidden_files (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FileDialog "set_show_hidden_files" '[Bool] (IO ()) where nodeMethod = Godot.Core.FileDialog.set_show_hidden_files ================================================ FILE: src/Godot/Core/Font.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Font (Godot.Core.Font.draw, Godot.Core.Font.draw_char, Godot.Core.Font.get_ascent, Godot.Core.Font.get_descent, Godot.Core.Font.get_height, Godot.Core.Font.get_string_size, Godot.Core.Font.get_wordwrap_string_size, Godot.Core.Font.has_outline, Godot.Core.Font.is_distance_field_hint, Godot.Core.Font.update_changes) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindFont_draw #-} -- | Draw @string@ into a canvas item using the font at a given position, with @modulate@ color, and optionally clipping the width. @position@ specifies the baseline, not the top. To draw from the top, @i@ascent@/i@ must be added to the Y axis. -- See also @method CanvasItem.draw_string@. bindFont_draw :: MethodBind bindFont_draw = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draw @string@ into a canvas item using the font at a given position, with @modulate@ color, and optionally clipping the width. @position@ specifies the baseline, not the top. To draw from the top, @i@ascent@/i@ must be added to the Y axis. -- See also @method CanvasItem.draw_string@. draw :: (Font :< cls, Object :< cls) => cls -> Rid -> Vector2 -> GodotString -> Maybe Color -> Maybe Int -> Maybe Color -> IO () draw cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4, maybe (VariantInt (-1)) toVariant arg5, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg6] (\ (arrPtr, len) -> godot_method_bind_call bindFont_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "draw" '[Rid, Vector2, GodotString, Maybe Color, Maybe Int, Maybe Color] (IO ()) where nodeMethod = Godot.Core.Font.draw {-# NOINLINE bindFont_draw_char #-} -- | Draw character @char@ into a canvas item using the font at a given position, with @modulate@ color, and optionally kerning if @next@ is passed. clipping the width. @position@ specifies the baseline, not the top. To draw from the top, @i@ascent@/i@ must be added to the Y axis. The width used by the character is returned, making this function useful for drawing strings character by character. bindFont_draw_char :: MethodBind bindFont_draw_char = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "draw_char" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draw character @char@ into a canvas item using the font at a given position, with @modulate@ color, and optionally kerning if @next@ is passed. clipping the width. @position@ specifies the baseline, not the top. To draw from the top, @i@ascent@/i@ must be added to the Y axis. The width used by the character is returned, making this function useful for drawing strings character by character. draw_char :: (Font :< cls, Object :< cls) => cls -> Rid -> Vector2 -> Int -> Maybe Int -> Maybe Color -> Maybe Bool -> IO Float draw_char cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantInt (-1)) toVariant arg4, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg5, maybe (VariantBool False) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindFont_draw_char (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "draw_char" '[Rid, Vector2, Int, Maybe Int, Maybe Color, Maybe Bool] (IO Float) where nodeMethod = Godot.Core.Font.draw_char {-# NOINLINE bindFont_get_ascent #-} -- | Returns the font ascent (number of pixels above the baseline). bindFont_get_ascent :: MethodBind bindFont_get_ascent = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "get_ascent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the font ascent (number of pixels above the baseline). get_ascent :: (Font :< cls, Object :< cls) => cls -> IO Float get_ascent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFont_get_ascent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "get_ascent" '[] (IO Float) where nodeMethod = Godot.Core.Font.get_ascent {-# NOINLINE bindFont_get_descent #-} -- | Returns the font descent (number of pixels below the baseline). bindFont_get_descent :: MethodBind bindFont_get_descent = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "get_descent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the font descent (number of pixels below the baseline). get_descent :: (Font :< cls, Object :< cls) => cls -> IO Float get_descent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFont_get_descent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "get_descent" '[] (IO Float) where nodeMethod = Godot.Core.Font.get_descent {-# NOINLINE bindFont_get_height #-} -- | Returns the total font height (ascent plus descent) in pixels. bindFont_get_height :: MethodBind bindFont_get_height = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total font height (ascent plus descent) in pixels. get_height :: (Font :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFont_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "get_height" '[] (IO Float) where nodeMethod = Godot.Core.Font.get_height {-# NOINLINE bindFont_get_string_size #-} -- | Returns the size of a string, taking kerning and advance into account. bindFont_get_string_size :: MethodBind bindFont_get_string_size = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "get_string_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of a string, taking kerning and advance into account. get_string_size :: (Font :< cls, Object :< cls) => cls -> GodotString -> IO Vector2 get_string_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFont_get_string_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "get_string_size" '[GodotString] (IO Vector2) where nodeMethod = Godot.Core.Font.get_string_size {-# NOINLINE bindFont_get_wordwrap_string_size #-} -- | Returns the size that the string would have with word wrapping enabled with a fixed @width@. bindFont_get_wordwrap_string_size :: MethodBind bindFont_get_wordwrap_string_size = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "get_wordwrap_string_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size that the string would have with word wrapping enabled with a fixed @width@. get_wordwrap_string_size :: (Font :< cls, Object :< cls) => cls -> GodotString -> Float -> IO Vector2 get_wordwrap_string_size cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindFont_get_wordwrap_string_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "get_wordwrap_string_size" '[GodotString, Float] (IO Vector2) where nodeMethod = Godot.Core.Font.get_wordwrap_string_size {-# NOINLINE bindFont_has_outline #-} -- | Returns @true@ if the font has an outline. bindFont_has_outline :: MethodBind bindFont_has_outline = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "has_outline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the font has an outline. has_outline :: (Font :< cls, Object :< cls) => cls -> IO Bool has_outline cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFont_has_outline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "has_outline" '[] (IO Bool) where nodeMethod = Godot.Core.Font.has_outline {-# NOINLINE bindFont_is_distance_field_hint #-} bindFont_is_distance_field_hint :: MethodBind bindFont_is_distance_field_hint = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "is_distance_field_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_distance_field_hint :: (Font :< cls, Object :< cls) => cls -> IO Bool is_distance_field_hint cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFont_is_distance_field_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "is_distance_field_hint" '[] (IO Bool) where nodeMethod = Godot.Core.Font.is_distance_field_hint {-# NOINLINE bindFont_update_changes #-} -- | After editing a font (changing size, ascent, char rects, etc.). Call this function to propagate changes to controls that might use it. bindFont_update_changes :: MethodBind bindFont_update_changes = unsafePerformIO $ withCString "Font" $ \ clsNamePtr -> withCString "update_changes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | After editing a font (changing size, ascent, char rects, etc.). Call this function to propagate changes to controls that might use it. update_changes :: (Font :< cls, Object :< cls) => cls -> IO () update_changes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFont_update_changes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Font "update_changes" '[] (IO ()) where nodeMethod = Godot.Core.Font.update_changes ================================================ FILE: src/Godot/Core/FuncRef.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.FuncRef (Godot.Core.FuncRef.call_func, Godot.Core.FuncRef.call_funcv, Godot.Core.FuncRef.is_valid, Godot.Core.FuncRef.set_function, Godot.Core.FuncRef.set_instance) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindFuncRef_call_func #-} -- | Calls the referenced function previously set by @method set_function@ or @method @GDScript.funcref@. bindFuncRef_call_func :: MethodBind bindFuncRef_call_func = unsafePerformIO $ withCString "FuncRef" $ \ clsNamePtr -> withCString "call_func" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the referenced function previously set by @method set_function@ or @method @GDScript.funcref@. call_func :: (FuncRef :< cls, Object :< cls) => cls -> [Variant 'GodotTy] -> IO GodotVariant call_func cls varargs = withVariantArray ([] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindFuncRef_call_func (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FuncRef "call_func" '[[Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.FuncRef.call_func {-# NOINLINE bindFuncRef_call_funcv #-} -- | Calls the referenced function previously set by @method set_function@ or @method @GDScript.funcref@. Contrarily to @method call_func@, this method does not support a variable number of arguments but expects all parameters to be passed via a single @Array@. bindFuncRef_call_funcv :: MethodBind bindFuncRef_call_funcv = unsafePerformIO $ withCString "FuncRef" $ \ clsNamePtr -> withCString "call_funcv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the referenced function previously set by @method set_function@ or @method @GDScript.funcref@. Contrarily to @method call_func@, this method does not support a variable number of arguments but expects all parameters to be passed via a single @Array@. call_funcv :: (FuncRef :< cls, Object :< cls) => cls -> Array -> IO GodotVariant call_funcv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFuncRef_call_funcv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FuncRef "call_funcv" '[Array] (IO GodotVariant) where nodeMethod = Godot.Core.FuncRef.call_funcv {-# NOINLINE bindFuncRef_is_valid #-} -- | Returns whether the object still exists and has the function assigned. bindFuncRef_is_valid :: MethodBind bindFuncRef_is_valid = unsafePerformIO $ withCString "FuncRef" $ \ clsNamePtr -> withCString "is_valid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the object still exists and has the function assigned. is_valid :: (FuncRef :< cls, Object :< cls) => cls -> IO Bool is_valid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindFuncRef_is_valid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FuncRef "is_valid" '[] (IO Bool) where nodeMethod = Godot.Core.FuncRef.is_valid {-# NOINLINE bindFuncRef_set_function #-} -- | The name of the referenced function to call on the object, without parentheses or any parameters. bindFuncRef_set_function :: MethodBind bindFuncRef_set_function = unsafePerformIO $ withCString "FuncRef" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the referenced function to call on the object, without parentheses or any parameters. set_function :: (FuncRef :< cls, Object :< cls) => cls -> GodotString -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFuncRef_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FuncRef "set_function" '[GodotString] (IO ()) where nodeMethod = Godot.Core.FuncRef.set_function {-# NOINLINE bindFuncRef_set_instance #-} -- | The object containing the referenced function. This object must be of a type actually inheriting from @Object@, not a built-in type such as @int@, @Vector2@ or @Dictionary@. bindFuncRef_set_instance :: MethodBind bindFuncRef_set_instance = unsafePerformIO $ withCString "FuncRef" $ \ clsNamePtr -> withCString "set_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The object containing the referenced function. This object must be of a type actually inheriting from @Object@, not a built-in type such as @int@, @Vector2@ or @Dictionary@. set_instance :: (FuncRef :< cls, Object :< cls) => cls -> Object -> IO () set_instance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindFuncRef_set_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod FuncRef "set_instance" '[Object] (IO ()) where nodeMethod = Godot.Core.FuncRef.set_instance ================================================ FILE: src/Godot/Core/GDNative.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GDNative (Godot.Core.GDNative.call_native, Godot.Core.GDNative.get_library, Godot.Core.GDNative.initialize, Godot.Core.GDNative.set_library, Godot.Core.GDNative.terminate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty GDNative "library" GDNativeLibrary 'False where nodeProperty = (get_library, wrapDroppingSetter set_library, Nothing) {-# NOINLINE bindGDNative_call_native #-} bindGDNative_call_native :: MethodBind bindGDNative_call_native = unsafePerformIO $ withCString "GDNative" $ \ clsNamePtr -> withCString "call_native" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr call_native :: (GDNative :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Array -> IO GodotVariant call_native cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGDNative_call_native (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNative "call_native" '[GodotString, GodotString, Array] (IO GodotVariant) where nodeMethod = Godot.Core.GDNative.call_native {-# NOINLINE bindGDNative_get_library #-} bindGDNative_get_library :: MethodBind bindGDNative_get_library = unsafePerformIO $ withCString "GDNative" $ \ clsNamePtr -> withCString "get_library" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_library :: (GDNative :< cls, Object :< cls) => cls -> IO GDNativeLibrary get_library cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNative_get_library (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNative "get_library" '[] (IO GDNativeLibrary) where nodeMethod = Godot.Core.GDNative.get_library {-# NOINLINE bindGDNative_initialize #-} bindGDNative_initialize :: MethodBind bindGDNative_initialize = unsafePerformIO $ withCString "GDNative" $ \ clsNamePtr -> withCString "initialize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr initialize :: (GDNative :< cls, Object :< cls) => cls -> IO Bool initialize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNative_initialize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNative "initialize" '[] (IO Bool) where nodeMethod = Godot.Core.GDNative.initialize {-# NOINLINE bindGDNative_set_library #-} bindGDNative_set_library :: MethodBind bindGDNative_set_library = unsafePerformIO $ withCString "GDNative" $ \ clsNamePtr -> withCString "set_library" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_library :: (GDNative :< cls, Object :< cls) => cls -> GDNativeLibrary -> IO () set_library cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGDNative_set_library (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNative "set_library" '[GDNativeLibrary] (IO ()) where nodeMethod = Godot.Core.GDNative.set_library {-# NOINLINE bindGDNative_terminate #-} bindGDNative_terminate :: MethodBind bindGDNative_terminate = unsafePerformIO $ withCString "GDNative" $ \ clsNamePtr -> withCString "terminate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr terminate :: (GDNative :< cls, Object :< cls) => cls -> IO Bool terminate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNative_terminate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNative "terminate" '[] (IO Bool) where nodeMethod = Godot.Core.GDNative.terminate ================================================ FILE: src/Godot/Core/GDNativeLibrary.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GDNativeLibrary (Godot.Core.GDNativeLibrary.get_config_file, Godot.Core.GDNativeLibrary.get_current_dependencies, Godot.Core.GDNativeLibrary.get_current_library_path, Godot.Core.GDNativeLibrary.get_symbol_prefix, Godot.Core.GDNativeLibrary.is_reloadable, Godot.Core.GDNativeLibrary.is_singleton, Godot.Core.GDNativeLibrary.set_config_file, Godot.Core.GDNativeLibrary.set_load_once, Godot.Core.GDNativeLibrary.set_reloadable, Godot.Core.GDNativeLibrary.set_singleton, Godot.Core.GDNativeLibrary.set_symbol_prefix, Godot.Core.GDNativeLibrary.should_load_once) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty GDNativeLibrary "config_file" ConfigFile 'False where nodeProperty = (get_config_file, wrapDroppingSetter set_config_file, Nothing) instance NodeProperty GDNativeLibrary "load_once" Bool 'False where nodeProperty = (should_load_once, wrapDroppingSetter set_load_once, Nothing) instance NodeProperty GDNativeLibrary "reloadable" Bool 'False where nodeProperty = (is_reloadable, wrapDroppingSetter set_reloadable, Nothing) instance NodeProperty GDNativeLibrary "singleton" Bool 'False where nodeProperty = (is_singleton, wrapDroppingSetter set_singleton, Nothing) instance NodeProperty GDNativeLibrary "symbol_prefix" GodotString 'False where nodeProperty = (get_symbol_prefix, wrapDroppingSetter set_symbol_prefix, Nothing) {-# NOINLINE bindGDNativeLibrary_get_config_file #-} bindGDNativeLibrary_get_config_file :: MethodBind bindGDNativeLibrary_get_config_file = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "get_config_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_config_file :: (GDNativeLibrary :< cls, Object :< cls) => cls -> IO ConfigFile get_config_file cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_get_config_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "get_config_file" '[] (IO ConfigFile) where nodeMethod = Godot.Core.GDNativeLibrary.get_config_file {-# NOINLINE bindGDNativeLibrary_get_current_dependencies #-} bindGDNativeLibrary_get_current_dependencies :: MethodBind bindGDNativeLibrary_get_current_dependencies = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "get_current_dependencies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_current_dependencies :: (GDNativeLibrary :< cls, Object :< cls) => cls -> IO PoolStringArray get_current_dependencies cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_get_current_dependencies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "get_current_dependencies" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.GDNativeLibrary.get_current_dependencies {-# NOINLINE bindGDNativeLibrary_get_current_library_path #-} bindGDNativeLibrary_get_current_library_path :: MethodBind bindGDNativeLibrary_get_current_library_path = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "get_current_library_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_current_library_path :: (GDNativeLibrary :< cls, Object :< cls) => cls -> IO GodotString get_current_library_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_get_current_library_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "get_current_library_path" '[] (IO GodotString) where nodeMethod = Godot.Core.GDNativeLibrary.get_current_library_path {-# NOINLINE bindGDNativeLibrary_get_symbol_prefix #-} bindGDNativeLibrary_get_symbol_prefix :: MethodBind bindGDNativeLibrary_get_symbol_prefix = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "get_symbol_prefix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_symbol_prefix :: (GDNativeLibrary :< cls, Object :< cls) => cls -> IO GodotString get_symbol_prefix cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_get_symbol_prefix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "get_symbol_prefix" '[] (IO GodotString) where nodeMethod = Godot.Core.GDNativeLibrary.get_symbol_prefix {-# NOINLINE bindGDNativeLibrary_is_reloadable #-} bindGDNativeLibrary_is_reloadable :: MethodBind bindGDNativeLibrary_is_reloadable = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "is_reloadable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_reloadable :: (GDNativeLibrary :< cls, Object :< cls) => cls -> IO Bool is_reloadable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_is_reloadable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "is_reloadable" '[] (IO Bool) where nodeMethod = Godot.Core.GDNativeLibrary.is_reloadable {-# NOINLINE bindGDNativeLibrary_is_singleton #-} bindGDNativeLibrary_is_singleton :: MethodBind bindGDNativeLibrary_is_singleton = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "is_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_singleton :: (GDNativeLibrary :< cls, Object :< cls) => cls -> IO Bool is_singleton cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_is_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "is_singleton" '[] (IO Bool) where nodeMethod = Godot.Core.GDNativeLibrary.is_singleton {-# NOINLINE bindGDNativeLibrary_set_config_file #-} bindGDNativeLibrary_set_config_file :: MethodBind bindGDNativeLibrary_set_config_file = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "set_config_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_config_file :: (GDNativeLibrary :< cls, Object :< cls) => cls -> ConfigFile -> IO () set_config_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_set_config_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "set_config_file" '[ConfigFile] (IO ()) where nodeMethod = Godot.Core.GDNativeLibrary.set_config_file {-# NOINLINE bindGDNativeLibrary_set_load_once #-} bindGDNativeLibrary_set_load_once :: MethodBind bindGDNativeLibrary_set_load_once = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "set_load_once" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_load_once :: (GDNativeLibrary :< cls, Object :< cls) => cls -> Bool -> IO () set_load_once cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_set_load_once (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "set_load_once" '[Bool] (IO ()) where nodeMethod = Godot.Core.GDNativeLibrary.set_load_once {-# NOINLINE bindGDNativeLibrary_set_reloadable #-} bindGDNativeLibrary_set_reloadable :: MethodBind bindGDNativeLibrary_set_reloadable = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "set_reloadable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_reloadable :: (GDNativeLibrary :< cls, Object :< cls) => cls -> Bool -> IO () set_reloadable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_set_reloadable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "set_reloadable" '[Bool] (IO ()) where nodeMethod = Godot.Core.GDNativeLibrary.set_reloadable {-# NOINLINE bindGDNativeLibrary_set_singleton #-} bindGDNativeLibrary_set_singleton :: MethodBind bindGDNativeLibrary_set_singleton = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "set_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_singleton :: (GDNativeLibrary :< cls, Object :< cls) => cls -> Bool -> IO () set_singleton cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_set_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "set_singleton" '[Bool] (IO ()) where nodeMethod = Godot.Core.GDNativeLibrary.set_singleton {-# NOINLINE bindGDNativeLibrary_set_symbol_prefix #-} bindGDNativeLibrary_set_symbol_prefix :: MethodBind bindGDNativeLibrary_set_symbol_prefix = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "set_symbol_prefix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_symbol_prefix :: (GDNativeLibrary :< cls, Object :< cls) => cls -> GodotString -> IO () set_symbol_prefix cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_set_symbol_prefix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "set_symbol_prefix" '[GodotString] (IO ()) where nodeMethod = Godot.Core.GDNativeLibrary.set_symbol_prefix {-# NOINLINE bindGDNativeLibrary_should_load_once #-} bindGDNativeLibrary_should_load_once :: MethodBind bindGDNativeLibrary_should_load_once = unsafePerformIO $ withCString "GDNativeLibrary" $ \ clsNamePtr -> withCString "should_load_once" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr should_load_once :: (GDNativeLibrary :< cls, Object :< cls) => cls -> IO Bool should_load_once cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDNativeLibrary_should_load_once (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDNativeLibrary "should_load_once" '[] (IO Bool) where nodeMethod = Godot.Core.GDNativeLibrary.should_load_once ================================================ FILE: src/Godot/Core/GDScript.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GDScript (Godot.Core.GDScript.get_as_byte_code, Godot.Core.GDScript.new) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Script() {-# NOINLINE bindGDScript_get_as_byte_code #-} bindGDScript_get_as_byte_code :: MethodBind bindGDScript_get_as_byte_code = unsafePerformIO $ withCString "GDScript" $ \ clsNamePtr -> withCString "get_as_byte_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_as_byte_code :: (GDScript :< cls, Object :< cls) => cls -> IO PoolByteArray get_as_byte_code cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGDScript_get_as_byte_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDScript "get_as_byte_code" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.GDScript.get_as_byte_code {-# NOINLINE bindGDScript_new #-} bindGDScript_new :: MethodBind bindGDScript_new = unsafePerformIO $ withCString "GDScript" $ \ clsNamePtr -> withCString "new" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr new :: (GDScript :< cls, Object :< cls) => cls -> [Variant 'GodotTy] -> IO GodotVariant new cls varargs = withVariantArray ([] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindGDScript_new (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDScript "new" '[[Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.GDScript.new ================================================ FILE: src/Godot/Core/GDScriptFunctionState.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GDScriptFunctionState (Godot.Core.GDScriptFunctionState.sig_completed, Godot.Core.GDScriptFunctionState._signal_callback, Godot.Core.GDScriptFunctionState.is_valid, Godot.Core.GDScriptFunctionState.resume) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() sig_completed :: Godot.Internal.Dispatch.Signal GDScriptFunctionState sig_completed = Godot.Internal.Dispatch.Signal "completed" instance NodeSignal GDScriptFunctionState "completed" '[GodotVariant] {-# NOINLINE bindGDScriptFunctionState__signal_callback #-} bindGDScriptFunctionState__signal_callback :: MethodBind bindGDScriptFunctionState__signal_callback = unsafePerformIO $ withCString "GDScriptFunctionState" $ \ clsNamePtr -> withCString "_signal_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _signal_callback :: (GDScriptFunctionState :< cls, Object :< cls) => cls -> [Variant 'GodotTy] -> IO GodotVariant _signal_callback cls varargs = withVariantArray ([] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindGDScriptFunctionState__signal_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDScriptFunctionState "_signal_callback" '[[Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.GDScriptFunctionState._signal_callback {-# NOINLINE bindGDScriptFunctionState_is_valid #-} bindGDScriptFunctionState_is_valid :: MethodBind bindGDScriptFunctionState_is_valid = unsafePerformIO $ withCString "GDScriptFunctionState" $ \ clsNamePtr -> withCString "is_valid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_valid :: (GDScriptFunctionState :< cls, Object :< cls) => cls -> Maybe Bool -> IO Bool is_valid cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGDScriptFunctionState_is_valid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDScriptFunctionState "is_valid" '[Maybe Bool] (IO Bool) where nodeMethod = Godot.Core.GDScriptFunctionState.is_valid {-# NOINLINE bindGDScriptFunctionState_resume #-} bindGDScriptFunctionState_resume :: MethodBind bindGDScriptFunctionState_resume = unsafePerformIO $ withCString "GDScriptFunctionState" $ \ clsNamePtr -> withCString "resume" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr resume :: (GDScriptFunctionState :< cls, Object :< cls) => cls -> Maybe GodotVariant -> IO GodotVariant resume cls arg1 = withVariantArray [maybe VariantNil toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGDScriptFunctionState_resume (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GDScriptFunctionState "resume" '[Maybe GodotVariant] (IO GodotVariant) where nodeMethod = Godot.Core.GDScriptFunctionState.resume ================================================ FILE: src/Godot/Core/GIProbe.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GIProbe (Godot.Core.GIProbe._SUBDIV_64, Godot.Core.GIProbe._SUBDIV_256, Godot.Core.GIProbe._SUBDIV_MAX, Godot.Core.GIProbe._SUBDIV_128, Godot.Core.GIProbe._SUBDIV_512, Godot.Core.GIProbe.bake, Godot.Core.GIProbe.debug_bake, Godot.Core.GIProbe.get_bias, Godot.Core.GIProbe.get_dynamic_range, Godot.Core.GIProbe.get_energy, Godot.Core.GIProbe.get_extents, Godot.Core.GIProbe.get_normal_bias, Godot.Core.GIProbe.get_probe_data, Godot.Core.GIProbe.get_propagation, Godot.Core.GIProbe.get_subdiv, Godot.Core.GIProbe.is_compressed, Godot.Core.GIProbe.is_interior, Godot.Core.GIProbe.set_bias, Godot.Core.GIProbe.set_compress, Godot.Core.GIProbe.set_dynamic_range, Godot.Core.GIProbe.set_energy, Godot.Core.GIProbe.set_extents, Godot.Core.GIProbe.set_interior, Godot.Core.GIProbe.set_normal_bias, Godot.Core.GIProbe.set_probe_data, Godot.Core.GIProbe.set_propagation, Godot.Core.GIProbe.set_subdiv) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualInstance() _SUBDIV_64 :: Int _SUBDIV_64 = 0 _SUBDIV_256 :: Int _SUBDIV_256 = 2 _SUBDIV_MAX :: Int _SUBDIV_MAX = 4 _SUBDIV_128 :: Int _SUBDIV_128 = 1 _SUBDIV_512 :: Int _SUBDIV_512 = 3 instance NodeProperty GIProbe "bias" Float 'False where nodeProperty = (get_bias, wrapDroppingSetter set_bias, Nothing) instance NodeProperty GIProbe "compress" Bool 'False where nodeProperty = (is_compressed, wrapDroppingSetter set_compress, Nothing) instance NodeProperty GIProbe "data" GIProbeData 'False where nodeProperty = (get_probe_data, wrapDroppingSetter set_probe_data, Nothing) instance NodeProperty GIProbe "dynamic_range" Int 'False where nodeProperty = (get_dynamic_range, wrapDroppingSetter set_dynamic_range, Nothing) instance NodeProperty GIProbe "energy" Float 'False where nodeProperty = (get_energy, wrapDroppingSetter set_energy, Nothing) instance NodeProperty GIProbe "extents" Vector3 'False where nodeProperty = (get_extents, wrapDroppingSetter set_extents, Nothing) instance NodeProperty GIProbe "interior" Bool 'False where nodeProperty = (is_interior, wrapDroppingSetter set_interior, Nothing) instance NodeProperty GIProbe "normal_bias" Float 'False where nodeProperty = (get_normal_bias, wrapDroppingSetter set_normal_bias, Nothing) instance NodeProperty GIProbe "propagation" Float 'False where nodeProperty = (get_propagation, wrapDroppingSetter set_propagation, Nothing) instance NodeProperty GIProbe "subdiv" Int 'False where nodeProperty = (get_subdiv, wrapDroppingSetter set_subdiv, Nothing) {-# NOINLINE bindGIProbe_bake #-} -- | Bakes the effect from all @GeometryInstance@s marked with @GeometryInstance.use_in_baked_light@ and @Light@s marked with either @Light.BAKE_INDIRECT@ or @Light.BAKE_ALL@. If @create_visual_debug@ is @true@, after baking the light, this will generate a @MultiMesh@ that has a cube representing each solid cell with each cube colored to the cell's albedo color. This can be used to visualize the @GIProbe@'s data and debug any issues that may be occurring. bindGIProbe_bake :: MethodBind bindGIProbe_bake = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "bake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bakes the effect from all @GeometryInstance@s marked with @GeometryInstance.use_in_baked_light@ and @Light@s marked with either @Light.BAKE_INDIRECT@ or @Light.BAKE_ALL@. If @create_visual_debug@ is @true@, after baking the light, this will generate a @MultiMesh@ that has a cube representing each solid cell with each cube colored to the cell's albedo color. This can be used to visualize the @GIProbe@'s data and debug any issues that may be occurring. bake :: (GIProbe :< cls, Object :< cls) => cls -> Maybe Node -> Maybe Bool -> IO () bake cls arg1 arg2 = withVariantArray [maybe VariantNil toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_bake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "bake" '[Maybe Node, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.GIProbe.bake {-# NOINLINE bindGIProbe_debug_bake #-} -- | Calls @method bake@ with @create_visual_debug@ enabled. bindGIProbe_debug_bake :: MethodBind bindGIProbe_debug_bake = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "debug_bake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls @method bake@ with @create_visual_debug@ enabled. debug_bake :: (GIProbe :< cls, Object :< cls) => cls -> IO () debug_bake cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_debug_bake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "debug_bake" '[] (IO ()) where nodeMethod = Godot.Core.GIProbe.debug_bake {-# NOINLINE bindGIProbe_get_bias #-} -- | Offsets the lookup of the light contribution from the @GIProbe@. This can be used to avoid self-shadowing, but may introduce light leaking at higher values. This and @normal_bias@ should be played around with to minimize self-shadowing and light leaking. -- __Note:__ @bias@ should usually be above 1.0 as that is the size of the voxels. bindGIProbe_get_bias :: MethodBind bindGIProbe_get_bias = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "get_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Offsets the lookup of the light contribution from the @GIProbe@. This can be used to avoid self-shadowing, but may introduce light leaking at higher values. This and @normal_bias@ should be played around with to minimize self-shadowing and light leaking. -- __Note:__ @bias@ should usually be above 1.0 as that is the size of the voxels. get_bias :: (GIProbe :< cls, Object :< cls) => cls -> IO Float get_bias cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_get_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "get_bias" '[] (IO Float) where nodeMethod = Godot.Core.GIProbe.get_bias {-# NOINLINE bindGIProbe_get_dynamic_range #-} -- | The maximum brightness that the @GIProbe@ will recognize. Brightness will be scaled within this range. bindGIProbe_get_dynamic_range :: MethodBind bindGIProbe_get_dynamic_range = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "get_dynamic_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum brightness that the @GIProbe@ will recognize. Brightness will be scaled within this range. get_dynamic_range :: (GIProbe :< cls, Object :< cls) => cls -> IO Int get_dynamic_range cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_get_dynamic_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "get_dynamic_range" '[] (IO Int) where nodeMethod = Godot.Core.GIProbe.get_dynamic_range {-# NOINLINE bindGIProbe_get_energy #-} -- | Energy multiplier. Makes the lighting contribution from the @GIProbe@ brighter. bindGIProbe_get_energy :: MethodBind bindGIProbe_get_energy = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "get_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Energy multiplier. Makes the lighting contribution from the @GIProbe@ brighter. get_energy :: (GIProbe :< cls, Object :< cls) => cls -> IO Float get_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_get_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "get_energy" '[] (IO Float) where nodeMethod = Godot.Core.GIProbe.get_energy {-# NOINLINE bindGIProbe_get_extents #-} -- | The size of the area covered by the @GIProbe@. If you make the extents larger without increasing the subdivisions with @subdiv@, the size of each cell will increase and result in lower detailed lighting. bindGIProbe_get_extents :: MethodBind bindGIProbe_get_extents = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "get_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the area covered by the @GIProbe@. If you make the extents larger without increasing the subdivisions with @subdiv@, the size of each cell will increase and result in lower detailed lighting. get_extents :: (GIProbe :< cls, Object :< cls) => cls -> IO Vector3 get_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_get_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "get_extents" '[] (IO Vector3) where nodeMethod = Godot.Core.GIProbe.get_extents {-# NOINLINE bindGIProbe_get_normal_bias #-} -- | Offsets the lookup into the @GIProbe@ based on the object's normal direction. Can be used to reduce some self-shadowing artifacts. bindGIProbe_get_normal_bias :: MethodBind bindGIProbe_get_normal_bias = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "get_normal_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Offsets the lookup into the @GIProbe@ based on the object's normal direction. Can be used to reduce some self-shadowing artifacts. get_normal_bias :: (GIProbe :< cls, Object :< cls) => cls -> IO Float get_normal_bias cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_get_normal_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "get_normal_bias" '[] (IO Float) where nodeMethod = Godot.Core.GIProbe.get_normal_bias {-# NOINLINE bindGIProbe_get_probe_data #-} -- | The @GIProbeData@ resource that holds the data for this @GIProbe@. bindGIProbe_get_probe_data :: MethodBind bindGIProbe_get_probe_data = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "get_probe_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @GIProbeData@ resource that holds the data for this @GIProbe@. get_probe_data :: (GIProbe :< cls, Object :< cls) => cls -> IO GIProbeData get_probe_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_get_probe_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "get_probe_data" '[] (IO GIProbeData) where nodeMethod = Godot.Core.GIProbe.get_probe_data {-# NOINLINE bindGIProbe_get_propagation #-} -- | How much light propagates through the probe internally. A higher value allows light to spread further. bindGIProbe_get_propagation :: MethodBind bindGIProbe_get_propagation = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "get_propagation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much light propagates through the probe internally. A higher value allows light to spread further. get_propagation :: (GIProbe :< cls, Object :< cls) => cls -> IO Float get_propagation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_get_propagation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "get_propagation" '[] (IO Float) where nodeMethod = Godot.Core.GIProbe.get_propagation {-# NOINLINE bindGIProbe_get_subdiv #-} -- | Number of times to subdivide the grid that the @GIProbe@ operates on. A higher number results in finer detail and thus higher visual quality, while lower numbers result in better performance. bindGIProbe_get_subdiv :: MethodBind bindGIProbe_get_subdiv = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "get_subdiv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of times to subdivide the grid that the @GIProbe@ operates on. A higher number results in finer detail and thus higher visual quality, while lower numbers result in better performance. get_subdiv :: (GIProbe :< cls, Object :< cls) => cls -> IO Int get_subdiv cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_get_subdiv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "get_subdiv" '[] (IO Int) where nodeMethod = Godot.Core.GIProbe.get_subdiv {-# NOINLINE bindGIProbe_is_compressed #-} -- | If @true@, the data for this @GIProbe@ will be compressed. Compression saves space, but results in far worse visual quality. bindGIProbe_is_compressed :: MethodBind bindGIProbe_is_compressed = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "is_compressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the data for this @GIProbe@ will be compressed. Compression saves space, but results in far worse visual quality. is_compressed :: (GIProbe :< cls, Object :< cls) => cls -> IO Bool is_compressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_is_compressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "is_compressed" '[] (IO Bool) where nodeMethod = Godot.Core.GIProbe.is_compressed {-# NOINLINE bindGIProbe_is_interior #-} -- | If @true@, ignores the sky contribution when calculating lighting. bindGIProbe_is_interior :: MethodBind bindGIProbe_is_interior = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "is_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, ignores the sky contribution when calculating lighting. is_interior :: (GIProbe :< cls, Object :< cls) => cls -> IO Bool is_interior cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_is_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "is_interior" '[] (IO Bool) where nodeMethod = Godot.Core.GIProbe.is_interior {-# NOINLINE bindGIProbe_set_bias #-} -- | Offsets the lookup of the light contribution from the @GIProbe@. This can be used to avoid self-shadowing, but may introduce light leaking at higher values. This and @normal_bias@ should be played around with to minimize self-shadowing and light leaking. -- __Note:__ @bias@ should usually be above 1.0 as that is the size of the voxels. bindGIProbe_set_bias :: MethodBind bindGIProbe_set_bias = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Offsets the lookup of the light contribution from the @GIProbe@. This can be used to avoid self-shadowing, but may introduce light leaking at higher values. This and @normal_bias@ should be played around with to minimize self-shadowing and light leaking. -- __Note:__ @bias@ should usually be above 1.0 as that is the size of the voxels. set_bias :: (GIProbe :< cls, Object :< cls) => cls -> Float -> IO () set_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_bias" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_bias {-# NOINLINE bindGIProbe_set_compress #-} -- | If @true@, the data for this @GIProbe@ will be compressed. Compression saves space, but results in far worse visual quality. bindGIProbe_set_compress :: MethodBind bindGIProbe_set_compress = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_compress" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the data for this @GIProbe@ will be compressed. Compression saves space, but results in far worse visual quality. set_compress :: (GIProbe :< cls, Object :< cls) => cls -> Bool -> IO () set_compress cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_compress (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_compress" '[Bool] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_compress {-# NOINLINE bindGIProbe_set_dynamic_range #-} -- | The maximum brightness that the @GIProbe@ will recognize. Brightness will be scaled within this range. bindGIProbe_set_dynamic_range :: MethodBind bindGIProbe_set_dynamic_range = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_dynamic_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum brightness that the @GIProbe@ will recognize. Brightness will be scaled within this range. set_dynamic_range :: (GIProbe :< cls, Object :< cls) => cls -> Int -> IO () set_dynamic_range cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_dynamic_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_dynamic_range" '[Int] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_dynamic_range {-# NOINLINE bindGIProbe_set_energy #-} -- | Energy multiplier. Makes the lighting contribution from the @GIProbe@ brighter. bindGIProbe_set_energy :: MethodBind bindGIProbe_set_energy = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Energy multiplier. Makes the lighting contribution from the @GIProbe@ brighter. set_energy :: (GIProbe :< cls, Object :< cls) => cls -> Float -> IO () set_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_energy {-# NOINLINE bindGIProbe_set_extents #-} -- | The size of the area covered by the @GIProbe@. If you make the extents larger without increasing the subdivisions with @subdiv@, the size of each cell will increase and result in lower detailed lighting. bindGIProbe_set_extents :: MethodBind bindGIProbe_set_extents = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the area covered by the @GIProbe@. If you make the extents larger without increasing the subdivisions with @subdiv@, the size of each cell will increase and result in lower detailed lighting. set_extents :: (GIProbe :< cls, Object :< cls) => cls -> Vector3 -> IO () set_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_extents" '[Vector3] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_extents {-# NOINLINE bindGIProbe_set_interior #-} -- | If @true@, ignores the sky contribution when calculating lighting. bindGIProbe_set_interior :: MethodBind bindGIProbe_set_interior = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, ignores the sky contribution when calculating lighting. set_interior :: (GIProbe :< cls, Object :< cls) => cls -> Bool -> IO () set_interior cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_interior" '[Bool] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_interior {-# NOINLINE bindGIProbe_set_normal_bias #-} -- | Offsets the lookup into the @GIProbe@ based on the object's normal direction. Can be used to reduce some self-shadowing artifacts. bindGIProbe_set_normal_bias :: MethodBind bindGIProbe_set_normal_bias = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_normal_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Offsets the lookup into the @GIProbe@ based on the object's normal direction. Can be used to reduce some self-shadowing artifacts. set_normal_bias :: (GIProbe :< cls, Object :< cls) => cls -> Float -> IO () set_normal_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_normal_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_normal_bias" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_normal_bias {-# NOINLINE bindGIProbe_set_probe_data #-} -- | The @GIProbeData@ resource that holds the data for this @GIProbe@. bindGIProbe_set_probe_data :: MethodBind bindGIProbe_set_probe_data = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_probe_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @GIProbeData@ resource that holds the data for this @GIProbe@. set_probe_data :: (GIProbe :< cls, Object :< cls) => cls -> GIProbeData -> IO () set_probe_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_probe_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_probe_data" '[GIProbeData] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_probe_data {-# NOINLINE bindGIProbe_set_propagation #-} -- | How much light propagates through the probe internally. A higher value allows light to spread further. bindGIProbe_set_propagation :: MethodBind bindGIProbe_set_propagation = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_propagation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much light propagates through the probe internally. A higher value allows light to spread further. set_propagation :: (GIProbe :< cls, Object :< cls) => cls -> Float -> IO () set_propagation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_propagation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_propagation" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_propagation {-# NOINLINE bindGIProbe_set_subdiv #-} -- | Number of times to subdivide the grid that the @GIProbe@ operates on. A higher number results in finer detail and thus higher visual quality, while lower numbers result in better performance. bindGIProbe_set_subdiv :: MethodBind bindGIProbe_set_subdiv = unsafePerformIO $ withCString "GIProbe" $ \ clsNamePtr -> withCString "set_subdiv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of times to subdivide the grid that the @GIProbe@ operates on. A higher number results in finer detail and thus higher visual quality, while lower numbers result in better performance. set_subdiv :: (GIProbe :< cls, Object :< cls) => cls -> Int -> IO () set_subdiv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbe_set_subdiv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbe "set_subdiv" '[Int] (IO ()) where nodeMethod = Godot.Core.GIProbe.set_subdiv ================================================ FILE: src/Godot/Core/GIProbeData.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GIProbeData (Godot.Core.GIProbeData.get_bias, Godot.Core.GIProbeData.get_bounds, Godot.Core.GIProbeData.get_cell_size, Godot.Core.GIProbeData.get_dynamic_data, Godot.Core.GIProbeData.get_dynamic_range, Godot.Core.GIProbeData.get_energy, Godot.Core.GIProbeData.get_normal_bias, Godot.Core.GIProbeData.get_propagation, Godot.Core.GIProbeData.get_to_cell_xform, Godot.Core.GIProbeData.is_compressed, Godot.Core.GIProbeData.is_interior, Godot.Core.GIProbeData.set_bias, Godot.Core.GIProbeData.set_bounds, Godot.Core.GIProbeData.set_cell_size, Godot.Core.GIProbeData.set_compress, Godot.Core.GIProbeData.set_dynamic_data, Godot.Core.GIProbeData.set_dynamic_range, Godot.Core.GIProbeData.set_energy, Godot.Core.GIProbeData.set_interior, Godot.Core.GIProbeData.set_normal_bias, Godot.Core.GIProbeData.set_propagation, Godot.Core.GIProbeData.set_to_cell_xform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty GIProbeData "bias" Float 'False where nodeProperty = (get_bias, wrapDroppingSetter set_bias, Nothing) instance NodeProperty GIProbeData "bounds" Aabb 'False where nodeProperty = (get_bounds, wrapDroppingSetter set_bounds, Nothing) instance NodeProperty GIProbeData "cell_size" Float 'False where nodeProperty = (get_cell_size, wrapDroppingSetter set_cell_size, Nothing) instance NodeProperty GIProbeData "compress" Bool 'False where nodeProperty = (is_compressed, wrapDroppingSetter set_compress, Nothing) instance NodeProperty GIProbeData "dynamic_data" PoolIntArray 'False where nodeProperty = (get_dynamic_data, wrapDroppingSetter set_dynamic_data, Nothing) instance NodeProperty GIProbeData "dynamic_range" Int 'False where nodeProperty = (get_dynamic_range, wrapDroppingSetter set_dynamic_range, Nothing) instance NodeProperty GIProbeData "energy" Float 'False where nodeProperty = (get_energy, wrapDroppingSetter set_energy, Nothing) instance NodeProperty GIProbeData "interior" Bool 'False where nodeProperty = (is_interior, wrapDroppingSetter set_interior, Nothing) instance NodeProperty GIProbeData "normal_bias" Float 'False where nodeProperty = (get_normal_bias, wrapDroppingSetter set_normal_bias, Nothing) instance NodeProperty GIProbeData "propagation" Float 'False where nodeProperty = (get_propagation, wrapDroppingSetter set_propagation, Nothing) instance NodeProperty GIProbeData "to_cell_xform" Transform 'False where nodeProperty = (get_to_cell_xform, wrapDroppingSetter set_to_cell_xform, Nothing) {-# NOINLINE bindGIProbeData_get_bias #-} bindGIProbeData_get_bias :: MethodBind bindGIProbeData_get_bias = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bias :: (GIProbeData :< cls, Object :< cls) => cls -> IO Float get_bias cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_bias" '[] (IO Float) where nodeMethod = Godot.Core.GIProbeData.get_bias {-# NOINLINE bindGIProbeData_get_bounds #-} bindGIProbeData_get_bounds :: MethodBind bindGIProbeData_get_bounds = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bounds :: (GIProbeData :< cls, Object :< cls) => cls -> IO Aabb get_bounds cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_bounds" '[] (IO Aabb) where nodeMethod = Godot.Core.GIProbeData.get_bounds {-# NOINLINE bindGIProbeData_get_cell_size #-} bindGIProbeData_get_cell_size :: MethodBind bindGIProbeData_get_cell_size = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_size :: (GIProbeData :< cls, Object :< cls) => cls -> IO Float get_cell_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_cell_size" '[] (IO Float) where nodeMethod = Godot.Core.GIProbeData.get_cell_size {-# NOINLINE bindGIProbeData_get_dynamic_data #-} bindGIProbeData_get_dynamic_data :: MethodBind bindGIProbeData_get_dynamic_data = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_dynamic_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_dynamic_data :: (GIProbeData :< cls, Object :< cls) => cls -> IO PoolIntArray get_dynamic_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_dynamic_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_dynamic_data" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.GIProbeData.get_dynamic_data {-# NOINLINE bindGIProbeData_get_dynamic_range #-} bindGIProbeData_get_dynamic_range :: MethodBind bindGIProbeData_get_dynamic_range = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_dynamic_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_dynamic_range :: (GIProbeData :< cls, Object :< cls) => cls -> IO Int get_dynamic_range cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_dynamic_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_dynamic_range" '[] (IO Int) where nodeMethod = Godot.Core.GIProbeData.get_dynamic_range {-# NOINLINE bindGIProbeData_get_energy #-} bindGIProbeData_get_energy :: MethodBind bindGIProbeData_get_energy = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_energy :: (GIProbeData :< cls, Object :< cls) => cls -> IO Float get_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_energy" '[] (IO Float) where nodeMethod = Godot.Core.GIProbeData.get_energy {-# NOINLINE bindGIProbeData_get_normal_bias #-} bindGIProbeData_get_normal_bias :: MethodBind bindGIProbeData_get_normal_bias = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_normal_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_normal_bias :: (GIProbeData :< cls, Object :< cls) => cls -> IO Float get_normal_bias cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_normal_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_normal_bias" '[] (IO Float) where nodeMethod = Godot.Core.GIProbeData.get_normal_bias {-# NOINLINE bindGIProbeData_get_propagation #-} bindGIProbeData_get_propagation :: MethodBind bindGIProbeData_get_propagation = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_propagation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_propagation :: (GIProbeData :< cls, Object :< cls) => cls -> IO Float get_propagation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_propagation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_propagation" '[] (IO Float) where nodeMethod = Godot.Core.GIProbeData.get_propagation {-# NOINLINE bindGIProbeData_get_to_cell_xform #-} bindGIProbeData_get_to_cell_xform :: MethodBind bindGIProbeData_get_to_cell_xform = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "get_to_cell_xform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_to_cell_xform :: (GIProbeData :< cls, Object :< cls) => cls -> IO Transform get_to_cell_xform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_get_to_cell_xform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "get_to_cell_xform" '[] (IO Transform) where nodeMethod = Godot.Core.GIProbeData.get_to_cell_xform {-# NOINLINE bindGIProbeData_is_compressed #-} bindGIProbeData_is_compressed :: MethodBind bindGIProbeData_is_compressed = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "is_compressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_compressed :: (GIProbeData :< cls, Object :< cls) => cls -> IO Bool is_compressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_is_compressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "is_compressed" '[] (IO Bool) where nodeMethod = Godot.Core.GIProbeData.is_compressed {-# NOINLINE bindGIProbeData_is_interior #-} bindGIProbeData_is_interior :: MethodBind bindGIProbeData_is_interior = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "is_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_interior :: (GIProbeData :< cls, Object :< cls) => cls -> IO Bool is_interior cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_is_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "is_interior" '[] (IO Bool) where nodeMethod = Godot.Core.GIProbeData.is_interior {-# NOINLINE bindGIProbeData_set_bias #-} bindGIProbeData_set_bias :: MethodBind bindGIProbeData_set_bias = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bias :: (GIProbeData :< cls, Object :< cls) => cls -> Float -> IO () set_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_bias" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_bias {-# NOINLINE bindGIProbeData_set_bounds #-} bindGIProbeData_set_bounds :: MethodBind bindGIProbeData_set_bounds = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bounds :: (GIProbeData :< cls, Object :< cls) => cls -> Aabb -> IO () set_bounds cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_bounds" '[Aabb] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_bounds {-# NOINLINE bindGIProbeData_set_cell_size #-} bindGIProbeData_set_cell_size :: MethodBind bindGIProbeData_set_cell_size = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_size :: (GIProbeData :< cls, Object :< cls) => cls -> Float -> IO () set_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_cell_size" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_cell_size {-# NOINLINE bindGIProbeData_set_compress #-} bindGIProbeData_set_compress :: MethodBind bindGIProbeData_set_compress = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_compress" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_compress :: (GIProbeData :< cls, Object :< cls) => cls -> Bool -> IO () set_compress cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_compress (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_compress" '[Bool] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_compress {-# NOINLINE bindGIProbeData_set_dynamic_data #-} bindGIProbeData_set_dynamic_data :: MethodBind bindGIProbeData_set_dynamic_data = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_dynamic_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_dynamic_data :: (GIProbeData :< cls, Object :< cls) => cls -> PoolIntArray -> IO () set_dynamic_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_dynamic_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_dynamic_data" '[PoolIntArray] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_dynamic_data {-# NOINLINE bindGIProbeData_set_dynamic_range #-} bindGIProbeData_set_dynamic_range :: MethodBind bindGIProbeData_set_dynamic_range = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_dynamic_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_dynamic_range :: (GIProbeData :< cls, Object :< cls) => cls -> Int -> IO () set_dynamic_range cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_dynamic_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_dynamic_range" '[Int] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_dynamic_range {-# NOINLINE bindGIProbeData_set_energy #-} bindGIProbeData_set_energy :: MethodBind bindGIProbeData_set_energy = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_energy :: (GIProbeData :< cls, Object :< cls) => cls -> Float -> IO () set_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_energy {-# NOINLINE bindGIProbeData_set_interior #-} bindGIProbeData_set_interior :: MethodBind bindGIProbeData_set_interior = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_interior :: (GIProbeData :< cls, Object :< cls) => cls -> Bool -> IO () set_interior cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_interior" '[Bool] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_interior {-# NOINLINE bindGIProbeData_set_normal_bias #-} bindGIProbeData_set_normal_bias :: MethodBind bindGIProbeData_set_normal_bias = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_normal_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_normal_bias :: (GIProbeData :< cls, Object :< cls) => cls -> Float -> IO () set_normal_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_normal_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_normal_bias" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_normal_bias {-# NOINLINE bindGIProbeData_set_propagation #-} bindGIProbeData_set_propagation :: MethodBind bindGIProbeData_set_propagation = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_propagation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_propagation :: (GIProbeData :< cls, Object :< cls) => cls -> Float -> IO () set_propagation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_propagation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_propagation" '[Float] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_propagation {-# NOINLINE bindGIProbeData_set_to_cell_xform #-} bindGIProbeData_set_to_cell_xform :: MethodBind bindGIProbeData_set_to_cell_xform = unsafePerformIO $ withCString "GIProbeData" $ \ clsNamePtr -> withCString "set_to_cell_xform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_to_cell_xform :: (GIProbeData :< cls, Object :< cls) => cls -> Transform -> IO () set_to_cell_xform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGIProbeData_set_to_cell_xform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GIProbeData "set_to_cell_xform" '[Transform] (IO ()) where nodeMethod = Godot.Core.GIProbeData.set_to_cell_xform ================================================ FILE: src/Godot/Core/Generic6DOFJoint.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Generic6DOFJoint (Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_LOWER_LIMIT, Godot.Core.Generic6DOFJoint._FLAG_ENABLE_LINEAR_MOTOR, Godot.Core.Generic6DOFJoint._PARAM_LINEAR_MOTOR_TARGET_VELOCITY, Godot.Core.Generic6DOFJoint._PARAM_LINEAR_DAMPING, Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_ERP, Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_DAMPING, Godot.Core.Generic6DOFJoint._FLAG_ENABLE_ANGULAR_LIMIT, Godot.Core.Generic6DOFJoint._PARAM_LINEAR_LIMIT_SOFTNESS, Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_MOTOR_TARGET_VELOCITY, Godot.Core.Generic6DOFJoint._PARAM_LINEAR_LOWER_LIMIT, Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_MOTOR_FORCE_LIMIT, Godot.Core.Generic6DOFJoint._PARAM_LINEAR_RESTITUTION, Godot.Core.Generic6DOFJoint._FLAG_ENABLE_ANGULAR_SPRING, Godot.Core.Generic6DOFJoint._PARAM_MAX, Godot.Core.Generic6DOFJoint._FLAG_MAX, Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_LIMIT_SOFTNESS, Godot.Core.Generic6DOFJoint._PARAM_LINEAR_UPPER_LIMIT, Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_FORCE_LIMIT, Godot.Core.Generic6DOFJoint._FLAG_ENABLE_LINEAR_LIMIT, Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_UPPER_LIMIT, Godot.Core.Generic6DOFJoint._FLAG_ENABLE_LINEAR_SPRING, Godot.Core.Generic6DOFJoint._FLAG_ENABLE_MOTOR, Godot.Core.Generic6DOFJoint._PARAM_LINEAR_MOTOR_FORCE_LIMIT, Godot.Core.Generic6DOFJoint._PARAM_ANGULAR_RESTITUTION, Godot.Core.Generic6DOFJoint._get_angular_hi_limit_x, Godot.Core.Generic6DOFJoint._get_angular_hi_limit_y, Godot.Core.Generic6DOFJoint._get_angular_hi_limit_z, Godot.Core.Generic6DOFJoint._get_angular_lo_limit_x, Godot.Core.Generic6DOFJoint._get_angular_lo_limit_y, Godot.Core.Generic6DOFJoint._get_angular_lo_limit_z, Godot.Core.Generic6DOFJoint._set_angular_hi_limit_x, Godot.Core.Generic6DOFJoint._set_angular_hi_limit_y, Godot.Core.Generic6DOFJoint._set_angular_hi_limit_z, Godot.Core.Generic6DOFJoint._set_angular_lo_limit_x, Godot.Core.Generic6DOFJoint._set_angular_lo_limit_y, Godot.Core.Generic6DOFJoint._set_angular_lo_limit_z, Godot.Core.Generic6DOFJoint.get_flag_x, Godot.Core.Generic6DOFJoint.get_flag_y, Godot.Core.Generic6DOFJoint.get_flag_z, Godot.Core.Generic6DOFJoint.get_param_x, Godot.Core.Generic6DOFJoint.get_param_y, Godot.Core.Generic6DOFJoint.get_param_z, Godot.Core.Generic6DOFJoint.get_precision, Godot.Core.Generic6DOFJoint.set_flag_x, Godot.Core.Generic6DOFJoint.set_flag_y, Godot.Core.Generic6DOFJoint.set_flag_z, Godot.Core.Generic6DOFJoint.set_param_x, Godot.Core.Generic6DOFJoint.set_param_y, Godot.Core.Generic6DOFJoint.set_param_z, Godot.Core.Generic6DOFJoint.set_precision) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Joint() _PARAM_ANGULAR_LOWER_LIMIT :: Int _PARAM_ANGULAR_LOWER_LIMIT = 10 _FLAG_ENABLE_LINEAR_MOTOR :: Int _FLAG_ENABLE_LINEAR_MOTOR = 5 _PARAM_LINEAR_MOTOR_TARGET_VELOCITY :: Int _PARAM_LINEAR_MOTOR_TARGET_VELOCITY = 5 _PARAM_LINEAR_DAMPING :: Int _PARAM_LINEAR_DAMPING = 4 _PARAM_ANGULAR_ERP :: Int _PARAM_ANGULAR_ERP = 16 _PARAM_ANGULAR_DAMPING :: Int _PARAM_ANGULAR_DAMPING = 13 _FLAG_ENABLE_ANGULAR_LIMIT :: Int _FLAG_ENABLE_ANGULAR_LIMIT = 1 _PARAM_LINEAR_LIMIT_SOFTNESS :: Int _PARAM_LINEAR_LIMIT_SOFTNESS = 2 _PARAM_ANGULAR_MOTOR_TARGET_VELOCITY :: Int _PARAM_ANGULAR_MOTOR_TARGET_VELOCITY = 17 _PARAM_LINEAR_LOWER_LIMIT :: Int _PARAM_LINEAR_LOWER_LIMIT = 0 _PARAM_ANGULAR_MOTOR_FORCE_LIMIT :: Int _PARAM_ANGULAR_MOTOR_FORCE_LIMIT = 18 _PARAM_LINEAR_RESTITUTION :: Int _PARAM_LINEAR_RESTITUTION = 3 _FLAG_ENABLE_ANGULAR_SPRING :: Int _FLAG_ENABLE_ANGULAR_SPRING = 2 _PARAM_MAX :: Int _PARAM_MAX = 22 _FLAG_MAX :: Int _FLAG_MAX = 6 _PARAM_ANGULAR_LIMIT_SOFTNESS :: Int _PARAM_ANGULAR_LIMIT_SOFTNESS = 12 _PARAM_LINEAR_UPPER_LIMIT :: Int _PARAM_LINEAR_UPPER_LIMIT = 1 _PARAM_ANGULAR_FORCE_LIMIT :: Int _PARAM_ANGULAR_FORCE_LIMIT = 15 _FLAG_ENABLE_LINEAR_LIMIT :: Int _FLAG_ENABLE_LINEAR_LIMIT = 0 _PARAM_ANGULAR_UPPER_LIMIT :: Int _PARAM_ANGULAR_UPPER_LIMIT = 11 _FLAG_ENABLE_LINEAR_SPRING :: Int _FLAG_ENABLE_LINEAR_SPRING = 3 _FLAG_ENABLE_MOTOR :: Int _FLAG_ENABLE_MOTOR = 4 _PARAM_LINEAR_MOTOR_FORCE_LIMIT :: Int _PARAM_LINEAR_MOTOR_FORCE_LIMIT = 6 _PARAM_ANGULAR_RESTITUTION :: Int _PARAM_ANGULAR_RESTITUTION = 14 instance NodeProperty Generic6DOFJoint "angular_limit_x/damping" Float 'False where nodeProperty = (wrapIndexedGetter 13 get_param_x, wrapIndexedSetter 13 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_x/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_flag_x, wrapIndexedSetter 1 set_flag_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_x/erp" Float 'False where nodeProperty = (wrapIndexedGetter 16 get_param_x, wrapIndexedSetter 16 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_x/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 15 get_param_x, wrapIndexedSetter 15 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_x/lower_angle" Float 'False where nodeProperty = (_get_angular_lo_limit_x, wrapDroppingSetter _set_angular_lo_limit_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_x/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 14 get_param_x, wrapIndexedSetter 14 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_x/softness" Float 'False where nodeProperty = (wrapIndexedGetter 12 get_param_x, wrapIndexedSetter 12 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_x/upper_angle" Float 'False where nodeProperty = (_get_angular_hi_limit_x, wrapDroppingSetter _set_angular_hi_limit_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_y/damping" Float 'False where nodeProperty = (wrapIndexedGetter 13 get_param_y, wrapIndexedSetter 13 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_y/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_flag_y, wrapIndexedSetter 1 set_flag_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_y/erp" Float 'False where nodeProperty = (wrapIndexedGetter 16 get_param_y, wrapIndexedSetter 16 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_y/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 15 get_param_y, wrapIndexedSetter 15 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_y/lower_angle" Float 'False where nodeProperty = (_get_angular_lo_limit_y, wrapDroppingSetter _set_angular_lo_limit_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_y/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 14 get_param_y, wrapIndexedSetter 14 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_y/softness" Float 'False where nodeProperty = (wrapIndexedGetter 12 get_param_y, wrapIndexedSetter 12 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_y/upper_angle" Float 'False where nodeProperty = (_get_angular_hi_limit_y, wrapDroppingSetter _set_angular_hi_limit_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_z/damping" Float 'False where nodeProperty = (wrapIndexedGetter 13 get_param_z, wrapIndexedSetter 13 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_z/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_flag_z, wrapIndexedSetter 1 set_flag_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_z/erp" Float 'False where nodeProperty = (wrapIndexedGetter 16 get_param_z, wrapIndexedSetter 16 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_z/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 15 get_param_z, wrapIndexedSetter 15 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_z/lower_angle" Float 'False where nodeProperty = (_get_angular_lo_limit_z, wrapDroppingSetter _set_angular_lo_limit_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_z/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 14 get_param_z, wrapIndexedSetter 14 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_z/softness" Float 'False where nodeProperty = (wrapIndexedGetter 12 get_param_z, wrapIndexedSetter 12 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_limit_z/upper_angle" Float 'False where nodeProperty = (_get_angular_hi_limit_z, wrapDroppingSetter _set_angular_hi_limit_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_x/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 4 get_flag_x, wrapIndexedSetter 4 set_flag_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_x/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 18 get_param_x, wrapIndexedSetter 18 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_x/target_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 17 get_param_x, wrapIndexedSetter 17 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_y/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 4 get_flag_y, wrapIndexedSetter 4 set_flag_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_y/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 18 get_param_y, wrapIndexedSetter 18 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_y/target_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 17 get_param_y, wrapIndexedSetter 17 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_z/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 4 get_flag_z, wrapIndexedSetter 4 set_flag_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_z/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 18 get_param_z, wrapIndexedSetter 18 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_motor_z/target_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 17 get_param_z, wrapIndexedSetter 17 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_x/damping" Float 'False where nodeProperty = (wrapIndexedGetter 20 get_param_x, wrapIndexedSetter 20 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_x/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_flag_x, wrapIndexedSetter 2 set_flag_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_x/equilibrium_point" Float 'False where nodeProperty = (wrapIndexedGetter 21 get_param_x, wrapIndexedSetter 21 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_x/stiffness" Float 'False where nodeProperty = (wrapIndexedGetter 19 get_param_x, wrapIndexedSetter 19 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_y/damping" Float 'False where nodeProperty = (wrapIndexedGetter 20 get_param_y, wrapIndexedSetter 20 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_y/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_flag_y, wrapIndexedSetter 2 set_flag_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_y/equilibrium_point" Float 'False where nodeProperty = (wrapIndexedGetter 21 get_param_y, wrapIndexedSetter 21 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_y/stiffness" Float 'False where nodeProperty = (wrapIndexedGetter 19 get_param_y, wrapIndexedSetter 19 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_z/damping" Float 'False where nodeProperty = (wrapIndexedGetter 20 get_param_z, wrapIndexedSetter 20 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_z/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_flag_z, wrapIndexedSetter 2 set_flag_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_z/equilibrium_point" Float 'False where nodeProperty = (wrapIndexedGetter 21 get_param_z, wrapIndexedSetter 21 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "angular_spring_z/stiffness" Float 'False where nodeProperty = (wrapIndexedGetter 19 get_param_z, wrapIndexedSetter 19 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_x/damping" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param_x, wrapIndexedSetter 4 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_x/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_flag_x, wrapIndexedSetter 0 set_flag_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_x/lower_distance" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param_x, wrapIndexedSetter 0 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_x/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param_x, wrapIndexedSetter 3 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_x/softness" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param_x, wrapIndexedSetter 2 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_x/upper_distance" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param_x, wrapIndexedSetter 1 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_y/damping" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param_y, wrapIndexedSetter 4 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_y/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_flag_y, wrapIndexedSetter 0 set_flag_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_y/lower_distance" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param_y, wrapIndexedSetter 0 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_y/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param_y, wrapIndexedSetter 3 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_y/softness" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param_y, wrapIndexedSetter 2 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_y/upper_distance" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param_y, wrapIndexedSetter 1 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_z/damping" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param_z, wrapIndexedSetter 4 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_z/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_flag_z, wrapIndexedSetter 0 set_flag_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_z/lower_distance" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param_z, wrapIndexedSetter 0 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_z/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param_z, wrapIndexedSetter 3 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_z/softness" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param_z, wrapIndexedSetter 2 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_limit_z/upper_distance" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param_z, wrapIndexedSetter 1 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_x/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 5 get_flag_x, wrapIndexedSetter 5 set_flag_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_x/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param_x, wrapIndexedSetter 6 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_x/target_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param_x, wrapIndexedSetter 5 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_y/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 5 get_flag_y, wrapIndexedSetter 5 set_flag_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_y/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param_y, wrapIndexedSetter 6 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_y/target_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param_y, wrapIndexedSetter 5 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_z/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 5 get_flag_z, wrapIndexedSetter 5 set_flag_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_z/force_limit" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param_z, wrapIndexedSetter 6 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_motor_z/target_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param_z, wrapIndexedSetter 5 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_x/damping" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param_x, wrapIndexedSetter 8 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_x/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 3 get_flag_x, wrapIndexedSetter 3 set_flag_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_x/equilibrium_point" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param_x, wrapIndexedSetter 9 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_x/stiffness" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param_x, wrapIndexedSetter 7 set_param_x, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_y/damping" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param_y, wrapIndexedSetter 8 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_y/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 3 get_flag_y, wrapIndexedSetter 3 set_flag_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_y/equilibrium_point" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param_y, wrapIndexedSetter 9 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_y/stiffness" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param_y, wrapIndexedSetter 7 set_param_y, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_z/damping" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param_z, wrapIndexedSetter 8 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_z/enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 3 get_flag_z, wrapIndexedSetter 3 set_flag_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_z/equilibrium_point" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param_z, wrapIndexedSetter 9 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "linear_spring_z/stiffness" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param_z, wrapIndexedSetter 7 set_param_z, Nothing) instance NodeProperty Generic6DOFJoint "precision" Int 'False where nodeProperty = (get_precision, wrapDroppingSetter set_precision, Nothing) {-# NOINLINE bindGeneric6DOFJoint__get_angular_hi_limit_x #-} -- | The minimum rotation in positive direction to break loose and rotate around the X axis. bindGeneric6DOFJoint__get_angular_hi_limit_x :: MethodBind bindGeneric6DOFJoint__get_angular_hi_limit_x = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_get_angular_hi_limit_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in positive direction to break loose and rotate around the X axis. _get_angular_hi_limit_x :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> IO Float _get_angular_hi_limit_x cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__get_angular_hi_limit_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_get_angular_hi_limit_x" '[] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint._get_angular_hi_limit_x {-# NOINLINE bindGeneric6DOFJoint__get_angular_hi_limit_y #-} -- | The minimum rotation in positive direction to break loose and rotate around the Y axis. bindGeneric6DOFJoint__get_angular_hi_limit_y :: MethodBind bindGeneric6DOFJoint__get_angular_hi_limit_y = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_get_angular_hi_limit_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in positive direction to break loose and rotate around the Y axis. _get_angular_hi_limit_y :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> IO Float _get_angular_hi_limit_y cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__get_angular_hi_limit_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_get_angular_hi_limit_y" '[] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint._get_angular_hi_limit_y {-# NOINLINE bindGeneric6DOFJoint__get_angular_hi_limit_z #-} -- | The minimum rotation in positive direction to break loose and rotate around the Z axis. bindGeneric6DOFJoint__get_angular_hi_limit_z :: MethodBind bindGeneric6DOFJoint__get_angular_hi_limit_z = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_get_angular_hi_limit_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in positive direction to break loose and rotate around the Z axis. _get_angular_hi_limit_z :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> IO Float _get_angular_hi_limit_z cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__get_angular_hi_limit_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_get_angular_hi_limit_z" '[] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint._get_angular_hi_limit_z {-# NOINLINE bindGeneric6DOFJoint__get_angular_lo_limit_x #-} -- | The minimum rotation in negative direction to break loose and rotate around the X axis. bindGeneric6DOFJoint__get_angular_lo_limit_x :: MethodBind bindGeneric6DOFJoint__get_angular_lo_limit_x = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_get_angular_lo_limit_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in negative direction to break loose and rotate around the X axis. _get_angular_lo_limit_x :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> IO Float _get_angular_lo_limit_x cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__get_angular_lo_limit_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_get_angular_lo_limit_x" '[] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint._get_angular_lo_limit_x {-# NOINLINE bindGeneric6DOFJoint__get_angular_lo_limit_y #-} -- | The minimum rotation in negative direction to break loose and rotate around the Y axis. bindGeneric6DOFJoint__get_angular_lo_limit_y :: MethodBind bindGeneric6DOFJoint__get_angular_lo_limit_y = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_get_angular_lo_limit_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in negative direction to break loose and rotate around the Y axis. _get_angular_lo_limit_y :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> IO Float _get_angular_lo_limit_y cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__get_angular_lo_limit_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_get_angular_lo_limit_y" '[] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint._get_angular_lo_limit_y {-# NOINLINE bindGeneric6DOFJoint__get_angular_lo_limit_z #-} -- | The minimum rotation in negative direction to break loose and rotate around the Z axis. bindGeneric6DOFJoint__get_angular_lo_limit_z :: MethodBind bindGeneric6DOFJoint__get_angular_lo_limit_z = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_get_angular_lo_limit_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in negative direction to break loose and rotate around the Z axis. _get_angular_lo_limit_z :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> IO Float _get_angular_lo_limit_z cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__get_angular_lo_limit_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_get_angular_lo_limit_z" '[] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint._get_angular_lo_limit_z {-# NOINLINE bindGeneric6DOFJoint__set_angular_hi_limit_x #-} -- | The minimum rotation in positive direction to break loose and rotate around the X axis. bindGeneric6DOFJoint__set_angular_hi_limit_x :: MethodBind bindGeneric6DOFJoint__set_angular_hi_limit_x = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_set_angular_hi_limit_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in positive direction to break loose and rotate around the X axis. _set_angular_hi_limit_x :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_angular_hi_limit_x cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__set_angular_hi_limit_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_set_angular_hi_limit_x" '[Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint._set_angular_hi_limit_x {-# NOINLINE bindGeneric6DOFJoint__set_angular_hi_limit_y #-} -- | The minimum rotation in positive direction to break loose and rotate around the Y axis. bindGeneric6DOFJoint__set_angular_hi_limit_y :: MethodBind bindGeneric6DOFJoint__set_angular_hi_limit_y = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_set_angular_hi_limit_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in positive direction to break loose and rotate around the Y axis. _set_angular_hi_limit_y :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_angular_hi_limit_y cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__set_angular_hi_limit_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_set_angular_hi_limit_y" '[Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint._set_angular_hi_limit_y {-# NOINLINE bindGeneric6DOFJoint__set_angular_hi_limit_z #-} -- | The minimum rotation in positive direction to break loose and rotate around the Z axis. bindGeneric6DOFJoint__set_angular_hi_limit_z :: MethodBind bindGeneric6DOFJoint__set_angular_hi_limit_z = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_set_angular_hi_limit_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in positive direction to break loose and rotate around the Z axis. _set_angular_hi_limit_z :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_angular_hi_limit_z cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__set_angular_hi_limit_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_set_angular_hi_limit_z" '[Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint._set_angular_hi_limit_z {-# NOINLINE bindGeneric6DOFJoint__set_angular_lo_limit_x #-} -- | The minimum rotation in negative direction to break loose and rotate around the X axis. bindGeneric6DOFJoint__set_angular_lo_limit_x :: MethodBind bindGeneric6DOFJoint__set_angular_lo_limit_x = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_set_angular_lo_limit_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in negative direction to break loose and rotate around the X axis. _set_angular_lo_limit_x :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_angular_lo_limit_x cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__set_angular_lo_limit_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_set_angular_lo_limit_x" '[Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint._set_angular_lo_limit_x {-# NOINLINE bindGeneric6DOFJoint__set_angular_lo_limit_y #-} -- | The minimum rotation in negative direction to break loose and rotate around the Y axis. bindGeneric6DOFJoint__set_angular_lo_limit_y :: MethodBind bindGeneric6DOFJoint__set_angular_lo_limit_y = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_set_angular_lo_limit_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in negative direction to break loose and rotate around the Y axis. _set_angular_lo_limit_y :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_angular_lo_limit_y cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__set_angular_lo_limit_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_set_angular_lo_limit_y" '[Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint._set_angular_lo_limit_y {-# NOINLINE bindGeneric6DOFJoint__set_angular_lo_limit_z #-} -- | The minimum rotation in negative direction to break loose and rotate around the Z axis. bindGeneric6DOFJoint__set_angular_lo_limit_z :: MethodBind bindGeneric6DOFJoint__set_angular_lo_limit_z = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "_set_angular_lo_limit_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation in negative direction to break loose and rotate around the Z axis. _set_angular_lo_limit_z :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_angular_lo_limit_z cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint__set_angular_lo_limit_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "_set_angular_lo_limit_z" '[Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint._set_angular_lo_limit_z {-# NOINLINE bindGeneric6DOFJoint_get_flag_x #-} -- | If @true@, rotation across the X axis is limited. bindGeneric6DOFJoint_get_flag_x :: MethodBind bindGeneric6DOFJoint_get_flag_x = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "get_flag_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, rotation across the X axis is limited. get_flag_x :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> IO Bool get_flag_x cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_get_flag_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "get_flag_x" '[Int] (IO Bool) where nodeMethod = Godot.Core.Generic6DOFJoint.get_flag_x {-# NOINLINE bindGeneric6DOFJoint_get_flag_y #-} -- | If @true@, rotation across the Y axis is limited. bindGeneric6DOFJoint_get_flag_y :: MethodBind bindGeneric6DOFJoint_get_flag_y = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "get_flag_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, rotation across the Y axis is limited. get_flag_y :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> IO Bool get_flag_y cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_get_flag_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "get_flag_y" '[Int] (IO Bool) where nodeMethod = Godot.Core.Generic6DOFJoint.get_flag_y {-# NOINLINE bindGeneric6DOFJoint_get_flag_z #-} -- | If @true@, rotation across the Z axis is limited. bindGeneric6DOFJoint_get_flag_z :: MethodBind bindGeneric6DOFJoint_get_flag_z = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "get_flag_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, rotation across the Z axis is limited. get_flag_z :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> IO Bool get_flag_z cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_get_flag_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "get_flag_z" '[Int] (IO Bool) where nodeMethod = Godot.Core.Generic6DOFJoint.get_flag_z {-# NOINLINE bindGeneric6DOFJoint_get_param_x #-} -- | The amount of rotational damping across the X axis. -- The lower, the longer an impulse from one side takes to travel to the other side. bindGeneric6DOFJoint_get_param_x :: MethodBind bindGeneric6DOFJoint_get_param_x = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "get_param_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of rotational damping across the X axis. -- The lower, the longer an impulse from one side takes to travel to the other side. get_param_x :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> IO Float get_param_x cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_get_param_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "get_param_x" '[Int] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint.get_param_x {-# NOINLINE bindGeneric6DOFJoint_get_param_y #-} -- | The amount of rotational damping across the Y axis. The lower, the more dampening occurs. bindGeneric6DOFJoint_get_param_y :: MethodBind bindGeneric6DOFJoint_get_param_y = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "get_param_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of rotational damping across the Y axis. The lower, the more dampening occurs. get_param_y :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> IO Float get_param_y cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_get_param_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "get_param_y" '[Int] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint.get_param_y {-# NOINLINE bindGeneric6DOFJoint_get_param_z #-} -- | The amount of rotational damping across the Z axis. The lower, the more dampening occurs. bindGeneric6DOFJoint_get_param_z :: MethodBind bindGeneric6DOFJoint_get_param_z = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "get_param_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of rotational damping across the Z axis. The lower, the more dampening occurs. get_param_z :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> IO Float get_param_z cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_get_param_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "get_param_z" '[Int] (IO Float) where nodeMethod = Godot.Core.Generic6DOFJoint.get_param_z {-# NOINLINE bindGeneric6DOFJoint_get_precision #-} bindGeneric6DOFJoint_get_precision :: MethodBind bindGeneric6DOFJoint_get_precision = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "get_precision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_precision :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> IO Int get_precision cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_get_precision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "get_precision" '[] (IO Int) where nodeMethod = Godot.Core.Generic6DOFJoint.get_precision {-# NOINLINE bindGeneric6DOFJoint_set_flag_x #-} -- | If @true@, rotation across the X axis is limited. bindGeneric6DOFJoint_set_flag_x :: MethodBind bindGeneric6DOFJoint_set_flag_x = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "set_flag_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, rotation across the X axis is limited. set_flag_x :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_flag_x cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_set_flag_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "set_flag_x" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint.set_flag_x {-# NOINLINE bindGeneric6DOFJoint_set_flag_y #-} -- | If @true@, rotation across the Y axis is limited. bindGeneric6DOFJoint_set_flag_y :: MethodBind bindGeneric6DOFJoint_set_flag_y = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "set_flag_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, rotation across the Y axis is limited. set_flag_y :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_flag_y cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_set_flag_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "set_flag_y" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint.set_flag_y {-# NOINLINE bindGeneric6DOFJoint_set_flag_z #-} -- | If @true@, rotation across the Z axis is limited. bindGeneric6DOFJoint_set_flag_z :: MethodBind bindGeneric6DOFJoint_set_flag_z = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "set_flag_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, rotation across the Z axis is limited. set_flag_z :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_flag_z cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_set_flag_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "set_flag_z" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint.set_flag_z {-# NOINLINE bindGeneric6DOFJoint_set_param_x #-} -- | The amount of rotational damping across the X axis. -- The lower, the longer an impulse from one side takes to travel to the other side. bindGeneric6DOFJoint_set_param_x :: MethodBind bindGeneric6DOFJoint_set_param_x = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "set_param_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of rotational damping across the X axis. -- The lower, the longer an impulse from one side takes to travel to the other side. set_param_x :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param_x cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_set_param_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "set_param_x" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint.set_param_x {-# NOINLINE bindGeneric6DOFJoint_set_param_y #-} -- | The amount of rotational damping across the Y axis. The lower, the more dampening occurs. bindGeneric6DOFJoint_set_param_y :: MethodBind bindGeneric6DOFJoint_set_param_y = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "set_param_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of rotational damping across the Y axis. The lower, the more dampening occurs. set_param_y :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param_y cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_set_param_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "set_param_y" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint.set_param_y {-# NOINLINE bindGeneric6DOFJoint_set_param_z #-} -- | The amount of rotational damping across the Z axis. The lower, the more dampening occurs. bindGeneric6DOFJoint_set_param_z :: MethodBind bindGeneric6DOFJoint_set_param_z = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "set_param_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of rotational damping across the Z axis. The lower, the more dampening occurs. set_param_z :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param_z cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_set_param_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "set_param_z" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint.set_param_z {-# NOINLINE bindGeneric6DOFJoint_set_precision #-} bindGeneric6DOFJoint_set_precision :: MethodBind bindGeneric6DOFJoint_set_precision = unsafePerformIO $ withCString "Generic6DOFJoint" $ \ clsNamePtr -> withCString "set_precision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_precision :: (Generic6DOFJoint :< cls, Object :< cls) => cls -> Int -> IO () set_precision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeneric6DOFJoint_set_precision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Generic6DOFJoint "set_precision" '[Int] (IO ()) where nodeMethod = Godot.Core.Generic6DOFJoint.set_precision ================================================ FILE: src/Godot/Core/Geometry.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Geometry (Godot.Core.Geometry._END_POLYGON, Godot.Core.Geometry._JOIN_ROUND, Godot.Core.Geometry._OPERATION_XOR, Godot.Core.Geometry._JOIN_MITER, Godot.Core.Geometry._END_JOINED, Godot.Core.Geometry._OPERATION_UNION, Godot.Core.Geometry._JOIN_SQUARE, Godot.Core.Geometry._OPERATION_INTERSECTION, Godot.Core.Geometry._END_BUTT, Godot.Core.Geometry._END_ROUND, Godot.Core.Geometry._OPERATION_DIFFERENCE, Godot.Core.Geometry._END_SQUARE, Godot.Core.Geometry.build_box_planes, Godot.Core.Geometry.build_capsule_planes, Godot.Core.Geometry.build_cylinder_planes, Godot.Core.Geometry.clip_polygon, Godot.Core.Geometry.clip_polygons_2d, Godot.Core.Geometry.clip_polyline_with_polygon_2d, Godot.Core.Geometry.convex_hull_2d, Godot.Core.Geometry.exclude_polygons_2d, Godot.Core.Geometry.get_closest_point_to_segment, Godot.Core.Geometry.get_closest_point_to_segment_2d, Godot.Core.Geometry.get_closest_point_to_segment_uncapped, Godot.Core.Geometry.get_closest_point_to_segment_uncapped_2d, Godot.Core.Geometry.get_closest_points_between_segments, Godot.Core.Geometry.get_closest_points_between_segments_2d, Godot.Core.Geometry.get_uv84_normal_bit, Godot.Core.Geometry.intersect_polygons_2d, Godot.Core.Geometry.intersect_polyline_with_polygon_2d, Godot.Core.Geometry.is_point_in_circle, Godot.Core.Geometry.is_point_in_polygon, Godot.Core.Geometry.is_polygon_clockwise, Godot.Core.Geometry.line_intersects_line_2d, Godot.Core.Geometry.make_atlas, Godot.Core.Geometry.merge_polygons_2d, Godot.Core.Geometry.offset_polygon_2d, Godot.Core.Geometry.offset_polyline_2d, Godot.Core.Geometry.point_is_inside_triangle, Godot.Core.Geometry.ray_intersects_triangle, Godot.Core.Geometry.segment_intersects_circle, Godot.Core.Geometry.segment_intersects_convex, Godot.Core.Geometry.segment_intersects_cylinder, Godot.Core.Geometry.segment_intersects_segment_2d, Godot.Core.Geometry.segment_intersects_sphere, Godot.Core.Geometry.segment_intersects_triangle, Godot.Core.Geometry.triangulate_delaunay_2d, Godot.Core.Geometry.triangulate_polygon) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _END_POLYGON :: Int _END_POLYGON = 0 _JOIN_ROUND :: Int _JOIN_ROUND = 1 _OPERATION_XOR :: Int _OPERATION_XOR = 3 _JOIN_MITER :: Int _JOIN_MITER = 2 _END_JOINED :: Int _END_JOINED = 1 _OPERATION_UNION :: Int _OPERATION_UNION = 0 _JOIN_SQUARE :: Int _JOIN_SQUARE = 0 _OPERATION_INTERSECTION :: Int _OPERATION_INTERSECTION = 2 _END_BUTT :: Int _END_BUTT = 2 _END_ROUND :: Int _END_ROUND = 4 _OPERATION_DIFFERENCE :: Int _OPERATION_DIFFERENCE = 1 _END_SQUARE :: Int _END_SQUARE = 3 {-# NOINLINE bindGeometry_build_box_planes #-} -- | Returns an array with 6 @Plane@s that describe the sides of a box centered at the origin. The box size is defined by @extents@, which represents one (positive) corner of the box (i.e. half its actual size). bindGeometry_build_box_planes :: MethodBind bindGeometry_build_box_planes = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "build_box_planes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with 6 @Plane@s that describe the sides of a box centered at the origin. The box size is defined by @extents@, which represents one (positive) corner of the box (i.e. half its actual size). build_box_planes :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> IO Array build_box_planes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_build_box_planes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "build_box_planes" '[Vector3] (IO Array) where nodeMethod = Godot.Core.Geometry.build_box_planes {-# NOINLINE bindGeometry_build_capsule_planes #-} -- | Returns an array of @Plane@s closely bounding a faceted capsule centered at the origin with radius @radius@ and height @height@. The parameter @sides@ defines how many planes will be generated for the side part of the capsule, whereas @lats@ gives the number of latitudinal steps at the bottom and top of the capsule. The parameter @axis@ describes the axis along which the capsule is oriented (0 for X, 1 for Y, 2 for Z). bindGeometry_build_capsule_planes :: MethodBind bindGeometry_build_capsule_planes = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "build_capsule_planes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of @Plane@s closely bounding a faceted capsule centered at the origin with radius @radius@ and height @height@. The parameter @sides@ defines how many planes will be generated for the side part of the capsule, whereas @lats@ gives the number of latitudinal steps at the bottom and top of the capsule. The parameter @axis@ describes the axis along which the capsule is oriented (0 for X, 1 for Y, 2 for Z). build_capsule_planes :: (Geometry :< cls, Object :< cls) => cls -> Float -> Float -> Int -> Int -> Maybe Int -> IO Array build_capsule_planes cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantInt (2)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_build_capsule_planes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "build_capsule_planes" '[Float, Float, Int, Int, Maybe Int] (IO Array) where nodeMethod = Godot.Core.Geometry.build_capsule_planes {-# NOINLINE bindGeometry_build_cylinder_planes #-} -- | Returns an array of @Plane@s closely bounding a faceted cylinder centered at the origin with radius @radius@ and height @height@. The parameter @sides@ defines how many planes will be generated for the round part of the cylinder. The parameter @axis@ describes the axis along which the cylinder is oriented (0 for X, 1 for Y, 2 for Z). bindGeometry_build_cylinder_planes :: MethodBind bindGeometry_build_cylinder_planes = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "build_cylinder_planes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of @Plane@s closely bounding a faceted cylinder centered at the origin with radius @radius@ and height @height@. The parameter @sides@ defines how many planes will be generated for the round part of the cylinder. The parameter @axis@ describes the axis along which the cylinder is oriented (0 for X, 1 for Y, 2 for Z). build_cylinder_planes :: (Geometry :< cls, Object :< cls) => cls -> Float -> Float -> Int -> Maybe Int -> IO Array build_cylinder_planes cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantInt (2)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_build_cylinder_planes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "build_cylinder_planes" '[Float, Float, Int, Maybe Int] (IO Array) where nodeMethod = Godot.Core.Geometry.build_cylinder_planes {-# NOINLINE bindGeometry_clip_polygon #-} -- | Clips the polygon defined by the points in @points@ against the @plane@ and returns the points of the clipped polygon. bindGeometry_clip_polygon :: MethodBind bindGeometry_clip_polygon = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "clip_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clips the polygon defined by the points in @points@ against the @plane@ and returns the points of the clipped polygon. clip_polygon :: (Geometry :< cls, Object :< cls) => cls -> PoolVector3Array -> Plane -> IO PoolVector3Array clip_polygon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_clip_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "clip_polygon" '[PoolVector3Array, Plane] (IO PoolVector3Array) where nodeMethod = Godot.Core.Geometry.clip_polygon {-# NOINLINE bindGeometry_clip_polygons_2d #-} -- | Clips @polygon_a@ against @polygon_b@ and returns an array of clipped polygons. This performs @OPERATION_DIFFERENCE@ between polygons. Returns an empty array if @polygon_b@ completely overlaps @polygon_a@. -- If @polygon_b@ is enclosed by @polygon_a@, returns an outer polygon (boundary) and inner polygon (hole) which could be distiguished by calling @method is_polygon_clockwise@. bindGeometry_clip_polygons_2d :: MethodBind bindGeometry_clip_polygons_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "clip_polygons_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clips @polygon_a@ against @polygon_b@ and returns an array of clipped polygons. This performs @OPERATION_DIFFERENCE@ between polygons. Returns an empty array if @polygon_b@ completely overlaps @polygon_a@. -- If @polygon_b@ is enclosed by @polygon_a@, returns an outer polygon (boundary) and inner polygon (hole) which could be distiguished by calling @method is_polygon_clockwise@. clip_polygons_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolVector2Array -> IO Array clip_polygons_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_clip_polygons_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "clip_polygons_2d" '[PoolVector2Array, PoolVector2Array] (IO Array) where nodeMethod = Godot.Core.Geometry.clip_polygons_2d {-# NOINLINE bindGeometry_clip_polyline_with_polygon_2d #-} -- | Clips @polyline@ against @polygon@ and returns an array of clipped polylines. This performs @OPERATION_DIFFERENCE@ between the polyline and the polygon. This operation can be thought of as cutting a line with a closed shape. bindGeometry_clip_polyline_with_polygon_2d :: MethodBind bindGeometry_clip_polyline_with_polygon_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "clip_polyline_with_polygon_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clips @polyline@ against @polygon@ and returns an array of clipped polylines. This performs @OPERATION_DIFFERENCE@ between the polyline and the polygon. This operation can be thought of as cutting a line with a closed shape. clip_polyline_with_polygon_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolVector2Array -> IO Array clip_polyline_with_polygon_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_clip_polyline_with_polygon_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "clip_polyline_with_polygon_2d" '[PoolVector2Array, PoolVector2Array] (IO Array) where nodeMethod = Godot.Core.Geometry.clip_polyline_with_polygon_2d {-# NOINLINE bindGeometry_convex_hull_2d #-} -- | Given an array of @Vector2@s, returns the convex hull as a list of points in counterclockwise order. The last point is the same as the first one. bindGeometry_convex_hull_2d :: MethodBind bindGeometry_convex_hull_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "convex_hull_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Given an array of @Vector2@s, returns the convex hull as a list of points in counterclockwise order. The last point is the same as the first one. convex_hull_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> IO PoolVector2Array convex_hull_2d cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_convex_hull_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "convex_hull_2d" '[PoolVector2Array] (IO PoolVector2Array) where nodeMethod = Godot.Core.Geometry.convex_hull_2d {-# NOINLINE bindGeometry_exclude_polygons_2d #-} -- | Mutually excludes common area defined by intersection of @polygon_a@ and @polygon_b@ (see @method intersect_polygons_2d@) and returns an array of excluded polygons. This performs @OPERATION_XOR@ between polygons. In other words, returns all but common area between polygons. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distiguished by calling @method is_polygon_clockwise@. bindGeometry_exclude_polygons_2d :: MethodBind bindGeometry_exclude_polygons_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "exclude_polygons_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Mutually excludes common area defined by intersection of @polygon_a@ and @polygon_b@ (see @method intersect_polygons_2d@) and returns an array of excluded polygons. This performs @OPERATION_XOR@ between polygons. In other words, returns all but common area between polygons. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distiguished by calling @method is_polygon_clockwise@. exclude_polygons_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolVector2Array -> IO Array exclude_polygons_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_exclude_polygons_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "exclude_polygons_2d" '[PoolVector2Array, PoolVector2Array] (IO Array) where nodeMethod = Godot.Core.Geometry.exclude_polygons_2d {-# NOINLINE bindGeometry_get_closest_point_to_segment #-} -- | Returns the 3D point on the 3D segment (@s1@, @s2@) that is closest to @point@. The returned point will always be inside the specified segment. bindGeometry_get_closest_point_to_segment :: MethodBind bindGeometry_get_closest_point_to_segment = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "get_closest_point_to_segment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the 3D point on the 3D segment (@s1@, @s2@) that is closest to @point@. The returned point will always be inside the specified segment. get_closest_point_to_segment :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Vector3 -> IO Vector3 get_closest_point_to_segment cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_get_closest_point_to_segment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "get_closest_point_to_segment" '[Vector3, Vector3, Vector3] (IO Vector3) where nodeMethod = Godot.Core.Geometry.get_closest_point_to_segment {-# NOINLINE bindGeometry_get_closest_point_to_segment_2d #-} -- | Returns the 2D point on the 2D segment (@s1@, @s2@) that is closest to @point@. The returned point will always be inside the specified segment. bindGeometry_get_closest_point_to_segment_2d :: MethodBind bindGeometry_get_closest_point_to_segment_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "get_closest_point_to_segment_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the 2D point on the 2D segment (@s1@, @s2@) that is closest to @point@. The returned point will always be inside the specified segment. get_closest_point_to_segment_2d :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Vector2 -> IO Vector2 get_closest_point_to_segment_2d cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_get_closest_point_to_segment_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "get_closest_point_to_segment_2d" '[Vector2, Vector2, Vector2] (IO Vector2) where nodeMethod = Godot.Core.Geometry.get_closest_point_to_segment_2d {-# NOINLINE bindGeometry_get_closest_point_to_segment_uncapped #-} -- | Returns the 3D point on the 3D line defined by (@s1@, @s2@) that is closest to @point@. The returned point can be inside the segment (@s1@, @s2@) or outside of it, i.e. somewhere on the line extending from the segment. bindGeometry_get_closest_point_to_segment_uncapped :: MethodBind bindGeometry_get_closest_point_to_segment_uncapped = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "get_closest_point_to_segment_uncapped" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the 3D point on the 3D line defined by (@s1@, @s2@) that is closest to @point@. The returned point can be inside the segment (@s1@, @s2@) or outside of it, i.e. somewhere on the line extending from the segment. get_closest_point_to_segment_uncapped :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Vector3 -> IO Vector3 get_closest_point_to_segment_uncapped cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_get_closest_point_to_segment_uncapped (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "get_closest_point_to_segment_uncapped" '[Vector3, Vector3, Vector3] (IO Vector3) where nodeMethod = Godot.Core.Geometry.get_closest_point_to_segment_uncapped {-# NOINLINE bindGeometry_get_closest_point_to_segment_uncapped_2d #-} -- | Returns the 2D point on the 2D line defined by (@s1@, @s2@) that is closest to @point@. The returned point can be inside the segment (@s1@, @s2@) or outside of it, i.e. somewhere on the line extending from the segment. bindGeometry_get_closest_point_to_segment_uncapped_2d :: MethodBind bindGeometry_get_closest_point_to_segment_uncapped_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "get_closest_point_to_segment_uncapped_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the 2D point on the 2D line defined by (@s1@, @s2@) that is closest to @point@. The returned point can be inside the segment (@s1@, @s2@) or outside of it, i.e. somewhere on the line extending from the segment. get_closest_point_to_segment_uncapped_2d :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Vector2 -> IO Vector2 get_closest_point_to_segment_uncapped_2d cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_get_closest_point_to_segment_uncapped_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "get_closest_point_to_segment_uncapped_2d" '[Vector2, Vector2, Vector2] (IO Vector2) where nodeMethod = Godot.Core.Geometry.get_closest_point_to_segment_uncapped_2d {-# NOINLINE bindGeometry_get_closest_points_between_segments #-} -- | Given the two 3D segments (@p1@, @p2@) and (@q1@, @q2@), finds those two points on the two segments that are closest to each other. Returns a @PoolVector3Array@ that contains this point on (@p1@, @p2@) as well the accompanying point on (@q1@, @q2@). bindGeometry_get_closest_points_between_segments :: MethodBind bindGeometry_get_closest_points_between_segments = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "get_closest_points_between_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Given the two 3D segments (@p1@, @p2@) and (@q1@, @q2@), finds those two points on the two segments that are closest to each other. Returns a @PoolVector3Array@ that contains this point on (@p1@, @p2@) as well the accompanying point on (@q1@, @q2@). get_closest_points_between_segments :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Vector3 -> Vector3 -> IO PoolVector3Array get_closest_points_between_segments cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_get_closest_points_between_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "get_closest_points_between_segments" '[Vector3, Vector3, Vector3, Vector3] (IO PoolVector3Array) where nodeMethod = Godot.Core.Geometry.get_closest_points_between_segments {-# NOINLINE bindGeometry_get_closest_points_between_segments_2d #-} -- | Given the two 2D segments (@p1@, @p2@) and (@q1@, @q2@), finds those two points on the two segments that are closest to each other. Returns a @PoolVector2Array@ that contains this point on (@p1@, @p2@) as well the accompanying point on (@q1@, @q2@). bindGeometry_get_closest_points_between_segments_2d :: MethodBind bindGeometry_get_closest_points_between_segments_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "get_closest_points_between_segments_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Given the two 2D segments (@p1@, @p2@) and (@q1@, @q2@), finds those two points on the two segments that are closest to each other. Returns a @PoolVector2Array@ that contains this point on (@p1@, @p2@) as well the accompanying point on (@q1@, @q2@). get_closest_points_between_segments_2d :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Vector2 -> Vector2 -> IO PoolVector2Array get_closest_points_between_segments_2d cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_get_closest_points_between_segments_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "get_closest_points_between_segments_2d" '[Vector2, Vector2, Vector2, Vector2] (IO PoolVector2Array) where nodeMethod = Godot.Core.Geometry.get_closest_points_between_segments_2d {-# NOINLINE bindGeometry_get_uv84_normal_bit #-} -- | Used internally by the engine. bindGeometry_get_uv84_normal_bit :: MethodBind bindGeometry_get_uv84_normal_bit = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "get_uv84_normal_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used internally by the engine. get_uv84_normal_bit :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> IO Int get_uv84_normal_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_get_uv84_normal_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "get_uv84_normal_bit" '[Vector3] (IO Int) where nodeMethod = Godot.Core.Geometry.get_uv84_normal_bit {-# NOINLINE bindGeometry_intersect_polygons_2d #-} -- | Intersects @polygon_a@ with @polygon_b@ and returns an array of intersected polygons. This performs @OPERATION_INTERSECTION@ between polygons. In other words, returns common area shared by polygons. Returns an empty array if no intersection occurs. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling @method is_polygon_clockwise@. bindGeometry_intersect_polygons_2d :: MethodBind bindGeometry_intersect_polygons_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "intersect_polygons_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Intersects @polygon_a@ with @polygon_b@ and returns an array of intersected polygons. This performs @OPERATION_INTERSECTION@ between polygons. In other words, returns common area shared by polygons. Returns an empty array if no intersection occurs. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling @method is_polygon_clockwise@. intersect_polygons_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolVector2Array -> IO Array intersect_polygons_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_intersect_polygons_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "intersect_polygons_2d" '[PoolVector2Array, PoolVector2Array] (IO Array) where nodeMethod = Godot.Core.Geometry.intersect_polygons_2d {-# NOINLINE bindGeometry_intersect_polyline_with_polygon_2d #-} -- | Intersects @polyline@ with @polygon@ and returns an array of intersected polylines. This performs @OPERATION_INTERSECTION@ between the polyline and the polygon. This operation can be thought of as chopping a line with a closed shape. bindGeometry_intersect_polyline_with_polygon_2d :: MethodBind bindGeometry_intersect_polyline_with_polygon_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "intersect_polyline_with_polygon_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Intersects @polyline@ with @polygon@ and returns an array of intersected polylines. This performs @OPERATION_INTERSECTION@ between the polyline and the polygon. This operation can be thought of as chopping a line with a closed shape. intersect_polyline_with_polygon_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolVector2Array -> IO Array intersect_polyline_with_polygon_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_intersect_polyline_with_polygon_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "intersect_polyline_with_polygon_2d" '[PoolVector2Array, PoolVector2Array] (IO Array) where nodeMethod = Godot.Core.Geometry.intersect_polyline_with_polygon_2d {-# NOINLINE bindGeometry_is_point_in_circle #-} -- | Returns @true@ if @point@ is inside the circle or if it's located exactly @i@on@/i@ the circle's boundary, otherwise returns @false@. bindGeometry_is_point_in_circle :: MethodBind bindGeometry_is_point_in_circle = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "is_point_in_circle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @point@ is inside the circle or if it's located exactly @i@on@/i@ the circle's boundary, otherwise returns @false@. is_point_in_circle :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Float -> IO Bool is_point_in_circle cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_is_point_in_circle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "is_point_in_circle" '[Vector2, Vector2, Float] (IO Bool) where nodeMethod = Godot.Core.Geometry.is_point_in_circle {-# NOINLINE bindGeometry_is_point_in_polygon #-} -- | Returns @true@ if @point@ is inside @polygon@ or if it's located exactly @i@on@/i@ polygon's boundary, otherwise returns @false@. bindGeometry_is_point_in_polygon :: MethodBind bindGeometry_is_point_in_polygon = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "is_point_in_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @point@ is inside @polygon@ or if it's located exactly @i@on@/i@ polygon's boundary, otherwise returns @false@. is_point_in_polygon :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> PoolVector2Array -> IO Bool is_point_in_polygon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_is_point_in_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "is_point_in_polygon" '[Vector2, PoolVector2Array] (IO Bool) where nodeMethod = Godot.Core.Geometry.is_point_in_polygon {-# NOINLINE bindGeometry_is_polygon_clockwise #-} -- | Returns @true@ if @polygon@'s vertices are ordered in clockwise order, otherwise returns @false@. bindGeometry_is_polygon_clockwise :: MethodBind bindGeometry_is_polygon_clockwise = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "is_polygon_clockwise" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @polygon@'s vertices are ordered in clockwise order, otherwise returns @false@. is_polygon_clockwise :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> IO Bool is_polygon_clockwise cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_is_polygon_clockwise (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "is_polygon_clockwise" '[PoolVector2Array] (IO Bool) where nodeMethod = Godot.Core.Geometry.is_polygon_clockwise {-# NOINLINE bindGeometry_line_intersects_line_2d #-} -- | Checks if the two lines (@from_a@, @dir_a@) and (@from_b@, @dir_b@) intersect. If yes, return the point of intersection as @Vector2@. If no intersection takes place, returns an empty @Variant@. -- __Note:__ The lines are specified using direction vectors, not end points. bindGeometry_line_intersects_line_2d :: MethodBind bindGeometry_line_intersects_line_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "line_intersects_line_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks if the two lines (@from_a@, @dir_a@) and (@from_b@, @dir_b@) intersect. If yes, return the point of intersection as @Vector2@. If no intersection takes place, returns an empty @Variant@. -- __Note:__ The lines are specified using direction vectors, not end points. line_intersects_line_2d :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Vector2 -> Vector2 -> IO GodotVariant line_intersects_line_2d cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_line_intersects_line_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "line_intersects_line_2d" '[Vector2, Vector2, Vector2, Vector2] (IO GodotVariant) where nodeMethod = Godot.Core.Geometry.line_intersects_line_2d {-# NOINLINE bindGeometry_make_atlas #-} -- | Given an array of @Vector2@s representing tiles, builds an atlas. The returned dictionary has two keys: @points@ is a vector of @Vector2@ that specifies the positions of each tile, @size@ contains the overall size of the whole atlas as @Vector2@. bindGeometry_make_atlas :: MethodBind bindGeometry_make_atlas = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "make_atlas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Given an array of @Vector2@s representing tiles, builds an atlas. The returned dictionary has two keys: @points@ is a vector of @Vector2@ that specifies the positions of each tile, @size@ contains the overall size of the whole atlas as @Vector2@. make_atlas :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> IO Dictionary make_atlas cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_make_atlas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "make_atlas" '[PoolVector2Array] (IO Dictionary) where nodeMethod = Godot.Core.Geometry.make_atlas {-# NOINLINE bindGeometry_merge_polygons_2d #-} -- | Merges (combines) @polygon_a@ and @polygon_b@ and returns an array of merged polygons. This performs @OPERATION_UNION@ between polygons. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling @method is_polygon_clockwise@. bindGeometry_merge_polygons_2d :: MethodBind bindGeometry_merge_polygons_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "merge_polygons_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Merges (combines) @polygon_a@ and @polygon_b@ and returns an array of merged polygons. This performs @OPERATION_UNION@ between polygons. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling @method is_polygon_clockwise@. merge_polygons_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolVector2Array -> IO Array merge_polygons_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_merge_polygons_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "merge_polygons_2d" '[PoolVector2Array, PoolVector2Array] (IO Array) where nodeMethod = Godot.Core.Geometry.merge_polygons_2d {-# NOINLINE bindGeometry_offset_polygon_2d #-} -- | Inflates or deflates @polygon@ by @delta@ units (pixels). If @delta@ is positive, makes the polygon grow outward. If @delta@ is negative, shrinks the polygon inward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. Returns an empty array if @delta@ is negative and the absolute value of it approximately exceeds the minimum bounding rectangle dimensions of the polygon. -- Each polygon's vertices will be rounded as determined by @join_type@, see @enum PolyJoinType@. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling @method is_polygon_clockwise@. -- __Note:__ To translate the polygon's vertices specifically, use the @method Transform2D.xform@ method: -- -- @ -- -- var polygon = PoolVector2Array(@Vector2(0, 0), Vector2(100, 0), Vector2(100, 100), Vector2(0, 100)@) -- var offset = Vector2(50, 50) -- polygon = Transform2D(0, offset).xform(polygon) -- print(polygon) # prints @Vector2(50, 50), Vector2(150, 50), Vector2(150, 150), Vector2(50, 150)@ -- -- @ bindGeometry_offset_polygon_2d :: MethodBind bindGeometry_offset_polygon_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "offset_polygon_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Inflates or deflates @polygon@ by @delta@ units (pixels). If @delta@ is positive, makes the polygon grow outward. If @delta@ is negative, shrinks the polygon inward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. Returns an empty array if @delta@ is negative and the absolute value of it approximately exceeds the minimum bounding rectangle dimensions of the polygon. -- Each polygon's vertices will be rounded as determined by @join_type@, see @enum PolyJoinType@. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling @method is_polygon_clockwise@. -- __Note:__ To translate the polygon's vertices specifically, use the @method Transform2D.xform@ method: -- -- @ -- -- var polygon = PoolVector2Array(@Vector2(0, 0), Vector2(100, 0), Vector2(100, 100), Vector2(0, 100)@) -- var offset = Vector2(50, 50) -- polygon = Transform2D(0, offset).xform(polygon) -- print(polygon) # prints @Vector2(50, 50), Vector2(150, 50), Vector2(150, 150), Vector2(50, 150)@ -- -- @ offset_polygon_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> Float -> Maybe Int -> IO Array offset_polygon_2d cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_offset_polygon_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "offset_polygon_2d" '[PoolVector2Array, Float, Maybe Int] (IO Array) where nodeMethod = Godot.Core.Geometry.offset_polygon_2d {-# NOINLINE bindGeometry_offset_polyline_2d #-} -- | Inflates or deflates @polyline@ by @delta@ units (pixels), producing polygons. If @delta@ is positive, makes the polyline grow outward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. If @delta@ is negative, returns an empty array. -- Each polygon's vertices will be rounded as determined by @join_type@, see @enum PolyJoinType@. -- Each polygon's endpoints will be rounded as determined by @end_type@, see @enum PolyEndType@. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling @method is_polygon_clockwise@. bindGeometry_offset_polyline_2d :: MethodBind bindGeometry_offset_polyline_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "offset_polyline_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Inflates or deflates @polyline@ by @delta@ units (pixels), producing polygons. If @delta@ is positive, makes the polyline grow outward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. If @delta@ is negative, returns an empty array. -- Each polygon's vertices will be rounded as determined by @join_type@, see @enum PolyJoinType@. -- Each polygon's endpoints will be rounded as determined by @end_type@, see @enum PolyEndType@. -- The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling @method is_polygon_clockwise@. offset_polyline_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> Float -> Maybe Int -> Maybe Int -> IO Array offset_polyline_2d cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (0)) toVariant arg3, maybe (VariantInt (3)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_offset_polyline_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "offset_polyline_2d" '[PoolVector2Array, Float, Maybe Int, Maybe Int] (IO Array) where nodeMethod = Godot.Core.Geometry.offset_polyline_2d {-# NOINLINE bindGeometry_point_is_inside_triangle #-} -- | Returns if @point@ is inside the triangle specified by @a@, @b@ and @c@. bindGeometry_point_is_inside_triangle :: MethodBind bindGeometry_point_is_inside_triangle = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "point_is_inside_triangle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns if @point@ is inside the triangle specified by @a@, @b@ and @c@. point_is_inside_triangle :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Vector2 -> Vector2 -> IO Bool point_is_inside_triangle cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_point_is_inside_triangle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "point_is_inside_triangle" '[Vector2, Vector2, Vector2, Vector2] (IO Bool) where nodeMethod = Godot.Core.Geometry.point_is_inside_triangle {-# NOINLINE bindGeometry_ray_intersects_triangle #-} -- | Tests if the 3D ray starting at @from@ with the direction of @dir@ intersects the triangle specified by @a@, @b@ and @c@. If yes, returns the point of intersection as @Vector3@. If no intersection takes place, an empty @Variant@ is returned. bindGeometry_ray_intersects_triangle :: MethodBind bindGeometry_ray_intersects_triangle = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "ray_intersects_triangle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tests if the 3D ray starting at @from@ with the direction of @dir@ intersects the triangle specified by @a@, @b@ and @c@. If yes, returns the point of intersection as @Vector3@. If no intersection takes place, an empty @Variant@ is returned. ray_intersects_triangle :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Vector3 -> Vector3 -> Vector3 -> IO GodotVariant ray_intersects_triangle cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_ray_intersects_triangle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "ray_intersects_triangle" '[Vector3, Vector3, Vector3, Vector3, Vector3] (IO GodotVariant) where nodeMethod = Godot.Core.Geometry.ray_intersects_triangle {-# NOINLINE bindGeometry_segment_intersects_circle #-} -- | Given the 2D segment (@segment_from@, @segment_to@), returns the position on the segment (as a number between 0 and 1) at which the segment hits the circle that is located at position @circle_position@ and has radius @circle_radius@. If the segment does not intersect the circle, -1 is returned (this is also the case if the line extending the segment would intersect the circle, but the segment does not). bindGeometry_segment_intersects_circle :: MethodBind bindGeometry_segment_intersects_circle = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "segment_intersects_circle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Given the 2D segment (@segment_from@, @segment_to@), returns the position on the segment (as a number between 0 and 1) at which the segment hits the circle that is located at position @circle_position@ and has radius @circle_radius@. If the segment does not intersect the circle, -1 is returned (this is also the case if the line extending the segment would intersect the circle, but the segment does not). segment_intersects_circle :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Vector2 -> Float -> IO Float segment_intersects_circle cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_segment_intersects_circle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "segment_intersects_circle" '[Vector2, Vector2, Vector2, Float] (IO Float) where nodeMethod = Godot.Core.Geometry.segment_intersects_circle {-# NOINLINE bindGeometry_segment_intersects_convex #-} -- | Given a convex hull defined though the @Plane@s in the array @planes@, tests if the segment (@from@, @to@) intersects with that hull. If an intersection is found, returns a @PoolVector3Array@ containing the point the intersection and the hull's normal. If no intersecion is found, an the returned array is empty. bindGeometry_segment_intersects_convex :: MethodBind bindGeometry_segment_intersects_convex = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "segment_intersects_convex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Given a convex hull defined though the @Plane@s in the array @planes@, tests if the segment (@from@, @to@) intersects with that hull. If an intersection is found, returns a @PoolVector3Array@ containing the point the intersection and the hull's normal. If no intersecion is found, an the returned array is empty. segment_intersects_convex :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Array -> IO PoolVector3Array segment_intersects_convex cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_segment_intersects_convex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "segment_intersects_convex" '[Vector3, Vector3, Array] (IO PoolVector3Array) where nodeMethod = Godot.Core.Geometry.segment_intersects_convex {-# NOINLINE bindGeometry_segment_intersects_cylinder #-} -- | Checks if the segment (@from@, @to@) intersects the cylinder with height @height@ that is centered at the origin and has radius @radius@. If no, returns an empty @PoolVector3Array@. If an intersection takes place, the returned array contains the point of intersection and the cylinder's normal at the point of intersection. bindGeometry_segment_intersects_cylinder :: MethodBind bindGeometry_segment_intersects_cylinder = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "segment_intersects_cylinder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks if the segment (@from@, @to@) intersects the cylinder with height @height@ that is centered at the origin and has radius @radius@. If no, returns an empty @PoolVector3Array@. If an intersection takes place, the returned array contains the point of intersection and the cylinder's normal at the point of intersection. segment_intersects_cylinder :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Float -> Float -> IO PoolVector3Array segment_intersects_cylinder cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_segment_intersects_cylinder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "segment_intersects_cylinder" '[Vector3, Vector3, Float, Float] (IO PoolVector3Array) where nodeMethod = Godot.Core.Geometry.segment_intersects_cylinder {-# NOINLINE bindGeometry_segment_intersects_segment_2d #-} -- | Checks if the two segments (@from_a@, @to_a@) and (@from_b@, @to_b@) intersect. If yes, return the point of intersection as @Vector2@. If no intersection takes place, returns an empty @Variant@. bindGeometry_segment_intersects_segment_2d :: MethodBind bindGeometry_segment_intersects_segment_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "segment_intersects_segment_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks if the two segments (@from_a@, @to_a@) and (@from_b@, @to_b@) intersect. If yes, return the point of intersection as @Vector2@. If no intersection takes place, returns an empty @Variant@. segment_intersects_segment_2d :: (Geometry :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Vector2 -> Vector2 -> IO GodotVariant segment_intersects_segment_2d cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_segment_intersects_segment_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "segment_intersects_segment_2d" '[Vector2, Vector2, Vector2, Vector2] (IO GodotVariant) where nodeMethod = Godot.Core.Geometry.segment_intersects_segment_2d {-# NOINLINE bindGeometry_segment_intersects_sphere #-} -- | Checks if the segment (@from@, @to@) intersects the sphere that is located at @sphere_position@ and has radius @sphere_radius@. If no, returns an empty @PoolVector3Array@. If yes, returns a @PoolVector3Array@ containing the point of intersection and the sphere's normal at the point of intersection. bindGeometry_segment_intersects_sphere :: MethodBind bindGeometry_segment_intersects_sphere = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "segment_intersects_sphere" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks if the segment (@from@, @to@) intersects the sphere that is located at @sphere_position@ and has radius @sphere_radius@. If no, returns an empty @PoolVector3Array@. If yes, returns a @PoolVector3Array@ containing the point of intersection and the sphere's normal at the point of intersection. segment_intersects_sphere :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Vector3 -> Float -> IO PoolVector3Array segment_intersects_sphere cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_segment_intersects_sphere (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "segment_intersects_sphere" '[Vector3, Vector3, Vector3, Float] (IO PoolVector3Array) where nodeMethod = Godot.Core.Geometry.segment_intersects_sphere {-# NOINLINE bindGeometry_segment_intersects_triangle #-} -- | Tests if the segment (@from@, @to@) intersects the triangle @a@, @b@, @c@. If yes, returns the point of intersection as @Vector3@. If no intersection takes place, an empty @Variant@ is returned. bindGeometry_segment_intersects_triangle :: MethodBind bindGeometry_segment_intersects_triangle = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "segment_intersects_triangle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tests if the segment (@from@, @to@) intersects the triangle @a@, @b@, @c@. If yes, returns the point of intersection as @Vector3@. If no intersection takes place, an empty @Variant@ is returned. segment_intersects_triangle :: (Geometry :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Vector3 -> Vector3 -> Vector3 -> IO GodotVariant segment_intersects_triangle cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_segment_intersects_triangle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "segment_intersects_triangle" '[Vector3, Vector3, Vector3, Vector3, Vector3] (IO GodotVariant) where nodeMethod = Godot.Core.Geometry.segment_intersects_triangle {-# NOINLINE bindGeometry_triangulate_delaunay_2d #-} -- | Triangulates the area specified by discrete set of @points@ such that no point is inside the circumcircle of any resulting triangle. Returns a @PoolIntArray@ where each triangle consists of three consecutive point indices into @points@ (i.e. the returned array will have @n * 3@ elements, with @n@ being the number of found triangles). If the triangulation did not succeed, an empty @PoolIntArray@ is returned. bindGeometry_triangulate_delaunay_2d :: MethodBind bindGeometry_triangulate_delaunay_2d = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "triangulate_delaunay_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Triangulates the area specified by discrete set of @points@ such that no point is inside the circumcircle of any resulting triangle. Returns a @PoolIntArray@ where each triangle consists of three consecutive point indices into @points@ (i.e. the returned array will have @n * 3@ elements, with @n@ being the number of found triangles). If the triangulation did not succeed, an empty @PoolIntArray@ is returned. triangulate_delaunay_2d :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> IO PoolIntArray triangulate_delaunay_2d cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_triangulate_delaunay_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "triangulate_delaunay_2d" '[PoolVector2Array] (IO PoolIntArray) where nodeMethod = Godot.Core.Geometry.triangulate_delaunay_2d {-# NOINLINE bindGeometry_triangulate_polygon #-} -- | Triangulates the polygon specified by the points in @polygon@. Returns a @PoolIntArray@ where each triangle consists of three consecutive point indices into @polygon@ (i.e. the returned array will have @n * 3@ elements, with @n@ being the number of found triangles). If the triangulation did not succeed, an empty @PoolIntArray@ is returned. bindGeometry_triangulate_polygon :: MethodBind bindGeometry_triangulate_polygon = unsafePerformIO $ withCString "_Geometry" $ \ clsNamePtr -> withCString "triangulate_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Triangulates the polygon specified by the points in @polygon@. Returns a @PoolIntArray@ where each triangle consists of three consecutive point indices into @polygon@ (i.e. the returned array will have @n * 3@ elements, with @n@ being the number of found triangles). If the triangulation did not succeed, an empty @PoolIntArray@ is returned. triangulate_polygon :: (Geometry :< cls, Object :< cls) => cls -> PoolVector2Array -> IO PoolIntArray triangulate_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometry_triangulate_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Geometry "triangulate_polygon" '[PoolVector2Array] (IO PoolIntArray) where nodeMethod = Godot.Core.Geometry.triangulate_polygon ================================================ FILE: src/Godot/Core/GeometryInstance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GeometryInstance (Godot.Core.GeometryInstance._SHADOW_CASTING_SETTING_SHADOWS_ONLY, Godot.Core.GeometryInstance._FLAG_USE_BAKED_LIGHT, Godot.Core.GeometryInstance._FLAG_MAX, Godot.Core.GeometryInstance._SHADOW_CASTING_SETTING_DOUBLE_SIDED, Godot.Core.GeometryInstance._SHADOW_CASTING_SETTING_OFF, Godot.Core.GeometryInstance._FLAG_DRAW_NEXT_FRAME_IF_VISIBLE, Godot.Core.GeometryInstance._SHADOW_CASTING_SETTING_ON, Godot.Core.GeometryInstance.get_cast_shadows_setting, Godot.Core.GeometryInstance.get_extra_cull_margin, Godot.Core.GeometryInstance.get_flag, Godot.Core.GeometryInstance.get_lod_max_distance, Godot.Core.GeometryInstance.get_lod_max_hysteresis, Godot.Core.GeometryInstance.get_lod_min_distance, Godot.Core.GeometryInstance.get_lod_min_hysteresis, Godot.Core.GeometryInstance.get_material_override, Godot.Core.GeometryInstance.set_cast_shadows_setting, Godot.Core.GeometryInstance.set_custom_aabb, Godot.Core.GeometryInstance.set_extra_cull_margin, Godot.Core.GeometryInstance.set_flag, Godot.Core.GeometryInstance.set_lod_max_distance, Godot.Core.GeometryInstance.set_lod_max_hysteresis, Godot.Core.GeometryInstance.set_lod_min_distance, Godot.Core.GeometryInstance.set_lod_min_hysteresis, Godot.Core.GeometryInstance.set_material_override) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualInstance() _SHADOW_CASTING_SETTING_SHADOWS_ONLY :: Int _SHADOW_CASTING_SETTING_SHADOWS_ONLY = 3 _FLAG_USE_BAKED_LIGHT :: Int _FLAG_USE_BAKED_LIGHT = 0 _FLAG_MAX :: Int _FLAG_MAX = 2 _SHADOW_CASTING_SETTING_DOUBLE_SIDED :: Int _SHADOW_CASTING_SETTING_DOUBLE_SIDED = 2 _SHADOW_CASTING_SETTING_OFF :: Int _SHADOW_CASTING_SETTING_OFF = 0 _FLAG_DRAW_NEXT_FRAME_IF_VISIBLE :: Int _FLAG_DRAW_NEXT_FRAME_IF_VISIBLE = 1 _SHADOW_CASTING_SETTING_ON :: Int _SHADOW_CASTING_SETTING_ON = 1 instance NodeProperty GeometryInstance "cast_shadow" Int 'False where nodeProperty = (get_cast_shadows_setting, wrapDroppingSetter set_cast_shadows_setting, Nothing) instance NodeProperty GeometryInstance "extra_cull_margin" Float 'False where nodeProperty = (get_extra_cull_margin, wrapDroppingSetter set_extra_cull_margin, Nothing) instance NodeProperty GeometryInstance "lod_max_distance" Float 'False where nodeProperty = (get_lod_max_distance, wrapDroppingSetter set_lod_max_distance, Nothing) instance NodeProperty GeometryInstance "lod_max_hysteresis" Float 'False where nodeProperty = (get_lod_max_hysteresis, wrapDroppingSetter set_lod_max_hysteresis, Nothing) instance NodeProperty GeometryInstance "lod_min_distance" Float 'False where nodeProperty = (get_lod_min_distance, wrapDroppingSetter set_lod_min_distance, Nothing) instance NodeProperty GeometryInstance "lod_min_hysteresis" Float 'False where nodeProperty = (get_lod_min_hysteresis, wrapDroppingSetter set_lod_min_hysteresis, Nothing) instance NodeProperty GeometryInstance "material_override" Material 'False where nodeProperty = (get_material_override, wrapDroppingSetter set_material_override, Nothing) instance NodeProperty GeometryInstance "use_in_baked_light" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_flag, wrapIndexedSetter 0 set_flag, Nothing) {-# NOINLINE bindGeometryInstance_get_cast_shadows_setting #-} -- | The selected shadow casting flag. See @enum ShadowCastingSetting@ for possible values. bindGeometryInstance_get_cast_shadows_setting :: MethodBind bindGeometryInstance_get_cast_shadows_setting = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "get_cast_shadows_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The selected shadow casting flag. See @enum ShadowCastingSetting@ for possible values. get_cast_shadows_setting :: (GeometryInstance :< cls, Object :< cls) => cls -> IO Int get_cast_shadows_setting cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_get_cast_shadows_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "get_cast_shadows_setting" '[] (IO Int) where nodeMethod = Godot.Core.GeometryInstance.get_cast_shadows_setting {-# NOINLINE bindGeometryInstance_get_extra_cull_margin #-} -- | The extra distance added to the GeometryInstance's bounding box (@AABB@) to increase its cull box. bindGeometryInstance_get_extra_cull_margin :: MethodBind bindGeometryInstance_get_extra_cull_margin = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "get_extra_cull_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The extra distance added to the GeometryInstance's bounding box (@AABB@) to increase its cull box. get_extra_cull_margin :: (GeometryInstance :< cls, Object :< cls) => cls -> IO Float get_extra_cull_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_get_extra_cull_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "get_extra_cull_margin" '[] (IO Float) where nodeMethod = Godot.Core.GeometryInstance.get_extra_cull_margin {-# NOINLINE bindGeometryInstance_get_flag #-} -- | Returns the @enum GeometryInstance.Flags@ that have been set for this object. bindGeometryInstance_get_flag :: MethodBind bindGeometryInstance_get_flag = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "get_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @enum GeometryInstance.Flags@ that have been set for this object. get_flag :: (GeometryInstance :< cls, Object :< cls) => cls -> Int -> IO Bool get_flag cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_get_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "get_flag" '[Int] (IO Bool) where nodeMethod = Godot.Core.GeometryInstance.get_flag {-# NOINLINE bindGeometryInstance_get_lod_max_distance #-} -- | The GeometryInstance's max LOD distance. -- __Note:__ This property currently has no effect. bindGeometryInstance_get_lod_max_distance :: MethodBind bindGeometryInstance_get_lod_max_distance = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "get_lod_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The GeometryInstance's max LOD distance. -- __Note:__ This property currently has no effect. get_lod_max_distance :: (GeometryInstance :< cls, Object :< cls) => cls -> IO Float get_lod_max_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_get_lod_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "get_lod_max_distance" '[] (IO Float) where nodeMethod = Godot.Core.GeometryInstance.get_lod_max_distance {-# NOINLINE bindGeometryInstance_get_lod_max_hysteresis #-} -- | The GeometryInstance's max LOD margin. -- __Note:__ This property currently has no effect. bindGeometryInstance_get_lod_max_hysteresis :: MethodBind bindGeometryInstance_get_lod_max_hysteresis = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "get_lod_max_hysteresis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The GeometryInstance's max LOD margin. -- __Note:__ This property currently has no effect. get_lod_max_hysteresis :: (GeometryInstance :< cls, Object :< cls) => cls -> IO Float get_lod_max_hysteresis cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_get_lod_max_hysteresis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "get_lod_max_hysteresis" '[] (IO Float) where nodeMethod = Godot.Core.GeometryInstance.get_lod_max_hysteresis {-# NOINLINE bindGeometryInstance_get_lod_min_distance #-} -- | The GeometryInstance's min LOD distance. -- __Note:__ This property currently has no effect. bindGeometryInstance_get_lod_min_distance :: MethodBind bindGeometryInstance_get_lod_min_distance = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "get_lod_min_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The GeometryInstance's min LOD distance. -- __Note:__ This property currently has no effect. get_lod_min_distance :: (GeometryInstance :< cls, Object :< cls) => cls -> IO Float get_lod_min_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_get_lod_min_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "get_lod_min_distance" '[] (IO Float) where nodeMethod = Godot.Core.GeometryInstance.get_lod_min_distance {-# NOINLINE bindGeometryInstance_get_lod_min_hysteresis #-} -- | The GeometryInstance's min LOD margin. -- __Note:__ This property currently has no effect. bindGeometryInstance_get_lod_min_hysteresis :: MethodBind bindGeometryInstance_get_lod_min_hysteresis = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "get_lod_min_hysteresis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The GeometryInstance's min LOD margin. -- __Note:__ This property currently has no effect. get_lod_min_hysteresis :: (GeometryInstance :< cls, Object :< cls) => cls -> IO Float get_lod_min_hysteresis cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_get_lod_min_hysteresis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "get_lod_min_hysteresis" '[] (IO Float) where nodeMethod = Godot.Core.GeometryInstance.get_lod_min_hysteresis {-# NOINLINE bindGeometryInstance_get_material_override #-} -- | The material override for the whole geometry. -- If a material is assigned to this property, it will be used instead of any material set in any material slot of the mesh. bindGeometryInstance_get_material_override :: MethodBind bindGeometryInstance_get_material_override = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "get_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The material override for the whole geometry. -- If a material is assigned to this property, it will be used instead of any material set in any material slot of the mesh. get_material_override :: (GeometryInstance :< cls, Object :< cls) => cls -> IO Material get_material_override cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_get_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "get_material_override" '[] (IO Material) where nodeMethod = Godot.Core.GeometryInstance.get_material_override {-# NOINLINE bindGeometryInstance_set_cast_shadows_setting #-} -- | The selected shadow casting flag. See @enum ShadowCastingSetting@ for possible values. bindGeometryInstance_set_cast_shadows_setting :: MethodBind bindGeometryInstance_set_cast_shadows_setting = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_cast_shadows_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The selected shadow casting flag. See @enum ShadowCastingSetting@ for possible values. set_cast_shadows_setting :: (GeometryInstance :< cls, Object :< cls) => cls -> Int -> IO () set_cast_shadows_setting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_cast_shadows_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_cast_shadows_setting" '[Int] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_cast_shadows_setting {-# NOINLINE bindGeometryInstance_set_custom_aabb #-} -- | Overrides the bounding box of this node with a custom one. To remove it, set an @AABB@ with all fields set to zero. bindGeometryInstance_set_custom_aabb :: MethodBind bindGeometryInstance_set_custom_aabb = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the bounding box of this node with a custom one. To remove it, set an @AABB@ with all fields set to zero. set_custom_aabb :: (GeometryInstance :< cls, Object :< cls) => cls -> Aabb -> IO () set_custom_aabb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_custom_aabb" '[Aabb] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_custom_aabb {-# NOINLINE bindGeometryInstance_set_extra_cull_margin #-} -- | The extra distance added to the GeometryInstance's bounding box (@AABB@) to increase its cull box. bindGeometryInstance_set_extra_cull_margin :: MethodBind bindGeometryInstance_set_extra_cull_margin = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_extra_cull_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The extra distance added to the GeometryInstance's bounding box (@AABB@) to increase its cull box. set_extra_cull_margin :: (GeometryInstance :< cls, Object :< cls) => cls -> Float -> IO () set_extra_cull_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_extra_cull_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_extra_cull_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_extra_cull_margin {-# NOINLINE bindGeometryInstance_set_flag #-} -- | Sets the @enum GeometryInstance.Flags@ specified. See @enum GeometryInstance.Flags@ for options. bindGeometryInstance_set_flag :: MethodBind bindGeometryInstance_set_flag = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @enum GeometryInstance.Flags@ specified. See @enum GeometryInstance.Flags@ for options. set_flag :: (GeometryInstance :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_flag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_flag" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_flag {-# NOINLINE bindGeometryInstance_set_lod_max_distance #-} -- | The GeometryInstance's max LOD distance. -- __Note:__ This property currently has no effect. bindGeometryInstance_set_lod_max_distance :: MethodBind bindGeometryInstance_set_lod_max_distance = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_lod_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The GeometryInstance's max LOD distance. -- __Note:__ This property currently has no effect. set_lod_max_distance :: (GeometryInstance :< cls, Object :< cls) => cls -> Float -> IO () set_lod_max_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_lod_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_lod_max_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_lod_max_distance {-# NOINLINE bindGeometryInstance_set_lod_max_hysteresis #-} -- | The GeometryInstance's max LOD margin. -- __Note:__ This property currently has no effect. bindGeometryInstance_set_lod_max_hysteresis :: MethodBind bindGeometryInstance_set_lod_max_hysteresis = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_lod_max_hysteresis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The GeometryInstance's max LOD margin. -- __Note:__ This property currently has no effect. set_lod_max_hysteresis :: (GeometryInstance :< cls, Object :< cls) => cls -> Float -> IO () set_lod_max_hysteresis cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_lod_max_hysteresis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_lod_max_hysteresis" '[Float] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_lod_max_hysteresis {-# NOINLINE bindGeometryInstance_set_lod_min_distance #-} -- | The GeometryInstance's min LOD distance. -- __Note:__ This property currently has no effect. bindGeometryInstance_set_lod_min_distance :: MethodBind bindGeometryInstance_set_lod_min_distance = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_lod_min_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The GeometryInstance's min LOD distance. -- __Note:__ This property currently has no effect. set_lod_min_distance :: (GeometryInstance :< cls, Object :< cls) => cls -> Float -> IO () set_lod_min_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_lod_min_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_lod_min_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_lod_min_distance {-# NOINLINE bindGeometryInstance_set_lod_min_hysteresis #-} -- | The GeometryInstance's min LOD margin. -- __Note:__ This property currently has no effect. bindGeometryInstance_set_lod_min_hysteresis :: MethodBind bindGeometryInstance_set_lod_min_hysteresis = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_lod_min_hysteresis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The GeometryInstance's min LOD margin. -- __Note:__ This property currently has no effect. set_lod_min_hysteresis :: (GeometryInstance :< cls, Object :< cls) => cls -> Float -> IO () set_lod_min_hysteresis cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_lod_min_hysteresis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_lod_min_hysteresis" '[Float] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_lod_min_hysteresis {-# NOINLINE bindGeometryInstance_set_material_override #-} -- | The material override for the whole geometry. -- If a material is assigned to this property, it will be used instead of any material set in any material slot of the mesh. bindGeometryInstance_set_material_override :: MethodBind bindGeometryInstance_set_material_override = unsafePerformIO $ withCString "GeometryInstance" $ \ clsNamePtr -> withCString "set_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The material override for the whole geometry. -- If a material is assigned to this property, it will be used instead of any material set in any material slot of the mesh. set_material_override :: (GeometryInstance :< cls, Object :< cls) => cls -> Material -> IO () set_material_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGeometryInstance_set_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GeometryInstance "set_material_override" '[Material] (IO ()) where nodeMethod = Godot.Core.GeometryInstance.set_material_override ================================================ FILE: src/Godot/Core/GlobalConstants.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GlobalConstants (Godot.Core.GlobalConstants._KEY_BACKTAB, Godot.Core.GlobalConstants._KEY_BRACELEFT, Godot.Core.GlobalConstants._OP_MULTIPLY, Godot.Core.GlobalConstants._KEY_LAUNCH1, Godot.Core.GlobalConstants._KEY_F2, Godot.Core.GlobalConstants._TYPE_NIL, Godot.Core.GlobalConstants._PROPERTY_USAGE_SCRIPT_VARIABLE, Godot.Core.GlobalConstants._KEY_KP_ENTER, Godot.Core.GlobalConstants._ERR_DUPLICATE_SYMBOL, Godot.Core.GlobalConstants._KEY_LAUNCHA, Godot.Core.GlobalConstants._OP_EQUAL, Godot.Core.GlobalConstants._TYPE_INT, Godot.Core.GlobalConstants._KEY_T, Godot.Core.GlobalConstants._KEY_MACRON, Godot.Core.GlobalConstants._TYPE_VECTOR2, Godot.Core.GlobalConstants._OK, Godot.Core.GlobalConstants._PROPERTY_USAGE_NETWORK, Godot.Core.GlobalConstants._PROPERTY_HINT_KEY_ACCEL, Godot.Core.GlobalConstants._MIDI_MESSAGE_CONTROL_CHANGE, Godot.Core.GlobalConstants._KEY_D, Godot.Core.GlobalConstants._KEY_MODIFIER_MASK, Godot.Core.GlobalConstants._KEY_KP_0, Godot.Core.GlobalConstants._JOY_AXIS_3, Godot.Core.GlobalConstants._KEY_CENT, Godot.Core.GlobalConstants._KEY_LAUNCHMAIL, Godot.Core.GlobalConstants._CORNER_TOP_RIGHT, Godot.Core.GlobalConstants._OP_MAX, Godot.Core.GlobalConstants._SPKEY, Godot.Core.GlobalConstants._KEY_4, Godot.Core.GlobalConstants._TYPE_STRING_ARRAY, Godot.Core.GlobalConstants._KEY_SUPER_R, Godot.Core.GlobalConstants._KEY_DEGREE, Godot.Core.GlobalConstants._ERR_QUERY_FAILED, Godot.Core.GlobalConstants._JOY_BUTTON_5, Godot.Core.GlobalConstants._KEY_CURRENCY, Godot.Core.GlobalConstants._PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS, Godot.Core.GlobalConstants._BUTTON_WHEEL_DOWN, Godot.Core.GlobalConstants._VALIGN_TOP, Godot.Core.GlobalConstants._KEY_OPENURL, Godot.Core.GlobalConstants._KEY_F10, Godot.Core.GlobalConstants._ERR_FILE_NOT_FOUND, Godot.Core.GlobalConstants._KEY_IACUTE, Godot.Core.GlobalConstants._KEY_F9, Godot.Core.GlobalConstants._JOY_OPENVR_MENU, Godot.Core.GlobalConstants._MIDI_MESSAGE_PROGRAM_CHANGE, Godot.Core.GlobalConstants._JOY_SONY_X, Godot.Core.GlobalConstants._ERR_BUSY, Godot.Core.GlobalConstants._ERR_FILE_EOF, Godot.Core.GlobalConstants._KEY_BRACERIGHT, Godot.Core.GlobalConstants._KEY_THORN, Godot.Core.GlobalConstants._BUTTON_MASK_MIDDLE, Godot.Core.GlobalConstants._KEY_TAB, Godot.Core.GlobalConstants._KEY_YACUTE, Godot.Core.GlobalConstants._JOY_DPAD_DOWN, Godot.Core.GlobalConstants._KEY_PERIODCENTERED, Godot.Core.GlobalConstants._JOY_AXIS_8, Godot.Core.GlobalConstants._KEY_O, Godot.Core.GlobalConstants._KEY_OTILDE, Godot.Core.GlobalConstants._ERR_FILE_BAD_DRIVE, Godot.Core.GlobalConstants._KEY_END, Godot.Core.GlobalConstants._KEY_PLUS, Godot.Core.GlobalConstants._MARGIN_TOP, Godot.Core.GlobalConstants._KEY_GREATER, Godot.Core.GlobalConstants._KEY_KP_6, Godot.Core.GlobalConstants._JOY_AXIS_5, Godot.Core.GlobalConstants._KEY_B, Godot.Core.GlobalConstants._KEY_NOBREAKSPACE, Godot.Core.GlobalConstants._METHOD_FLAG_VIRTUAL, Godot.Core.GlobalConstants._JOY_R3, Godot.Core.GlobalConstants._JOY_BUTTON_8, Godot.Core.GlobalConstants._KEY_2, Godot.Core.GlobalConstants._TYPE_INT_ARRAY, Godot.Core.GlobalConstants._PROPERTY_HINT_FILE, Godot.Core.GlobalConstants._JOY_ANALOG_LX, Godot.Core.GlobalConstants._MIDI_MESSAGE_NOTE_OFF, Godot.Core.GlobalConstants._TYPE_VECTOR2_ARRAY, Godot.Core.GlobalConstants._OP_LESS_EQUAL, Godot.Core.GlobalConstants._KEY_PAUSE, Godot.Core.GlobalConstants._JOY_BUTTON_11, Godot.Core.GlobalConstants._PROPERTY_USAGE_NOEDITOR, Godot.Core.GlobalConstants._BUTTON_LEFT, Godot.Core.GlobalConstants._KEY_LAUNCH7, Godot.Core.GlobalConstants._MARGIN_LEFT, Godot.Core.GlobalConstants._KEY_F4, Godot.Core.GlobalConstants._METHOD_FLAG_EDITOR, Godot.Core.GlobalConstants._BUTTON_MASK_RIGHT, Godot.Core.GlobalConstants._TYPE_STRING, Godot.Core.GlobalConstants._ERR_BUG, Godot.Core.GlobalConstants._KEY_ASCIICIRCUM, Godot.Core.GlobalConstants._JOY_DS_A, Godot.Core.GlobalConstants._KEY_R, Godot.Core.GlobalConstants._JOY_DPAD_RIGHT, Godot.Core.GlobalConstants._TYPE_VECTOR3, Godot.Core.GlobalConstants._ERR_DATABASE_CANT_READ, Godot.Core.GlobalConstants._KEY_ICIRCUMFLEX, Godot.Core.GlobalConstants._JOY_SONY_CIRCLE, Godot.Core.GlobalConstants._JOY_AXIS_2, Godot.Core.GlobalConstants._KEY_E, Godot.Core.GlobalConstants._KEY_KP_1, Godot.Core.GlobalConstants._ERR_CANT_FORK, Godot.Core.GlobalConstants._PROPERTY_USAGE_NO_INSTANCE_STATE, Godot.Core.GlobalConstants._KEY_5, Godot.Core.GlobalConstants._OP_NOT, Godot.Core.GlobalConstants._ERR_PRINTER_ON_FIRE, Godot.Core.GlobalConstants._KEY_MASK_KPAD, Godot.Core.GlobalConstants._OP_XOR, Godot.Core.GlobalConstants._KEY_META, Godot.Core.GlobalConstants._ERR_INVALID_PARAMETER, Godot.Core.GlobalConstants._KEY_LAUNCH0, Godot.Core.GlobalConstants._KEY_F3, Godot.Core.GlobalConstants._OP_BIT_XOR, Godot.Core.GlobalConstants._METHOD_FLAG_FROM_SCRIPT, Godot.Core.GlobalConstants._KEY_KP_ADD, Godot.Core.GlobalConstants._BUTTON_WHEEL_RIGHT, Godot.Core.GlobalConstants._TYPE_NODE_PATH, Godot.Core.GlobalConstants._KEY_U, Godot.Core.GlobalConstants._ERR_UNCONFIGURED, Godot.Core.GlobalConstants._JOY_XBOX_Y, Godot.Core.GlobalConstants._PROPERTY_HINT_LENGTH, Godot.Core.GlobalConstants._KEY_STOP, Godot.Core.GlobalConstants._ERR_UNAVAILABLE, Godot.Core.GlobalConstants._ERR_ALREADY_IN_USE, Godot.Core.GlobalConstants._JOY_DPAD_UP, Godot.Core.GlobalConstants._KEY_X, Godot.Core.GlobalConstants._KEY_QUOTEDBL, Godot.Core.GlobalConstants._KEY_REGISTERED, Godot.Core.GlobalConstants._KEY_H, Godot.Core.GlobalConstants._KEY_DIRECTION_R, Godot.Core.GlobalConstants._JOY_VR_TRIGGER, Godot.Core.GlobalConstants._KEY_RIGHT, Godot.Core.GlobalConstants._JOY_ANALOG_L2, Godot.Core.GlobalConstants._JOY_BUTTON_2, Godot.Core.GlobalConstants._KEY_GUILLEMOTRIGHT, Godot.Core.GlobalConstants._PROPERTY_USAGE_RESTART_IF_CHANGED, Godot.Core.GlobalConstants._KEY_MEDIAPLAY, Godot.Core.GlobalConstants._BUTTON_WHEEL_UP, Godot.Core.GlobalConstants._KEY_8, Godot.Core.GlobalConstants._ERR_PARSE_ERROR, Godot.Core.GlobalConstants._KEY_KP_MULTIPLY, Godot.Core.GlobalConstants._JOY_BUTTON_10, Godot.Core.GlobalConstants._KEY_EACUTE, Godot.Core.GlobalConstants._KEY_LAUNCH6, Godot.Core.GlobalConstants._KEY_F5, Godot.Core.GlobalConstants._MIDI_MESSAGE_AFTERTOUCH, Godot.Core.GlobalConstants._KEY_UACUTE, Godot.Core.GlobalConstants._KEY_THREESUPERIOR, Godot.Core.GlobalConstants._TYPE_VECTOR3_ARRAY, Godot.Core.GlobalConstants._KEY_OCIRCUMFLEX, Godot.Core.GlobalConstants._KEY_LAUNCHF, Godot.Core.GlobalConstants._CORNER_BOTTOM_LEFT, Godot.Core.GlobalConstants._PROPERTY_HINT_DIR, Godot.Core.GlobalConstants._JOY_XBOX_B, Godot.Core.GlobalConstants._KEY_ARING, Godot.Core.GlobalConstants._KEY_S, Godot.Core.GlobalConstants._KEY_SEMICOLON, Godot.Core.GlobalConstants._MIDI_MESSAGE_CHANNEL_PRESSURE, Godot.Core.GlobalConstants._KEY_BRACKETLEFT, Godot.Core.GlobalConstants._PROPERTY_HINT_FLAGS, Godot.Core.GlobalConstants._OP_AND, Godot.Core.GlobalConstants._KEY_PARENLEFT, Godot.Core.GlobalConstants._PROPERTY_USAGE_EDITOR, Godot.Core.GlobalConstants._KEY_KP_7, Godot.Core.GlobalConstants._JOY_AXIS_4, Godot.Core.GlobalConstants._ERR_CANT_CONNECT, Godot.Core.GlobalConstants._KEY_HYPER_R, Godot.Core.GlobalConstants._KEY_C, Godot.Core.GlobalConstants._ERR_CONNECTION_ERROR, Godot.Core.GlobalConstants._OP_BIT_AND, Godot.Core.GlobalConstants._JOY_R2, Godot.Core.GlobalConstants._KEY_MEDIANEXT, Godot.Core.GlobalConstants._KEY_BACK, Godot.Core.GlobalConstants._JOY_BUTTON_9, Godot.Core.GlobalConstants._KEY_MASK_SHIFT, Godot.Core.GlobalConstants._KEY_3, Godot.Core.GlobalConstants._KEY_SSHARP, Godot.Core.GlobalConstants._JOY_ANALOG_LY, Godot.Core.GlobalConstants._JOY_OCULUS_AX, Godot.Core.GlobalConstants._KEY_SCROLLLOCK, Godot.Core.GlobalConstants._PROPERTY_HINT_GLOBAL_FILE, Godot.Core.GlobalConstants._KEY_CODE_MASK, Godot.Core.GlobalConstants._JOY_ANALOG_R2, Godot.Core.GlobalConstants._ERR_LINK_FAILED, Godot.Core.GlobalConstants._JOY_BUTTON_15, Godot.Core.GlobalConstants._KEY_LAUNCH3, Godot.Core.GlobalConstants._JOY_BUTTON_MAX, Godot.Core.GlobalConstants._PROPERTY_USAGE_CHECKABLE, Godot.Core.GlobalConstants._KEY_PAGEUP, Godot.Core.GlobalConstants._METHOD_FLAG_CONST, Godot.Core.GlobalConstants._OP_STRING_CONCAT, Godot.Core.GlobalConstants._TYPE_ARRAY, Godot.Core.GlobalConstants._ERR_FILE_BAD_PATH, Godot.Core.GlobalConstants._KEY_LAUNCHC, Godot.Core.GlobalConstants._KEY_SEARCH, Godot.Core.GlobalConstants._KEY_IDIAERESIS, Godot.Core.GlobalConstants._KEY_BACKSLASH, Godot.Core.GlobalConstants._KEY_DIRECTION_L, Godot.Core.GlobalConstants._KEY_V, Godot.Core.GlobalConstants._KEY_YDIAERESIS, Godot.Core.GlobalConstants._KEY_KP_2, Godot.Core.GlobalConstants._JOY_AXIS_1, Godot.Core.GlobalConstants._KEY_F, Godot.Core.GlobalConstants._KEY_BASSUP, Godot.Core.GlobalConstants._KEY_BASSBOOST, Godot.Core.GlobalConstants._KEY_NTILDE, Godot.Core.GlobalConstants._ERR_METHOD_NOT_FOUND, Godot.Core.GlobalConstants._KEY_IGRAVE, Godot.Core.GlobalConstants._KEY_QUESTION, Godot.Core.GlobalConstants._KEY_6, Godot.Core.GlobalConstants._KEY_EXCLAM, Godot.Core.GlobalConstants._KEY_KP_PERIOD, Godot.Core.GlobalConstants._KEY_I, Godot.Core.GlobalConstants._KEY_ECIRCUMFLEX, Godot.Core.GlobalConstants._OP_ADD, Godot.Core.GlobalConstants._ERR_FILE_MISSING_DEPENDENCIES, Godot.Core.GlobalConstants._PROPERTY_HINT_LAYERS_2D_PHYSICS, Godot.Core.GlobalConstants._JOY_BUTTON_3, Godot.Core.GlobalConstants._KEY_QUOTELEFT, Godot.Core.GlobalConstants._ERR_FILE_CANT_WRITE, Godot.Core.GlobalConstants._KEY_9, Godot.Core.GlobalConstants._HALIGN_CENTER, Godot.Core.GlobalConstants._ERR_DOES_NOT_EXIST, Godot.Core.GlobalConstants._TYPE_BOOL, Godot.Core.GlobalConstants._KEY_F16, Godot.Core.GlobalConstants._PROPERTY_HINT_EXP_EASING, Godot.Core.GlobalConstants._KEY_DIVISION, Godot.Core.GlobalConstants._KEY_DELETE, Godot.Core.GlobalConstants._JOY_XBOX_X, Godot.Core.GlobalConstants._KEY_BAR, Godot.Core.GlobalConstants._ERR_CANT_RESOLVE, Godot.Core.GlobalConstants._HALIGN_LEFT, Godot.Core.GlobalConstants._JOY_SONY_TRIANGLE, Godot.Core.GlobalConstants._KEY_OACUTE, Godot.Core.GlobalConstants._MARGIN_RIGHT, Godot.Core.GlobalConstants._KEY_SECTION, Godot.Core.GlobalConstants._ERR_TIMEOUT, Godot.Core.GlobalConstants._BUTTON_RIGHT, Godot.Core.GlobalConstants._KEY_Y, Godot.Core.GlobalConstants._ERR_SCRIPT_FAILED, Godot.Core.GlobalConstants._KEY_ETH, Godot.Core.GlobalConstants._KEY_ALT, Godot.Core.GlobalConstants._JOY_R, Godot.Core.GlobalConstants._KEY_UCIRCUMFLEX, Godot.Core.GlobalConstants._OP_LESS, Godot.Core.GlobalConstants._ERR_INVALID_DATA, Godot.Core.GlobalConstants._JOY_OCULUS_MENU, Godot.Core.GlobalConstants._ERR_OUT_OF_MEMORY, Godot.Core.GlobalConstants._KEY_HOMEPAGE, Godot.Core.GlobalConstants._OP_SUBTRACT, Godot.Core.GlobalConstants._KEY_KP_8, Godot.Core.GlobalConstants._JOY_ANALOG_RX, Godot.Core.GlobalConstants._KEY_L, Godot.Core.GlobalConstants._KEY_MEDIASTOP, Godot.Core.GlobalConstants._JOY_VR_GRIP, Godot.Core.GlobalConstants._MIDI_MESSAGE_NOTE_ON, Godot.Core.GlobalConstants._KEY_MULTIPLY, Godot.Core.GlobalConstants._KEY_STERLING, Godot.Core.GlobalConstants._OP_NEGATE, Godot.Core.GlobalConstants._JOY_BUTTON_6, Godot.Core.GlobalConstants._PROPERTY_HINT_COLOR_NO_ALPHA, Godot.Core.GlobalConstants._KEY_AE, Godot.Core.GlobalConstants._KEY_MINUS, Godot.Core.GlobalConstants._BUTTON_MIDDLE, Godot.Core.GlobalConstants._KEY_F13, Godot.Core.GlobalConstants._KEY_LAUNCH9, Godot.Core.GlobalConstants._KEY_EXCLAMDOWN, Godot.Core.GlobalConstants._ERR_PARAMETER_RANGE_ERROR, Godot.Core.GlobalConstants._KEY_QUESTIONDOWN, Godot.Core.GlobalConstants._ERR_INVALID_DECLARATION, Godot.Core.GlobalConstants._TYPE_COLOR_ARRAY, Godot.Core.GlobalConstants._KEY_EQUAL, Godot.Core.GlobalConstants._JOY_OPENVR_TOUCHPADX, Godot.Core.GlobalConstants._JOY_OCULUS_BY, Godot.Core.GlobalConstants._OP_BIT_NEGATE, Godot.Core.GlobalConstants._JOY_L3, Godot.Core.GlobalConstants._OP_SHIFT_LEFT, Godot.Core.GlobalConstants._KEY_SPACE, Godot.Core.GlobalConstants._CORNER_TOP_LEFT, Godot.Core.GlobalConstants._KEY_HOME, Godot.Core.GlobalConstants._KEY_MASCULINE, Godot.Core.GlobalConstants._ERR_COMPILATION_FAILED, Godot.Core.GlobalConstants._KEY_W, Godot.Core.GlobalConstants._VALIGN_CENTER, Godot.Core.GlobalConstants._KEY_KP_3, Godot.Core.GlobalConstants._PROPERTY_HINT_GLOBAL_DIR, Godot.Core.GlobalConstants._JOY_AXIS_0, Godot.Core.GlobalConstants._KEY_G, Godot.Core.GlobalConstants._TYPE_DICTIONARY, Godot.Core.GlobalConstants._KEY_FAVORITES, Godot.Core.GlobalConstants._JOY_L, Godot.Core.GlobalConstants._KEY_DIAERESIS, Godot.Core.GlobalConstants._PROPERTY_HINT_IMAGE_COMPRESS_LOSSY, Godot.Core.GlobalConstants._KEY_ONEHALF, Godot.Core.GlobalConstants._KEY_7, Godot.Core.GlobalConstants._KEY_INSERT, Godot.Core.GlobalConstants._KEY_STANDBY, Godot.Core.GlobalConstants._OP_IN, Godot.Core.GlobalConstants._PROPERTY_HINT_ENUM, Godot.Core.GlobalConstants._KEY_BACKSPACE, Godot.Core.GlobalConstants._TYPE_AABB, Godot.Core.GlobalConstants._KEY_KP_DIVIDE, Godot.Core.GlobalConstants._JOY_BUTTON_14, Godot.Core.GlobalConstants._OP_SHIFT_RIGHT, Godot.Core.GlobalConstants._KEY_LAUNCH2, Godot.Core.GlobalConstants._KEY_F1, Godot.Core.GlobalConstants._KEY_CONTROL, Godot.Core.GlobalConstants._KEY_AACUTE, Godot.Core.GlobalConstants._KEY_SYSREQ, Godot.Core.GlobalConstants._KEY_LAUNCHB, Godot.Core.GlobalConstants._PROPERTY_USAGE_CATEGORY, Godot.Core.GlobalConstants._PROPERTY_USAGE_INTERNATIONALIZED, Godot.Core.GlobalConstants._TYPE_OBJECT, Godot.Core.GlobalConstants._KEY_CAPSLOCK, Godot.Core.GlobalConstants._KEY_UGRAVE, Godot.Core.GlobalConstants._JOY_DS_Y, Godot.Core.GlobalConstants._KEY_CEDILLA, Godot.Core.GlobalConstants._KEY_ORDFEMININE, Godot.Core.GlobalConstants._KEY_Z, Godot.Core.GlobalConstants._PROPERTY_USAGE_EDITOR_HELPER, Godot.Core.GlobalConstants._ERR_CYCLIC_LINK, Godot.Core.GlobalConstants._KEY_EGRAVE, Godot.Core.GlobalConstants._KEY_DOWN, Godot.Core.GlobalConstants._OP_MODULE, Godot.Core.GlobalConstants._KEY_MASK_ALT, Godot.Core.GlobalConstants._KEY_J, Godot.Core.GlobalConstants._KEY_SUPER_L, Godot.Core.GlobalConstants._HALIGN_RIGHT, Godot.Core.GlobalConstants._JOY_BUTTON_0, Godot.Core.GlobalConstants._KEY_TREBLEDOWN, Godot.Core.GlobalConstants._KEY_EDIAERESIS, Godot.Core.GlobalConstants._KEY_MASK_CTRL, Godot.Core.GlobalConstants._OP_GREATER, Godot.Core.GlobalConstants._KEY_HYPHEN, Godot.Core.GlobalConstants._KEY_YEN, Godot.Core.GlobalConstants._ERR_DATABASE_CANT_WRITE, Godot.Core.GlobalConstants._TYPE_COLOR, Godot.Core.GlobalConstants._VERTICAL, Godot.Core.GlobalConstants._KEY_VOLUMEDOWN, Godot.Core.GlobalConstants._KEY_F15, Godot.Core.GlobalConstants._KEY_UDIAERESIS, Godot.Core.GlobalConstants._KEY_REFRESH, Godot.Core.GlobalConstants._KEY_SLASH, Godot.Core.GlobalConstants._PROPERTY_HINT_PLACEHOLDER_TEXT, Godot.Core.GlobalConstants._KEY_F12, Godot.Core.GlobalConstants._PROPERTY_USAGE_GROUP, Godot.Core.GlobalConstants._OP_OR, Godot.Core.GlobalConstants._KEY_COPYRIGHT, Godot.Core.GlobalConstants._KEY_LAUNCH8, Godot.Core.GlobalConstants._PROPERTY_USAGE_CHECKED, Godot.Core.GlobalConstants._OP_BIT_OR, Godot.Core.GlobalConstants._KEY_COMMA, Godot.Core.GlobalConstants._TYPE_BASIS, Godot.Core.GlobalConstants._JOY_OPENVR_TOUCHPADY, Godot.Core.GlobalConstants._KEY_NUMLOCK, Godot.Core.GlobalConstants._KEY_VOLUMEUP, Godot.Core.GlobalConstants._METHOD_FLAG_NOSCRIPT, Godot.Core.GlobalConstants._JOY_L2, Godot.Core.GlobalConstants._TYPE_REAL, Godot.Core.GlobalConstants._TYPE_TRANSFORM2D, Godot.Core.GlobalConstants._KEY_HYPER_L, Godot.Core.GlobalConstants._KEY_UP, Godot.Core.GlobalConstants._JOY_VR_PAD, Godot.Core.GlobalConstants._TYPE_RAW_ARRAY, Godot.Core.GlobalConstants._KEY_PERIOD, Godot.Core.GlobalConstants._KEY_ACIRCUMFLEX, Godot.Core.GlobalConstants._TYPE_RECT2, Godot.Core.GlobalConstants._KEY_KP_9, Godot.Core.GlobalConstants._JOY_ANALOG_RY, Godot.Core.GlobalConstants._KEY_M, Godot.Core.GlobalConstants._KEY_MEDIAPREVIOUS, Godot.Core.GlobalConstants._KEY_AT, Godot.Core.GlobalConstants._JOY_VR_ANALOG_TRIGGER, Godot.Core.GlobalConstants._KEY_TREBLEUP, Godot.Core.GlobalConstants._JOY_BUTTON_7, Godot.Core.GlobalConstants._BUTTON_MASK_XBUTTON1, Godot.Core.GlobalConstants._BUTTON_XBUTTON2, Godot.Core.GlobalConstants._KEY_0, Godot.Core.GlobalConstants._KEY_UNDERSCORE, Godot.Core.GlobalConstants._PROPERTY_HINT_LAYERS_2D_RENDER, Godot.Core.GlobalConstants._KEY_ENTER, Godot.Core.GlobalConstants._KEY_ASTERISK, Godot.Core.GlobalConstants._KEY_UNKNOWN, Godot.Core.GlobalConstants._KEY_PARENRIGHT, Godot.Core.GlobalConstants._JOY_BUTTON_13, Godot.Core.GlobalConstants._PROPERTY_HINT_LAYERS_3D_PHYSICS, Godot.Core.GlobalConstants._KEY_LAUNCH5, Godot.Core.GlobalConstants._KEY_F6, Godot.Core.GlobalConstants._CORNER_BOTTOM_RIGHT, Godot.Core.GlobalConstants._ERR_FILE_CANT_OPEN, Godot.Core.GlobalConstants._KEY_LAUNCHE, Godot.Core.GlobalConstants._KEY_NUMBERSIGN, Godot.Core.GlobalConstants._JOY_XBOX_A, Godot.Core.GlobalConstants._KEY_KP_SUBTRACT, Godot.Core.GlobalConstants._KEY_SHIFT, Godot.Core.GlobalConstants._KEY_P, Godot.Core.GlobalConstants._ERR_CANT_ACQUIRE_RESOURCE, Godot.Core.GlobalConstants._METHOD_FLAG_NORMAL, Godot.Core.GlobalConstants._KEY_OGRAVE, Godot.Core.GlobalConstants._TYPE_RID, Godot.Core.GlobalConstants._KEY_ODIAERESIS, Godot.Core.GlobalConstants._ERR_FILE_UNRECOGNIZED, Godot.Core.GlobalConstants._KEY_DOLLAR, Godot.Core.GlobalConstants._KEY_KP_4, Godot.Core.GlobalConstants._JOY_AXIS_7, Godot.Core.GlobalConstants._KEY_BRACKETRIGHT, Godot.Core.GlobalConstants._KEY_MU, Godot.Core.GlobalConstants._KEY_ONEQUARTER, Godot.Core.GlobalConstants._ERR_LOCKED, Godot.Core.GlobalConstants._TYPE_REAL_ARRAY, Godot.Core.GlobalConstants._ERR_ALREADY_EXISTS, Godot.Core.GlobalConstants._ERR_HELP, Godot.Core.GlobalConstants._PROPERTY_USAGE_STORAGE, Godot.Core.GlobalConstants._JOY_START, Godot.Core.GlobalConstants._KEY_K, Godot.Core.GlobalConstants._OP_DIVIDE, Godot.Core.GlobalConstants._FAILED, Godot.Core.GlobalConstants._JOY_BUTTON_1, Godot.Core.GlobalConstants._KEY_PERCENT, Godot.Core.GlobalConstants._PROPERTY_HINT_RANGE, Godot.Core.GlobalConstants._KEY_LEFT, Godot.Core.GlobalConstants._KEY_F14, Godot.Core.GlobalConstants._METHOD_FLAGS_DEFAULT, Godot.Core.GlobalConstants._JOY_AXIS_MAX, Godot.Core.GlobalConstants._METHOD_FLAG_REVERSE, Godot.Core.GlobalConstants._KEY_GUILLEMOTLEFT, Godot.Core.GlobalConstants._TYPE_TRANSFORM, Godot.Core.GlobalConstants._JOY_DS_X, Godot.Core.GlobalConstants._ERR_SKIP, Godot.Core.GlobalConstants._OP_POSITIVE, Godot.Core.GlobalConstants._KEY_FORWARD, Godot.Core.GlobalConstants._KEY_AMPERSAND, Godot.Core.GlobalConstants._TYPE_MAX, Godot.Core.GlobalConstants._KEY_MENU, Godot.Core.GlobalConstants._JOY_SELECT, Godot.Core.GlobalConstants._VALIGN_BOTTOM, Godot.Core.GlobalConstants._ERR_UNAUTHORIZED, Godot.Core.GlobalConstants._JOY_DPAD_LEFT, Godot.Core.GlobalConstants._KEY_PARAGRAPH, Godot.Core.GlobalConstants._KEY_NOTSIGN, Godot.Core.GlobalConstants._TYPE_QUAT, Godot.Core.GlobalConstants._KEY_N, Godot.Core.GlobalConstants._ERR_FILE_CANT_READ, Godot.Core.GlobalConstants._JOY_AXIS_9, Godot.Core.GlobalConstants._KEY_AGRAVE, Godot.Core.GlobalConstants._JOY_BUTTON_4, Godot.Core.GlobalConstants._KEY_BROKENBAR, Godot.Core.GlobalConstants._ERR_FILE_NO_PERMISSION, Godot.Core.GlobalConstants._BUTTON_WHEEL_LEFT, Godot.Core.GlobalConstants._BUTTON_MASK_XBUTTON2, Godot.Core.GlobalConstants._KEY_PLUSMINUS, Godot.Core.GlobalConstants._JOY_SONY_SQUARE, Godot.Core.GlobalConstants._ERR_FILE_CORRUPT, Godot.Core.GlobalConstants._BUTTON_XBUTTON1, Godot.Core.GlobalConstants._KEY_F11, Godot.Core.GlobalConstants._OP_NOT_EQUAL, Godot.Core.GlobalConstants._KEY_OOBLIQUE, Godot.Core.GlobalConstants._MIDI_MESSAGE_PITCH_BEND, Godot.Core.GlobalConstants._HORIZONTAL, Godot.Core.GlobalConstants._KEY_ACUTE, Godot.Core.GlobalConstants._KEY_F8, Godot.Core.GlobalConstants._KEY_ADIAERESIS, Godot.Core.GlobalConstants._MARGIN_BOTTOM, Godot.Core.GlobalConstants._PROPERTY_HINT_NONE, Godot.Core.GlobalConstants._KEY_MASK_META, Godot.Core.GlobalConstants._KEY_MASK_GROUP_SWITCH, Godot.Core.GlobalConstants._KEY_COLON, Godot.Core.GlobalConstants._KEY_HELP, Godot.Core.GlobalConstants._KEY_LAUNCHD, Godot.Core.GlobalConstants._KEY_ONESUPERIOR, Godot.Core.GlobalConstants._KEY_BASSDOWN, Godot.Core.GlobalConstants._KEY_ATILDE, Godot.Core.GlobalConstants._PROPERTY_HINT_MULTILINE_TEXT, Godot.Core.GlobalConstants._KEY_LAUNCHMEDIA, Godot.Core.GlobalConstants._JOY_DS_B, Godot.Core.GlobalConstants._KEY_MEDIARECORD, Godot.Core.GlobalConstants._KEY_Q, Godot.Core.GlobalConstants._BUTTON_MASK_LEFT, Godot.Core.GlobalConstants._KEY_CCEDILLA, Godot.Core.GlobalConstants._ERR_CANT_CREATE, Godot.Core.GlobalConstants._PROPERTY_HINT_EXP_RANGE, Godot.Core.GlobalConstants._OP_GREATER_EQUAL, Godot.Core.GlobalConstants._KEY_KP_5, Godot.Core.GlobalConstants._KEY_APOSTROPHE, Godot.Core.GlobalConstants._JOY_AXIS_6, Godot.Core.GlobalConstants._KEY_A, Godot.Core.GlobalConstants._KEY_THREEQUARTERS, Godot.Core.GlobalConstants._PROPERTY_USAGE_DEFAULT, Godot.Core.GlobalConstants._KEY_LESS, Godot.Core.GlobalConstants._JOY_VR_ANALOG_GRIP, Godot.Core.GlobalConstants._KEY_CLEAR, Godot.Core.GlobalConstants._PROPERTY_HINT_RESOURCE_TYPE, Godot.Core.GlobalConstants._KEY_ESCAPE, Godot.Core.GlobalConstants._KEY_1, Godot.Core.GlobalConstants._KEY_PAGEDOWN, Godot.Core.GlobalConstants._KEY_TWOSUPERIOR, Godot.Core.GlobalConstants._PROPERTY_HINT_LAYERS_3D_RENDER, Godot.Core.GlobalConstants._PROPERTY_USAGE_DEFAULT_INTL, Godot.Core.GlobalConstants._TYPE_PLANE, Godot.Core.GlobalConstants._JOY_BUTTON_12, Godot.Core.GlobalConstants._KEY_PRINT, Godot.Core.GlobalConstants._ERR_FILE_ALREADY_IN_USE, Godot.Core.GlobalConstants._KEY_LAUNCH4, Godot.Core.GlobalConstants._KEY_F7, Godot.Core.GlobalConstants._KEY_ASCIITILDE, Godot.Core.GlobalConstants._KEY_MASK_CMD, Godot.Core.GlobalConstants._KEY_VOLUMEMUTE, Godot.Core.GlobalConstants._ERR_CANT_OPEN) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types _KEY_BACKTAB :: Int _KEY_BACKTAB = 16777219 _KEY_BRACELEFT :: Int _KEY_BRACELEFT = 123 _OP_MULTIPLY :: Int _OP_MULTIPLY = 8 _KEY_LAUNCH1 :: Int _KEY_LAUNCH1 = 16777305 _KEY_F2 :: Int _KEY_F2 = 16777245 _TYPE_NIL :: Int _TYPE_NIL = 0 _PROPERTY_USAGE_SCRIPT_VARIABLE :: Int _PROPERTY_USAGE_SCRIPT_VARIABLE = 8192 _KEY_KP_ENTER :: Int _KEY_KP_ENTER = 16777222 _ERR_DUPLICATE_SYMBOL :: Int _ERR_DUPLICATE_SYMBOL = 42 _KEY_LAUNCHA :: Int _KEY_LAUNCHA = 16777314 _OP_EQUAL :: Int _OP_EQUAL = 0 _TYPE_INT :: Int _TYPE_INT = 2 _KEY_T :: Int _KEY_T = 84 _KEY_MACRON :: Int _KEY_MACRON = 175 _TYPE_VECTOR2 :: Int _TYPE_VECTOR2 = 5 _OK :: Int _OK = 0 _PROPERTY_USAGE_NETWORK :: Int _PROPERTY_USAGE_NETWORK = 4 _PROPERTY_HINT_KEY_ACCEL :: Int _PROPERTY_HINT_KEY_ACCEL = 7 _MIDI_MESSAGE_CONTROL_CHANGE :: Int _MIDI_MESSAGE_CONTROL_CHANGE = 11 _KEY_D :: Int _KEY_D = 68 _KEY_MODIFIER_MASK :: Int _KEY_MODIFIER_MASK = -16777216 _KEY_KP_0 :: Int _KEY_KP_0 = 16777350 _JOY_AXIS_3 :: Int _JOY_AXIS_3 = 3 _KEY_CENT :: Int _KEY_CENT = 162 _KEY_LAUNCHMAIL :: Int _KEY_LAUNCHMAIL = 16777302 _CORNER_TOP_RIGHT :: Int _CORNER_TOP_RIGHT = 1 _OP_MAX :: Int _OP_MAX = 25 _SPKEY :: Int _SPKEY = 16777216 _KEY_4 :: Int _KEY_4 = 52 _TYPE_STRING_ARRAY :: Int _TYPE_STRING_ARRAY = 23 _KEY_SUPER_R :: Int _KEY_SUPER_R = 16777261 _KEY_DEGREE :: Int _KEY_DEGREE = 176 _ERR_QUERY_FAILED :: Int _ERR_QUERY_FAILED = 21 _JOY_BUTTON_5 :: Int _JOY_BUTTON_5 = 5 _KEY_CURRENCY :: Int _KEY_CURRENCY = 164 _PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS :: Int _PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS = 22 _BUTTON_WHEEL_DOWN :: Int _BUTTON_WHEEL_DOWN = 5 _VALIGN_TOP :: Int _VALIGN_TOP = 0 _KEY_OPENURL :: Int _KEY_OPENURL = 16777301 _KEY_F10 :: Int _KEY_F10 = 16777253 _ERR_FILE_NOT_FOUND :: Int _ERR_FILE_NOT_FOUND = 7 _KEY_IACUTE :: Int _KEY_IACUTE = 205 _KEY_F9 :: Int _KEY_F9 = 16777252 _JOY_OPENVR_MENU :: Int _JOY_OPENVR_MENU = 1 _MIDI_MESSAGE_PROGRAM_CHANGE :: Int _MIDI_MESSAGE_PROGRAM_CHANGE = 12 _JOY_SONY_X :: Int _JOY_SONY_X = 0 _ERR_BUSY :: Int _ERR_BUSY = 44 _ERR_FILE_EOF :: Int _ERR_FILE_EOF = 18 _KEY_BRACERIGHT :: Int _KEY_BRACERIGHT = 125 _KEY_THORN :: Int _KEY_THORN = 222 _BUTTON_MASK_MIDDLE :: Int _BUTTON_MASK_MIDDLE = 4 _KEY_TAB :: Int _KEY_TAB = 16777218 _KEY_YACUTE :: Int _KEY_YACUTE = 221 _JOY_DPAD_DOWN :: Int _JOY_DPAD_DOWN = 13 _KEY_PERIODCENTERED :: Int _KEY_PERIODCENTERED = 183 _JOY_AXIS_8 :: Int _JOY_AXIS_8 = 8 _KEY_O :: Int _KEY_O = 79 _KEY_OTILDE :: Int _KEY_OTILDE = 213 _ERR_FILE_BAD_DRIVE :: Int _ERR_FILE_BAD_DRIVE = 8 _KEY_END :: Int _KEY_END = 16777230 _KEY_PLUS :: Int _KEY_PLUS = 43 _MARGIN_TOP :: Int _MARGIN_TOP = 1 _KEY_GREATER :: Int _KEY_GREATER = 62 _KEY_KP_6 :: Int _KEY_KP_6 = 16777356 _JOY_AXIS_5 :: Int _JOY_AXIS_5 = 5 _KEY_B :: Int _KEY_B = 66 _KEY_NOBREAKSPACE :: Int _KEY_NOBREAKSPACE = 160 _METHOD_FLAG_VIRTUAL :: Int _METHOD_FLAG_VIRTUAL = 32 _JOY_R3 :: Int _JOY_R3 = 9 _JOY_BUTTON_8 :: Int _JOY_BUTTON_8 = 8 _KEY_2 :: Int _KEY_2 = 50 _TYPE_INT_ARRAY :: Int _TYPE_INT_ARRAY = 21 _PROPERTY_HINT_FILE :: Int _PROPERTY_HINT_FILE = 13 _JOY_ANALOG_LX :: Int _JOY_ANALOG_LX = 0 _MIDI_MESSAGE_NOTE_OFF :: Int _MIDI_MESSAGE_NOTE_OFF = 8 _TYPE_VECTOR2_ARRAY :: Int _TYPE_VECTOR2_ARRAY = 24 _OP_LESS_EQUAL :: Int _OP_LESS_EQUAL = 3 _KEY_PAUSE :: Int _KEY_PAUSE = 16777225 _JOY_BUTTON_11 :: Int _JOY_BUTTON_11 = 11 _PROPERTY_USAGE_NOEDITOR :: Int _PROPERTY_USAGE_NOEDITOR = 5 _BUTTON_LEFT :: Int _BUTTON_LEFT = 1 _KEY_LAUNCH7 :: Int _KEY_LAUNCH7 = 16777311 _MARGIN_LEFT :: Int _MARGIN_LEFT = 0 _KEY_F4 :: Int _KEY_F4 = 16777247 _METHOD_FLAG_EDITOR :: Int _METHOD_FLAG_EDITOR = 2 _BUTTON_MASK_RIGHT :: Int _BUTTON_MASK_RIGHT = 2 _TYPE_STRING :: Int _TYPE_STRING = 4 _ERR_BUG :: Int _ERR_BUG = 47 _KEY_ASCIICIRCUM :: Int _KEY_ASCIICIRCUM = 94 _JOY_DS_A :: Int _JOY_DS_A = 1 _KEY_R :: Int _KEY_R = 82 _JOY_DPAD_RIGHT :: Int _JOY_DPAD_RIGHT = 15 _TYPE_VECTOR3 :: Int _TYPE_VECTOR3 = 7 _ERR_DATABASE_CANT_READ :: Int _ERR_DATABASE_CANT_READ = 34 _KEY_ICIRCUMFLEX :: Int _KEY_ICIRCUMFLEX = 206 _JOY_SONY_CIRCLE :: Int _JOY_SONY_CIRCLE = 1 _JOY_AXIS_2 :: Int _JOY_AXIS_2 = 2 _KEY_E :: Int _KEY_E = 69 _KEY_KP_1 :: Int _KEY_KP_1 = 16777351 _ERR_CANT_FORK :: Int _ERR_CANT_FORK = 29 _PROPERTY_USAGE_NO_INSTANCE_STATE :: Int _PROPERTY_USAGE_NO_INSTANCE_STATE = 2048 _KEY_5 :: Int _KEY_5 = 53 _OP_NOT :: Int _OP_NOT = 23 _ERR_PRINTER_ON_FIRE :: Int _ERR_PRINTER_ON_FIRE = 48 _KEY_MASK_KPAD :: Int _KEY_MASK_KPAD = 536870912 _OP_XOR :: Int _OP_XOR = 22 _KEY_META :: Int _KEY_META = 16777239 _ERR_INVALID_PARAMETER :: Int _ERR_INVALID_PARAMETER = 31 _KEY_LAUNCH0 :: Int _KEY_LAUNCH0 = 16777304 _KEY_F3 :: Int _KEY_F3 = 16777246 _OP_BIT_XOR :: Int _OP_BIT_XOR = 18 _METHOD_FLAG_FROM_SCRIPT :: Int _METHOD_FLAG_FROM_SCRIPT = 64 _KEY_KP_ADD :: Int _KEY_KP_ADD = 16777349 _BUTTON_WHEEL_RIGHT :: Int _BUTTON_WHEEL_RIGHT = 7 _TYPE_NODE_PATH :: Int _TYPE_NODE_PATH = 15 _KEY_U :: Int _KEY_U = 85 _ERR_UNCONFIGURED :: Int _ERR_UNCONFIGURED = 3 _JOY_XBOX_Y :: Int _JOY_XBOX_Y = 3 _PROPERTY_HINT_LENGTH :: Int _PROPERTY_HINT_LENGTH = 5 _KEY_STOP :: Int _KEY_STOP = 16777282 _ERR_UNAVAILABLE :: Int _ERR_UNAVAILABLE = 2 _ERR_ALREADY_IN_USE :: Int _ERR_ALREADY_IN_USE = 22 _JOY_DPAD_UP :: Int _JOY_DPAD_UP = 12 _KEY_X :: Int _KEY_X = 88 _KEY_QUOTEDBL :: Int _KEY_QUOTEDBL = 34 _KEY_REGISTERED :: Int _KEY_REGISTERED = 174 _KEY_H :: Int _KEY_H = 72 _KEY_DIRECTION_R :: Int _KEY_DIRECTION_R = 16777267 _JOY_VR_TRIGGER :: Int _JOY_VR_TRIGGER = 15 _KEY_RIGHT :: Int _KEY_RIGHT = 16777233 _JOY_ANALOG_L2 :: Int _JOY_ANALOG_L2 = 6 _JOY_BUTTON_2 :: Int _JOY_BUTTON_2 = 2 _KEY_GUILLEMOTRIGHT :: Int _KEY_GUILLEMOTRIGHT = 187 _PROPERTY_USAGE_RESTART_IF_CHANGED :: Int _PROPERTY_USAGE_RESTART_IF_CHANGED = 4096 _KEY_MEDIAPLAY :: Int _KEY_MEDIAPLAY = 16777292 _BUTTON_WHEEL_UP :: Int _BUTTON_WHEEL_UP = 4 _KEY_8 :: Int _KEY_8 = 56 _ERR_PARSE_ERROR :: Int _ERR_PARSE_ERROR = 43 _KEY_KP_MULTIPLY :: Int _KEY_KP_MULTIPLY = 16777345 _JOY_BUTTON_10 :: Int _JOY_BUTTON_10 = 10 _KEY_EACUTE :: Int _KEY_EACUTE = 201 _KEY_LAUNCH6 :: Int _KEY_LAUNCH6 = 16777310 _KEY_F5 :: Int _KEY_F5 = 16777248 _MIDI_MESSAGE_AFTERTOUCH :: Int _MIDI_MESSAGE_AFTERTOUCH = 10 _KEY_UACUTE :: Int _KEY_UACUTE = 218 _KEY_THREESUPERIOR :: Int _KEY_THREESUPERIOR = 179 _TYPE_VECTOR3_ARRAY :: Int _TYPE_VECTOR3_ARRAY = 25 _KEY_OCIRCUMFLEX :: Int _KEY_OCIRCUMFLEX = 212 _KEY_LAUNCHF :: Int _KEY_LAUNCHF = 16777319 _CORNER_BOTTOM_LEFT :: Int _CORNER_BOTTOM_LEFT = 3 _PROPERTY_HINT_DIR :: Int _PROPERTY_HINT_DIR = 14 _JOY_XBOX_B :: Int _JOY_XBOX_B = 1 _KEY_ARING :: Int _KEY_ARING = 197 _KEY_S :: Int _KEY_S = 83 _KEY_SEMICOLON :: Int _KEY_SEMICOLON = 59 _MIDI_MESSAGE_CHANNEL_PRESSURE :: Int _MIDI_MESSAGE_CHANNEL_PRESSURE = 13 _KEY_BRACKETLEFT :: Int _KEY_BRACKETLEFT = 91 _PROPERTY_HINT_FLAGS :: Int _PROPERTY_HINT_FLAGS = 8 _OP_AND :: Int _OP_AND = 20 _KEY_PARENLEFT :: Int _KEY_PARENLEFT = 40 _PROPERTY_USAGE_EDITOR :: Int _PROPERTY_USAGE_EDITOR = 2 _KEY_KP_7 :: Int _KEY_KP_7 = 16777357 _JOY_AXIS_4 :: Int _JOY_AXIS_4 = 4 _ERR_CANT_CONNECT :: Int _ERR_CANT_CONNECT = 25 _KEY_HYPER_R :: Int _KEY_HYPER_R = 16777264 _KEY_C :: Int _KEY_C = 67 _ERR_CONNECTION_ERROR :: Int _ERR_CONNECTION_ERROR = 27 _OP_BIT_AND :: Int _OP_BIT_AND = 16 _JOY_R2 :: Int _JOY_R2 = 7 _KEY_MEDIANEXT :: Int _KEY_MEDIANEXT = 16777295 _KEY_BACK :: Int _KEY_BACK = 16777280 _JOY_BUTTON_9 :: Int _JOY_BUTTON_9 = 9 _KEY_MASK_SHIFT :: Int _KEY_MASK_SHIFT = 33554432 _KEY_3 :: Int _KEY_3 = 51 _KEY_SSHARP :: Int _KEY_SSHARP = 223 _JOY_ANALOG_LY :: Int _JOY_ANALOG_LY = 1 _JOY_OCULUS_AX :: Int _JOY_OCULUS_AX = 7 _KEY_SCROLLLOCK :: Int _KEY_SCROLLLOCK = 16777243 _PROPERTY_HINT_GLOBAL_FILE :: Int _PROPERTY_HINT_GLOBAL_FILE = 15 _KEY_CODE_MASK :: Int _KEY_CODE_MASK = 33554431 _JOY_ANALOG_R2 :: Int _JOY_ANALOG_R2 = 7 _ERR_LINK_FAILED :: Int _ERR_LINK_FAILED = 38 _JOY_BUTTON_15 :: Int _JOY_BUTTON_15 = 15 _KEY_LAUNCH3 :: Int _KEY_LAUNCH3 = 16777307 _JOY_BUTTON_MAX :: Int _JOY_BUTTON_MAX = 16 _PROPERTY_USAGE_CHECKABLE :: Int _PROPERTY_USAGE_CHECKABLE = 16 _KEY_PAGEUP :: Int _KEY_PAGEUP = 16777235 _METHOD_FLAG_CONST :: Int _METHOD_FLAG_CONST = 8 _OP_STRING_CONCAT :: Int _OP_STRING_CONCAT = 13 _TYPE_ARRAY :: Int _TYPE_ARRAY = 19 _ERR_FILE_BAD_PATH :: Int _ERR_FILE_BAD_PATH = 9 _KEY_LAUNCHC :: Int _KEY_LAUNCHC = 16777316 _KEY_SEARCH :: Int _KEY_SEARCH = 16777299 _KEY_IDIAERESIS :: Int _KEY_IDIAERESIS = 207 _KEY_BACKSLASH :: Int _KEY_BACKSLASH = 92 _KEY_DIRECTION_L :: Int _KEY_DIRECTION_L = 16777266 _KEY_V :: Int _KEY_V = 86 _KEY_YDIAERESIS :: Int _KEY_YDIAERESIS = 255 _KEY_KP_2 :: Int _KEY_KP_2 = 16777352 _JOY_AXIS_1 :: Int _JOY_AXIS_1 = 1 _KEY_F :: Int _KEY_F = 70 _KEY_BASSUP :: Int _KEY_BASSUP = 16777288 _KEY_BASSBOOST :: Int _KEY_BASSBOOST = 16777287 _KEY_NTILDE :: Int _KEY_NTILDE = 209 _ERR_METHOD_NOT_FOUND :: Int _ERR_METHOD_NOT_FOUND = 37 _KEY_IGRAVE :: Int _KEY_IGRAVE = 204 _KEY_QUESTION :: Int _KEY_QUESTION = 63 _KEY_6 :: Int _KEY_6 = 54 _KEY_EXCLAM :: Int _KEY_EXCLAM = 33 _KEY_KP_PERIOD :: Int _KEY_KP_PERIOD = 16777348 _KEY_I :: Int _KEY_I = 73 _KEY_ECIRCUMFLEX :: Int _KEY_ECIRCUMFLEX = 202 _OP_ADD :: Int _OP_ADD = 6 _ERR_FILE_MISSING_DEPENDENCIES :: Int _ERR_FILE_MISSING_DEPENDENCIES = 17 _PROPERTY_HINT_LAYERS_2D_PHYSICS :: Int _PROPERTY_HINT_LAYERS_2D_PHYSICS = 10 _JOY_BUTTON_3 :: Int _JOY_BUTTON_3 = 3 _KEY_QUOTELEFT :: Int _KEY_QUOTELEFT = 96 _ERR_FILE_CANT_WRITE :: Int _ERR_FILE_CANT_WRITE = 13 _KEY_9 :: Int _KEY_9 = 57 _HALIGN_CENTER :: Int _HALIGN_CENTER = 1 _ERR_DOES_NOT_EXIST :: Int _ERR_DOES_NOT_EXIST = 33 _TYPE_BOOL :: Int _TYPE_BOOL = 1 _KEY_F16 :: Int _KEY_F16 = 16777259 _PROPERTY_HINT_EXP_EASING :: Int _PROPERTY_HINT_EXP_EASING = 4 _KEY_DIVISION :: Int _KEY_DIVISION = 247 _KEY_DELETE :: Int _KEY_DELETE = 16777224 _JOY_XBOX_X :: Int _JOY_XBOX_X = 2 _KEY_BAR :: Int _KEY_BAR = 124 _ERR_CANT_RESOLVE :: Int _ERR_CANT_RESOLVE = 26 _HALIGN_LEFT :: Int _HALIGN_LEFT = 0 _JOY_SONY_TRIANGLE :: Int _JOY_SONY_TRIANGLE = 3 _KEY_OACUTE :: Int _KEY_OACUTE = 211 _MARGIN_RIGHT :: Int _MARGIN_RIGHT = 2 _KEY_SECTION :: Int _KEY_SECTION = 167 _ERR_TIMEOUT :: Int _ERR_TIMEOUT = 24 _BUTTON_RIGHT :: Int _BUTTON_RIGHT = 2 _KEY_Y :: Int _KEY_Y = 89 _ERR_SCRIPT_FAILED :: Int _ERR_SCRIPT_FAILED = 39 _KEY_ETH :: Int _KEY_ETH = 208 _KEY_ALT :: Int _KEY_ALT = 16777240 _JOY_R :: Int _JOY_R = 5 _KEY_UCIRCUMFLEX :: Int _KEY_UCIRCUMFLEX = 219 _OP_LESS :: Int _OP_LESS = 2 _ERR_INVALID_DATA :: Int _ERR_INVALID_DATA = 30 _JOY_OCULUS_MENU :: Int _JOY_OCULUS_MENU = 3 _ERR_OUT_OF_MEMORY :: Int _ERR_OUT_OF_MEMORY = 6 _KEY_HOMEPAGE :: Int _KEY_HOMEPAGE = 16777297 _OP_SUBTRACT :: Int _OP_SUBTRACT = 7 _KEY_KP_8 :: Int _KEY_KP_8 = 16777358 _JOY_ANALOG_RX :: Int _JOY_ANALOG_RX = 2 _KEY_L :: Int _KEY_L = 76 _KEY_MEDIASTOP :: Int _KEY_MEDIASTOP = 16777293 _JOY_VR_GRIP :: Int _JOY_VR_GRIP = 2 _MIDI_MESSAGE_NOTE_ON :: Int _MIDI_MESSAGE_NOTE_ON = 9 _KEY_MULTIPLY :: Int _KEY_MULTIPLY = 215 _KEY_STERLING :: Int _KEY_STERLING = 163 _OP_NEGATE :: Int _OP_NEGATE = 10 _JOY_BUTTON_6 :: Int _JOY_BUTTON_6 = 6 _PROPERTY_HINT_COLOR_NO_ALPHA :: Int _PROPERTY_HINT_COLOR_NO_ALPHA = 20 _KEY_AE :: Int _KEY_AE = 198 _KEY_MINUS :: Int _KEY_MINUS = 45 _BUTTON_MIDDLE :: Int _BUTTON_MIDDLE = 3 _KEY_F13 :: Int _KEY_F13 = 16777256 _KEY_LAUNCH9 :: Int _KEY_LAUNCH9 = 16777313 _KEY_EXCLAMDOWN :: Int _KEY_EXCLAMDOWN = 161 _ERR_PARAMETER_RANGE_ERROR :: Int _ERR_PARAMETER_RANGE_ERROR = 5 _KEY_QUESTIONDOWN :: Int _KEY_QUESTIONDOWN = 191 _ERR_INVALID_DECLARATION :: Int _ERR_INVALID_DECLARATION = 41 _TYPE_COLOR_ARRAY :: Int _TYPE_COLOR_ARRAY = 26 _KEY_EQUAL :: Int _KEY_EQUAL = 61 _JOY_OPENVR_TOUCHPADX :: Int _JOY_OPENVR_TOUCHPADX = 0 _JOY_OCULUS_BY :: Int _JOY_OCULUS_BY = 1 _OP_BIT_NEGATE :: Int _OP_BIT_NEGATE = 19 _JOY_L3 :: Int _JOY_L3 = 8 _OP_SHIFT_LEFT :: Int _OP_SHIFT_LEFT = 14 _KEY_SPACE :: Int _KEY_SPACE = 32 _CORNER_TOP_LEFT :: Int _CORNER_TOP_LEFT = 0 _KEY_HOME :: Int _KEY_HOME = 16777229 _KEY_MASCULINE :: Int _KEY_MASCULINE = 186 _ERR_COMPILATION_FAILED :: Int _ERR_COMPILATION_FAILED = 36 _KEY_W :: Int _KEY_W = 87 _VALIGN_CENTER :: Int _VALIGN_CENTER = 1 _KEY_KP_3 :: Int _KEY_KP_3 = 16777353 _PROPERTY_HINT_GLOBAL_DIR :: Int _PROPERTY_HINT_GLOBAL_DIR = 16 _JOY_AXIS_0 :: Int _JOY_AXIS_0 = 0 _KEY_G :: Int _KEY_G = 71 _TYPE_DICTIONARY :: Int _TYPE_DICTIONARY = 18 _KEY_FAVORITES :: Int _KEY_FAVORITES = 16777298 _JOY_L :: Int _JOY_L = 4 _KEY_DIAERESIS :: Int _KEY_DIAERESIS = 168 _PROPERTY_HINT_IMAGE_COMPRESS_LOSSY :: Int _PROPERTY_HINT_IMAGE_COMPRESS_LOSSY = 21 _KEY_ONEHALF :: Int _KEY_ONEHALF = 189 _KEY_7 :: Int _KEY_7 = 55 _KEY_INSERT :: Int _KEY_INSERT = 16777223 _KEY_STANDBY :: Int _KEY_STANDBY = 16777300 _OP_IN :: Int _OP_IN = 24 _PROPERTY_HINT_ENUM :: Int _PROPERTY_HINT_ENUM = 3 _KEY_BACKSPACE :: Int _KEY_BACKSPACE = 16777220 _TYPE_AABB :: Int _TYPE_AABB = 11 _KEY_KP_DIVIDE :: Int _KEY_KP_DIVIDE = 16777346 _JOY_BUTTON_14 :: Int _JOY_BUTTON_14 = 14 _OP_SHIFT_RIGHT :: Int _OP_SHIFT_RIGHT = 15 _KEY_LAUNCH2 :: Int _KEY_LAUNCH2 = 16777306 _KEY_F1 :: Int _KEY_F1 = 16777244 _KEY_CONTROL :: Int _KEY_CONTROL = 16777238 _KEY_AACUTE :: Int _KEY_AACUTE = 193 _KEY_SYSREQ :: Int _KEY_SYSREQ = 16777227 _KEY_LAUNCHB :: Int _KEY_LAUNCHB = 16777315 _PROPERTY_USAGE_CATEGORY :: Int _PROPERTY_USAGE_CATEGORY = 256 _PROPERTY_USAGE_INTERNATIONALIZED :: Int _PROPERTY_USAGE_INTERNATIONALIZED = 64 _TYPE_OBJECT :: Int _TYPE_OBJECT = 17 _KEY_CAPSLOCK :: Int _KEY_CAPSLOCK = 16777241 _KEY_UGRAVE :: Int _KEY_UGRAVE = 217 _JOY_DS_Y :: Int _JOY_DS_Y = 2 _KEY_CEDILLA :: Int _KEY_CEDILLA = 184 _KEY_ORDFEMININE :: Int _KEY_ORDFEMININE = 170 _KEY_Z :: Int _KEY_Z = 90 _PROPERTY_USAGE_EDITOR_HELPER :: Int _PROPERTY_USAGE_EDITOR_HELPER = 8 _ERR_CYCLIC_LINK :: Int _ERR_CYCLIC_LINK = 40 _KEY_EGRAVE :: Int _KEY_EGRAVE = 200 _KEY_DOWN :: Int _KEY_DOWN = 16777234 _OP_MODULE :: Int _OP_MODULE = 12 _KEY_MASK_ALT :: Int _KEY_MASK_ALT = 67108864 _KEY_J :: Int _KEY_J = 74 _KEY_SUPER_L :: Int _KEY_SUPER_L = 16777260 _HALIGN_RIGHT :: Int _HALIGN_RIGHT = 2 _JOY_BUTTON_0 :: Int _JOY_BUTTON_0 = 0 _KEY_TREBLEDOWN :: Int _KEY_TREBLEDOWN = 16777291 _KEY_EDIAERESIS :: Int _KEY_EDIAERESIS = 203 _KEY_MASK_CTRL :: Int _KEY_MASK_CTRL = 268435456 _OP_GREATER :: Int _OP_GREATER = 4 _KEY_HYPHEN :: Int _KEY_HYPHEN = 173 _KEY_YEN :: Int _KEY_YEN = 165 _ERR_DATABASE_CANT_WRITE :: Int _ERR_DATABASE_CANT_WRITE = 35 _TYPE_COLOR :: Int _TYPE_COLOR = 14 _VERTICAL :: Int _VERTICAL = 1 _KEY_VOLUMEDOWN :: Int _KEY_VOLUMEDOWN = 16777284 _KEY_F15 :: Int _KEY_F15 = 16777258 _KEY_UDIAERESIS :: Int _KEY_UDIAERESIS = 220 _KEY_REFRESH :: Int _KEY_REFRESH = 16777283 _KEY_SLASH :: Int _KEY_SLASH = 47 _PROPERTY_HINT_PLACEHOLDER_TEXT :: Int _PROPERTY_HINT_PLACEHOLDER_TEXT = 19 _KEY_F12 :: Int _KEY_F12 = 16777255 _PROPERTY_USAGE_GROUP :: Int _PROPERTY_USAGE_GROUP = 128 _OP_OR :: Int _OP_OR = 21 _KEY_COPYRIGHT :: Int _KEY_COPYRIGHT = 169 _KEY_LAUNCH8 :: Int _KEY_LAUNCH8 = 16777312 _PROPERTY_USAGE_CHECKED :: Int _PROPERTY_USAGE_CHECKED = 32 _OP_BIT_OR :: Int _OP_BIT_OR = 17 _KEY_COMMA :: Int _KEY_COMMA = 44 _TYPE_BASIS :: Int _TYPE_BASIS = 12 _JOY_OPENVR_TOUCHPADY :: Int _JOY_OPENVR_TOUCHPADY = 1 _KEY_NUMLOCK :: Int _KEY_NUMLOCK = 16777242 _KEY_VOLUMEUP :: Int _KEY_VOLUMEUP = 16777286 _METHOD_FLAG_NOSCRIPT :: Int _METHOD_FLAG_NOSCRIPT = 4 _JOY_L2 :: Int _JOY_L2 = 6 _TYPE_REAL :: Int _TYPE_REAL = 3 _TYPE_TRANSFORM2D :: Int _TYPE_TRANSFORM2D = 8 _KEY_HYPER_L :: Int _KEY_HYPER_L = 16777263 _KEY_UP :: Int _KEY_UP = 16777232 _JOY_VR_PAD :: Int _JOY_VR_PAD = 14 _TYPE_RAW_ARRAY :: Int _TYPE_RAW_ARRAY = 20 _KEY_PERIOD :: Int _KEY_PERIOD = 46 _KEY_ACIRCUMFLEX :: Int _KEY_ACIRCUMFLEX = 194 _TYPE_RECT2 :: Int _TYPE_RECT2 = 6 _KEY_KP_9 :: Int _KEY_KP_9 = 16777359 _JOY_ANALOG_RY :: Int _JOY_ANALOG_RY = 3 _KEY_M :: Int _KEY_M = 77 _KEY_MEDIAPREVIOUS :: Int _KEY_MEDIAPREVIOUS = 16777294 _KEY_AT :: Int _KEY_AT = 64 _JOY_VR_ANALOG_TRIGGER :: Int _JOY_VR_ANALOG_TRIGGER = 2 _KEY_TREBLEUP :: Int _KEY_TREBLEUP = 16777290 _JOY_BUTTON_7 :: Int _JOY_BUTTON_7 = 7 _BUTTON_MASK_XBUTTON1 :: Int _BUTTON_MASK_XBUTTON1 = 128 _BUTTON_XBUTTON2 :: Int _BUTTON_XBUTTON2 = 9 _KEY_0 :: Int _KEY_0 = 48 _KEY_UNDERSCORE :: Int _KEY_UNDERSCORE = 95 _PROPERTY_HINT_LAYERS_2D_RENDER :: Int _PROPERTY_HINT_LAYERS_2D_RENDER = 9 _KEY_ENTER :: Int _KEY_ENTER = 16777221 _KEY_ASTERISK :: Int _KEY_ASTERISK = 42 _KEY_UNKNOWN :: Int _KEY_UNKNOWN = 33554431 _KEY_PARENRIGHT :: Int _KEY_PARENRIGHT = 41 _JOY_BUTTON_13 :: Int _JOY_BUTTON_13 = 13 _PROPERTY_HINT_LAYERS_3D_PHYSICS :: Int _PROPERTY_HINT_LAYERS_3D_PHYSICS = 12 _KEY_LAUNCH5 :: Int _KEY_LAUNCH5 = 16777309 _KEY_F6 :: Int _KEY_F6 = 16777249 _CORNER_BOTTOM_RIGHT :: Int _CORNER_BOTTOM_RIGHT = 2 _ERR_FILE_CANT_OPEN :: Int _ERR_FILE_CANT_OPEN = 12 _KEY_LAUNCHE :: Int _KEY_LAUNCHE = 16777318 _KEY_NUMBERSIGN :: Int _KEY_NUMBERSIGN = 35 _JOY_XBOX_A :: Int _JOY_XBOX_A = 0 _KEY_KP_SUBTRACT :: Int _KEY_KP_SUBTRACT = 16777347 _KEY_SHIFT :: Int _KEY_SHIFT = 16777237 _KEY_P :: Int _KEY_P = 80 _ERR_CANT_ACQUIRE_RESOURCE :: Int _ERR_CANT_ACQUIRE_RESOURCE = 28 _METHOD_FLAG_NORMAL :: Int _METHOD_FLAG_NORMAL = 1 _KEY_OGRAVE :: Int _KEY_OGRAVE = 210 _TYPE_RID :: Int _TYPE_RID = 16 _KEY_ODIAERESIS :: Int _KEY_ODIAERESIS = 214 _ERR_FILE_UNRECOGNIZED :: Int _ERR_FILE_UNRECOGNIZED = 15 _KEY_DOLLAR :: Int _KEY_DOLLAR = 36 _KEY_KP_4 :: Int _KEY_KP_4 = 16777354 _JOY_AXIS_7 :: Int _JOY_AXIS_7 = 7 _KEY_BRACKETRIGHT :: Int _KEY_BRACKETRIGHT = 93 _KEY_MU :: Int _KEY_MU = 181 _KEY_ONEQUARTER :: Int _KEY_ONEQUARTER = 188 _ERR_LOCKED :: Int _ERR_LOCKED = 23 _TYPE_REAL_ARRAY :: Int _TYPE_REAL_ARRAY = 22 _ERR_ALREADY_EXISTS :: Int _ERR_ALREADY_EXISTS = 32 _ERR_HELP :: Int _ERR_HELP = 46 _PROPERTY_USAGE_STORAGE :: Int _PROPERTY_USAGE_STORAGE = 1 _JOY_START :: Int _JOY_START = 11 _KEY_K :: Int _KEY_K = 75 _OP_DIVIDE :: Int _OP_DIVIDE = 9 _FAILED :: Int _FAILED = 1 _JOY_BUTTON_1 :: Int _JOY_BUTTON_1 = 1 _KEY_PERCENT :: Int _KEY_PERCENT = 37 _PROPERTY_HINT_RANGE :: Int _PROPERTY_HINT_RANGE = 1 _KEY_LEFT :: Int _KEY_LEFT = 16777231 _KEY_F14 :: Int _KEY_F14 = 16777257 _METHOD_FLAGS_DEFAULT :: Int _METHOD_FLAGS_DEFAULT = 1 _JOY_AXIS_MAX :: Int _JOY_AXIS_MAX = 10 _METHOD_FLAG_REVERSE :: Int _METHOD_FLAG_REVERSE = 16 _KEY_GUILLEMOTLEFT :: Int _KEY_GUILLEMOTLEFT = 171 _TYPE_TRANSFORM :: Int _TYPE_TRANSFORM = 13 _JOY_DS_X :: Int _JOY_DS_X = 3 _ERR_SKIP :: Int _ERR_SKIP = 45 _OP_POSITIVE :: Int _OP_POSITIVE = 11 _KEY_FORWARD :: Int _KEY_FORWARD = 16777281 _KEY_AMPERSAND :: Int _KEY_AMPERSAND = 38 _TYPE_MAX :: Int _TYPE_MAX = 27 _KEY_MENU :: Int _KEY_MENU = 16777262 _JOY_SELECT :: Int _JOY_SELECT = 10 _VALIGN_BOTTOM :: Int _VALIGN_BOTTOM = 2 _ERR_UNAUTHORIZED :: Int _ERR_UNAUTHORIZED = 4 _JOY_DPAD_LEFT :: Int _JOY_DPAD_LEFT = 14 _KEY_PARAGRAPH :: Int _KEY_PARAGRAPH = 182 _KEY_NOTSIGN :: Int _KEY_NOTSIGN = 172 _TYPE_QUAT :: Int _TYPE_QUAT = 10 _KEY_N :: Int _KEY_N = 78 _ERR_FILE_CANT_READ :: Int _ERR_FILE_CANT_READ = 14 _JOY_AXIS_9 :: Int _JOY_AXIS_9 = 9 _KEY_AGRAVE :: Int _KEY_AGRAVE = 192 _JOY_BUTTON_4 :: Int _JOY_BUTTON_4 = 4 _KEY_BROKENBAR :: Int _KEY_BROKENBAR = 166 _ERR_FILE_NO_PERMISSION :: Int _ERR_FILE_NO_PERMISSION = 10 _BUTTON_WHEEL_LEFT :: Int _BUTTON_WHEEL_LEFT = 6 _BUTTON_MASK_XBUTTON2 :: Int _BUTTON_MASK_XBUTTON2 = 256 _KEY_PLUSMINUS :: Int _KEY_PLUSMINUS = 177 _JOY_SONY_SQUARE :: Int _JOY_SONY_SQUARE = 2 _ERR_FILE_CORRUPT :: Int _ERR_FILE_CORRUPT = 16 _BUTTON_XBUTTON1 :: Int _BUTTON_XBUTTON1 = 8 _KEY_F11 :: Int _KEY_F11 = 16777254 _OP_NOT_EQUAL :: Int _OP_NOT_EQUAL = 1 _KEY_OOBLIQUE :: Int _KEY_OOBLIQUE = 216 _MIDI_MESSAGE_PITCH_BEND :: Int _MIDI_MESSAGE_PITCH_BEND = 14 _HORIZONTAL :: Int _HORIZONTAL = 0 _KEY_ACUTE :: Int _KEY_ACUTE = 180 _KEY_F8 :: Int _KEY_F8 = 16777251 _KEY_ADIAERESIS :: Int _KEY_ADIAERESIS = 196 _MARGIN_BOTTOM :: Int _MARGIN_BOTTOM = 3 _PROPERTY_HINT_NONE :: Int _PROPERTY_HINT_NONE = 0 _KEY_MASK_META :: Int _KEY_MASK_META = 134217728 _KEY_MASK_GROUP_SWITCH :: Int _KEY_MASK_GROUP_SWITCH = 1073741824 _KEY_COLON :: Int _KEY_COLON = 58 _KEY_HELP :: Int _KEY_HELP = 16777265 _KEY_LAUNCHD :: Int _KEY_LAUNCHD = 16777317 _KEY_ONESUPERIOR :: Int _KEY_ONESUPERIOR = 185 _KEY_BASSDOWN :: Int _KEY_BASSDOWN = 16777289 _KEY_ATILDE :: Int _KEY_ATILDE = 195 _PROPERTY_HINT_MULTILINE_TEXT :: Int _PROPERTY_HINT_MULTILINE_TEXT = 18 _KEY_LAUNCHMEDIA :: Int _KEY_LAUNCHMEDIA = 16777303 _JOY_DS_B :: Int _JOY_DS_B = 0 _KEY_MEDIARECORD :: Int _KEY_MEDIARECORD = 16777296 _KEY_Q :: Int _KEY_Q = 81 _BUTTON_MASK_LEFT :: Int _BUTTON_MASK_LEFT = 1 _KEY_CCEDILLA :: Int _KEY_CCEDILLA = 199 _ERR_CANT_CREATE :: Int _ERR_CANT_CREATE = 20 _PROPERTY_HINT_EXP_RANGE :: Int _PROPERTY_HINT_EXP_RANGE = 2 _OP_GREATER_EQUAL :: Int _OP_GREATER_EQUAL = 5 _KEY_KP_5 :: Int _KEY_KP_5 = 16777355 _KEY_APOSTROPHE :: Int _KEY_APOSTROPHE = 39 _JOY_AXIS_6 :: Int _JOY_AXIS_6 = 6 _KEY_A :: Int _KEY_A = 65 _KEY_THREEQUARTERS :: Int _KEY_THREEQUARTERS = 190 _PROPERTY_USAGE_DEFAULT :: Int _PROPERTY_USAGE_DEFAULT = 7 _KEY_LESS :: Int _KEY_LESS = 60 _JOY_VR_ANALOG_GRIP :: Int _JOY_VR_ANALOG_GRIP = 4 _KEY_CLEAR :: Int _KEY_CLEAR = 16777228 _PROPERTY_HINT_RESOURCE_TYPE :: Int _PROPERTY_HINT_RESOURCE_TYPE = 17 _KEY_ESCAPE :: Int _KEY_ESCAPE = 16777217 _KEY_1 :: Int _KEY_1 = 49 _KEY_PAGEDOWN :: Int _KEY_PAGEDOWN = 16777236 _KEY_TWOSUPERIOR :: Int _KEY_TWOSUPERIOR = 178 _PROPERTY_HINT_LAYERS_3D_RENDER :: Int _PROPERTY_HINT_LAYERS_3D_RENDER = 11 _PROPERTY_USAGE_DEFAULT_INTL :: Int _PROPERTY_USAGE_DEFAULT_INTL = 71 _TYPE_PLANE :: Int _TYPE_PLANE = 9 _JOY_BUTTON_12 :: Int _JOY_BUTTON_12 = 12 _KEY_PRINT :: Int _KEY_PRINT = 16777226 _ERR_FILE_ALREADY_IN_USE :: Int _ERR_FILE_ALREADY_IN_USE = 11 _KEY_LAUNCH4 :: Int _KEY_LAUNCH4 = 16777308 _KEY_F7 :: Int _KEY_F7 = 16777250 _KEY_ASCIITILDE :: Int _KEY_ASCIITILDE = 126 _KEY_MASK_CMD :: Int _KEY_MASK_CMD = 268435456 _KEY_VOLUMEMUTE :: Int _KEY_VOLUMEMUTE = 16777285 _ERR_CANT_OPEN :: Int _ERR_CANT_OPEN = 19 ================================================ FILE: src/Godot/Core/Gradient.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Gradient (Godot.Core.Gradient.add_point, Godot.Core.Gradient.get_color, Godot.Core.Gradient.get_colors, Godot.Core.Gradient.get_offset, Godot.Core.Gradient.get_offsets, Godot.Core.Gradient.get_point_count, Godot.Core.Gradient.interpolate, Godot.Core.Gradient.remove_point, Godot.Core.Gradient.set_color, Godot.Core.Gradient.set_colors, Godot.Core.Gradient.set_offset, Godot.Core.Gradient.set_offsets) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty Gradient "colors" PoolColorArray 'False where nodeProperty = (get_colors, wrapDroppingSetter set_colors, Nothing) instance NodeProperty Gradient "offsets" PoolRealArray 'False where nodeProperty = (get_offsets, wrapDroppingSetter set_offsets, Nothing) {-# NOINLINE bindGradient_add_point #-} -- | Adds the specified color to the end of the ramp, with the specified offset. bindGradient_add_point :: MethodBind bindGradient_add_point = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "add_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the specified color to the end of the ramp, with the specified offset. add_point :: (Gradient :< cls, Object :< cls) => cls -> Float -> Color -> IO () add_point cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_add_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "add_point" '[Float, Color] (IO ()) where nodeMethod = Godot.Core.Gradient.add_point {-# NOINLINE bindGradient_get_color #-} -- | Returns the color of the ramp color at index @point@. bindGradient_get_color :: MethodBind bindGradient_get_color = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color of the ramp color at index @point@. get_color :: (Gradient :< cls, Object :< cls) => cls -> Int -> IO Color get_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "get_color" '[Int] (IO Color) where nodeMethod = Godot.Core.Gradient.get_color {-# NOINLINE bindGradient_get_colors #-} -- | Gradient's colors returned as a @PoolColorArray@. bindGradient_get_colors :: MethodBind bindGradient_get_colors = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "get_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gradient's colors returned as a @PoolColorArray@. get_colors :: (Gradient :< cls, Object :< cls) => cls -> IO PoolColorArray get_colors cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_get_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "get_colors" '[] (IO PoolColorArray) where nodeMethod = Godot.Core.Gradient.get_colors {-# NOINLINE bindGradient_get_offset #-} -- | Returns the offset of the ramp color at index @point@. bindGradient_get_offset :: MethodBind bindGradient_get_offset = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the offset of the ramp color at index @point@. get_offset :: (Gradient :< cls, Object :< cls) => cls -> Int -> IO Float get_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "get_offset" '[Int] (IO Float) where nodeMethod = Godot.Core.Gradient.get_offset {-# NOINLINE bindGradient_get_offsets #-} -- | Gradient's offsets returned as a @PoolRealArray@. bindGradient_get_offsets :: MethodBind bindGradient_get_offsets = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "get_offsets" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gradient's offsets returned as a @PoolRealArray@. get_offsets :: (Gradient :< cls, Object :< cls) => cls -> IO PoolRealArray get_offsets cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_get_offsets (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "get_offsets" '[] (IO PoolRealArray) where nodeMethod = Godot.Core.Gradient.get_offsets {-# NOINLINE bindGradient_get_point_count #-} -- | Returns the number of colors in the ramp. bindGradient_get_point_count :: MethodBind bindGradient_get_point_count = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "get_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of colors in the ramp. get_point_count :: (Gradient :< cls, Object :< cls) => cls -> IO Int get_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_get_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "get_point_count" '[] (IO Int) where nodeMethod = Godot.Core.Gradient.get_point_count {-# NOINLINE bindGradient_interpolate #-} -- | Returns the interpolated color specified by @offset@. bindGradient_interpolate :: MethodBind bindGradient_interpolate = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "interpolate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the interpolated color specified by @offset@. interpolate :: (Gradient :< cls, Object :< cls) => cls -> Float -> IO Color interpolate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_interpolate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "interpolate" '[Float] (IO Color) where nodeMethod = Godot.Core.Gradient.interpolate {-# NOINLINE bindGradient_remove_point #-} -- | Removes the color at the index @offset@. bindGradient_remove_point :: MethodBind bindGradient_remove_point = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "remove_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the color at the index @offset@. remove_point :: (Gradient :< cls, Object :< cls) => cls -> Int -> IO () remove_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_remove_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "remove_point" '[Int] (IO ()) where nodeMethod = Godot.Core.Gradient.remove_point {-# NOINLINE bindGradient_set_color #-} -- | Sets the color of the ramp color at index @point@. bindGradient_set_color :: MethodBind bindGradient_set_color = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color of the ramp color at index @point@. set_color :: (Gradient :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "set_color" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.Gradient.set_color {-# NOINLINE bindGradient_set_colors #-} -- | Gradient's colors returned as a @PoolColorArray@. bindGradient_set_colors :: MethodBind bindGradient_set_colors = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "set_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gradient's colors returned as a @PoolColorArray@. set_colors :: (Gradient :< cls, Object :< cls) => cls -> PoolColorArray -> IO () set_colors cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_set_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "set_colors" '[PoolColorArray] (IO ()) where nodeMethod = Godot.Core.Gradient.set_colors {-# NOINLINE bindGradient_set_offset #-} -- | Sets the offset for the ramp color at index @point@. bindGradient_set_offset :: MethodBind bindGradient_set_offset = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the offset for the ramp color at index @point@. set_offset :: (Gradient :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "set_offset" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Gradient.set_offset {-# NOINLINE bindGradient_set_offsets #-} -- | Gradient's offsets returned as a @PoolRealArray@. bindGradient_set_offsets :: MethodBind bindGradient_set_offsets = unsafePerformIO $ withCString "Gradient" $ \ clsNamePtr -> withCString "set_offsets" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gradient's offsets returned as a @PoolRealArray@. set_offsets :: (Gradient :< cls, Object :< cls) => cls -> PoolRealArray -> IO () set_offsets cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGradient_set_offsets (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Gradient "set_offsets" '[PoolRealArray] (IO ()) where nodeMethod = Godot.Core.Gradient.set_offsets ================================================ FILE: src/Godot/Core/GradientTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GradientTexture (Godot.Core.GradientTexture.get_width, Godot.Core.GradientTexture._update, Godot.Core.GradientTexture.get_gradient, Godot.Core.GradientTexture.set_gradient, Godot.Core.GradientTexture.set_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty GradientTexture "gradient" Gradient 'False where nodeProperty = (get_gradient, wrapDroppingSetter set_gradient, Nothing) {-# NOINLINE bindGradientTexture_get_width #-} -- | The number of color samples that will be obtained from the @Gradient@. bindGradientTexture_get_width :: MethodBind bindGradientTexture_get_width = unsafePerformIO $ withCString "GradientTexture" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of color samples that will be obtained from the @Gradient@. get_width :: (GradientTexture :< cls, Object :< cls) => cls -> IO Int get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGradientTexture_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GradientTexture "get_width" '[] (IO Int) where nodeMethod = Godot.Core.GradientTexture.get_width instance NodeProperty GradientTexture "width" Int 'False where nodeProperty = (get_width, wrapDroppingSetter set_width, Nothing) {-# NOINLINE bindGradientTexture__update #-} bindGradientTexture__update :: MethodBind bindGradientTexture__update = unsafePerformIO $ withCString "GradientTexture" $ \ clsNamePtr -> withCString "_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update :: (GradientTexture :< cls, Object :< cls) => cls -> IO () _update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGradientTexture__update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GradientTexture "_update" '[] (IO ()) where nodeMethod = Godot.Core.GradientTexture._update {-# NOINLINE bindGradientTexture_get_gradient #-} -- | The @Gradient@ that will be used to fill the texture. bindGradientTexture_get_gradient :: MethodBind bindGradientTexture_get_gradient = unsafePerformIO $ withCString "GradientTexture" $ \ clsNamePtr -> withCString "get_gradient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Gradient@ that will be used to fill the texture. get_gradient :: (GradientTexture :< cls, Object :< cls) => cls -> IO Gradient get_gradient cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGradientTexture_get_gradient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GradientTexture "get_gradient" '[] (IO Gradient) where nodeMethod = Godot.Core.GradientTexture.get_gradient {-# NOINLINE bindGradientTexture_set_gradient #-} -- | The @Gradient@ that will be used to fill the texture. bindGradientTexture_set_gradient :: MethodBind bindGradientTexture_set_gradient = unsafePerformIO $ withCString "GradientTexture" $ \ clsNamePtr -> withCString "set_gradient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Gradient@ that will be used to fill the texture. set_gradient :: (GradientTexture :< cls, Object :< cls) => cls -> Gradient -> IO () set_gradient cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGradientTexture_set_gradient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GradientTexture "set_gradient" '[Gradient] (IO ()) where nodeMethod = Godot.Core.GradientTexture.set_gradient {-# NOINLINE bindGradientTexture_set_width #-} -- | The number of color samples that will be obtained from the @Gradient@. bindGradientTexture_set_width :: MethodBind bindGradientTexture_set_width = unsafePerformIO $ withCString "GradientTexture" $ \ clsNamePtr -> withCString "set_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of color samples that will be obtained from the @Gradient@. set_width :: (GradientTexture :< cls, Object :< cls) => cls -> Int -> IO () set_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGradientTexture_set_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GradientTexture "set_width" '[Int] (IO ()) where nodeMethod = Godot.Core.GradientTexture.set_width ================================================ FILE: src/Godot/Core/GraphEdit.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GraphEdit (Godot.Core.GraphEdit.sig__begin_node_move, Godot.Core.GraphEdit.sig__end_node_move, Godot.Core.GraphEdit.sig_connection_from_empty, Godot.Core.GraphEdit.sig_connection_request, Godot.Core.GraphEdit.sig_connection_to_empty, Godot.Core.GraphEdit.sig_copy_nodes_request, Godot.Core.GraphEdit.sig_delete_nodes_request, Godot.Core.GraphEdit.sig_disconnection_request, Godot.Core.GraphEdit.sig_duplicate_nodes_request, Godot.Core.GraphEdit.sig_node_selected, Godot.Core.GraphEdit.sig_paste_nodes_request, Godot.Core.GraphEdit.sig_popup_request, Godot.Core.GraphEdit.sig_scroll_offset_changed, Godot.Core.GraphEdit._connections_layer_draw, Godot.Core.GraphEdit._graph_node_moved, Godot.Core.GraphEdit._graph_node_raised, Godot.Core.GraphEdit._gui_input, Godot.Core.GraphEdit._scroll_moved, Godot.Core.GraphEdit._snap_toggled, Godot.Core.GraphEdit._snap_value_changed, Godot.Core.GraphEdit._top_layer_draw, Godot.Core.GraphEdit._top_layer_input, Godot.Core.GraphEdit._update_scroll_offset, Godot.Core.GraphEdit._zoom_minus, Godot.Core.GraphEdit._zoom_plus, Godot.Core.GraphEdit._zoom_reset, Godot.Core.GraphEdit.add_valid_connection_type, Godot.Core.GraphEdit.add_valid_left_disconnect_type, Godot.Core.GraphEdit.add_valid_right_disconnect_type, Godot.Core.GraphEdit.clear_connections, Godot.Core.GraphEdit.connect_node, Godot.Core.GraphEdit.disconnect_node, Godot.Core.GraphEdit.get_connection_list, Godot.Core.GraphEdit.get_scroll_ofs, Godot.Core.GraphEdit.get_snap, Godot.Core.GraphEdit.get_zoom, Godot.Core.GraphEdit.get_zoom_hbox, Godot.Core.GraphEdit.is_node_connected, Godot.Core.GraphEdit.is_right_disconnects_enabled, Godot.Core.GraphEdit.is_using_snap, Godot.Core.GraphEdit.is_valid_connection_type, Godot.Core.GraphEdit.remove_valid_connection_type, Godot.Core.GraphEdit.remove_valid_left_disconnect_type, Godot.Core.GraphEdit.remove_valid_right_disconnect_type, Godot.Core.GraphEdit.set_connection_activity, Godot.Core.GraphEdit.set_right_disconnects, Godot.Core.GraphEdit.set_scroll_ofs, Godot.Core.GraphEdit.set_selected, Godot.Core.GraphEdit.set_snap, Godot.Core.GraphEdit.set_use_snap, Godot.Core.GraphEdit.set_zoom) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() -- | Emitted at the beginning of a GraphNode movement. sig__begin_node_move :: Godot.Internal.Dispatch.Signal GraphEdit sig__begin_node_move = Godot.Internal.Dispatch.Signal "_begin_node_move" instance NodeSignal GraphEdit "_begin_node_move" '[] -- | Emitted at the end of a GraphNode movement. sig__end_node_move :: Godot.Internal.Dispatch.Signal GraphEdit sig__end_node_move = Godot.Internal.Dispatch.Signal "_end_node_move" instance NodeSignal GraphEdit "_end_node_move" '[] -- | Emitted when user dragging connection from input port into empty space of the graph. sig_connection_from_empty :: Godot.Internal.Dispatch.Signal GraphEdit sig_connection_from_empty = Godot.Internal.Dispatch.Signal "connection_from_empty" instance NodeSignal GraphEdit "connection_from_empty" '[GodotString, Int, Vector2] -- | Emitted to the GraphEdit when the connection between the @from_slot@ slot of the @from@ GraphNode and the @to_slot@ slot of the @to@ GraphNode is attempted to be created. sig_connection_request :: Godot.Internal.Dispatch.Signal GraphEdit sig_connection_request = Godot.Internal.Dispatch.Signal "connection_request" instance NodeSignal GraphEdit "connection_request" '[GodotString, Int, GodotString, Int] -- | Emitted when user dragging connection from output port into empty space of the graph. sig_connection_to_empty :: Godot.Internal.Dispatch.Signal GraphEdit sig_connection_to_empty = Godot.Internal.Dispatch.Signal "connection_to_empty" instance NodeSignal GraphEdit "connection_to_empty" '[GodotString, Int, Vector2] -- | Emitted when the user presses @Ctrl + C@. sig_copy_nodes_request :: Godot.Internal.Dispatch.Signal GraphEdit sig_copy_nodes_request = Godot.Internal.Dispatch.Signal "copy_nodes_request" instance NodeSignal GraphEdit "copy_nodes_request" '[] -- | Emitted when a GraphNode is attempted to be removed from the GraphEdit. sig_delete_nodes_request :: Godot.Internal.Dispatch.Signal GraphEdit sig_delete_nodes_request = Godot.Internal.Dispatch.Signal "delete_nodes_request" instance NodeSignal GraphEdit "delete_nodes_request" '[] -- | Emitted to the GraphEdit when the connection between @from_slot@ slot of @from@ GraphNode and @to_slot@ slot of @to@ GraphNode is attempted to be removed. sig_disconnection_request :: Godot.Internal.Dispatch.Signal GraphEdit sig_disconnection_request = Godot.Internal.Dispatch.Signal "disconnection_request" instance NodeSignal GraphEdit "disconnection_request" '[GodotString, Int, GodotString, Int] -- | Emitted when a GraphNode is attempted to be duplicated in the GraphEdit. sig_duplicate_nodes_request :: Godot.Internal.Dispatch.Signal GraphEdit sig_duplicate_nodes_request = Godot.Internal.Dispatch.Signal "duplicate_nodes_request" instance NodeSignal GraphEdit "duplicate_nodes_request" '[] -- | Emitted when a GraphNode is selected. sig_node_selected :: Godot.Internal.Dispatch.Signal GraphEdit sig_node_selected = Godot.Internal.Dispatch.Signal "node_selected" instance NodeSignal GraphEdit "node_selected" '[Node] -- | Emitted when the user presses @Ctrl + V@. sig_paste_nodes_request :: Godot.Internal.Dispatch.Signal GraphEdit sig_paste_nodes_request = Godot.Internal.Dispatch.Signal "paste_nodes_request" instance NodeSignal GraphEdit "paste_nodes_request" '[] -- | Emitted when a popup is requested. Happens on right-clicking in the GraphEdit. @position@ is the position of the mouse pointer when the signal is sent. sig_popup_request :: Godot.Internal.Dispatch.Signal GraphEdit sig_popup_request = Godot.Internal.Dispatch.Signal "popup_request" instance NodeSignal GraphEdit "popup_request" '[Vector2] -- | Emitted when the scroll offset is changed by the user. It will not be emitted when changed in code. sig_scroll_offset_changed :: Godot.Internal.Dispatch.Signal GraphEdit sig_scroll_offset_changed = Godot.Internal.Dispatch.Signal "scroll_offset_changed" instance NodeSignal GraphEdit "scroll_offset_changed" '[Vector2] instance NodeProperty GraphEdit "right_disconnects" Bool 'False where nodeProperty = (is_right_disconnects_enabled, wrapDroppingSetter set_right_disconnects, Nothing) instance NodeProperty GraphEdit "scroll_offset" Vector2 'False where nodeProperty = (get_scroll_ofs, wrapDroppingSetter set_scroll_ofs, Nothing) instance NodeProperty GraphEdit "snap_distance" Int 'False where nodeProperty = (get_snap, wrapDroppingSetter set_snap, Nothing) instance NodeProperty GraphEdit "use_snap" Bool 'False where nodeProperty = (is_using_snap, wrapDroppingSetter set_use_snap, Nothing) instance NodeProperty GraphEdit "zoom" Float 'False where nodeProperty = (get_zoom, wrapDroppingSetter set_zoom, Nothing) {-# NOINLINE bindGraphEdit__connections_layer_draw #-} bindGraphEdit__connections_layer_draw :: MethodBind bindGraphEdit__connections_layer_draw = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_connections_layer_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _connections_layer_draw :: (GraphEdit :< cls, Object :< cls) => cls -> IO () _connections_layer_draw cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__connections_layer_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_connections_layer_draw" '[] (IO ()) where nodeMethod = Godot.Core.GraphEdit._connections_layer_draw {-# NOINLINE bindGraphEdit__graph_node_moved #-} bindGraphEdit__graph_node_moved :: MethodBind bindGraphEdit__graph_node_moved = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_graph_node_moved" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _graph_node_moved :: (GraphEdit :< cls, Object :< cls) => cls -> Node -> IO () _graph_node_moved cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__graph_node_moved (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_graph_node_moved" '[Node] (IO ()) where nodeMethod = Godot.Core.GraphEdit._graph_node_moved {-# NOINLINE bindGraphEdit__graph_node_raised #-} bindGraphEdit__graph_node_raised :: MethodBind bindGraphEdit__graph_node_raised = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_graph_node_raised" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _graph_node_raised :: (GraphEdit :< cls, Object :< cls) => cls -> Node -> IO () _graph_node_raised cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__graph_node_raised (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_graph_node_raised" '[Node] (IO ()) where nodeMethod = Godot.Core.GraphEdit._graph_node_raised {-# NOINLINE bindGraphEdit__gui_input #-} bindGraphEdit__gui_input :: MethodBind bindGraphEdit__gui_input = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (GraphEdit :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.GraphEdit._gui_input {-# NOINLINE bindGraphEdit__scroll_moved #-} bindGraphEdit__scroll_moved :: MethodBind bindGraphEdit__scroll_moved = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_scroll_moved" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _scroll_moved :: (GraphEdit :< cls, Object :< cls) => cls -> Float -> IO () _scroll_moved cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__scroll_moved (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_scroll_moved" '[Float] (IO ()) where nodeMethod = Godot.Core.GraphEdit._scroll_moved {-# NOINLINE bindGraphEdit__snap_toggled #-} bindGraphEdit__snap_toggled :: MethodBind bindGraphEdit__snap_toggled = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_snap_toggled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _snap_toggled :: (GraphEdit :< cls, Object :< cls) => cls -> IO () _snap_toggled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__snap_toggled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_snap_toggled" '[] (IO ()) where nodeMethod = Godot.Core.GraphEdit._snap_toggled {-# NOINLINE bindGraphEdit__snap_value_changed #-} bindGraphEdit__snap_value_changed :: MethodBind bindGraphEdit__snap_value_changed = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_snap_value_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _snap_value_changed :: (GraphEdit :< cls, Object :< cls) => cls -> Float -> IO () _snap_value_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__snap_value_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_snap_value_changed" '[Float] (IO ()) where nodeMethod = Godot.Core.GraphEdit._snap_value_changed {-# NOINLINE bindGraphEdit__top_layer_draw #-} bindGraphEdit__top_layer_draw :: MethodBind bindGraphEdit__top_layer_draw = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_top_layer_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _top_layer_draw :: (GraphEdit :< cls, Object :< cls) => cls -> IO () _top_layer_draw cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__top_layer_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_top_layer_draw" '[] (IO ()) where nodeMethod = Godot.Core.GraphEdit._top_layer_draw {-# NOINLINE bindGraphEdit__top_layer_input #-} bindGraphEdit__top_layer_input :: MethodBind bindGraphEdit__top_layer_input = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_top_layer_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _top_layer_input :: (GraphEdit :< cls, Object :< cls) => cls -> InputEvent -> IO () _top_layer_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__top_layer_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_top_layer_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.GraphEdit._top_layer_input {-# NOINLINE bindGraphEdit__update_scroll_offset #-} bindGraphEdit__update_scroll_offset :: MethodBind bindGraphEdit__update_scroll_offset = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_update_scroll_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_scroll_offset :: (GraphEdit :< cls, Object :< cls) => cls -> IO () _update_scroll_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__update_scroll_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_update_scroll_offset" '[] (IO ()) where nodeMethod = Godot.Core.GraphEdit._update_scroll_offset {-# NOINLINE bindGraphEdit__zoom_minus #-} bindGraphEdit__zoom_minus :: MethodBind bindGraphEdit__zoom_minus = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_zoom_minus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _zoom_minus :: (GraphEdit :< cls, Object :< cls) => cls -> IO () _zoom_minus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__zoom_minus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_zoom_minus" '[] (IO ()) where nodeMethod = Godot.Core.GraphEdit._zoom_minus {-# NOINLINE bindGraphEdit__zoom_plus #-} bindGraphEdit__zoom_plus :: MethodBind bindGraphEdit__zoom_plus = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_zoom_plus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _zoom_plus :: (GraphEdit :< cls, Object :< cls) => cls -> IO () _zoom_plus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__zoom_plus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_zoom_plus" '[] (IO ()) where nodeMethod = Godot.Core.GraphEdit._zoom_plus {-# NOINLINE bindGraphEdit__zoom_reset #-} bindGraphEdit__zoom_reset :: MethodBind bindGraphEdit__zoom_reset = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "_zoom_reset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _zoom_reset :: (GraphEdit :< cls, Object :< cls) => cls -> IO () _zoom_reset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit__zoom_reset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "_zoom_reset" '[] (IO ()) where nodeMethod = Godot.Core.GraphEdit._zoom_reset {-# NOINLINE bindGraphEdit_add_valid_connection_type #-} -- | Makes possible the connection between two different slot types. The type is defined with the @method GraphNode.set_slot@ method. bindGraphEdit_add_valid_connection_type :: MethodBind bindGraphEdit_add_valid_connection_type = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "add_valid_connection_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Makes possible the connection between two different slot types. The type is defined with the @method GraphNode.set_slot@ method. add_valid_connection_type :: (GraphEdit :< cls, Object :< cls) => cls -> Int -> Int -> IO () add_valid_connection_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_add_valid_connection_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "add_valid_connection_type" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.GraphEdit.add_valid_connection_type {-# NOINLINE bindGraphEdit_add_valid_left_disconnect_type #-} -- | Makes possible to disconnect nodes when dragging from the slot at the left if it has the specified type. bindGraphEdit_add_valid_left_disconnect_type :: MethodBind bindGraphEdit_add_valid_left_disconnect_type = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "add_valid_left_disconnect_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Makes possible to disconnect nodes when dragging from the slot at the left if it has the specified type. add_valid_left_disconnect_type :: (GraphEdit :< cls, Object :< cls) => cls -> Int -> IO () add_valid_left_disconnect_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_add_valid_left_disconnect_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "add_valid_left_disconnect_type" '[Int] (IO ()) where nodeMethod = Godot.Core.GraphEdit.add_valid_left_disconnect_type {-# NOINLINE bindGraphEdit_add_valid_right_disconnect_type #-} -- | Makes possible to disconnect nodes when dragging from the slot at the right if it has the specified type. bindGraphEdit_add_valid_right_disconnect_type :: MethodBind bindGraphEdit_add_valid_right_disconnect_type = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "add_valid_right_disconnect_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Makes possible to disconnect nodes when dragging from the slot at the right if it has the specified type. add_valid_right_disconnect_type :: (GraphEdit :< cls, Object :< cls) => cls -> Int -> IO () add_valid_right_disconnect_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_add_valid_right_disconnect_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "add_valid_right_disconnect_type" '[Int] (IO ()) where nodeMethod = Godot.Core.GraphEdit.add_valid_right_disconnect_type {-# NOINLINE bindGraphEdit_clear_connections #-} -- | Removes all connections between nodes. bindGraphEdit_clear_connections :: MethodBind bindGraphEdit_clear_connections = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "clear_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all connections between nodes. clear_connections :: (GraphEdit :< cls, Object :< cls) => cls -> IO () clear_connections cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_clear_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "clear_connections" '[] (IO ()) where nodeMethod = Godot.Core.GraphEdit.clear_connections {-# NOINLINE bindGraphEdit_connect_node #-} -- | Create a connection between the @from_port@ slot of the @from@ GraphNode and the @to_port@ slot of the @to@ GraphNode. If the connection already exists, no connection is created. bindGraphEdit_connect_node :: MethodBind bindGraphEdit_connect_node = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "connect_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Create a connection between the @from_port@ slot of the @from@ GraphNode and the @to_port@ slot of the @to@ GraphNode. If the connection already exists, no connection is created. connect_node :: (GraphEdit :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> Int -> IO Int connect_node cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_connect_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "connect_node" '[GodotString, Int, GodotString, Int] (IO Int) where nodeMethod = Godot.Core.GraphEdit.connect_node {-# NOINLINE bindGraphEdit_disconnect_node #-} -- | Removes the connection between the @from_port@ slot of the @from@ GraphNode and the @to_port@ slot of the @to@ GraphNode. If the connection does not exist, no connection is removed. bindGraphEdit_disconnect_node :: MethodBind bindGraphEdit_disconnect_node = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "disconnect_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the connection between the @from_port@ slot of the @from@ GraphNode and the @to_port@ slot of the @to@ GraphNode. If the connection does not exist, no connection is removed. disconnect_node :: (GraphEdit :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> Int -> IO () disconnect_node cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_disconnect_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "disconnect_node" '[GodotString, Int, GodotString, Int] (IO ()) where nodeMethod = Godot.Core.GraphEdit.disconnect_node {-# NOINLINE bindGraphEdit_get_connection_list #-} -- | Returns an Array containing the list of connections. A connection consists in a structure of the form @{ from_port: 0, from: "GraphNode name 0", to_port: 1, to: "GraphNode name 1" }@. bindGraphEdit_get_connection_list :: MethodBind bindGraphEdit_get_connection_list = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "get_connection_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an Array containing the list of connections. A connection consists in a structure of the form @{ from_port: 0, from: "GraphNode name 0", to_port: 1, to: "GraphNode name 1" }@. get_connection_list :: (GraphEdit :< cls, Object :< cls) => cls -> IO Array get_connection_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_get_connection_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "get_connection_list" '[] (IO Array) where nodeMethod = Godot.Core.GraphEdit.get_connection_list {-# NOINLINE bindGraphEdit_get_scroll_ofs #-} -- | The scroll offset. bindGraphEdit_get_scroll_ofs :: MethodBind bindGraphEdit_get_scroll_ofs = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "get_scroll_ofs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The scroll offset. get_scroll_ofs :: (GraphEdit :< cls, Object :< cls) => cls -> IO Vector2 get_scroll_ofs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_get_scroll_ofs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "get_scroll_ofs" '[] (IO Vector2) where nodeMethod = Godot.Core.GraphEdit.get_scroll_ofs {-# NOINLINE bindGraphEdit_get_snap #-} -- | The snapping distance in pixels. bindGraphEdit_get_snap :: MethodBind bindGraphEdit_get_snap = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "get_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The snapping distance in pixels. get_snap :: (GraphEdit :< cls, Object :< cls) => cls -> IO Int get_snap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_get_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "get_snap" '[] (IO Int) where nodeMethod = Godot.Core.GraphEdit.get_snap {-# NOINLINE bindGraphEdit_get_zoom #-} -- | The current zoom value. bindGraphEdit_get_zoom :: MethodBind bindGraphEdit_get_zoom = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "get_zoom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current zoom value. get_zoom :: (GraphEdit :< cls, Object :< cls) => cls -> IO Float get_zoom cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_get_zoom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "get_zoom" '[] (IO Float) where nodeMethod = Godot.Core.GraphEdit.get_zoom {-# NOINLINE bindGraphEdit_get_zoom_hbox #-} -- | Gets the @HBoxContainer@ that contains the zooming and grid snap controls in the top left of the graph. -- Warning: The intended usage of this function is to allow you to reposition or add your own custom controls to the container. This is an internal control and as such should not be freed. If you wish to hide this or any of it's children use their @CanvasItem.visible@ property instead. bindGraphEdit_get_zoom_hbox :: MethodBind bindGraphEdit_get_zoom_hbox = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "get_zoom_hbox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the @HBoxContainer@ that contains the zooming and grid snap controls in the top left of the graph. -- Warning: The intended usage of this function is to allow you to reposition or add your own custom controls to the container. This is an internal control and as such should not be freed. If you wish to hide this or any of it's children use their @CanvasItem.visible@ property instead. get_zoom_hbox :: (GraphEdit :< cls, Object :< cls) => cls -> IO HBoxContainer get_zoom_hbox cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_get_zoom_hbox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "get_zoom_hbox" '[] (IO HBoxContainer) where nodeMethod = Godot.Core.GraphEdit.get_zoom_hbox {-# NOINLINE bindGraphEdit_is_node_connected #-} -- | Returns @true@ if the @from_port@ slot of the @from@ GraphNode is connected to the @to_port@ slot of the @to@ GraphNode. bindGraphEdit_is_node_connected :: MethodBind bindGraphEdit_is_node_connected = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "is_node_connected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the @from_port@ slot of the @from@ GraphNode is connected to the @to_port@ slot of the @to@ GraphNode. is_node_connected :: (GraphEdit :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> Int -> IO Bool is_node_connected cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_is_node_connected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "is_node_connected" '[GodotString, Int, GodotString, Int] (IO Bool) where nodeMethod = Godot.Core.GraphEdit.is_node_connected {-# NOINLINE bindGraphEdit_is_right_disconnects_enabled #-} -- | If @true@, enables disconnection of existing connections in the GraphEdit by dragging the right end. bindGraphEdit_is_right_disconnects_enabled :: MethodBind bindGraphEdit_is_right_disconnects_enabled = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "is_right_disconnects_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables disconnection of existing connections in the GraphEdit by dragging the right end. is_right_disconnects_enabled :: (GraphEdit :< cls, Object :< cls) => cls -> IO Bool is_right_disconnects_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_is_right_disconnects_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "is_right_disconnects_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.GraphEdit.is_right_disconnects_enabled {-# NOINLINE bindGraphEdit_is_using_snap #-} -- | If @true@, enables snapping. bindGraphEdit_is_using_snap :: MethodBind bindGraphEdit_is_using_snap = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "is_using_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables snapping. is_using_snap :: (GraphEdit :< cls, Object :< cls) => cls -> IO Bool is_using_snap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_is_using_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "is_using_snap" '[] (IO Bool) where nodeMethod = Godot.Core.GraphEdit.is_using_snap {-# NOINLINE bindGraphEdit_is_valid_connection_type #-} -- | Returns whether it's possible to connect slots of the specified types. bindGraphEdit_is_valid_connection_type :: MethodBind bindGraphEdit_is_valid_connection_type = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "is_valid_connection_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether it's possible to connect slots of the specified types. is_valid_connection_type :: (GraphEdit :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool is_valid_connection_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_is_valid_connection_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "is_valid_connection_type" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.GraphEdit.is_valid_connection_type {-# NOINLINE bindGraphEdit_remove_valid_connection_type #-} -- | Makes it not possible to connect between two different slot types. The type is defined with the @method GraphNode.set_slot@ method. bindGraphEdit_remove_valid_connection_type :: MethodBind bindGraphEdit_remove_valid_connection_type = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "remove_valid_connection_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Makes it not possible to connect between two different slot types. The type is defined with the @method GraphNode.set_slot@ method. remove_valid_connection_type :: (GraphEdit :< cls, Object :< cls) => cls -> Int -> Int -> IO () remove_valid_connection_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_remove_valid_connection_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "remove_valid_connection_type" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.GraphEdit.remove_valid_connection_type {-# NOINLINE bindGraphEdit_remove_valid_left_disconnect_type #-} -- | Removes the possibility to disconnect nodes when dragging from the slot at the left if it has the specified type. bindGraphEdit_remove_valid_left_disconnect_type :: MethodBind bindGraphEdit_remove_valid_left_disconnect_type = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "remove_valid_left_disconnect_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the possibility to disconnect nodes when dragging from the slot at the left if it has the specified type. remove_valid_left_disconnect_type :: (GraphEdit :< cls, Object :< cls) => cls -> Int -> IO () remove_valid_left_disconnect_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_remove_valid_left_disconnect_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "remove_valid_left_disconnect_type" '[Int] (IO ()) where nodeMethod = Godot.Core.GraphEdit.remove_valid_left_disconnect_type {-# NOINLINE bindGraphEdit_remove_valid_right_disconnect_type #-} -- | Removes the possibility to disconnect nodes when dragging from the slot at the right if it has the specified type. bindGraphEdit_remove_valid_right_disconnect_type :: MethodBind bindGraphEdit_remove_valid_right_disconnect_type = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "remove_valid_right_disconnect_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the possibility to disconnect nodes when dragging from the slot at the right if it has the specified type. remove_valid_right_disconnect_type :: (GraphEdit :< cls, Object :< cls) => cls -> Int -> IO () remove_valid_right_disconnect_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_remove_valid_right_disconnect_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "remove_valid_right_disconnect_type" '[Int] (IO ()) where nodeMethod = Godot.Core.GraphEdit.remove_valid_right_disconnect_type {-# NOINLINE bindGraphEdit_set_connection_activity #-} -- | Sets the coloration of the connection between @from@'s @from_port@ and @to@'s @to_port@ with the color provided in the @activity@ theme property. bindGraphEdit_set_connection_activity :: MethodBind bindGraphEdit_set_connection_activity = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "set_connection_activity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the coloration of the connection between @from@'s @from_port@ and @to@'s @to_port@ with the color provided in the @activity@ theme property. set_connection_activity :: (GraphEdit :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> Int -> Float -> IO () set_connection_activity cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_set_connection_activity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "set_connection_activity" '[GodotString, Int, GodotString, Int, Float] (IO ()) where nodeMethod = Godot.Core.GraphEdit.set_connection_activity {-# NOINLINE bindGraphEdit_set_right_disconnects #-} -- | If @true@, enables disconnection of existing connections in the GraphEdit by dragging the right end. bindGraphEdit_set_right_disconnects :: MethodBind bindGraphEdit_set_right_disconnects = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "set_right_disconnects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables disconnection of existing connections in the GraphEdit by dragging the right end. set_right_disconnects :: (GraphEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_right_disconnects cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_set_right_disconnects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "set_right_disconnects" '[Bool] (IO ()) where nodeMethod = Godot.Core.GraphEdit.set_right_disconnects {-# NOINLINE bindGraphEdit_set_scroll_ofs #-} -- | The scroll offset. bindGraphEdit_set_scroll_ofs :: MethodBind bindGraphEdit_set_scroll_ofs = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "set_scroll_ofs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The scroll offset. set_scroll_ofs :: (GraphEdit :< cls, Object :< cls) => cls -> Vector2 -> IO () set_scroll_ofs cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_set_scroll_ofs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "set_scroll_ofs" '[Vector2] (IO ()) where nodeMethod = Godot.Core.GraphEdit.set_scroll_ofs {-# NOINLINE bindGraphEdit_set_selected #-} -- | Sets the specified @node@ as the one selected. bindGraphEdit_set_selected :: MethodBind bindGraphEdit_set_selected = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "set_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified @node@ as the one selected. set_selected :: (GraphEdit :< cls, Object :< cls) => cls -> Node -> IO () set_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_set_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "set_selected" '[Node] (IO ()) where nodeMethod = Godot.Core.GraphEdit.set_selected {-# NOINLINE bindGraphEdit_set_snap #-} -- | The snapping distance in pixels. bindGraphEdit_set_snap :: MethodBind bindGraphEdit_set_snap = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "set_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The snapping distance in pixels. set_snap :: (GraphEdit :< cls, Object :< cls) => cls -> Int -> IO () set_snap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_set_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "set_snap" '[Int] (IO ()) where nodeMethod = Godot.Core.GraphEdit.set_snap {-# NOINLINE bindGraphEdit_set_use_snap #-} -- | If @true@, enables snapping. bindGraphEdit_set_use_snap :: MethodBind bindGraphEdit_set_use_snap = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "set_use_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables snapping. set_use_snap :: (GraphEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_use_snap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_set_use_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "set_use_snap" '[Bool] (IO ()) where nodeMethod = Godot.Core.GraphEdit.set_use_snap {-# NOINLINE bindGraphEdit_set_zoom #-} -- | The current zoom value. bindGraphEdit_set_zoom :: MethodBind bindGraphEdit_set_zoom = unsafePerformIO $ withCString "GraphEdit" $ \ clsNamePtr -> withCString "set_zoom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current zoom value. set_zoom :: (GraphEdit :< cls, Object :< cls) => cls -> Float -> IO () set_zoom cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphEdit_set_zoom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphEdit "set_zoom" '[Float] (IO ()) where nodeMethod = Godot.Core.GraphEdit.set_zoom ================================================ FILE: src/Godot/Core/GraphNode.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GraphNode (Godot.Core.GraphNode._OVERLAY_DISABLED, Godot.Core.GraphNode._OVERLAY_POSITION, Godot.Core.GraphNode._OVERLAY_BREAKPOINT, Godot.Core.GraphNode.sig_close_request, Godot.Core.GraphNode.sig_dragged, Godot.Core.GraphNode.sig_offset_changed, Godot.Core.GraphNode.sig_raise_request, Godot.Core.GraphNode.sig_resize_request, Godot.Core.GraphNode._gui_input, Godot.Core.GraphNode.clear_all_slots, Godot.Core.GraphNode.clear_slot, Godot.Core.GraphNode.get_connection_input_color, Godot.Core.GraphNode.get_connection_input_count, Godot.Core.GraphNode.get_connection_input_position, Godot.Core.GraphNode.get_connection_input_type, Godot.Core.GraphNode.get_connection_output_color, Godot.Core.GraphNode.get_connection_output_count, Godot.Core.GraphNode.get_connection_output_position, Godot.Core.GraphNode.get_connection_output_type, Godot.Core.GraphNode.get_offset, Godot.Core.GraphNode.get_overlay, Godot.Core.GraphNode.get_slot_color_left, Godot.Core.GraphNode.get_slot_color_right, Godot.Core.GraphNode.get_slot_type_left, Godot.Core.GraphNode.get_slot_type_right, Godot.Core.GraphNode.get_title, Godot.Core.GraphNode.is_close_button_visible, Godot.Core.GraphNode.is_comment, Godot.Core.GraphNode.is_resizable, Godot.Core.GraphNode.is_selected, Godot.Core.GraphNode.is_slot_enabled_left, Godot.Core.GraphNode.is_slot_enabled_right, Godot.Core.GraphNode.set_comment, Godot.Core.GraphNode.set_offset, Godot.Core.GraphNode.set_overlay, Godot.Core.GraphNode.set_resizable, Godot.Core.GraphNode.set_selected, Godot.Core.GraphNode.set_show_close_button, Godot.Core.GraphNode.set_slot, Godot.Core.GraphNode.set_title) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() _OVERLAY_DISABLED :: Int _OVERLAY_DISABLED = 0 _OVERLAY_POSITION :: Int _OVERLAY_POSITION = 2 _OVERLAY_BREAKPOINT :: Int _OVERLAY_BREAKPOINT = 1 -- | Emitted when the GraphNode is requested to be closed. Happens on clicking the close button (see @show_close@). sig_close_request :: Godot.Internal.Dispatch.Signal GraphNode sig_close_request = Godot.Internal.Dispatch.Signal "close_request" instance NodeSignal GraphNode "close_request" '[] -- | Emitted when the GraphNode is dragged. sig_dragged :: Godot.Internal.Dispatch.Signal GraphNode sig_dragged = Godot.Internal.Dispatch.Signal "dragged" instance NodeSignal GraphNode "dragged" '[Vector2, Vector2] -- | Emitted when the GraphNode is moved. sig_offset_changed :: Godot.Internal.Dispatch.Signal GraphNode sig_offset_changed = Godot.Internal.Dispatch.Signal "offset_changed" instance NodeSignal GraphNode "offset_changed" '[] -- | Emitted when the GraphNode is requested to be displayed over other ones. Happens on focusing (clicking into) the GraphNode. sig_raise_request :: Godot.Internal.Dispatch.Signal GraphNode sig_raise_request = Godot.Internal.Dispatch.Signal "raise_request" instance NodeSignal GraphNode "raise_request" '[] -- | Emitted when the GraphNode is requested to be resized. Happens on dragging the resizer handle (see @resizable@). sig_resize_request :: Godot.Internal.Dispatch.Signal GraphNode sig_resize_request = Godot.Internal.Dispatch.Signal "resize_request" instance NodeSignal GraphNode "resize_request" '[Vector2] instance NodeProperty GraphNode "comment" Bool 'False where nodeProperty = (is_comment, wrapDroppingSetter set_comment, Nothing) instance NodeProperty GraphNode "offset" Vector2 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty GraphNode "overlay" Int 'False where nodeProperty = (get_overlay, wrapDroppingSetter set_overlay, Nothing) instance NodeProperty GraphNode "resizable" Bool 'False where nodeProperty = (is_resizable, wrapDroppingSetter set_resizable, Nothing) instance NodeProperty GraphNode "selected" Bool 'False where nodeProperty = (is_selected, wrapDroppingSetter set_selected, Nothing) instance NodeProperty GraphNode "show_close" Bool 'False where nodeProperty = (is_close_button_visible, wrapDroppingSetter set_show_close_button, Nothing) instance NodeProperty GraphNode "title" GodotString 'False where nodeProperty = (get_title, wrapDroppingSetter set_title, Nothing) {-# NOINLINE bindGraphNode__gui_input #-} bindGraphNode__gui_input :: MethodBind bindGraphNode__gui_input = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (GraphNode :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.GraphNode._gui_input {-# NOINLINE bindGraphNode_clear_all_slots #-} -- | Disables all input and output slots of the GraphNode. bindGraphNode_clear_all_slots :: MethodBind bindGraphNode_clear_all_slots = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "clear_all_slots" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables all input and output slots of the GraphNode. clear_all_slots :: (GraphNode :< cls, Object :< cls) => cls -> IO () clear_all_slots cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_clear_all_slots (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "clear_all_slots" '[] (IO ()) where nodeMethod = Godot.Core.GraphNode.clear_all_slots {-# NOINLINE bindGraphNode_clear_slot #-} -- | Disables input and output slot whose index is @idx@. bindGraphNode_clear_slot :: MethodBind bindGraphNode_clear_slot = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "clear_slot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables input and output slot whose index is @idx@. clear_slot :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO () clear_slot cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_clear_slot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "clear_slot" '[Int] (IO ()) where nodeMethod = Godot.Core.GraphNode.clear_slot {-# NOINLINE bindGraphNode_get_connection_input_color #-} -- | Returns the color of the input connection @idx@. bindGraphNode_get_connection_input_color :: MethodBind bindGraphNode_get_connection_input_color = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_connection_input_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color of the input connection @idx@. get_connection_input_color :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Color get_connection_input_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_connection_input_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_connection_input_color" '[Int] (IO Color) where nodeMethod = Godot.Core.GraphNode.get_connection_input_color {-# NOINLINE bindGraphNode_get_connection_input_count #-} -- | Returns the number of enabled input slots (connections) to the GraphNode. bindGraphNode_get_connection_input_count :: MethodBind bindGraphNode_get_connection_input_count = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_connection_input_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of enabled input slots (connections) to the GraphNode. get_connection_input_count :: (GraphNode :< cls, Object :< cls) => cls -> IO Int get_connection_input_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_connection_input_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_connection_input_count" '[] (IO Int) where nodeMethod = Godot.Core.GraphNode.get_connection_input_count {-# NOINLINE bindGraphNode_get_connection_input_position #-} -- | Returns the position of the input connection @idx@. bindGraphNode_get_connection_input_position :: MethodBind bindGraphNode_get_connection_input_position = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_connection_input_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the input connection @idx@. get_connection_input_position :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_connection_input_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_connection_input_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_connection_input_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.GraphNode.get_connection_input_position {-# NOINLINE bindGraphNode_get_connection_input_type #-} -- | Returns the type of the input connection @idx@. bindGraphNode_get_connection_input_type :: MethodBind bindGraphNode_get_connection_input_type = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_connection_input_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the type of the input connection @idx@. get_connection_input_type :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Int get_connection_input_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_connection_input_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_connection_input_type" '[Int] (IO Int) where nodeMethod = Godot.Core.GraphNode.get_connection_input_type {-# NOINLINE bindGraphNode_get_connection_output_color #-} -- | Returns the color of the output connection @idx@. bindGraphNode_get_connection_output_color :: MethodBind bindGraphNode_get_connection_output_color = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_connection_output_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color of the output connection @idx@. get_connection_output_color :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Color get_connection_output_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_connection_output_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_connection_output_color" '[Int] (IO Color) where nodeMethod = Godot.Core.GraphNode.get_connection_output_color {-# NOINLINE bindGraphNode_get_connection_output_count #-} -- | Returns the number of enabled output slots (connections) of the GraphNode. bindGraphNode_get_connection_output_count :: MethodBind bindGraphNode_get_connection_output_count = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_connection_output_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of enabled output slots (connections) of the GraphNode. get_connection_output_count :: (GraphNode :< cls, Object :< cls) => cls -> IO Int get_connection_output_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_connection_output_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_connection_output_count" '[] (IO Int) where nodeMethod = Godot.Core.GraphNode.get_connection_output_count {-# NOINLINE bindGraphNode_get_connection_output_position #-} -- | Returns the position of the output connection @idx@. bindGraphNode_get_connection_output_position :: MethodBind bindGraphNode_get_connection_output_position = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_connection_output_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the output connection @idx@. get_connection_output_position :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_connection_output_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_connection_output_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_connection_output_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.GraphNode.get_connection_output_position {-# NOINLINE bindGraphNode_get_connection_output_type #-} -- | Returns the type of the output connection @idx@. bindGraphNode_get_connection_output_type :: MethodBind bindGraphNode_get_connection_output_type = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_connection_output_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the type of the output connection @idx@. get_connection_output_type :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Int get_connection_output_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_connection_output_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_connection_output_type" '[Int] (IO Int) where nodeMethod = Godot.Core.GraphNode.get_connection_output_type {-# NOINLINE bindGraphNode_get_offset #-} -- | The offset of the GraphNode, relative to the scroll offset of the @GraphEdit@. -- __Note:__ You cannot use position directly, as @GraphEdit@ is a @Container@. bindGraphNode_get_offset :: MethodBind bindGraphNode_get_offset = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The offset of the GraphNode, relative to the scroll offset of the @GraphEdit@. -- __Note:__ You cannot use position directly, as @GraphEdit@ is a @Container@. get_offset :: (GraphNode :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.GraphNode.get_offset {-# NOINLINE bindGraphNode_get_overlay #-} -- | Sets the overlay shown above the GraphNode. See @enum Overlay@. bindGraphNode_get_overlay :: MethodBind bindGraphNode_get_overlay = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_overlay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the overlay shown above the GraphNode. See @enum Overlay@. get_overlay :: (GraphNode :< cls, Object :< cls) => cls -> IO Int get_overlay cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_overlay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_overlay" '[] (IO Int) where nodeMethod = Godot.Core.GraphNode.get_overlay {-# NOINLINE bindGraphNode_get_slot_color_left #-} -- | Returns the color set to @idx@ left (input) slot. bindGraphNode_get_slot_color_left :: MethodBind bindGraphNode_get_slot_color_left = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_slot_color_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color set to @idx@ left (input) slot. get_slot_color_left :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Color get_slot_color_left cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_slot_color_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_slot_color_left" '[Int] (IO Color) where nodeMethod = Godot.Core.GraphNode.get_slot_color_left {-# NOINLINE bindGraphNode_get_slot_color_right #-} -- | Returns the color set to @idx@ right (output) slot. bindGraphNode_get_slot_color_right :: MethodBind bindGraphNode_get_slot_color_right = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_slot_color_right" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color set to @idx@ right (output) slot. get_slot_color_right :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Color get_slot_color_right cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_slot_color_right (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_slot_color_right" '[Int] (IO Color) where nodeMethod = Godot.Core.GraphNode.get_slot_color_right {-# NOINLINE bindGraphNode_get_slot_type_left #-} -- | Returns the (integer) type of left (input) @idx@ slot. bindGraphNode_get_slot_type_left :: MethodBind bindGraphNode_get_slot_type_left = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_slot_type_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the (integer) type of left (input) @idx@ slot. get_slot_type_left :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Int get_slot_type_left cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_slot_type_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_slot_type_left" '[Int] (IO Int) where nodeMethod = Godot.Core.GraphNode.get_slot_type_left {-# NOINLINE bindGraphNode_get_slot_type_right #-} -- | Returns the (integer) type of right (output) @idx@ slot. bindGraphNode_get_slot_type_right :: MethodBind bindGraphNode_get_slot_type_right = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_slot_type_right" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the (integer) type of right (output) @idx@ slot. get_slot_type_right :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Int get_slot_type_right cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_slot_type_right (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_slot_type_right" '[Int] (IO Int) where nodeMethod = Godot.Core.GraphNode.get_slot_type_right {-# NOINLINE bindGraphNode_get_title #-} -- | The text displayed in the GraphNode's title bar. bindGraphNode_get_title :: MethodBind bindGraphNode_get_title = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "get_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The text displayed in the GraphNode's title bar. get_title :: (GraphNode :< cls, Object :< cls) => cls -> IO GodotString get_title cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_get_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "get_title" '[] (IO GodotString) where nodeMethod = Godot.Core.GraphNode.get_title {-# NOINLINE bindGraphNode_is_close_button_visible #-} -- | If @true@, the close button will be visible. -- __Note:__ Pressing it will only emit the @signal close_request@ signal, the GraphNode needs to be removed manually. bindGraphNode_is_close_button_visible :: MethodBind bindGraphNode_is_close_button_visible = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "is_close_button_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the close button will be visible. -- __Note:__ Pressing it will only emit the @signal close_request@ signal, the GraphNode needs to be removed manually. is_close_button_visible :: (GraphNode :< cls, Object :< cls) => cls -> IO Bool is_close_button_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_is_close_button_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "is_close_button_visible" '[] (IO Bool) where nodeMethod = Godot.Core.GraphNode.is_close_button_visible {-# NOINLINE bindGraphNode_is_comment #-} -- | If @true@, the GraphNode is a comment node. bindGraphNode_is_comment :: MethodBind bindGraphNode_is_comment = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "is_comment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the GraphNode is a comment node. is_comment :: (GraphNode :< cls, Object :< cls) => cls -> IO Bool is_comment cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_is_comment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "is_comment" '[] (IO Bool) where nodeMethod = Godot.Core.GraphNode.is_comment {-# NOINLINE bindGraphNode_is_resizable #-} -- | If @true@, the user can resize the GraphNode. -- __Note:__ Dragging the handle will only emit the @signal resize_request@ signal, the GraphNode needs to be resized manually. bindGraphNode_is_resizable :: MethodBind bindGraphNode_is_resizable = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "is_resizable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the user can resize the GraphNode. -- __Note:__ Dragging the handle will only emit the @signal resize_request@ signal, the GraphNode needs to be resized manually. is_resizable :: (GraphNode :< cls, Object :< cls) => cls -> IO Bool is_resizable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_is_resizable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "is_resizable" '[] (IO Bool) where nodeMethod = Godot.Core.GraphNode.is_resizable {-# NOINLINE bindGraphNode_is_selected #-} -- | If @true@, the GraphNode is selected. bindGraphNode_is_selected :: MethodBind bindGraphNode_is_selected = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "is_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the GraphNode is selected. is_selected :: (GraphNode :< cls, Object :< cls) => cls -> IO Bool is_selected cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_is_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "is_selected" '[] (IO Bool) where nodeMethod = Godot.Core.GraphNode.is_selected {-# NOINLINE bindGraphNode_is_slot_enabled_left #-} -- | Returns @true@ if left (input) slot @idx@ is enabled, @false@ otherwise. bindGraphNode_is_slot_enabled_left :: MethodBind bindGraphNode_is_slot_enabled_left = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "is_slot_enabled_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if left (input) slot @idx@ is enabled, @false@ otherwise. is_slot_enabled_left :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Bool is_slot_enabled_left cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_is_slot_enabled_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "is_slot_enabled_left" '[Int] (IO Bool) where nodeMethod = Godot.Core.GraphNode.is_slot_enabled_left {-# NOINLINE bindGraphNode_is_slot_enabled_right #-} -- | Returns @true@ if right (output) slot @idx@ is enabled, @false@ otherwise. bindGraphNode_is_slot_enabled_right :: MethodBind bindGraphNode_is_slot_enabled_right = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "is_slot_enabled_right" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if right (output) slot @idx@ is enabled, @false@ otherwise. is_slot_enabled_right :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO Bool is_slot_enabled_right cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_is_slot_enabled_right (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "is_slot_enabled_right" '[Int] (IO Bool) where nodeMethod = Godot.Core.GraphNode.is_slot_enabled_right {-# NOINLINE bindGraphNode_set_comment #-} -- | If @true@, the GraphNode is a comment node. bindGraphNode_set_comment :: MethodBind bindGraphNode_set_comment = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "set_comment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the GraphNode is a comment node. set_comment :: (GraphNode :< cls, Object :< cls) => cls -> Bool -> IO () set_comment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_set_comment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "set_comment" '[Bool] (IO ()) where nodeMethod = Godot.Core.GraphNode.set_comment {-# NOINLINE bindGraphNode_set_offset #-} -- | The offset of the GraphNode, relative to the scroll offset of the @GraphEdit@. -- __Note:__ You cannot use position directly, as @GraphEdit@ is a @Container@. bindGraphNode_set_offset :: MethodBind bindGraphNode_set_offset = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The offset of the GraphNode, relative to the scroll offset of the @GraphEdit@. -- __Note:__ You cannot use position directly, as @GraphEdit@ is a @Container@. set_offset :: (GraphNode :< cls, Object :< cls) => cls -> Vector2 -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "set_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.GraphNode.set_offset {-# NOINLINE bindGraphNode_set_overlay #-} -- | Sets the overlay shown above the GraphNode. See @enum Overlay@. bindGraphNode_set_overlay :: MethodBind bindGraphNode_set_overlay = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "set_overlay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the overlay shown above the GraphNode. See @enum Overlay@. set_overlay :: (GraphNode :< cls, Object :< cls) => cls -> Int -> IO () set_overlay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_set_overlay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "set_overlay" '[Int] (IO ()) where nodeMethod = Godot.Core.GraphNode.set_overlay {-# NOINLINE bindGraphNode_set_resizable #-} -- | If @true@, the user can resize the GraphNode. -- __Note:__ Dragging the handle will only emit the @signal resize_request@ signal, the GraphNode needs to be resized manually. bindGraphNode_set_resizable :: MethodBind bindGraphNode_set_resizable = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "set_resizable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the user can resize the GraphNode. -- __Note:__ Dragging the handle will only emit the @signal resize_request@ signal, the GraphNode needs to be resized manually. set_resizable :: (GraphNode :< cls, Object :< cls) => cls -> Bool -> IO () set_resizable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_set_resizable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "set_resizable" '[Bool] (IO ()) where nodeMethod = Godot.Core.GraphNode.set_resizable {-# NOINLINE bindGraphNode_set_selected #-} -- | If @true@, the GraphNode is selected. bindGraphNode_set_selected :: MethodBind bindGraphNode_set_selected = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "set_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the GraphNode is selected. set_selected :: (GraphNode :< cls, Object :< cls) => cls -> Bool -> IO () set_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_set_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "set_selected" '[Bool] (IO ()) where nodeMethod = Godot.Core.GraphNode.set_selected {-# NOINLINE bindGraphNode_set_show_close_button #-} -- | If @true@, the close button will be visible. -- __Note:__ Pressing it will only emit the @signal close_request@ signal, the GraphNode needs to be removed manually. bindGraphNode_set_show_close_button :: MethodBind bindGraphNode_set_show_close_button = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "set_show_close_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the close button will be visible. -- __Note:__ Pressing it will only emit the @signal close_request@ signal, the GraphNode needs to be removed manually. set_show_close_button :: (GraphNode :< cls, Object :< cls) => cls -> Bool -> IO () set_show_close_button cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_set_show_close_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "set_show_close_button" '[Bool] (IO ()) where nodeMethod = Godot.Core.GraphNode.set_show_close_button {-# NOINLINE bindGraphNode_set_slot #-} -- | Sets properties of the slot with ID @idx@. -- If @enable_left@/@right@, a port will appear and the slot will be able to be connected from this side. -- @type_left@/@right@ is an arbitrary type of the port. Only ports with the same type values can be connected. -- @color_left@/@right@ is the tint of the port's icon on this side. -- @custom_left@/@right@ is a custom texture for this side's port. -- __Note:__ This method only sets properties of the slot. To create the slot, add a @Control@-derived child to the GraphNode. bindGraphNode_set_slot :: MethodBind bindGraphNode_set_slot = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "set_slot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets properties of the slot with ID @idx@. -- If @enable_left@/@right@, a port will appear and the slot will be able to be connected from this side. -- @type_left@/@right@ is an arbitrary type of the port. Only ports with the same type values can be connected. -- @color_left@/@right@ is the tint of the port's icon on this side. -- @custom_left@/@right@ is a custom texture for this side's port. -- __Note:__ This method only sets properties of the slot. To create the slot, add a @Control@-derived child to the GraphNode. set_slot :: (GraphNode :< cls, Object :< cls) => cls -> Int -> Bool -> Int -> Color -> Bool -> Int -> Color -> Maybe Texture -> Maybe Texture -> IO () set_slot cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, toVariant arg7, maybe VariantNil toVariant arg8, maybe VariantNil toVariant arg9] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_set_slot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "set_slot" '[Int, Bool, Int, Color, Bool, Int, Color, Maybe Texture, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.GraphNode.set_slot {-# NOINLINE bindGraphNode_set_title #-} -- | The text displayed in the GraphNode's title bar. bindGraphNode_set_title :: MethodBind bindGraphNode_set_title = unsafePerformIO $ withCString "GraphNode" $ \ clsNamePtr -> withCString "set_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The text displayed in the GraphNode's title bar. set_title :: (GraphNode :< cls, Object :< cls) => cls -> GodotString -> IO () set_title cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGraphNode_set_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GraphNode "set_title" '[GodotString] (IO ()) where nodeMethod = Godot.Core.GraphNode.set_title ================================================ FILE: src/Godot/Core/GridContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GridContainer (Godot.Core.GridContainer.get_columns, Godot.Core.GridContainer.set_columns) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() instance NodeProperty GridContainer "columns" Int 'False where nodeProperty = (get_columns, wrapDroppingSetter set_columns, Nothing) {-# NOINLINE bindGridContainer_get_columns #-} -- | The number of columns in the @GridContainer@. If modified, @GridContainer@ reorders its Control-derived children to accommodate the new layout. bindGridContainer_get_columns :: MethodBind bindGridContainer_get_columns = unsafePerformIO $ withCString "GridContainer" $ \ clsNamePtr -> withCString "get_columns" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns in the @GridContainer@. If modified, @GridContainer@ reorders its Control-derived children to accommodate the new layout. get_columns :: (GridContainer :< cls, Object :< cls) => cls -> IO Int get_columns cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridContainer_get_columns (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridContainer "get_columns" '[] (IO Int) where nodeMethod = Godot.Core.GridContainer.get_columns {-# NOINLINE bindGridContainer_set_columns #-} -- | The number of columns in the @GridContainer@. If modified, @GridContainer@ reorders its Control-derived children to accommodate the new layout. bindGridContainer_set_columns :: MethodBind bindGridContainer_set_columns = unsafePerformIO $ withCString "GridContainer" $ \ clsNamePtr -> withCString "set_columns" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns in the @GridContainer@. If modified, @GridContainer@ reorders its Control-derived children to accommodate the new layout. set_columns :: (GridContainer :< cls, Object :< cls) => cls -> Int -> IO () set_columns cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridContainer_set_columns (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridContainer "set_columns" '[Int] (IO ()) where nodeMethod = Godot.Core.GridContainer.set_columns ================================================ FILE: src/Godot/Core/GridMap.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GridMap (Godot.Core.GridMap._INVALID_CELL_ITEM, Godot.Core.GridMap.sig_cell_size_changed, Godot.Core.GridMap._update_octants_callback, Godot.Core.GridMap.clear, Godot.Core.GridMap.clear_baked_meshes, Godot.Core.GridMap.get_bake_mesh_instance, Godot.Core.GridMap.get_bake_meshes, Godot.Core.GridMap.get_cell_item, Godot.Core.GridMap.get_cell_item_orientation, Godot.Core.GridMap.get_cell_scale, Godot.Core.GridMap.get_cell_size, Godot.Core.GridMap.get_center_x, Godot.Core.GridMap.get_center_y, Godot.Core.GridMap.get_center_z, Godot.Core.GridMap.get_collision_layer, Godot.Core.GridMap.get_collision_layer_bit, Godot.Core.GridMap.get_collision_mask, Godot.Core.GridMap.get_collision_mask_bit, Godot.Core.GridMap.get_mesh_library, Godot.Core.GridMap.get_meshes, Godot.Core.GridMap.get_octant_size, Godot.Core.GridMap.get_used_cells, Godot.Core.GridMap.make_baked_meshes, Godot.Core.GridMap.map_to_world, Godot.Core.GridMap.resource_changed, Godot.Core.GridMap.set_cell_item, Godot.Core.GridMap.set_cell_scale, Godot.Core.GridMap.set_cell_size, Godot.Core.GridMap.set_center_x, Godot.Core.GridMap.set_center_y, Godot.Core.GridMap.set_center_z, Godot.Core.GridMap.set_clip, Godot.Core.GridMap.set_collision_layer, Godot.Core.GridMap.set_collision_layer_bit, Godot.Core.GridMap.set_collision_mask, Godot.Core.GridMap.set_collision_mask_bit, Godot.Core.GridMap.set_mesh_library, Godot.Core.GridMap.set_octant_size, Godot.Core.GridMap.world_to_map) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() _INVALID_CELL_ITEM :: Int _INVALID_CELL_ITEM = -1 sig_cell_size_changed :: Godot.Internal.Dispatch.Signal GridMap sig_cell_size_changed = Godot.Internal.Dispatch.Signal "cell_size_changed" instance NodeSignal GridMap "cell_size_changed" '[Vector3] instance NodeProperty GridMap "cell_center_x" Bool 'False where nodeProperty = (get_center_x, wrapDroppingSetter set_center_x, Nothing) instance NodeProperty GridMap "cell_center_y" Bool 'False where nodeProperty = (get_center_y, wrapDroppingSetter set_center_y, Nothing) instance NodeProperty GridMap "cell_center_z" Bool 'False where nodeProperty = (get_center_z, wrapDroppingSetter set_center_z, Nothing) instance NodeProperty GridMap "cell_octant_size" Int 'False where nodeProperty = (get_octant_size, wrapDroppingSetter set_octant_size, Nothing) instance NodeProperty GridMap "cell_scale" Float 'False where nodeProperty = (get_cell_scale, wrapDroppingSetter set_cell_scale, Nothing) instance NodeProperty GridMap "cell_size" Vector3 'False where nodeProperty = (get_cell_size, wrapDroppingSetter set_cell_size, Nothing) instance NodeProperty GridMap "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty GridMap "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty GridMap "mesh_library" MeshLibrary 'False where nodeProperty = (get_mesh_library, wrapDroppingSetter set_mesh_library, Nothing) {-# NOINLINE bindGridMap__update_octants_callback #-} bindGridMap__update_octants_callback :: MethodBind bindGridMap__update_octants_callback = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "_update_octants_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_octants_callback :: (GridMap :< cls, Object :< cls) => cls -> IO () _update_octants_callback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap__update_octants_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "_update_octants_callback" '[] (IO ()) where nodeMethod = Godot.Core.GridMap._update_octants_callback {-# NOINLINE bindGridMap_clear #-} bindGridMap_clear :: MethodBind bindGridMap_clear = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear :: (GridMap :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "clear" '[] (IO ()) where nodeMethod = Godot.Core.GridMap.clear {-# NOINLINE bindGridMap_clear_baked_meshes #-} bindGridMap_clear_baked_meshes :: MethodBind bindGridMap_clear_baked_meshes = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "clear_baked_meshes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear_baked_meshes :: (GridMap :< cls, Object :< cls) => cls -> IO () clear_baked_meshes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_clear_baked_meshes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "clear_baked_meshes" '[] (IO ()) where nodeMethod = Godot.Core.GridMap.clear_baked_meshes {-# NOINLINE bindGridMap_get_bake_mesh_instance #-} bindGridMap_get_bake_mesh_instance :: MethodBind bindGridMap_get_bake_mesh_instance = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_bake_mesh_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bake_mesh_instance :: (GridMap :< cls, Object :< cls) => cls -> Int -> IO Rid get_bake_mesh_instance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_bake_mesh_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_bake_mesh_instance" '[Int] (IO Rid) where nodeMethod = Godot.Core.GridMap.get_bake_mesh_instance {-# NOINLINE bindGridMap_get_bake_meshes #-} bindGridMap_get_bake_meshes :: MethodBind bindGridMap_get_bake_meshes = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_bake_meshes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bake_meshes :: (GridMap :< cls, Object :< cls) => cls -> IO Array get_bake_meshes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_bake_meshes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_bake_meshes" '[] (IO Array) where nodeMethod = Godot.Core.GridMap.get_bake_meshes {-# NOINLINE bindGridMap_get_cell_item #-} bindGridMap_get_cell_item :: MethodBind bindGridMap_get_cell_item = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_cell_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_item :: (GridMap :< cls, Object :< cls) => cls -> Int -> Int -> Int -> IO Int get_cell_item cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_cell_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_cell_item" '[Int, Int, Int] (IO Int) where nodeMethod = Godot.Core.GridMap.get_cell_item {-# NOINLINE bindGridMap_get_cell_item_orientation #-} bindGridMap_get_cell_item_orientation :: MethodBind bindGridMap_get_cell_item_orientation = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_cell_item_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_item_orientation :: (GridMap :< cls, Object :< cls) => cls -> Int -> Int -> Int -> IO Int get_cell_item_orientation cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_cell_item_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_cell_item_orientation" '[Int, Int, Int] (IO Int) where nodeMethod = Godot.Core.GridMap.get_cell_item_orientation {-# NOINLINE bindGridMap_get_cell_scale #-} bindGridMap_get_cell_scale :: MethodBind bindGridMap_get_cell_scale = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_cell_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_scale :: (GridMap :< cls, Object :< cls) => cls -> IO Float get_cell_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_cell_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_cell_scale" '[] (IO Float) where nodeMethod = Godot.Core.GridMap.get_cell_scale {-# NOINLINE bindGridMap_get_cell_size #-} bindGridMap_get_cell_size :: MethodBind bindGridMap_get_cell_size = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_size :: (GridMap :< cls, Object :< cls) => cls -> IO Vector3 get_cell_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_cell_size" '[] (IO Vector3) where nodeMethod = Godot.Core.GridMap.get_cell_size {-# NOINLINE bindGridMap_get_center_x #-} bindGridMap_get_center_x :: MethodBind bindGridMap_get_center_x = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_center_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_center_x :: (GridMap :< cls, Object :< cls) => cls -> IO Bool get_center_x cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_center_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_center_x" '[] (IO Bool) where nodeMethod = Godot.Core.GridMap.get_center_x {-# NOINLINE bindGridMap_get_center_y #-} bindGridMap_get_center_y :: MethodBind bindGridMap_get_center_y = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_center_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_center_y :: (GridMap :< cls, Object :< cls) => cls -> IO Bool get_center_y cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_center_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_center_y" '[] (IO Bool) where nodeMethod = Godot.Core.GridMap.get_center_y {-# NOINLINE bindGridMap_get_center_z #-} bindGridMap_get_center_z :: MethodBind bindGridMap_get_center_z = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_center_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_center_z :: (GridMap :< cls, Object :< cls) => cls -> IO Bool get_center_z cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_center_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_center_z" '[] (IO Bool) where nodeMethod = Godot.Core.GridMap.get_center_z {-# NOINLINE bindGridMap_get_collision_layer #-} bindGridMap_get_collision_layer :: MethodBind bindGridMap_get_collision_layer = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_layer :: (GridMap :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.GridMap.get_collision_layer {-# NOINLINE bindGridMap_get_collision_layer_bit #-} bindGridMap_get_collision_layer_bit :: MethodBind bindGridMap_get_collision_layer_bit = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_layer_bit :: (GridMap :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_layer_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_collision_layer_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.GridMap.get_collision_layer_bit {-# NOINLINE bindGridMap_get_collision_mask #-} bindGridMap_get_collision_mask :: MethodBind bindGridMap_get_collision_mask = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_mask :: (GridMap :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.GridMap.get_collision_mask {-# NOINLINE bindGridMap_get_collision_mask_bit #-} bindGridMap_get_collision_mask_bit :: MethodBind bindGridMap_get_collision_mask_bit = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_mask_bit :: (GridMap :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.GridMap.get_collision_mask_bit {-# NOINLINE bindGridMap_get_mesh_library #-} bindGridMap_get_mesh_library :: MethodBind bindGridMap_get_mesh_library = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_mesh_library" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_mesh_library :: (GridMap :< cls, Object :< cls) => cls -> IO MeshLibrary get_mesh_library cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_mesh_library (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_mesh_library" '[] (IO MeshLibrary) where nodeMethod = Godot.Core.GridMap.get_mesh_library {-# NOINLINE bindGridMap_get_meshes #-} bindGridMap_get_meshes :: MethodBind bindGridMap_get_meshes = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_meshes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_meshes :: (GridMap :< cls, Object :< cls) => cls -> IO Array get_meshes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_meshes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_meshes" '[] (IO Array) where nodeMethod = Godot.Core.GridMap.get_meshes {-# NOINLINE bindGridMap_get_octant_size #-} bindGridMap_get_octant_size :: MethodBind bindGridMap_get_octant_size = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_octant_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_octant_size :: (GridMap :< cls, Object :< cls) => cls -> IO Int get_octant_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_octant_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_octant_size" '[] (IO Int) where nodeMethod = Godot.Core.GridMap.get_octant_size {-# NOINLINE bindGridMap_get_used_cells #-} bindGridMap_get_used_cells :: MethodBind bindGridMap_get_used_cells = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "get_used_cells" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_used_cells :: (GridMap :< cls, Object :< cls) => cls -> IO Array get_used_cells cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_get_used_cells (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "get_used_cells" '[] (IO Array) where nodeMethod = Godot.Core.GridMap.get_used_cells {-# NOINLINE bindGridMap_make_baked_meshes #-} bindGridMap_make_baked_meshes :: MethodBind bindGridMap_make_baked_meshes = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "make_baked_meshes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr make_baked_meshes :: (GridMap :< cls, Object :< cls) => cls -> Maybe Bool -> Maybe Float -> IO () make_baked_meshes cls arg1 arg2 = withVariantArray [maybe (VariantBool False) toVariant arg1, maybe (VariantReal (0.1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_make_baked_meshes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "make_baked_meshes" '[Maybe Bool, Maybe Float] (IO ()) where nodeMethod = Godot.Core.GridMap.make_baked_meshes {-# NOINLINE bindGridMap_map_to_world #-} bindGridMap_map_to_world :: MethodBind bindGridMap_map_to_world = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "map_to_world" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr map_to_world :: (GridMap :< cls, Object :< cls) => cls -> Int -> Int -> Int -> IO Vector3 map_to_world cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_map_to_world (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "map_to_world" '[Int, Int, Int] (IO Vector3) where nodeMethod = Godot.Core.GridMap.map_to_world {-# NOINLINE bindGridMap_resource_changed #-} bindGridMap_resource_changed :: MethodBind bindGridMap_resource_changed = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "resource_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr resource_changed :: (GridMap :< cls, Object :< cls) => cls -> Resource -> IO () resource_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_resource_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "resource_changed" '[Resource] (IO ()) where nodeMethod = Godot.Core.GridMap.resource_changed {-# NOINLINE bindGridMap_set_cell_item #-} bindGridMap_set_cell_item :: MethodBind bindGridMap_set_cell_item = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_cell_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_item :: (GridMap :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> Maybe Int -> IO () set_cell_item cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_cell_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_cell_item" '[Int, Int, Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.GridMap.set_cell_item {-# NOINLINE bindGridMap_set_cell_scale #-} bindGridMap_set_cell_scale :: MethodBind bindGridMap_set_cell_scale = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_cell_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_scale :: (GridMap :< cls, Object :< cls) => cls -> Float -> IO () set_cell_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_cell_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_cell_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.GridMap.set_cell_scale {-# NOINLINE bindGridMap_set_cell_size #-} bindGridMap_set_cell_size :: MethodBind bindGridMap_set_cell_size = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_size :: (GridMap :< cls, Object :< cls) => cls -> Vector3 -> IO () set_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_cell_size" '[Vector3] (IO ()) where nodeMethod = Godot.Core.GridMap.set_cell_size {-# NOINLINE bindGridMap_set_center_x #-} bindGridMap_set_center_x :: MethodBind bindGridMap_set_center_x = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_center_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_center_x :: (GridMap :< cls, Object :< cls) => cls -> Bool -> IO () set_center_x cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_center_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_center_x" '[Bool] (IO ()) where nodeMethod = Godot.Core.GridMap.set_center_x {-# NOINLINE bindGridMap_set_center_y #-} bindGridMap_set_center_y :: MethodBind bindGridMap_set_center_y = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_center_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_center_y :: (GridMap :< cls, Object :< cls) => cls -> Bool -> IO () set_center_y cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_center_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_center_y" '[Bool] (IO ()) where nodeMethod = Godot.Core.GridMap.set_center_y {-# NOINLINE bindGridMap_set_center_z #-} bindGridMap_set_center_z :: MethodBind bindGridMap_set_center_z = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_center_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_center_z :: (GridMap :< cls, Object :< cls) => cls -> Bool -> IO () set_center_z cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_center_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_center_z" '[Bool] (IO ()) where nodeMethod = Godot.Core.GridMap.set_center_z {-# NOINLINE bindGridMap_set_clip #-} bindGridMap_set_clip :: MethodBind bindGridMap_set_clip = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_clip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_clip :: (GridMap :< cls, Object :< cls) => cls -> Bool -> Maybe Bool -> Maybe Int -> Maybe Int -> IO () set_clip cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2, maybe (VariantInt (0)) toVariant arg3, maybe (VariantInt (0)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_clip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_clip" '[Bool, Maybe Bool, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.GridMap.set_clip {-# NOINLINE bindGridMap_set_collision_layer #-} bindGridMap_set_collision_layer :: MethodBind bindGridMap_set_collision_layer = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_layer :: (GridMap :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.GridMap.set_collision_layer {-# NOINLINE bindGridMap_set_collision_layer_bit #-} bindGridMap_set_collision_layer_bit :: MethodBind bindGridMap_set_collision_layer_bit = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_layer_bit :: (GridMap :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_layer_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_collision_layer_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.GridMap.set_collision_layer_bit {-# NOINLINE bindGridMap_set_collision_mask #-} bindGridMap_set_collision_mask :: MethodBind bindGridMap_set_collision_mask = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_mask :: (GridMap :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.GridMap.set_collision_mask {-# NOINLINE bindGridMap_set_collision_mask_bit #-} bindGridMap_set_collision_mask_bit :: MethodBind bindGridMap_set_collision_mask_bit = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_mask_bit :: (GridMap :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.GridMap.set_collision_mask_bit {-# NOINLINE bindGridMap_set_mesh_library #-} bindGridMap_set_mesh_library :: MethodBind bindGridMap_set_mesh_library = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_mesh_library" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_mesh_library :: (GridMap :< cls, Object :< cls) => cls -> MeshLibrary -> IO () set_mesh_library cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_mesh_library (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_mesh_library" '[MeshLibrary] (IO ()) where nodeMethod = Godot.Core.GridMap.set_mesh_library {-# NOINLINE bindGridMap_set_octant_size #-} bindGridMap_set_octant_size :: MethodBind bindGridMap_set_octant_size = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "set_octant_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_octant_size :: (GridMap :< cls, Object :< cls) => cls -> Int -> IO () set_octant_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_set_octant_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "set_octant_size" '[Int] (IO ()) where nodeMethod = Godot.Core.GridMap.set_octant_size {-# NOINLINE bindGridMap_world_to_map #-} bindGridMap_world_to_map :: MethodBind bindGridMap_world_to_map = unsafePerformIO $ withCString "GridMap" $ \ clsNamePtr -> withCString "world_to_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr world_to_map :: (GridMap :< cls, Object :< cls) => cls -> Vector3 -> IO Vector3 world_to_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGridMap_world_to_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GridMap "world_to_map" '[Vector3] (IO Vector3) where nodeMethod = Godot.Core.GridMap.world_to_map ================================================ FILE: src/Godot/Core/GrooveJoint2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.GrooveJoint2D (Godot.Core.GrooveJoint2D.get_initial_offset, Godot.Core.GrooveJoint2D.get_length, Godot.Core.GrooveJoint2D.set_initial_offset, Godot.Core.GrooveJoint2D.set_length) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Joint2D() instance NodeProperty GrooveJoint2D "initial_offset" Float 'False where nodeProperty = (get_initial_offset, wrapDroppingSetter set_initial_offset, Nothing) instance NodeProperty GrooveJoint2D "length" Float 'False where nodeProperty = (get_length, wrapDroppingSetter set_length, Nothing) {-# NOINLINE bindGrooveJoint2D_get_initial_offset #-} -- | The body B's initial anchor position defined by the joint's origin and a local offset @initial_offset@ along the joint's Y axis (along the groove). bindGrooveJoint2D_get_initial_offset :: MethodBind bindGrooveJoint2D_get_initial_offset = unsafePerformIO $ withCString "GrooveJoint2D" $ \ clsNamePtr -> withCString "get_initial_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body B's initial anchor position defined by the joint's origin and a local offset @initial_offset@ along the joint's Y axis (along the groove). get_initial_offset :: (GrooveJoint2D :< cls, Object :< cls) => cls -> IO Float get_initial_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGrooveJoint2D_get_initial_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GrooveJoint2D "get_initial_offset" '[] (IO Float) where nodeMethod = Godot.Core.GrooveJoint2D.get_initial_offset {-# NOINLINE bindGrooveJoint2D_get_length #-} -- | The groove's length. The groove is from the joint's origin towards @length@ along the joint's local Y axis. bindGrooveJoint2D_get_length :: MethodBind bindGrooveJoint2D_get_length = unsafePerformIO $ withCString "GrooveJoint2D" $ \ clsNamePtr -> withCString "get_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The groove's length. The groove is from the joint's origin towards @length@ along the joint's local Y axis. get_length :: (GrooveJoint2D :< cls, Object :< cls) => cls -> IO Float get_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindGrooveJoint2D_get_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GrooveJoint2D "get_length" '[] (IO Float) where nodeMethod = Godot.Core.GrooveJoint2D.get_length {-# NOINLINE bindGrooveJoint2D_set_initial_offset #-} -- | The body B's initial anchor position defined by the joint's origin and a local offset @initial_offset@ along the joint's Y axis (along the groove). bindGrooveJoint2D_set_initial_offset :: MethodBind bindGrooveJoint2D_set_initial_offset = unsafePerformIO $ withCString "GrooveJoint2D" $ \ clsNamePtr -> withCString "set_initial_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body B's initial anchor position defined by the joint's origin and a local offset @initial_offset@ along the joint's Y axis (along the groove). set_initial_offset :: (GrooveJoint2D :< cls, Object :< cls) => cls -> Float -> IO () set_initial_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGrooveJoint2D_set_initial_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GrooveJoint2D "set_initial_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.GrooveJoint2D.set_initial_offset {-# NOINLINE bindGrooveJoint2D_set_length #-} -- | The groove's length. The groove is from the joint's origin towards @length@ along the joint's local Y axis. bindGrooveJoint2D_set_length :: MethodBind bindGrooveJoint2D_set_length = unsafePerformIO $ withCString "GrooveJoint2D" $ \ clsNamePtr -> withCString "set_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The groove's length. The groove is from the joint's origin towards @length@ along the joint's local Y axis. set_length :: (GrooveJoint2D :< cls, Object :< cls) => cls -> Float -> IO () set_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindGrooveJoint2D_set_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod GrooveJoint2D "set_length" '[Float] (IO ()) where nodeMethod = Godot.Core.GrooveJoint2D.set_length ================================================ FILE: src/Godot/Core/HBoxContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HBoxContainer () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.BoxContainer() ================================================ FILE: src/Godot/Core/HScrollBar.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HScrollBar () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ScrollBar() ================================================ FILE: src/Godot/Core/HSeparator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HSeparator () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Separator() ================================================ FILE: src/Godot/Core/HSlider.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HSlider () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Slider() ================================================ FILE: src/Godot/Core/HSplitContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HSplitContainer () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.SplitContainer() ================================================ FILE: src/Godot/Core/HTTPClient.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HTTPClient (Godot.Core.HTTPClient._STATUS_CONNECTED, Godot.Core.HTTPClient._RESPONSE_CREATED, Godot.Core.HTTPClient._RESPONSE_SWITCHING_PROTOCOLS, Godot.Core.HTTPClient._RESPONSE_PRECONDITION_FAILED, Godot.Core.HTTPClient._RESPONSE_USE_PROXY, Godot.Core.HTTPClient._RESPONSE_SEE_OTHER, Godot.Core.HTTPClient._RESPONSE_FAILED_DEPENDENCY, Godot.Core.HTTPClient._RESPONSE_GONE, Godot.Core.HTTPClient._RESPONSE_FORBIDDEN, Godot.Core.HTTPClient._RESPONSE_INSUFFICIENT_STORAGE, Godot.Core.HTTPClient._RESPONSE_NOT_MODIFIED, Godot.Core.HTTPClient._RESPONSE_CONFLICT, Godot.Core.HTTPClient._RESPONSE_REQUEST_URI_TOO_LONG, Godot.Core.HTTPClient._STATUS_RESOLVING, Godot.Core.HTTPClient._STATUS_CONNECTION_ERROR, Godot.Core.HTTPClient._RESPONSE_ALREADY_REPORTED, Godot.Core.HTTPClient._RESPONSE_TEMPORARY_REDIRECT, Godot.Core.HTTPClient._STATUS_CANT_CONNECT, Godot.Core.HTTPClient._STATUS_CONNECTING, Godot.Core.HTTPClient._RESPONSE_BAD_REQUEST, Godot.Core.HTTPClient._RESPONSE_UNSUPPORTED_MEDIA_TYPE, Godot.Core.HTTPClient._RESPONSE_SWITCH_PROXY, Godot.Core.HTTPClient._STATUS_CANT_RESOLVE, Godot.Core.HTTPClient._RESPONSE_NOT_IMPLEMENTED, Godot.Core.HTTPClient._RESPONSE_REQUEST_ENTITY_TOO_LARGE, Godot.Core.HTTPClient._METHOD_OPTIONS, Godot.Core.HTTPClient._RESPONSE_NON_AUTHORITATIVE_INFORMATION, Godot.Core.HTTPClient._RESPONSE_OK, Godot.Core.HTTPClient._RESPONSE_NO_CONTENT, Godot.Core.HTTPClient._RESPONSE_NETWORK_AUTH_REQUIRED, Godot.Core.HTTPClient._RESPONSE_PERMANENT_REDIRECT, Godot.Core.HTTPClient._RESPONSE_PRECONDITION_REQUIRED, Godot.Core.HTTPClient._RESPONSE_LENGTH_REQUIRED, Godot.Core.HTTPClient._RESPONSE_UNAVAILABLE_FOR_LEGAL_REASONS, Godot.Core.HTTPClient._RESPONSE_INTERNAL_SERVER_ERROR, Godot.Core.HTTPClient._RESPONSE_REQUEST_TIMEOUT, Godot.Core.HTTPClient._METHOD_TRACE, Godot.Core.HTTPClient._RESPONSE_LOOP_DETECTED, Godot.Core.HTTPClient._RESPONSE_MISDIRECTED_REQUEST, Godot.Core.HTTPClient._METHOD_DELETE, Godot.Core.HTTPClient._RESPONSE_TOO_MANY_REQUESTS, Godot.Core.HTTPClient._RESPONSE_NOT_EXTENDED, Godot.Core.HTTPClient._METHOD_PUT, Godot.Core.HTTPClient._RESPONSE_MOVED_PERMANENTLY, Godot.Core.HTTPClient._RESPONSE_NOT_ACCEPTABLE, Godot.Core.HTTPClient._RESPONSE_SERVICE_UNAVAILABLE, Godot.Core.HTTPClient._RESPONSE_BAD_GATEWAY, Godot.Core.HTTPClient._METHOD_MAX, Godot.Core.HTTPClient._RESPONSE_RESET_CONTENT, Godot.Core.HTTPClient._RESPONSE_VARIANT_ALSO_NEGOTIATES, Godot.Core.HTTPClient._RESPONSE_PROCESSING, Godot.Core.HTTPClient._RESPONSE_UPGRADE_REQUIRED, Godot.Core.HTTPClient._RESPONSE_EXPECTATION_FAILED, Godot.Core.HTTPClient._RESPONSE_UNPROCESSABLE_ENTITY, Godot.Core.HTTPClient._RESPONSE_REQUEST_HEADER_FIELDS_TOO_LARGE, Godot.Core.HTTPClient._STATUS_REQUESTING, Godot.Core.HTTPClient._RESPONSE_IM_A_TEAPOT, Godot.Core.HTTPClient._RESPONSE_FOUND, Godot.Core.HTTPClient._STATUS_DISCONNECTED, Godot.Core.HTTPClient._RESPONSE_HTTP_VERSION_NOT_SUPPORTED, Godot.Core.HTTPClient._RESPONSE_CONTINUE, Godot.Core.HTTPClient._RESPONSE_ACCEPTED, Godot.Core.HTTPClient._RESPONSE_IM_USED, Godot.Core.HTTPClient._RESPONSE_REQUESTED_RANGE_NOT_SATISFIABLE, Godot.Core.HTTPClient._STATUS_SSL_HANDSHAKE_ERROR, Godot.Core.HTTPClient._METHOD_HEAD, Godot.Core.HTTPClient._RESPONSE_UNAUTHORIZED, Godot.Core.HTTPClient._RESPONSE_NOT_FOUND, Godot.Core.HTTPClient._RESPONSE_PAYMENT_REQUIRED, Godot.Core.HTTPClient._METHOD_POST, Godot.Core.HTTPClient._RESPONSE_GATEWAY_TIMEOUT, Godot.Core.HTTPClient._RESPONSE_MULTIPLE_CHOICES, Godot.Core.HTTPClient._STATUS_BODY, Godot.Core.HTTPClient._RESPONSE_METHOD_NOT_ALLOWED, Godot.Core.HTTPClient._RESPONSE_MULTI_STATUS, Godot.Core.HTTPClient._RESPONSE_LOCKED, Godot.Core.HTTPClient._METHOD_CONNECT, Godot.Core.HTTPClient._METHOD_PATCH, Godot.Core.HTTPClient._METHOD_GET, Godot.Core.HTTPClient._RESPONSE_PROXY_AUTHENTICATION_REQUIRED, Godot.Core.HTTPClient._RESPONSE_PARTIAL_CONTENT, Godot.Core.HTTPClient.close, Godot.Core.HTTPClient.connect_to_host, Godot.Core.HTTPClient.get_connection, Godot.Core.HTTPClient.get_read_chunk_size, Godot.Core.HTTPClient.get_response_body_length, Godot.Core.HTTPClient.get_response_code, Godot.Core.HTTPClient.get_response_headers, Godot.Core.HTTPClient.get_response_headers_as_dictionary, Godot.Core.HTTPClient.get_status, Godot.Core.HTTPClient.has_response, Godot.Core.HTTPClient.is_blocking_mode_enabled, Godot.Core.HTTPClient.is_response_chunked, Godot.Core.HTTPClient.poll, Godot.Core.HTTPClient.query_string_from_dict, Godot.Core.HTTPClient.read_response_body_chunk, Godot.Core.HTTPClient.request, Godot.Core.HTTPClient.request_raw, Godot.Core.HTTPClient.set_blocking_mode, Godot.Core.HTTPClient.set_connection, Godot.Core.HTTPClient.set_read_chunk_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _STATUS_CONNECTED :: Int _STATUS_CONNECTED = 5 _RESPONSE_CREATED :: Int _RESPONSE_CREATED = 201 _RESPONSE_SWITCHING_PROTOCOLS :: Int _RESPONSE_SWITCHING_PROTOCOLS = 101 _RESPONSE_PRECONDITION_FAILED :: Int _RESPONSE_PRECONDITION_FAILED = 412 _RESPONSE_USE_PROXY :: Int _RESPONSE_USE_PROXY = 305 _RESPONSE_SEE_OTHER :: Int _RESPONSE_SEE_OTHER = 303 _RESPONSE_FAILED_DEPENDENCY :: Int _RESPONSE_FAILED_DEPENDENCY = 424 _RESPONSE_GONE :: Int _RESPONSE_GONE = 410 _RESPONSE_FORBIDDEN :: Int _RESPONSE_FORBIDDEN = 403 _RESPONSE_INSUFFICIENT_STORAGE :: Int _RESPONSE_INSUFFICIENT_STORAGE = 507 _RESPONSE_NOT_MODIFIED :: Int _RESPONSE_NOT_MODIFIED = 304 _RESPONSE_CONFLICT :: Int _RESPONSE_CONFLICT = 409 _RESPONSE_REQUEST_URI_TOO_LONG :: Int _RESPONSE_REQUEST_URI_TOO_LONG = 414 _STATUS_RESOLVING :: Int _STATUS_RESOLVING = 1 _STATUS_CONNECTION_ERROR :: Int _STATUS_CONNECTION_ERROR = 8 _RESPONSE_ALREADY_REPORTED :: Int _RESPONSE_ALREADY_REPORTED = 208 _RESPONSE_TEMPORARY_REDIRECT :: Int _RESPONSE_TEMPORARY_REDIRECT = 307 _STATUS_CANT_CONNECT :: Int _STATUS_CANT_CONNECT = 4 _STATUS_CONNECTING :: Int _STATUS_CONNECTING = 3 _RESPONSE_BAD_REQUEST :: Int _RESPONSE_BAD_REQUEST = 400 _RESPONSE_UNSUPPORTED_MEDIA_TYPE :: Int _RESPONSE_UNSUPPORTED_MEDIA_TYPE = 415 _RESPONSE_SWITCH_PROXY :: Int _RESPONSE_SWITCH_PROXY = 306 _STATUS_CANT_RESOLVE :: Int _STATUS_CANT_RESOLVE = 2 _RESPONSE_NOT_IMPLEMENTED :: Int _RESPONSE_NOT_IMPLEMENTED = 501 _RESPONSE_REQUEST_ENTITY_TOO_LARGE :: Int _RESPONSE_REQUEST_ENTITY_TOO_LARGE = 413 _METHOD_OPTIONS :: Int _METHOD_OPTIONS = 5 _RESPONSE_NON_AUTHORITATIVE_INFORMATION :: Int _RESPONSE_NON_AUTHORITATIVE_INFORMATION = 203 _RESPONSE_OK :: Int _RESPONSE_OK = 200 _RESPONSE_NO_CONTENT :: Int _RESPONSE_NO_CONTENT = 204 _RESPONSE_NETWORK_AUTH_REQUIRED :: Int _RESPONSE_NETWORK_AUTH_REQUIRED = 511 _RESPONSE_PERMANENT_REDIRECT :: Int _RESPONSE_PERMANENT_REDIRECT = 308 _RESPONSE_PRECONDITION_REQUIRED :: Int _RESPONSE_PRECONDITION_REQUIRED = 428 _RESPONSE_LENGTH_REQUIRED :: Int _RESPONSE_LENGTH_REQUIRED = 411 _RESPONSE_UNAVAILABLE_FOR_LEGAL_REASONS :: Int _RESPONSE_UNAVAILABLE_FOR_LEGAL_REASONS = 451 _RESPONSE_INTERNAL_SERVER_ERROR :: Int _RESPONSE_INTERNAL_SERVER_ERROR = 500 _RESPONSE_REQUEST_TIMEOUT :: Int _RESPONSE_REQUEST_TIMEOUT = 408 _METHOD_TRACE :: Int _METHOD_TRACE = 6 _RESPONSE_LOOP_DETECTED :: Int _RESPONSE_LOOP_DETECTED = 508 _RESPONSE_MISDIRECTED_REQUEST :: Int _RESPONSE_MISDIRECTED_REQUEST = 421 _METHOD_DELETE :: Int _METHOD_DELETE = 4 _RESPONSE_TOO_MANY_REQUESTS :: Int _RESPONSE_TOO_MANY_REQUESTS = 429 _RESPONSE_NOT_EXTENDED :: Int _RESPONSE_NOT_EXTENDED = 510 _METHOD_PUT :: Int _METHOD_PUT = 3 _RESPONSE_MOVED_PERMANENTLY :: Int _RESPONSE_MOVED_PERMANENTLY = 301 _RESPONSE_NOT_ACCEPTABLE :: Int _RESPONSE_NOT_ACCEPTABLE = 406 _RESPONSE_SERVICE_UNAVAILABLE :: Int _RESPONSE_SERVICE_UNAVAILABLE = 503 _RESPONSE_BAD_GATEWAY :: Int _RESPONSE_BAD_GATEWAY = 502 _METHOD_MAX :: Int _METHOD_MAX = 9 _RESPONSE_RESET_CONTENT :: Int _RESPONSE_RESET_CONTENT = 205 _RESPONSE_VARIANT_ALSO_NEGOTIATES :: Int _RESPONSE_VARIANT_ALSO_NEGOTIATES = 506 _RESPONSE_PROCESSING :: Int _RESPONSE_PROCESSING = 102 _RESPONSE_UPGRADE_REQUIRED :: Int _RESPONSE_UPGRADE_REQUIRED = 426 _RESPONSE_EXPECTATION_FAILED :: Int _RESPONSE_EXPECTATION_FAILED = 417 _RESPONSE_UNPROCESSABLE_ENTITY :: Int _RESPONSE_UNPROCESSABLE_ENTITY = 422 _RESPONSE_REQUEST_HEADER_FIELDS_TOO_LARGE :: Int _RESPONSE_REQUEST_HEADER_FIELDS_TOO_LARGE = 431 _STATUS_REQUESTING :: Int _STATUS_REQUESTING = 6 _RESPONSE_IM_A_TEAPOT :: Int _RESPONSE_IM_A_TEAPOT = 418 _RESPONSE_FOUND :: Int _RESPONSE_FOUND = 302 _STATUS_DISCONNECTED :: Int _STATUS_DISCONNECTED = 0 _RESPONSE_HTTP_VERSION_NOT_SUPPORTED :: Int _RESPONSE_HTTP_VERSION_NOT_SUPPORTED = 505 _RESPONSE_CONTINUE :: Int _RESPONSE_CONTINUE = 100 _RESPONSE_ACCEPTED :: Int _RESPONSE_ACCEPTED = 202 _RESPONSE_IM_USED :: Int _RESPONSE_IM_USED = 226 _RESPONSE_REQUESTED_RANGE_NOT_SATISFIABLE :: Int _RESPONSE_REQUESTED_RANGE_NOT_SATISFIABLE = 416 _STATUS_SSL_HANDSHAKE_ERROR :: Int _STATUS_SSL_HANDSHAKE_ERROR = 9 _METHOD_HEAD :: Int _METHOD_HEAD = 1 _RESPONSE_UNAUTHORIZED :: Int _RESPONSE_UNAUTHORIZED = 401 _RESPONSE_NOT_FOUND :: Int _RESPONSE_NOT_FOUND = 404 _RESPONSE_PAYMENT_REQUIRED :: Int _RESPONSE_PAYMENT_REQUIRED = 402 _METHOD_POST :: Int _METHOD_POST = 2 _RESPONSE_GATEWAY_TIMEOUT :: Int _RESPONSE_GATEWAY_TIMEOUT = 504 _RESPONSE_MULTIPLE_CHOICES :: Int _RESPONSE_MULTIPLE_CHOICES = 300 _STATUS_BODY :: Int _STATUS_BODY = 7 _RESPONSE_METHOD_NOT_ALLOWED :: Int _RESPONSE_METHOD_NOT_ALLOWED = 405 _RESPONSE_MULTI_STATUS :: Int _RESPONSE_MULTI_STATUS = 207 _RESPONSE_LOCKED :: Int _RESPONSE_LOCKED = 423 _METHOD_CONNECT :: Int _METHOD_CONNECT = 7 _METHOD_PATCH :: Int _METHOD_PATCH = 8 _METHOD_GET :: Int _METHOD_GET = 0 _RESPONSE_PROXY_AUTHENTICATION_REQUIRED :: Int _RESPONSE_PROXY_AUTHENTICATION_REQUIRED = 407 _RESPONSE_PARTIAL_CONTENT :: Int _RESPONSE_PARTIAL_CONTENT = 206 instance NodeProperty HTTPClient "blocking_mode_enabled" Bool 'False where nodeProperty = (is_blocking_mode_enabled, wrapDroppingSetter set_blocking_mode, Nothing) instance NodeProperty HTTPClient "connection" StreamPeer 'False where nodeProperty = (get_connection, wrapDroppingSetter set_connection, Nothing) instance NodeProperty HTTPClient "read_chunk_size" Int 'False where nodeProperty = (get_read_chunk_size, wrapDroppingSetter set_read_chunk_size, Nothing) {-# NOINLINE bindHTTPClient_close #-} -- | Closes the current connection, allowing reuse of this @HTTPClient@. bindHTTPClient_close :: MethodBind bindHTTPClient_close = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "close" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Closes the current connection, allowing reuse of this @HTTPClient@. close :: (HTTPClient :< cls, Object :< cls) => cls -> IO () close cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_close (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "close" '[] (IO ()) where nodeMethod = Godot.Core.HTTPClient.close {-# NOINLINE bindHTTPClient_connect_to_host #-} -- | Connects to a host. This needs to be done before any requests are sent. -- The host should not have http:// prepended but will strip the protocol identifier if provided. -- If no @port@ is specified (or @-1@ is used), it is automatically set to 80 for HTTP and 443 for HTTPS (if @use_ssl@ is enabled). -- @verify_host@ will check the SSL identity of the host if set to @true@. bindHTTPClient_connect_to_host :: MethodBind bindHTTPClient_connect_to_host = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "connect_to_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects to a host. This needs to be done before any requests are sent. -- The host should not have http:// prepended but will strip the protocol identifier if provided. -- If no @port@ is specified (or @-1@ is used), it is automatically set to 80 for HTTP and 443 for HTTPS (if @use_ssl@ is enabled). -- @verify_host@ will check the SSL identity of the host if set to @true@. connect_to_host :: (HTTPClient :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> Maybe Bool -> Maybe Bool -> IO Int connect_to_host cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2, maybe (VariantBool False) toVariant arg3, maybe (VariantBool True) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_connect_to_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "connect_to_host" '[GodotString, Maybe Int, Maybe Bool, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.HTTPClient.connect_to_host {-# NOINLINE bindHTTPClient_get_connection #-} -- | The connection to use for this client. bindHTTPClient_get_connection :: MethodBind bindHTTPClient_get_connection = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "get_connection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The connection to use for this client. get_connection :: (HTTPClient :< cls, Object :< cls) => cls -> IO StreamPeer get_connection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_get_connection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "get_connection" '[] (IO StreamPeer) where nodeMethod = Godot.Core.HTTPClient.get_connection {-# NOINLINE bindHTTPClient_get_read_chunk_size #-} -- | The size of the buffer used and maximum bytes to read per iteration. See @method read_response_body_chunk@. bindHTTPClient_get_read_chunk_size :: MethodBind bindHTTPClient_get_read_chunk_size = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "get_read_chunk_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the buffer used and maximum bytes to read per iteration. See @method read_response_body_chunk@. get_read_chunk_size :: (HTTPClient :< cls, Object :< cls) => cls -> IO Int get_read_chunk_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_get_read_chunk_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "get_read_chunk_size" '[] (IO Int) where nodeMethod = Godot.Core.HTTPClient.get_read_chunk_size {-# NOINLINE bindHTTPClient_get_response_body_length #-} -- | Returns the response's body length. -- __Note:__ Some Web servers may not send a body length. In this case, the value returned will be @-1@. If using chunked transfer encoding, the body length will also be @-1@. bindHTTPClient_get_response_body_length :: MethodBind bindHTTPClient_get_response_body_length = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "get_response_body_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the response's body length. -- __Note:__ Some Web servers may not send a body length. In this case, the value returned will be @-1@. If using chunked transfer encoding, the body length will also be @-1@. get_response_body_length :: (HTTPClient :< cls, Object :< cls) => cls -> IO Int get_response_body_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_get_response_body_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "get_response_body_length" '[] (IO Int) where nodeMethod = Godot.Core.HTTPClient.get_response_body_length {-# NOINLINE bindHTTPClient_get_response_code #-} -- | Returns the response's HTTP status code. bindHTTPClient_get_response_code :: MethodBind bindHTTPClient_get_response_code = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "get_response_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the response's HTTP status code. get_response_code :: (HTTPClient :< cls, Object :< cls) => cls -> IO Int get_response_code cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_get_response_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "get_response_code" '[] (IO Int) where nodeMethod = Godot.Core.HTTPClient.get_response_code {-# NOINLINE bindHTTPClient_get_response_headers #-} -- | Returns the response headers. bindHTTPClient_get_response_headers :: MethodBind bindHTTPClient_get_response_headers = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "get_response_headers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the response headers. get_response_headers :: (HTTPClient :< cls, Object :< cls) => cls -> IO PoolStringArray get_response_headers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_get_response_headers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "get_response_headers" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.HTTPClient.get_response_headers {-# NOINLINE bindHTTPClient_get_response_headers_as_dictionary #-} -- | Returns all response headers as a Dictionary of structure @{ "key": "value1; value2" }@ where the case-sensitivity of the keys and values is kept like the server delivers it. A value is a simple String, this string can have more than one value where "; " is used as separator. -- __Example:__ -- -- @ -- -- { -- "content-length": 12, -- "Content-Type": "application/json; charset=UTF-8", -- } -- -- @ bindHTTPClient_get_response_headers_as_dictionary :: MethodBind bindHTTPClient_get_response_headers_as_dictionary = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "get_response_headers_as_dictionary" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all response headers as a Dictionary of structure @{ "key": "value1; value2" }@ where the case-sensitivity of the keys and values is kept like the server delivers it. A value is a simple String, this string can have more than one value where "; " is used as separator. -- __Example:__ -- -- @ -- -- { -- "content-length": 12, -- "Content-Type": "application/json; charset=UTF-8", -- } -- -- @ get_response_headers_as_dictionary :: (HTTPClient :< cls, Object :< cls) => cls -> IO Dictionary get_response_headers_as_dictionary cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_get_response_headers_as_dictionary (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "get_response_headers_as_dictionary" '[] (IO Dictionary) where nodeMethod = Godot.Core.HTTPClient.get_response_headers_as_dictionary {-# NOINLINE bindHTTPClient_get_status #-} -- | Returns a @enum Status@ constant. Need to call @method poll@ in order to get status updates. bindHTTPClient_get_status :: MethodBind bindHTTPClient_get_status = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "get_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @enum Status@ constant. Need to call @method poll@ in order to get status updates. get_status :: (HTTPClient :< cls, Object :< cls) => cls -> IO Int get_status cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_get_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "get_status" '[] (IO Int) where nodeMethod = Godot.Core.HTTPClient.get_status {-# NOINLINE bindHTTPClient_has_response #-} -- | If @true@, this @HTTPClient@ has a response available. bindHTTPClient_has_response :: MethodBind bindHTTPClient_has_response = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "has_response" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this @HTTPClient@ has a response available. has_response :: (HTTPClient :< cls, Object :< cls) => cls -> IO Bool has_response cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_has_response (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "has_response" '[] (IO Bool) where nodeMethod = Godot.Core.HTTPClient.has_response {-# NOINLINE bindHTTPClient_is_blocking_mode_enabled #-} -- | If @true@, execution will block until all data is read from the response. bindHTTPClient_is_blocking_mode_enabled :: MethodBind bindHTTPClient_is_blocking_mode_enabled = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "is_blocking_mode_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, execution will block until all data is read from the response. is_blocking_mode_enabled :: (HTTPClient :< cls, Object :< cls) => cls -> IO Bool is_blocking_mode_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_is_blocking_mode_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "is_blocking_mode_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.HTTPClient.is_blocking_mode_enabled {-# NOINLINE bindHTTPClient_is_response_chunked #-} -- | If @true@, this @HTTPClient@ has a response that is chunked. bindHTTPClient_is_response_chunked :: MethodBind bindHTTPClient_is_response_chunked = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "is_response_chunked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this @HTTPClient@ has a response that is chunked. is_response_chunked :: (HTTPClient :< cls, Object :< cls) => cls -> IO Bool is_response_chunked cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_is_response_chunked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "is_response_chunked" '[] (IO Bool) where nodeMethod = Godot.Core.HTTPClient.is_response_chunked {-# NOINLINE bindHTTPClient_poll #-} -- | This needs to be called in order to have any request processed. Check results with @method get_status@. bindHTTPClient_poll :: MethodBind bindHTTPClient_poll = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "poll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This needs to be called in order to have any request processed. Check results with @method get_status@. poll :: (HTTPClient :< cls, Object :< cls) => cls -> IO Int poll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_poll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "poll" '[] (IO Int) where nodeMethod = Godot.Core.HTTPClient.poll {-# NOINLINE bindHTTPClient_query_string_from_dict #-} -- | Generates a GET/POST application/x-www-form-urlencoded style query string from a provided dictionary, e.g.: -- -- @ -- -- var fields = {"username": "user", "password": "pass"} -- var query_string = http_client.query_string_from_dict(fields) -- # Returns "username=user&password=pass" -- -- @ -- -- Furthermore, if a key has a @null@ value, only the key itself is added, without equal sign and value. If the value is an array, for each value in it a pair with the same key is added. -- -- @ -- -- var fields = {"single": 123, "not_valued": null, "multiple": @22, 33, 44@} -- var query_string = http_client.query_string_from_dict(fields) -- # Returns "single=123¬_valued&multiple=22&multiple=33&multiple=44" -- -- @ bindHTTPClient_query_string_from_dict :: MethodBind bindHTTPClient_query_string_from_dict = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "query_string_from_dict" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a GET/POST application/x-www-form-urlencoded style query string from a provided dictionary, e.g.: -- -- @ -- -- var fields = {"username": "user", "password": "pass"} -- var query_string = http_client.query_string_from_dict(fields) -- # Returns "username=user&password=pass" -- -- @ -- -- Furthermore, if a key has a @null@ value, only the key itself is added, without equal sign and value. If the value is an array, for each value in it a pair with the same key is added. -- -- @ -- -- var fields = {"single": 123, "not_valued": null, "multiple": @22, 33, 44@} -- var query_string = http_client.query_string_from_dict(fields) -- # Returns "single=123¬_valued&multiple=22&multiple=33&multiple=44" -- -- @ query_string_from_dict :: (HTTPClient :< cls, Object :< cls) => cls -> Dictionary -> IO GodotString query_string_from_dict cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_query_string_from_dict (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "query_string_from_dict" '[Dictionary] (IO GodotString) where nodeMethod = Godot.Core.HTTPClient.query_string_from_dict {-# NOINLINE bindHTTPClient_read_response_body_chunk #-} -- | Reads one chunk from the response. bindHTTPClient_read_response_body_chunk :: MethodBind bindHTTPClient_read_response_body_chunk = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "read_response_body_chunk" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reads one chunk from the response. read_response_body_chunk :: (HTTPClient :< cls, Object :< cls) => cls -> IO PoolByteArray read_response_body_chunk cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_read_response_body_chunk (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "read_response_body_chunk" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.HTTPClient.read_response_body_chunk {-# NOINLINE bindHTTPClient_request #-} -- | Sends a request to the connected host. The URL parameter is just the part after the host, so for @http://somehost.com/index.php@, it is @index.php@. -- Headers are HTTP request headers. For available HTTP methods, see @enum Method@. -- To create a POST request with query strings to push to the server, do: -- -- @ -- -- var fields = {"username" : "user", "password" : "pass"} -- var query_string = http_client.query_string_from_dict(fields) -- var headers = @"Content-Type: application/x-www-form-urlencoded", "Content-Length: " + str(query_string.length())@ -- var result = http_client.request(http_client.METHOD_POST, "index.php", headers, query_string) -- -- @ -- -- __Note:__ The @request_data@ parameter is ignored if @method@ is @HTTPClient.METHOD_GET@. This is because GET methods can't contain request data. As a workaround, you can pass request data as a query string in the URL. See @method String.http_escape@ for an example. bindHTTPClient_request :: MethodBind bindHTTPClient_request = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "request" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a request to the connected host. The URL parameter is just the part after the host, so for @http://somehost.com/index.php@, it is @index.php@. -- Headers are HTTP request headers. For available HTTP methods, see @enum Method@. -- To create a POST request with query strings to push to the server, do: -- -- @ -- -- var fields = {"username" : "user", "password" : "pass"} -- var query_string = http_client.query_string_from_dict(fields) -- var headers = @"Content-Type: application/x-www-form-urlencoded", "Content-Length: " + str(query_string.length())@ -- var result = http_client.request(http_client.METHOD_POST, "index.php", headers, query_string) -- -- @ -- -- __Note:__ The @request_data@ parameter is ignored if @method@ is @HTTPClient.METHOD_GET@. This is because GET methods can't contain request data. As a workaround, you can pass request data as a query string in the URL. See @method String.http_escape@ for an example. request :: (HTTPClient :< cls, Object :< cls) => cls -> Int -> GodotString -> PoolStringArray -> Maybe GodotString -> IO Int request cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantString "" arg4] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_request (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "request" '[Int, GodotString, PoolStringArray, Maybe GodotString] (IO Int) where nodeMethod = Godot.Core.HTTPClient.request {-# NOINLINE bindHTTPClient_request_raw #-} -- | Sends a raw request to the connected host. The URL parameter is just the part after the host, so for @http://somehost.com/index.php@, it is @index.php@. -- Headers are HTTP request headers. For available HTTP methods, see @enum Method@. -- Sends the body data raw, as a byte array and does not encode it in any way. bindHTTPClient_request_raw :: MethodBind bindHTTPClient_request_raw = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "request_raw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a raw request to the connected host. The URL parameter is just the part after the host, so for @http://somehost.com/index.php@, it is @index.php@. -- Headers are HTTP request headers. For available HTTP methods, see @enum Method@. -- Sends the body data raw, as a byte array and does not encode it in any way. request_raw :: (HTTPClient :< cls, Object :< cls) => cls -> Int -> GodotString -> PoolStringArray -> PoolByteArray -> IO Int request_raw cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_request_raw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "request_raw" '[Int, GodotString, PoolStringArray, PoolByteArray] (IO Int) where nodeMethod = Godot.Core.HTTPClient.request_raw {-# NOINLINE bindHTTPClient_set_blocking_mode #-} -- | If @true@, execution will block until all data is read from the response. bindHTTPClient_set_blocking_mode :: MethodBind bindHTTPClient_set_blocking_mode = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "set_blocking_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, execution will block until all data is read from the response. set_blocking_mode :: (HTTPClient :< cls, Object :< cls) => cls -> Bool -> IO () set_blocking_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_set_blocking_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "set_blocking_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.HTTPClient.set_blocking_mode {-# NOINLINE bindHTTPClient_set_connection #-} -- | The connection to use for this client. bindHTTPClient_set_connection :: MethodBind bindHTTPClient_set_connection = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "set_connection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The connection to use for this client. set_connection :: (HTTPClient :< cls, Object :< cls) => cls -> StreamPeer -> IO () set_connection cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_set_connection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "set_connection" '[StreamPeer] (IO ()) where nodeMethod = Godot.Core.HTTPClient.set_connection {-# NOINLINE bindHTTPClient_set_read_chunk_size #-} -- | The size of the buffer used and maximum bytes to read per iteration. See @method read_response_body_chunk@. bindHTTPClient_set_read_chunk_size :: MethodBind bindHTTPClient_set_read_chunk_size = unsafePerformIO $ withCString "HTTPClient" $ \ clsNamePtr -> withCString "set_read_chunk_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the buffer used and maximum bytes to read per iteration. See @method read_response_body_chunk@. set_read_chunk_size :: (HTTPClient :< cls, Object :< cls) => cls -> Int -> IO () set_read_chunk_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPClient_set_read_chunk_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPClient "set_read_chunk_size" '[Int] (IO ()) where nodeMethod = Godot.Core.HTTPClient.set_read_chunk_size ================================================ FILE: src/Godot/Core/HTTPRequest.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HTTPRequest (Godot.Core.HTTPRequest._RESULT_DOWNLOAD_FILE_CANT_OPEN, Godot.Core.HTTPRequest._RESULT_SUCCESS, Godot.Core.HTTPRequest._RESULT_NO_RESPONSE, Godot.Core.HTTPRequest._RESULT_REQUEST_FAILED, Godot.Core.HTTPRequest._RESULT_CONNECTION_ERROR, Godot.Core.HTTPRequest._RESULT_CANT_CONNECT, Godot.Core.HTTPRequest._RESULT_CHUNKED_BODY_SIZE_MISMATCH, Godot.Core.HTTPRequest._RESULT_BODY_SIZE_LIMIT_EXCEEDED, Godot.Core.HTTPRequest._RESULT_REDIRECT_LIMIT_REACHED, Godot.Core.HTTPRequest._RESULT_SSL_HANDSHAKE_ERROR, Godot.Core.HTTPRequest._RESULT_CANT_RESOLVE, Godot.Core.HTTPRequest._RESULT_TIMEOUT, Godot.Core.HTTPRequest._RESULT_DOWNLOAD_FILE_WRITE_ERROR, Godot.Core.HTTPRequest.sig_request_completed, Godot.Core.HTTPRequest._redirect_request, Godot.Core.HTTPRequest._request_done, Godot.Core.HTTPRequest._timeout, Godot.Core.HTTPRequest.cancel_request, Godot.Core.HTTPRequest.get_body_size, Godot.Core.HTTPRequest.get_body_size_limit, Godot.Core.HTTPRequest.get_download_chunk_size, Godot.Core.HTTPRequest.get_download_file, Godot.Core.HTTPRequest.get_downloaded_bytes, Godot.Core.HTTPRequest.get_http_client_status, Godot.Core.HTTPRequest.get_max_redirects, Godot.Core.HTTPRequest.get_timeout, Godot.Core.HTTPRequest.is_using_threads, Godot.Core.HTTPRequest.request, Godot.Core.HTTPRequest.set_body_size_limit, Godot.Core.HTTPRequest.set_download_chunk_size, Godot.Core.HTTPRequest.set_download_file, Godot.Core.HTTPRequest.set_max_redirects, Godot.Core.HTTPRequest.set_timeout, Godot.Core.HTTPRequest.set_use_threads) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _RESULT_DOWNLOAD_FILE_CANT_OPEN :: Int _RESULT_DOWNLOAD_FILE_CANT_OPEN = 9 _RESULT_SUCCESS :: Int _RESULT_SUCCESS = 0 _RESULT_NO_RESPONSE :: Int _RESULT_NO_RESPONSE = 6 _RESULT_REQUEST_FAILED :: Int _RESULT_REQUEST_FAILED = 8 _RESULT_CONNECTION_ERROR :: Int _RESULT_CONNECTION_ERROR = 4 _RESULT_CANT_CONNECT :: Int _RESULT_CANT_CONNECT = 2 _RESULT_CHUNKED_BODY_SIZE_MISMATCH :: Int _RESULT_CHUNKED_BODY_SIZE_MISMATCH = 1 _RESULT_BODY_SIZE_LIMIT_EXCEEDED :: Int _RESULT_BODY_SIZE_LIMIT_EXCEEDED = 7 _RESULT_REDIRECT_LIMIT_REACHED :: Int _RESULT_REDIRECT_LIMIT_REACHED = 11 _RESULT_SSL_HANDSHAKE_ERROR :: Int _RESULT_SSL_HANDSHAKE_ERROR = 5 _RESULT_CANT_RESOLVE :: Int _RESULT_CANT_RESOLVE = 3 _RESULT_TIMEOUT :: Int _RESULT_TIMEOUT = 12 _RESULT_DOWNLOAD_FILE_WRITE_ERROR :: Int _RESULT_DOWNLOAD_FILE_WRITE_ERROR = 10 -- | Emitted when a request is completed. sig_request_completed :: Godot.Internal.Dispatch.Signal HTTPRequest sig_request_completed = Godot.Internal.Dispatch.Signal "request_completed" instance NodeSignal HTTPRequest "request_completed" '[Int, Int, PoolStringArray, PoolByteArray] instance NodeProperty HTTPRequest "body_size_limit" Int 'False where nodeProperty = (get_body_size_limit, wrapDroppingSetter set_body_size_limit, Nothing) instance NodeProperty HTTPRequest "download_chunk_size" Int 'False where nodeProperty = (get_download_chunk_size, wrapDroppingSetter set_download_chunk_size, Nothing) instance NodeProperty HTTPRequest "download_file" GodotString 'False where nodeProperty = (get_download_file, wrapDroppingSetter set_download_file, Nothing) instance NodeProperty HTTPRequest "max_redirects" Int 'False where nodeProperty = (get_max_redirects, wrapDroppingSetter set_max_redirects, Nothing) instance NodeProperty HTTPRequest "timeout" Int 'False where nodeProperty = (get_timeout, wrapDroppingSetter set_timeout, Nothing) instance NodeProperty HTTPRequest "use_threads" Bool 'False where nodeProperty = (is_using_threads, wrapDroppingSetter set_use_threads, Nothing) {-# NOINLINE bindHTTPRequest__redirect_request #-} bindHTTPRequest__redirect_request :: MethodBind bindHTTPRequest__redirect_request = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "_redirect_request" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _redirect_request :: (HTTPRequest :< cls, Object :< cls) => cls -> GodotString -> IO () _redirect_request cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest__redirect_request (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "_redirect_request" '[GodotString] (IO ()) where nodeMethod = Godot.Core.HTTPRequest._redirect_request {-# NOINLINE bindHTTPRequest__request_done #-} bindHTTPRequest__request_done :: MethodBind bindHTTPRequest__request_done = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "_request_done" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _request_done :: (HTTPRequest :< cls, Object :< cls) => cls -> Int -> Int -> PoolStringArray -> PoolByteArray -> IO () _request_done cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest__request_done (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "_request_done" '[Int, Int, PoolStringArray, PoolByteArray] (IO ()) where nodeMethod = Godot.Core.HTTPRequest._request_done {-# NOINLINE bindHTTPRequest__timeout #-} bindHTTPRequest__timeout :: MethodBind bindHTTPRequest__timeout = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "_timeout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _timeout :: (HTTPRequest :< cls, Object :< cls) => cls -> IO () _timeout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest__timeout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "_timeout" '[] (IO ()) where nodeMethod = Godot.Core.HTTPRequest._timeout {-# NOINLINE bindHTTPRequest_cancel_request #-} -- | Cancels the current request. bindHTTPRequest_cancel_request :: MethodBind bindHTTPRequest_cancel_request = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "cancel_request" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Cancels the current request. cancel_request :: (HTTPRequest :< cls, Object :< cls) => cls -> IO () cancel_request cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_cancel_request (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "cancel_request" '[] (IO ()) where nodeMethod = Godot.Core.HTTPRequest.cancel_request {-# NOINLINE bindHTTPRequest_get_body_size #-} -- | Returns the response body length. -- __Note:__ Some Web servers may not send a body length. In this case, the value returned will be @-1@. If using chunked transfer encoding, the body length will also be @-1@. bindHTTPRequest_get_body_size :: MethodBind bindHTTPRequest_get_body_size = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "get_body_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the response body length. -- __Note:__ Some Web servers may not send a body length. In this case, the value returned will be @-1@. If using chunked transfer encoding, the body length will also be @-1@. get_body_size :: (HTTPRequest :< cls, Object :< cls) => cls -> IO Int get_body_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_get_body_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "get_body_size" '[] (IO Int) where nodeMethod = Godot.Core.HTTPRequest.get_body_size {-# NOINLINE bindHTTPRequest_get_body_size_limit #-} -- | Maximum allowed size for response bodies. bindHTTPRequest_get_body_size_limit :: MethodBind bindHTTPRequest_get_body_size_limit = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "get_body_size_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum allowed size for response bodies. get_body_size_limit :: (HTTPRequest :< cls, Object :< cls) => cls -> IO Int get_body_size_limit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_get_body_size_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "get_body_size_limit" '[] (IO Int) where nodeMethod = Godot.Core.HTTPRequest.get_body_size_limit {-# NOINLINE bindHTTPRequest_get_download_chunk_size #-} -- | The size of the buffer used and maximum bytes to read per iteration. See @HTTPClient.read_chunk_size@. -- Set this to a higher value (e.g. 65536 for 64 KiB) when downloading large files to achieve better speeds at the cost of memory. bindHTTPRequest_get_download_chunk_size :: MethodBind bindHTTPRequest_get_download_chunk_size = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "get_download_chunk_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the buffer used and maximum bytes to read per iteration. See @HTTPClient.read_chunk_size@. -- Set this to a higher value (e.g. 65536 for 64 KiB) when downloading large files to achieve better speeds at the cost of memory. get_download_chunk_size :: (HTTPRequest :< cls, Object :< cls) => cls -> IO Int get_download_chunk_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_get_download_chunk_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "get_download_chunk_size" '[] (IO Int) where nodeMethod = Godot.Core.HTTPRequest.get_download_chunk_size {-# NOINLINE bindHTTPRequest_get_download_file #-} -- | The file to download into. Will output any received file into it. bindHTTPRequest_get_download_file :: MethodBind bindHTTPRequest_get_download_file = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "get_download_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The file to download into. Will output any received file into it. get_download_file :: (HTTPRequest :< cls, Object :< cls) => cls -> IO GodotString get_download_file cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_get_download_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "get_download_file" '[] (IO GodotString) where nodeMethod = Godot.Core.HTTPRequest.get_download_file {-# NOINLINE bindHTTPRequest_get_downloaded_bytes #-} -- | Returns the amount of bytes this HTTPRequest downloaded. bindHTTPRequest_get_downloaded_bytes :: MethodBind bindHTTPRequest_get_downloaded_bytes = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "get_downloaded_bytes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of bytes this HTTPRequest downloaded. get_downloaded_bytes :: (HTTPRequest :< cls, Object :< cls) => cls -> IO Int get_downloaded_bytes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_get_downloaded_bytes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "get_downloaded_bytes" '[] (IO Int) where nodeMethod = Godot.Core.HTTPRequest.get_downloaded_bytes {-# NOINLINE bindHTTPRequest_get_http_client_status #-} -- | Returns the current status of the underlying @HTTPClient@. See @enum HTTPClient.Status@. bindHTTPRequest_get_http_client_status :: MethodBind bindHTTPRequest_get_http_client_status = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "get_http_client_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current status of the underlying @HTTPClient@. See @enum HTTPClient.Status@. get_http_client_status :: (HTTPRequest :< cls, Object :< cls) => cls -> IO Int get_http_client_status cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_get_http_client_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "get_http_client_status" '[] (IO Int) where nodeMethod = Godot.Core.HTTPRequest.get_http_client_status {-# NOINLINE bindHTTPRequest_get_max_redirects #-} -- | Maximum number of allowed redirects. bindHTTPRequest_get_max_redirects :: MethodBind bindHTTPRequest_get_max_redirects = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "get_max_redirects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum number of allowed redirects. get_max_redirects :: (HTTPRequest :< cls, Object :< cls) => cls -> IO Int get_max_redirects cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_get_max_redirects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "get_max_redirects" '[] (IO Int) where nodeMethod = Godot.Core.HTTPRequest.get_max_redirects {-# NOINLINE bindHTTPRequest_get_timeout #-} bindHTTPRequest_get_timeout :: MethodBind bindHTTPRequest_get_timeout = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "get_timeout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_timeout :: (HTTPRequest :< cls, Object :< cls) => cls -> IO Int get_timeout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_get_timeout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "get_timeout" '[] (IO Int) where nodeMethod = Godot.Core.HTTPRequest.get_timeout {-# NOINLINE bindHTTPRequest_is_using_threads #-} -- | If @true@, multithreading is used to improve performance. bindHTTPRequest_is_using_threads :: MethodBind bindHTTPRequest_is_using_threads = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "is_using_threads" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, multithreading is used to improve performance. is_using_threads :: (HTTPRequest :< cls, Object :< cls) => cls -> IO Bool is_using_threads cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_is_using_threads (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "is_using_threads" '[] (IO Bool) where nodeMethod = Godot.Core.HTTPRequest.is_using_threads {-# NOINLINE bindHTTPRequest_request #-} -- | Creates request on the underlying @HTTPClient@. If there is no configuration errors, it tries to connect using @method HTTPClient.connect_to_host@ and passes parameters onto @method HTTPClient.request@. -- Returns @OK@ if request is successfully created. (Does not imply that the server has responded), @ERR_UNCONFIGURED@ if not in the tree, @ERR_BUSY@ if still processing previous request, @ERR_INVALID_PARAMETER@ if given string is not a valid URL format, or @ERR_CANT_CONNECT@ if not using thread and the @HTTPClient@ cannot connect to host. -- __Note:__ The @request_data@ parameter is ignored if @method@ is @HTTPClient.METHOD_GET@. This is because GET methods can't contain request data. As a workaround, you can pass request data as a query string in the URL. See @method String.http_escape@ for an example. bindHTTPRequest_request :: MethodBind bindHTTPRequest_request = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "request" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates request on the underlying @HTTPClient@. If there is no configuration errors, it tries to connect using @method HTTPClient.connect_to_host@ and passes parameters onto @method HTTPClient.request@. -- Returns @OK@ if request is successfully created. (Does not imply that the server has responded), @ERR_UNCONFIGURED@ if not in the tree, @ERR_BUSY@ if still processing previous request, @ERR_INVALID_PARAMETER@ if given string is not a valid URL format, or @ERR_CANT_CONNECT@ if not using thread and the @HTTPClient@ cannot connect to host. -- __Note:__ The @request_data@ parameter is ignored if @method@ is @HTTPClient.METHOD_GET@. This is because GET methods can't contain request data. As a workaround, you can pass request data as a query string in the URL. See @method String.http_escape@ for an example. request :: (HTTPRequest :< cls, Object :< cls) => cls -> GodotString -> Maybe PoolStringArray -> Maybe Bool -> Maybe Int -> Maybe GodotString -> IO Int request cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, defaultedVariant VariantPoolStringArray V.empty arg2, maybe (VariantBool True) toVariant arg3, maybe (VariantInt (0)) toVariant arg4, defaultedVariant VariantString "" arg5] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_request (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "request" '[GodotString, Maybe PoolStringArray, Maybe Bool, Maybe Int, Maybe GodotString] (IO Int) where nodeMethod = Godot.Core.HTTPRequest.request {-# NOINLINE bindHTTPRequest_set_body_size_limit #-} -- | Maximum allowed size for response bodies. bindHTTPRequest_set_body_size_limit :: MethodBind bindHTTPRequest_set_body_size_limit = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "set_body_size_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum allowed size for response bodies. set_body_size_limit :: (HTTPRequest :< cls, Object :< cls) => cls -> Int -> IO () set_body_size_limit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_set_body_size_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "set_body_size_limit" '[Int] (IO ()) where nodeMethod = Godot.Core.HTTPRequest.set_body_size_limit {-# NOINLINE bindHTTPRequest_set_download_chunk_size #-} -- | The size of the buffer used and maximum bytes to read per iteration. See @HTTPClient.read_chunk_size@. -- Set this to a higher value (e.g. 65536 for 64 KiB) when downloading large files to achieve better speeds at the cost of memory. bindHTTPRequest_set_download_chunk_size :: MethodBind bindHTTPRequest_set_download_chunk_size = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "set_download_chunk_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the buffer used and maximum bytes to read per iteration. See @HTTPClient.read_chunk_size@. -- Set this to a higher value (e.g. 65536 for 64 KiB) when downloading large files to achieve better speeds at the cost of memory. set_download_chunk_size :: (HTTPRequest :< cls, Object :< cls) => cls -> Int -> IO () set_download_chunk_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_set_download_chunk_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "set_download_chunk_size" '[Int] (IO ()) where nodeMethod = Godot.Core.HTTPRequest.set_download_chunk_size {-# NOINLINE bindHTTPRequest_set_download_file #-} -- | The file to download into. Will output any received file into it. bindHTTPRequest_set_download_file :: MethodBind bindHTTPRequest_set_download_file = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "set_download_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The file to download into. Will output any received file into it. set_download_file :: (HTTPRequest :< cls, Object :< cls) => cls -> GodotString -> IO () set_download_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_set_download_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "set_download_file" '[GodotString] (IO ()) where nodeMethod = Godot.Core.HTTPRequest.set_download_file {-# NOINLINE bindHTTPRequest_set_max_redirects #-} -- | Maximum number of allowed redirects. bindHTTPRequest_set_max_redirects :: MethodBind bindHTTPRequest_set_max_redirects = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "set_max_redirects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum number of allowed redirects. set_max_redirects :: (HTTPRequest :< cls, Object :< cls) => cls -> Int -> IO () set_max_redirects cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_set_max_redirects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "set_max_redirects" '[Int] (IO ()) where nodeMethod = Godot.Core.HTTPRequest.set_max_redirects {-# NOINLINE bindHTTPRequest_set_timeout #-} bindHTTPRequest_set_timeout :: MethodBind bindHTTPRequest_set_timeout = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "set_timeout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_timeout :: (HTTPRequest :< cls, Object :< cls) => cls -> Int -> IO () set_timeout cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_set_timeout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "set_timeout" '[Int] (IO ()) where nodeMethod = Godot.Core.HTTPRequest.set_timeout {-# NOINLINE bindHTTPRequest_set_use_threads #-} -- | If @true@, multithreading is used to improve performance. bindHTTPRequest_set_use_threads :: MethodBind bindHTTPRequest_set_use_threads = unsafePerformIO $ withCString "HTTPRequest" $ \ clsNamePtr -> withCString "set_use_threads" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, multithreading is used to improve performance. set_use_threads :: (HTTPRequest :< cls, Object :< cls) => cls -> Bool -> IO () set_use_threads cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHTTPRequest_set_use_threads (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HTTPRequest "set_use_threads" '[Bool] (IO ()) where nodeMethod = Godot.Core.HTTPRequest.set_use_threads ================================================ FILE: src/Godot/Core/HashingContext.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HashingContext (Godot.Core.HashingContext._HASH_SHA1, Godot.Core.HashingContext._HASH_MD5, Godot.Core.HashingContext._HASH_SHA256, Godot.Core.HashingContext.finish, Godot.Core.HashingContext.start, Godot.Core.HashingContext.update) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _HASH_SHA1 :: Int _HASH_SHA1 = 1 _HASH_MD5 :: Int _HASH_MD5 = 0 _HASH_SHA256 :: Int _HASH_SHA256 = 2 {-# NOINLINE bindHashingContext_finish #-} -- | Closes the current context, and return the computed hash. bindHashingContext_finish :: MethodBind bindHashingContext_finish = unsafePerformIO $ withCString "HashingContext" $ \ clsNamePtr -> withCString "finish" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Closes the current context, and return the computed hash. finish :: (HashingContext :< cls, Object :< cls) => cls -> IO PoolByteArray finish cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHashingContext_finish (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HashingContext "finish" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.HashingContext.finish {-# NOINLINE bindHashingContext_start #-} -- | Starts a new hash computation of the given @type@ (e.g. @HASH_SHA256@ to start computation of a SHA-256). bindHashingContext_start :: MethodBind bindHashingContext_start = unsafePerformIO $ withCString "HashingContext" $ \ clsNamePtr -> withCString "start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts a new hash computation of the given @type@ (e.g. @HASH_SHA256@ to start computation of a SHA-256). start :: (HashingContext :< cls, Object :< cls) => cls -> Int -> IO Int start cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHashingContext_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HashingContext "start" '[Int] (IO Int) where nodeMethod = Godot.Core.HashingContext.start {-# NOINLINE bindHashingContext_update #-} -- | Updates the computation with the given @chunk@ of data. bindHashingContext_update :: MethodBind bindHashingContext_update = unsafePerformIO $ withCString "HashingContext" $ \ clsNamePtr -> withCString "update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the computation with the given @chunk@ of data. update :: (HashingContext :< cls, Object :< cls) => cls -> PoolByteArray -> IO Int update cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHashingContext_update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HashingContext "update" '[PoolByteArray] (IO Int) where nodeMethod = Godot.Core.HashingContext.update ================================================ FILE: src/Godot/Core/HeightMapShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HeightMapShape (Godot.Core.HeightMapShape.get_map_data, Godot.Core.HeightMapShape.get_map_depth, Godot.Core.HeightMapShape.get_map_width, Godot.Core.HeightMapShape.set_map_data, Godot.Core.HeightMapShape.set_map_depth, Godot.Core.HeightMapShape.set_map_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty HeightMapShape "map_data" PoolRealArray 'False where nodeProperty = (get_map_data, wrapDroppingSetter set_map_data, Nothing) instance NodeProperty HeightMapShape "map_depth" Int 'False where nodeProperty = (get_map_depth, wrapDroppingSetter set_map_depth, Nothing) instance NodeProperty HeightMapShape "map_width" Int 'False where nodeProperty = (get_map_width, wrapDroppingSetter set_map_width, Nothing) {-# NOINLINE bindHeightMapShape_get_map_data #-} -- | Height map data, pool array must be of @map_width@ * @map_depth@ size. bindHeightMapShape_get_map_data :: MethodBind bindHeightMapShape_get_map_data = unsafePerformIO $ withCString "HeightMapShape" $ \ clsNamePtr -> withCString "get_map_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Height map data, pool array must be of @map_width@ * @map_depth@ size. get_map_data :: (HeightMapShape :< cls, Object :< cls) => cls -> IO PoolRealArray get_map_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHeightMapShape_get_map_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HeightMapShape "get_map_data" '[] (IO PoolRealArray) where nodeMethod = Godot.Core.HeightMapShape.get_map_data {-# NOINLINE bindHeightMapShape_get_map_depth #-} -- | Depth of the height map data. Changing this will resize the @map_data@. bindHeightMapShape_get_map_depth :: MethodBind bindHeightMapShape_get_map_depth = unsafePerformIO $ withCString "HeightMapShape" $ \ clsNamePtr -> withCString "get_map_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Depth of the height map data. Changing this will resize the @map_data@. get_map_depth :: (HeightMapShape :< cls, Object :< cls) => cls -> IO Int get_map_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHeightMapShape_get_map_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HeightMapShape "get_map_depth" '[] (IO Int) where nodeMethod = Godot.Core.HeightMapShape.get_map_depth {-# NOINLINE bindHeightMapShape_get_map_width #-} -- | Width of the height map data. Changing this will resize the @map_data@. bindHeightMapShape_get_map_width :: MethodBind bindHeightMapShape_get_map_width = unsafePerformIO $ withCString "HeightMapShape" $ \ clsNamePtr -> withCString "get_map_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Width of the height map data. Changing this will resize the @map_data@. get_map_width :: (HeightMapShape :< cls, Object :< cls) => cls -> IO Int get_map_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHeightMapShape_get_map_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HeightMapShape "get_map_width" '[] (IO Int) where nodeMethod = Godot.Core.HeightMapShape.get_map_width {-# NOINLINE bindHeightMapShape_set_map_data #-} -- | Height map data, pool array must be of @map_width@ * @map_depth@ size. bindHeightMapShape_set_map_data :: MethodBind bindHeightMapShape_set_map_data = unsafePerformIO $ withCString "HeightMapShape" $ \ clsNamePtr -> withCString "set_map_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Height map data, pool array must be of @map_width@ * @map_depth@ size. set_map_data :: (HeightMapShape :< cls, Object :< cls) => cls -> PoolRealArray -> IO () set_map_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHeightMapShape_set_map_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HeightMapShape "set_map_data" '[PoolRealArray] (IO ()) where nodeMethod = Godot.Core.HeightMapShape.set_map_data {-# NOINLINE bindHeightMapShape_set_map_depth #-} -- | Depth of the height map data. Changing this will resize the @map_data@. bindHeightMapShape_set_map_depth :: MethodBind bindHeightMapShape_set_map_depth = unsafePerformIO $ withCString "HeightMapShape" $ \ clsNamePtr -> withCString "set_map_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Depth of the height map data. Changing this will resize the @map_data@. set_map_depth :: (HeightMapShape :< cls, Object :< cls) => cls -> Int -> IO () set_map_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHeightMapShape_set_map_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HeightMapShape "set_map_depth" '[Int] (IO ()) where nodeMethod = Godot.Core.HeightMapShape.set_map_depth {-# NOINLINE bindHeightMapShape_set_map_width #-} -- | Width of the height map data. Changing this will resize the @map_data@. bindHeightMapShape_set_map_width :: MethodBind bindHeightMapShape_set_map_width = unsafePerformIO $ withCString "HeightMapShape" $ \ clsNamePtr -> withCString "set_map_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Width of the height map data. Changing this will resize the @map_data@. set_map_width :: (HeightMapShape :< cls, Object :< cls) => cls -> Int -> IO () set_map_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHeightMapShape_set_map_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HeightMapShape "set_map_width" '[Int] (IO ()) where nodeMethod = Godot.Core.HeightMapShape.set_map_width ================================================ FILE: src/Godot/Core/HingeJoint.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.HingeJoint (Godot.Core.HingeJoint._PARAM_MOTOR_MAX_IMPULSE, Godot.Core.HingeJoint._FLAG_USE_LIMIT, Godot.Core.HingeJoint._PARAM_LIMIT_RELAXATION, Godot.Core.HingeJoint._PARAM_LIMIT_UPPER, Godot.Core.HingeJoint._PARAM_LIMIT_BIAS, Godot.Core.HingeJoint._PARAM_MAX, Godot.Core.HingeJoint._FLAG_MAX, Godot.Core.HingeJoint._PARAM_LIMIT_SOFTNESS, Godot.Core.HingeJoint._PARAM_MOTOR_TARGET_VELOCITY, Godot.Core.HingeJoint._FLAG_ENABLE_MOTOR, Godot.Core.HingeJoint._PARAM_LIMIT_LOWER, Godot.Core.HingeJoint._PARAM_BIAS, Godot.Core.HingeJoint._get_lower_limit, Godot.Core.HingeJoint._get_upper_limit, Godot.Core.HingeJoint._set_lower_limit, Godot.Core.HingeJoint._set_upper_limit, Godot.Core.HingeJoint.get_flag, Godot.Core.HingeJoint.get_param, Godot.Core.HingeJoint.set_flag, Godot.Core.HingeJoint.set_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Joint() _PARAM_MOTOR_MAX_IMPULSE :: Int _PARAM_MOTOR_MAX_IMPULSE = 7 _FLAG_USE_LIMIT :: Int _FLAG_USE_LIMIT = 0 _PARAM_LIMIT_RELAXATION :: Int _PARAM_LIMIT_RELAXATION = 5 _PARAM_LIMIT_UPPER :: Int _PARAM_LIMIT_UPPER = 1 _PARAM_LIMIT_BIAS :: Int _PARAM_LIMIT_BIAS = 3 _PARAM_MAX :: Int _PARAM_MAX = 8 _FLAG_MAX :: Int _FLAG_MAX = 2 _PARAM_LIMIT_SOFTNESS :: Int _PARAM_LIMIT_SOFTNESS = 4 _PARAM_MOTOR_TARGET_VELOCITY :: Int _PARAM_MOTOR_TARGET_VELOCITY = 6 _FLAG_ENABLE_MOTOR :: Int _FLAG_ENABLE_MOTOR = 1 _PARAM_LIMIT_LOWER :: Int _PARAM_LIMIT_LOWER = 2 _PARAM_BIAS :: Int _PARAM_BIAS = 0 instance NodeProperty HingeJoint "angular_limit/bias" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param, wrapIndexedSetter 3 set_param, Nothing) instance NodeProperty HingeJoint "angular_limit/enable" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_flag, wrapIndexedSetter 0 set_flag, Nothing) instance NodeProperty HingeJoint "angular_limit/lower" Float 'False where nodeProperty = (_get_lower_limit, wrapDroppingSetter _set_lower_limit, Nothing) instance NodeProperty HingeJoint "angular_limit/relaxation" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param, wrapIndexedSetter 5 set_param, Nothing) instance NodeProperty HingeJoint "angular_limit/softness" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param, wrapIndexedSetter 4 set_param, Nothing) instance NodeProperty HingeJoint "angular_limit/upper" Float 'False where nodeProperty = (_get_upper_limit, wrapDroppingSetter _set_upper_limit, Nothing) instance NodeProperty HingeJoint "motor/enable" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_flag, wrapIndexedSetter 1 set_flag, Nothing) instance NodeProperty HingeJoint "motor/max_impulse" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param, wrapIndexedSetter 7 set_param, Nothing) instance NodeProperty HingeJoint "motor/target_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param, wrapIndexedSetter 6 set_param, Nothing) instance NodeProperty HingeJoint "params/bias" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param, wrapIndexedSetter 0 set_param, Nothing) {-# NOINLINE bindHingeJoint__get_lower_limit #-} -- | The minimum rotation. Only active if @angular_limit/enable@ is @true@. bindHingeJoint__get_lower_limit :: MethodBind bindHingeJoint__get_lower_limit = unsafePerformIO $ withCString "HingeJoint" $ \ clsNamePtr -> withCString "_get_lower_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation. Only active if @angular_limit/enable@ is @true@. _get_lower_limit :: (HingeJoint :< cls, Object :< cls) => cls -> IO Float _get_lower_limit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHingeJoint__get_lower_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HingeJoint "_get_lower_limit" '[] (IO Float) where nodeMethod = Godot.Core.HingeJoint._get_lower_limit {-# NOINLINE bindHingeJoint__get_upper_limit #-} -- | The maximum rotation. Only active if @angular_limit/enable@ is @true@. bindHingeJoint__get_upper_limit :: MethodBind bindHingeJoint__get_upper_limit = unsafePerformIO $ withCString "HingeJoint" $ \ clsNamePtr -> withCString "_get_upper_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum rotation. Only active if @angular_limit/enable@ is @true@. _get_upper_limit :: (HingeJoint :< cls, Object :< cls) => cls -> IO Float _get_upper_limit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindHingeJoint__get_upper_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HingeJoint "_get_upper_limit" '[] (IO Float) where nodeMethod = Godot.Core.HingeJoint._get_upper_limit {-# NOINLINE bindHingeJoint__set_lower_limit #-} -- | The minimum rotation. Only active if @angular_limit/enable@ is @true@. bindHingeJoint__set_lower_limit :: MethodBind bindHingeJoint__set_lower_limit = unsafePerformIO $ withCString "HingeJoint" $ \ clsNamePtr -> withCString "_set_lower_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum rotation. Only active if @angular_limit/enable@ is @true@. _set_lower_limit :: (HingeJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_lower_limit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHingeJoint__set_lower_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HingeJoint "_set_lower_limit" '[Float] (IO ()) where nodeMethod = Godot.Core.HingeJoint._set_lower_limit {-# NOINLINE bindHingeJoint__set_upper_limit #-} -- | The maximum rotation. Only active if @angular_limit/enable@ is @true@. bindHingeJoint__set_upper_limit :: MethodBind bindHingeJoint__set_upper_limit = unsafePerformIO $ withCString "HingeJoint" $ \ clsNamePtr -> withCString "_set_upper_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum rotation. Only active if @angular_limit/enable@ is @true@. _set_upper_limit :: (HingeJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_upper_limit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHingeJoint__set_upper_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HingeJoint "_set_upper_limit" '[Float] (IO ()) where nodeMethod = Godot.Core.HingeJoint._set_upper_limit {-# NOINLINE bindHingeJoint_get_flag #-} -- | Returns the value of the specified flag. bindHingeJoint_get_flag :: MethodBind bindHingeJoint_get_flag = unsafePerformIO $ withCString "HingeJoint" $ \ clsNamePtr -> withCString "get_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the specified flag. get_flag :: (HingeJoint :< cls, Object :< cls) => cls -> Int -> IO Bool get_flag cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHingeJoint_get_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HingeJoint "get_flag" '[Int] (IO Bool) where nodeMethod = Godot.Core.HingeJoint.get_flag {-# NOINLINE bindHingeJoint_get_param #-} -- | Returns the value of the specified parameter. bindHingeJoint_get_param :: MethodBind bindHingeJoint_get_param = unsafePerformIO $ withCString "HingeJoint" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the specified parameter. get_param :: (HingeJoint :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindHingeJoint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HingeJoint "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.HingeJoint.get_param {-# NOINLINE bindHingeJoint_set_flag #-} -- | If @true@, enables the specified flag. bindHingeJoint_set_flag :: MethodBind bindHingeJoint_set_flag = unsafePerformIO $ withCString "HingeJoint" $ \ clsNamePtr -> withCString "set_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the specified flag. set_flag :: (HingeJoint :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_flag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindHingeJoint_set_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HingeJoint "set_flag" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.HingeJoint.set_flag {-# NOINLINE bindHingeJoint_set_param #-} -- | Sets the value of the specified parameter. bindHingeJoint_set_param :: MethodBind bindHingeJoint_set_param = unsafePerformIO $ withCString "HingeJoint" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value of the specified parameter. set_param :: (HingeJoint :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindHingeJoint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod HingeJoint "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.HingeJoint.set_param ================================================ FILE: src/Godot/Core/IP.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.IP (Godot.Core.IP._RESOLVER_INVALID_ID, Godot.Core.IP._TYPE_NONE, Godot.Core.IP._RESOLVER_STATUS_WAITING, Godot.Core.IP._TYPE_IPV4, Godot.Core.IP._RESOLVER_STATUS_ERROR, Godot.Core.IP._RESOLVER_STATUS_DONE, Godot.Core.IP._RESOLVER_STATUS_NONE, Godot.Core.IP._TYPE_IPV6, Godot.Core.IP._RESOLVER_MAX_QUERIES, Godot.Core.IP._TYPE_ANY, Godot.Core.IP.clear_cache, Godot.Core.IP.erase_resolve_item, Godot.Core.IP.get_local_addresses, Godot.Core.IP.get_local_interfaces, Godot.Core.IP.get_resolve_item_address, Godot.Core.IP.get_resolve_item_status, Godot.Core.IP.resolve_hostname, Godot.Core.IP.resolve_hostname_queue_item) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _RESOLVER_INVALID_ID :: Int _RESOLVER_INVALID_ID = -1 _TYPE_NONE :: Int _TYPE_NONE = 0 _RESOLVER_STATUS_WAITING :: Int _RESOLVER_STATUS_WAITING = 1 _TYPE_IPV4 :: Int _TYPE_IPV4 = 1 _RESOLVER_STATUS_ERROR :: Int _RESOLVER_STATUS_ERROR = 3 _RESOLVER_STATUS_DONE :: Int _RESOLVER_STATUS_DONE = 2 _RESOLVER_STATUS_NONE :: Int _RESOLVER_STATUS_NONE = 0 _TYPE_IPV6 :: Int _TYPE_IPV6 = 2 _RESOLVER_MAX_QUERIES :: Int _RESOLVER_MAX_QUERIES = 32 _TYPE_ANY :: Int _TYPE_ANY = 3 {-# NOINLINE bindIP_clear_cache #-} -- | Removes all of a @hostname@'s cached references. If no @hostname@ is given, all cached IP addresses are removed. bindIP_clear_cache :: MethodBind bindIP_clear_cache = unsafePerformIO $ withCString "IP" $ \ clsNamePtr -> withCString "clear_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all of a @hostname@'s cached references. If no @hostname@ is given, all cached IP addresses are removed. clear_cache :: (IP :< cls, Object :< cls) => cls -> Maybe GodotString -> IO () clear_cache cls arg1 = withVariantArray [defaultedVariant VariantString "" arg1] (\ (arrPtr, len) -> godot_method_bind_call bindIP_clear_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod IP "clear_cache" '[Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.IP.clear_cache {-# NOINLINE bindIP_erase_resolve_item #-} -- | Removes a given item @id@ from the queue. This should be used to free a queue after it has completed to enable more queries to happen. bindIP_erase_resolve_item :: MethodBind bindIP_erase_resolve_item = unsafePerformIO $ withCString "IP" $ \ clsNamePtr -> withCString "erase_resolve_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a given item @id@ from the queue. This should be used to free a queue after it has completed to enable more queries to happen. erase_resolve_item :: (IP :< cls, Object :< cls) => cls -> Int -> IO () erase_resolve_item cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindIP_erase_resolve_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod IP "erase_resolve_item" '[Int] (IO ()) where nodeMethod = Godot.Core.IP.erase_resolve_item {-# NOINLINE bindIP_get_local_addresses #-} -- | Returns all of the user's current IPv4 and IPv6 addresses as an array. bindIP_get_local_addresses :: MethodBind bindIP_get_local_addresses = unsafePerformIO $ withCString "IP" $ \ clsNamePtr -> withCString "get_local_addresses" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all of the user's current IPv4 and IPv6 addresses as an array. get_local_addresses :: (IP :< cls, Object :< cls) => cls -> IO Array get_local_addresses cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindIP_get_local_addresses (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod IP "get_local_addresses" '[] (IO Array) where nodeMethod = Godot.Core.IP.get_local_addresses {-# NOINLINE bindIP_get_local_interfaces #-} -- | Returns all network adapters as an array. -- Each adapter is a dictionary of the form: -- -- @ -- -- { -- "index": "1", # Interface index. -- "name": "eth0", # Interface name. -- "friendly": "Ethernet One", # A friendly name (might be empty). -- "addresses": @"192.168.1.101"@, # An array of IP addresses associated to this interface. -- } -- -- @ bindIP_get_local_interfaces :: MethodBind bindIP_get_local_interfaces = unsafePerformIO $ withCString "IP" $ \ clsNamePtr -> withCString "get_local_interfaces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all network adapters as an array. -- Each adapter is a dictionary of the form: -- -- @ -- -- { -- "index": "1", # Interface index. -- "name": "eth0", # Interface name. -- "friendly": "Ethernet One", # A friendly name (might be empty). -- "addresses": @"192.168.1.101"@, # An array of IP addresses associated to this interface. -- } -- -- @ get_local_interfaces :: (IP :< cls, Object :< cls) => cls -> IO Array get_local_interfaces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindIP_get_local_interfaces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod IP "get_local_interfaces" '[] (IO Array) where nodeMethod = Godot.Core.IP.get_local_interfaces {-# NOINLINE bindIP_get_resolve_item_address #-} -- | Returns a queued hostname's IP address, given its queue @id@. Returns an empty string on error or if resolution hasn't happened yet (see @method get_resolve_item_status@). bindIP_get_resolve_item_address :: MethodBind bindIP_get_resolve_item_address = unsafePerformIO $ withCString "IP" $ \ clsNamePtr -> withCString "get_resolve_item_address" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a queued hostname's IP address, given its queue @id@. Returns an empty string on error or if resolution hasn't happened yet (see @method get_resolve_item_status@). get_resolve_item_address :: (IP :< cls, Object :< cls) => cls -> Int -> IO GodotString get_resolve_item_address cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindIP_get_resolve_item_address (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod IP "get_resolve_item_address" '[Int] (IO GodotString) where nodeMethod = Godot.Core.IP.get_resolve_item_address {-# NOINLINE bindIP_get_resolve_item_status #-} -- | Returns a queued hostname's status as a @enum ResolverStatus@ constant, given its queue @id@. bindIP_get_resolve_item_status :: MethodBind bindIP_get_resolve_item_status = unsafePerformIO $ withCString "IP" $ \ clsNamePtr -> withCString "get_resolve_item_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a queued hostname's status as a @enum ResolverStatus@ constant, given its queue @id@. get_resolve_item_status :: (IP :< cls, Object :< cls) => cls -> Int -> IO Int get_resolve_item_status cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindIP_get_resolve_item_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod IP "get_resolve_item_status" '[Int] (IO Int) where nodeMethod = Godot.Core.IP.get_resolve_item_status {-# NOINLINE bindIP_resolve_hostname #-} -- | Returns a given hostname's IPv4 or IPv6 address when resolved (blocking-type method). The address type returned depends on the @enum Type@ constant given as @ip_type@. bindIP_resolve_hostname :: MethodBind bindIP_resolve_hostname = unsafePerformIO $ withCString "IP" $ \ clsNamePtr -> withCString "resolve_hostname" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a given hostname's IPv4 or IPv6 address when resolved (blocking-type method). The address type returned depends on the @enum Type@ constant given as @ip_type@. resolve_hostname :: (IP :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> IO GodotString resolve_hostname cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (3)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindIP_resolve_hostname (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod IP "resolve_hostname" '[GodotString, Maybe Int] (IO GodotString) where nodeMethod = Godot.Core.IP.resolve_hostname {-# NOINLINE bindIP_resolve_hostname_queue_item #-} -- | Creates a queue item to resolve a hostname to an IPv4 or IPv6 address depending on the @enum Type@ constant given as @ip_type@. Returns the queue ID if successful, or @RESOLVER_INVALID_ID@ on error. bindIP_resolve_hostname_queue_item :: MethodBind bindIP_resolve_hostname_queue_item = unsafePerformIO $ withCString "IP" $ \ clsNamePtr -> withCString "resolve_hostname_queue_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a queue item to resolve a hostname to an IPv4 or IPv6 address depending on the @enum Type@ constant given as @ip_type@. Returns the queue ID if successful, or @RESOLVER_INVALID_ID@ on error. resolve_hostname_queue_item :: (IP :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> IO Int resolve_hostname_queue_item cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (3)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindIP_resolve_hostname_queue_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod IP "resolve_hostname_queue_item" '[GodotString, Maybe Int] (IO Int) where nodeMethod = Godot.Core.IP.resolve_hostname_queue_item ================================================ FILE: src/Godot/Core/IP_Unix.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.IP_Unix () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.IP() ================================================ FILE: src/Godot/Core/Image.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Image (Godot.Core.Image._FORMAT_RGBAF, Godot.Core.Image._FORMAT_PVRTC2A, Godot.Core.Image._FORMAT_ETC2_RGB8, Godot.Core.Image._FORMAT_RGF, Godot.Core.Image._FORMAT_DXT3, Godot.Core.Image._COMPRESS_SOURCE_GENERIC, Godot.Core.Image._FORMAT_ETC2_R11S, Godot.Core.Image._FORMAT_PVRTC4A, Godot.Core.Image._FORMAT_RGBA4444, Godot.Core.Image._FORMAT_ETC2_RG11S, Godot.Core.Image._FORMAT_RGBF, Godot.Core.Image._FORMAT_MAX, Godot.Core.Image._COMPRESS_SOURCE_NORMAL, Godot.Core.Image._COMPRESS_ETC, Godot.Core.Image._FORMAT_RGTC_R, Godot.Core.Image._COMPRESS_S3TC, Godot.Core.Image._COMPRESS_PVRTC4, Godot.Core.Image._FORMAT_ETC2_RG11, Godot.Core.Image._FORMAT_ETC, Godot.Core.Image._FORMAT_RGBA5551, Godot.Core.Image._COMPRESS_ETC2, Godot.Core.Image._FORMAT_ETC2_R11, Godot.Core.Image._FORMAT_LA8, Godot.Core.Image._FORMAT_DXT5, Godot.Core.Image._ALPHA_NONE, Godot.Core.Image._MAX_HEIGHT, Godot.Core.Image._ALPHA_BIT, Godot.Core.Image._FORMAT_ETC2_RGB8A1, Godot.Core.Image._FORMAT_RGTC_RG, Godot.Core.Image._FORMAT_BPTC_RGBF, Godot.Core.Image._COMPRESS_SOURCE_SRGB, Godot.Core.Image._FORMAT_RGBA8, Godot.Core.Image._INTERPOLATE_NEAREST, Godot.Core.Image._FORMAT_RGBAH, Godot.Core.Image._FORMAT_RGBE9995, Godot.Core.Image._FORMAT_BPTC_RGBFU, Godot.Core.Image._INTERPOLATE_TRILINEAR, Godot.Core.Image._ALPHA_BLEND, Godot.Core.Image._FORMAT_PVRTC2, Godot.Core.Image._FORMAT_DXT1, Godot.Core.Image._MAX_WIDTH, Godot.Core.Image._FORMAT_ETC2_RGBA8, Godot.Core.Image._FORMAT_BPTC_RGBA, Godot.Core.Image._COMPRESS_PVRTC2, Godot.Core.Image._FORMAT_RF, Godot.Core.Image._FORMAT_L8, Godot.Core.Image._FORMAT_RGB8, Godot.Core.Image._FORMAT_RGBH, Godot.Core.Image._FORMAT_PVRTC4, Godot.Core.Image._FORMAT_RH, Godot.Core.Image._FORMAT_R8, Godot.Core.Image._INTERPOLATE_BILINEAR, Godot.Core.Image._INTERPOLATE_CUBIC, Godot.Core.Image._INTERPOLATE_LANCZOS, Godot.Core.Image._FORMAT_RG8, Godot.Core.Image._FORMAT_RGH, Godot.Core.Image._get_data, Godot.Core.Image._set_data, Godot.Core.Image.blend_rect, Godot.Core.Image.blend_rect_mask, Godot.Core.Image.blit_rect, Godot.Core.Image.blit_rect_mask, Godot.Core.Image.bumpmap_to_normalmap, Godot.Core.Image.clear_mipmaps, Godot.Core.Image.compress, Godot.Core.Image.convert, Godot.Core.Image.copy_from, Godot.Core.Image.create, Godot.Core.Image.create_from_data, Godot.Core.Image.crop, Godot.Core.Image.decompress, Godot.Core.Image.detect_alpha, Godot.Core.Image.expand_x2_hq2x, Godot.Core.Image.fill, Godot.Core.Image.fix_alpha_edges, Godot.Core.Image.flip_x, Godot.Core.Image.flip_y, Godot.Core.Image.generate_mipmaps, Godot.Core.Image.get_data, Godot.Core.Image.get_format, Godot.Core.Image.get_height, Godot.Core.Image.get_mipmap_offset, Godot.Core.Image.get_pixel, Godot.Core.Image.get_pixelv, Godot.Core.Image.get_rect, Godot.Core.Image.get_size, Godot.Core.Image.get_used_rect, Godot.Core.Image.get_width, Godot.Core.Image.has_mipmaps, Godot.Core.Image.is_compressed, Godot.Core.Image.is_empty, Godot.Core.Image.is_invisible, Godot.Core.Image.load, Godot.Core.Image.load_jpg_from_buffer, Godot.Core.Image.load_png_from_buffer, Godot.Core.Image.load_webp_from_buffer, Godot.Core.Image.lock, Godot.Core.Image.normalmap_to_xy, Godot.Core.Image.premultiply_alpha, Godot.Core.Image.resize, Godot.Core.Image.resize_to_po2, Godot.Core.Image.rgbe_to_srgb, Godot.Core.Image.save_exr, Godot.Core.Image.save_png, Godot.Core.Image.set_pixel, Godot.Core.Image.set_pixelv, Godot.Core.Image.shrink_x2, Godot.Core.Image.srgb_to_linear, Godot.Core.Image.unlock) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _FORMAT_RGBAF :: Int _FORMAT_RGBAF = 11 _FORMAT_PVRTC2A :: Int _FORMAT_PVRTC2A = 26 _FORMAT_ETC2_RGB8 :: Int _FORMAT_ETC2_RGB8 = 34 _FORMAT_RGF :: Int _FORMAT_RGF = 9 _FORMAT_DXT3 :: Int _FORMAT_DXT3 = 18 _COMPRESS_SOURCE_GENERIC :: Int _COMPRESS_SOURCE_GENERIC = 0 _FORMAT_ETC2_R11S :: Int _FORMAT_ETC2_R11S = 31 _FORMAT_PVRTC4A :: Int _FORMAT_PVRTC4A = 28 _FORMAT_RGBA4444 :: Int _FORMAT_RGBA4444 = 6 _FORMAT_ETC2_RG11S :: Int _FORMAT_ETC2_RG11S = 33 _FORMAT_RGBF :: Int _FORMAT_RGBF = 10 _FORMAT_MAX :: Int _FORMAT_MAX = 37 _COMPRESS_SOURCE_NORMAL :: Int _COMPRESS_SOURCE_NORMAL = 2 _COMPRESS_ETC :: Int _COMPRESS_ETC = 3 _FORMAT_RGTC_R :: Int _FORMAT_RGTC_R = 20 _COMPRESS_S3TC :: Int _COMPRESS_S3TC = 0 _COMPRESS_PVRTC4 :: Int _COMPRESS_PVRTC4 = 2 _FORMAT_ETC2_RG11 :: Int _FORMAT_ETC2_RG11 = 32 _FORMAT_ETC :: Int _FORMAT_ETC = 29 _FORMAT_RGBA5551 :: Int _FORMAT_RGBA5551 = 7 _COMPRESS_ETC2 :: Int _COMPRESS_ETC2 = 4 _FORMAT_ETC2_R11 :: Int _FORMAT_ETC2_R11 = 30 _FORMAT_LA8 :: Int _FORMAT_LA8 = 1 _FORMAT_DXT5 :: Int _FORMAT_DXT5 = 19 _ALPHA_NONE :: Int _ALPHA_NONE = 0 _MAX_HEIGHT :: Int _MAX_HEIGHT = 16384 _ALPHA_BIT :: Int _ALPHA_BIT = 1 _FORMAT_ETC2_RGB8A1 :: Int _FORMAT_ETC2_RGB8A1 = 36 _FORMAT_RGTC_RG :: Int _FORMAT_RGTC_RG = 21 _FORMAT_BPTC_RGBF :: Int _FORMAT_BPTC_RGBF = 23 _COMPRESS_SOURCE_SRGB :: Int _COMPRESS_SOURCE_SRGB = 1 _FORMAT_RGBA8 :: Int _FORMAT_RGBA8 = 5 _INTERPOLATE_NEAREST :: Int _INTERPOLATE_NEAREST = 0 _FORMAT_RGBAH :: Int _FORMAT_RGBAH = 15 _FORMAT_RGBE9995 :: Int _FORMAT_RGBE9995 = 16 _FORMAT_BPTC_RGBFU :: Int _FORMAT_BPTC_RGBFU = 24 _INTERPOLATE_TRILINEAR :: Int _INTERPOLATE_TRILINEAR = 3 _ALPHA_BLEND :: Int _ALPHA_BLEND = 2 _FORMAT_PVRTC2 :: Int _FORMAT_PVRTC2 = 25 _FORMAT_DXT1 :: Int _FORMAT_DXT1 = 17 _MAX_WIDTH :: Int _MAX_WIDTH = 16384 _FORMAT_ETC2_RGBA8 :: Int _FORMAT_ETC2_RGBA8 = 35 _FORMAT_BPTC_RGBA :: Int _FORMAT_BPTC_RGBA = 22 _COMPRESS_PVRTC2 :: Int _COMPRESS_PVRTC2 = 1 _FORMAT_RF :: Int _FORMAT_RF = 8 _FORMAT_L8 :: Int _FORMAT_L8 = 0 _FORMAT_RGB8 :: Int _FORMAT_RGB8 = 4 _FORMAT_RGBH :: Int _FORMAT_RGBH = 14 _FORMAT_PVRTC4 :: Int _FORMAT_PVRTC4 = 27 _FORMAT_RH :: Int _FORMAT_RH = 12 _FORMAT_R8 :: Int _FORMAT_R8 = 2 _INTERPOLATE_BILINEAR :: Int _INTERPOLATE_BILINEAR = 1 _INTERPOLATE_CUBIC :: Int _INTERPOLATE_CUBIC = 2 _INTERPOLATE_LANCZOS :: Int _INTERPOLATE_LANCZOS = 4 _FORMAT_RG8 :: Int _FORMAT_RG8 = 3 _FORMAT_RGH :: Int _FORMAT_RGH = 13 instance NodeProperty Image "data" Dictionary 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) {-# NOINLINE bindImage__get_data #-} -- | Holds all of the image's color data in a given format. See @enum Format@ constants. bindImage__get_data :: MethodBind bindImage__get_data = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Holds all of the image's color data in a given format. See @enum Format@ constants. _get_data :: (Image :< cls, Object :< cls) => cls -> IO Dictionary _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "_get_data" '[] (IO Dictionary) where nodeMethod = Godot.Core.Image._get_data {-# NOINLINE bindImage__set_data #-} -- | Holds all of the image's color data in a given format. See @enum Format@ constants. bindImage__set_data :: MethodBind bindImage__set_data = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Holds all of the image's color data in a given format. See @enum Format@ constants. _set_data :: (Image :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "_set_data" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.Image._set_data {-# NOINLINE bindImage_blend_rect #-} -- | Alpha-blends @src_rect@ from @src@ image to this image at coordinates @dest@. bindImage_blend_rect :: MethodBind bindImage_blend_rect = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "blend_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Alpha-blends @src_rect@ from @src@ image to this image at coordinates @dest@. blend_rect :: (Image :< cls, Object :< cls) => cls -> Image -> Rect2 -> Vector2 -> IO () blend_rect cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindImage_blend_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "blend_rect" '[Image, Rect2, Vector2] (IO ()) where nodeMethod = Godot.Core.Image.blend_rect {-# NOINLINE bindImage_blend_rect_mask #-} -- | Alpha-blends @src_rect@ from @src@ image to this image using @mask@ image at coordinates @dst@. Alpha channels are required for both @src@ and @mask@. @dst@ pixels and @src@ pixels will blend if the corresponding mask pixel's alpha value is not 0. @src@ image and @mask@ image __must__ have the same size (width and height) but they can have different formats. bindImage_blend_rect_mask :: MethodBind bindImage_blend_rect_mask = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "blend_rect_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Alpha-blends @src_rect@ from @src@ image to this image using @mask@ image at coordinates @dst@. Alpha channels are required for both @src@ and @mask@. @dst@ pixels and @src@ pixels will blend if the corresponding mask pixel's alpha value is not 0. @src@ image and @mask@ image __must__ have the same size (width and height) but they can have different formats. blend_rect_mask :: (Image :< cls, Object :< cls) => cls -> Image -> Image -> Rect2 -> Vector2 -> IO () blend_rect_mask cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindImage_blend_rect_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "blend_rect_mask" '[Image, Image, Rect2, Vector2] (IO ()) where nodeMethod = Godot.Core.Image.blend_rect_mask {-# NOINLINE bindImage_blit_rect #-} -- | Copies @src_rect@ from @src@ image to this image at coordinates @dst@. bindImage_blit_rect :: MethodBind bindImage_blit_rect = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "blit_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Copies @src_rect@ from @src@ image to this image at coordinates @dst@. blit_rect :: (Image :< cls, Object :< cls) => cls -> Image -> Rect2 -> Vector2 -> IO () blit_rect cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindImage_blit_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "blit_rect" '[Image, Rect2, Vector2] (IO ()) where nodeMethod = Godot.Core.Image.blit_rect {-# NOINLINE bindImage_blit_rect_mask #-} -- | Blits @src_rect@ area from @src@ image to this image at the coordinates given by @dst@. @src@ pixel is copied onto @dst@ if the corresponding @mask@ pixel's alpha value is not 0. @src@ image and @mask@ image __must__ have the same size (width and height) but they can have different formats. bindImage_blit_rect_mask :: MethodBind bindImage_blit_rect_mask = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "blit_rect_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Blits @src_rect@ area from @src@ image to this image at the coordinates given by @dst@. @src@ pixel is copied onto @dst@ if the corresponding @mask@ pixel's alpha value is not 0. @src@ image and @mask@ image __must__ have the same size (width and height) but they can have different formats. blit_rect_mask :: (Image :< cls, Object :< cls) => cls -> Image -> Image -> Rect2 -> Vector2 -> IO () blit_rect_mask cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindImage_blit_rect_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "blit_rect_mask" '[Image, Image, Rect2, Vector2] (IO ()) where nodeMethod = Godot.Core.Image.blit_rect_mask {-# NOINLINE bindImage_bumpmap_to_normalmap #-} -- | Converts a bumpmap to a normalmap. A bumpmap provides a height offset per-pixel, while a normalmap provides a normal direction per pixel. bindImage_bumpmap_to_normalmap :: MethodBind bindImage_bumpmap_to_normalmap = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "bumpmap_to_normalmap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Converts a bumpmap to a normalmap. A bumpmap provides a height offset per-pixel, while a normalmap provides a normal direction per pixel. bumpmap_to_normalmap :: (Image :< cls, Object :< cls) => cls -> Maybe Float -> IO () bumpmap_to_normalmap cls arg1 = withVariantArray [maybe (VariantReal (1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_bumpmap_to_normalmap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "bumpmap_to_normalmap" '[Maybe Float] (IO ()) where nodeMethod = Godot.Core.Image.bumpmap_to_normalmap {-# NOINLINE bindImage_clear_mipmaps #-} -- | Removes the image's mipmaps. bindImage_clear_mipmaps :: MethodBind bindImage_clear_mipmaps = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "clear_mipmaps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the image's mipmaps. clear_mipmaps :: (Image :< cls, Object :< cls) => cls -> IO () clear_mipmaps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_clear_mipmaps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "clear_mipmaps" '[] (IO ()) where nodeMethod = Godot.Core.Image.clear_mipmaps {-# NOINLINE bindImage_compress #-} -- | Compresses the image to use less memory. Can not directly access pixel data while the image is compressed. Returns error if the chosen compression mode is not available. See @enum CompressMode@ and @enum CompressSource@ constants. bindImage_compress :: MethodBind bindImage_compress = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "compress" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Compresses the image to use less memory. Can not directly access pixel data while the image is compressed. Returns error if the chosen compression mode is not available. See @enum CompressMode@ and @enum CompressSource@ constants. compress :: (Image :< cls, Object :< cls) => cls -> Int -> Int -> Float -> IO Int compress cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindImage_compress (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "compress" '[Int, Int, Float] (IO Int) where nodeMethod = Godot.Core.Image.compress {-# NOINLINE bindImage_convert #-} -- | Converts the image's format. See @enum Format@ constants. bindImage_convert :: MethodBind bindImage_convert = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "convert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Converts the image's format. See @enum Format@ constants. convert :: (Image :< cls, Object :< cls) => cls -> Int -> IO () convert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_convert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "convert" '[Int] (IO ()) where nodeMethod = Godot.Core.Image.convert {-# NOINLINE bindImage_copy_from #-} -- | Copies @src@ image to this image. bindImage_copy_from :: MethodBind bindImage_copy_from = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "copy_from" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Copies @src@ image to this image. copy_from :: (Image :< cls, Object :< cls) => cls -> Image -> IO () copy_from cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_copy_from (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "copy_from" '[Image] (IO ()) where nodeMethod = Godot.Core.Image.copy_from {-# NOINLINE bindImage_create #-} -- | Creates an empty image of given size and format. See @enum Format@ constants. If @use_mipmaps@ is @true@ then generate mipmaps for this image. See the @method generate_mipmaps@. bindImage_create :: MethodBind bindImage_create = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an empty image of given size and format. See @enum Format@ constants. If @use_mipmaps@ is @true@ then generate mipmaps for this image. See the @method generate_mipmaps@. create :: (Image :< cls, Object :< cls) => cls -> Int -> Int -> Bool -> Int -> IO () create cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindImage_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "create" '[Int, Int, Bool, Int] (IO ()) where nodeMethod = Godot.Core.Image.create {-# NOINLINE bindImage_create_from_data #-} -- | Creates a new image of given size and format. See @enum Format@ constants. Fills the image with the given raw data. If @use_mipmaps@ is @true@ then loads mipmaps for this image from @data@. See @method generate_mipmaps@. bindImage_create_from_data :: MethodBind bindImage_create_from_data = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "create_from_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new image of given size and format. See @enum Format@ constants. Fills the image with the given raw data. If @use_mipmaps@ is @true@ then loads mipmaps for this image from @data@. See @method generate_mipmaps@. create_from_data :: (Image :< cls, Object :< cls) => cls -> Int -> Int -> Bool -> Int -> PoolByteArray -> IO () create_from_data cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindImage_create_from_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "create_from_data" '[Int, Int, Bool, Int, PoolByteArray] (IO ()) where nodeMethod = Godot.Core.Image.create_from_data {-# NOINLINE bindImage_crop #-} -- | Crops the image to the given @width@ and @height@. If the specified size is larger than the current size, the extra area is filled with black pixels. bindImage_crop :: MethodBind bindImage_crop = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "crop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Crops the image to the given @width@ and @height@. If the specified size is larger than the current size, the extra area is filled with black pixels. crop :: (Image :< cls, Object :< cls) => cls -> Int -> Int -> IO () crop cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindImage_crop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "crop" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Image.crop {-# NOINLINE bindImage_decompress #-} -- | Decompresses the image if it is compressed. Returns an error if decompress function is not available. bindImage_decompress :: MethodBind bindImage_decompress = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "decompress" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Decompresses the image if it is compressed. Returns an error if decompress function is not available. decompress :: (Image :< cls, Object :< cls) => cls -> IO Int decompress cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_decompress (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "decompress" '[] (IO Int) where nodeMethod = Godot.Core.Image.decompress {-# NOINLINE bindImage_detect_alpha #-} -- | Returns @ALPHA_BLEND@ if the image has data for alpha values. Returns @ALPHA_BIT@ if all the alpha values are stored in a single bit. Returns @ALPHA_NONE@ if no data for alpha values is found. bindImage_detect_alpha :: MethodBind bindImage_detect_alpha = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "detect_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @ALPHA_BLEND@ if the image has data for alpha values. Returns @ALPHA_BIT@ if all the alpha values are stored in a single bit. Returns @ALPHA_NONE@ if no data for alpha values is found. detect_alpha :: (Image :< cls, Object :< cls) => cls -> IO Int detect_alpha cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_detect_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "detect_alpha" '[] (IO Int) where nodeMethod = Godot.Core.Image.detect_alpha {-# NOINLINE bindImage_expand_x2_hq2x #-} -- | Stretches the image and enlarges it by a factor of 2. No interpolation is done. bindImage_expand_x2_hq2x :: MethodBind bindImage_expand_x2_hq2x = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "expand_x2_hq2x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stretches the image and enlarges it by a factor of 2. No interpolation is done. expand_x2_hq2x :: (Image :< cls, Object :< cls) => cls -> IO () expand_x2_hq2x cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_expand_x2_hq2x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "expand_x2_hq2x" '[] (IO ()) where nodeMethod = Godot.Core.Image.expand_x2_hq2x {-# NOINLINE bindImage_fill #-} -- | Fills the image with a given @Color@. bindImage_fill :: MethodBind bindImage_fill = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "fill" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Fills the image with a given @Color@. fill :: (Image :< cls, Object :< cls) => cls -> Color -> IO () fill cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_fill (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "fill" '[Color] (IO ()) where nodeMethod = Godot.Core.Image.fill {-# NOINLINE bindImage_fix_alpha_edges #-} -- | Blends low-alpha pixels with nearby pixels. bindImage_fix_alpha_edges :: MethodBind bindImage_fix_alpha_edges = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "fix_alpha_edges" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Blends low-alpha pixels with nearby pixels. fix_alpha_edges :: (Image :< cls, Object :< cls) => cls -> IO () fix_alpha_edges cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_fix_alpha_edges (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "fix_alpha_edges" '[] (IO ()) where nodeMethod = Godot.Core.Image.fix_alpha_edges {-# NOINLINE bindImage_flip_x #-} -- | Flips the image horizontally. bindImage_flip_x :: MethodBind bindImage_flip_x = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "flip_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Flips the image horizontally. flip_x :: (Image :< cls, Object :< cls) => cls -> IO () flip_x cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_flip_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "flip_x" '[] (IO ()) where nodeMethod = Godot.Core.Image.flip_x {-# NOINLINE bindImage_flip_y #-} -- | Flips the image vertically. bindImage_flip_y :: MethodBind bindImage_flip_y = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "flip_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Flips the image vertically. flip_y :: (Image :< cls, Object :< cls) => cls -> IO () flip_y cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_flip_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "flip_y" '[] (IO ()) where nodeMethod = Godot.Core.Image.flip_y {-# NOINLINE bindImage_generate_mipmaps #-} -- | Generates mipmaps for the image. Mipmaps are pre-calculated and lower resolution copies of the image. Mipmaps are automatically used if the image needs to be scaled down when rendered. This improves image quality and the performance of the rendering. Returns an error if the image is compressed, in a custom format or if the image's width/height is 0. bindImage_generate_mipmaps :: MethodBind bindImage_generate_mipmaps = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "generate_mipmaps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates mipmaps for the image. Mipmaps are pre-calculated and lower resolution copies of the image. Mipmaps are automatically used if the image needs to be scaled down when rendered. This improves image quality and the performance of the rendering. Returns an error if the image is compressed, in a custom format or if the image's width/height is 0. generate_mipmaps :: (Image :< cls, Object :< cls) => cls -> Maybe Bool -> IO Int generate_mipmaps cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_generate_mipmaps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "generate_mipmaps" '[Maybe Bool] (IO Int) where nodeMethod = Godot.Core.Image.generate_mipmaps {-# NOINLINE bindImage_get_data #-} -- | Returns a copy of the image's raw data. bindImage_get_data :: MethodBind bindImage_get_data = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a copy of the image's raw data. get_data :: (Image :< cls, Object :< cls) => cls -> IO PoolByteArray get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_data" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.Image.get_data {-# NOINLINE bindImage_get_format #-} -- | Returns the image's format. See @enum Format@ constants. bindImage_get_format :: MethodBind bindImage_get_format = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the image's format. See @enum Format@ constants. get_format :: (Image :< cls, Object :< cls) => cls -> IO Int get_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_format" '[] (IO Int) where nodeMethod = Godot.Core.Image.get_format {-# NOINLINE bindImage_get_height #-} -- | Returns the image's height. bindImage_get_height :: MethodBind bindImage_get_height = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the image's height. get_height :: (Image :< cls, Object :< cls) => cls -> IO Int get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_height" '[] (IO Int) where nodeMethod = Godot.Core.Image.get_height {-# NOINLINE bindImage_get_mipmap_offset #-} -- | Returns the offset where the image's mipmap with index @mipmap@ is stored in the @data@ dictionary. bindImage_get_mipmap_offset :: MethodBind bindImage_get_mipmap_offset = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_mipmap_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the offset where the image's mipmap with index @mipmap@ is stored in the @data@ dictionary. get_mipmap_offset :: (Image :< cls, Object :< cls) => cls -> Int -> IO Int get_mipmap_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_mipmap_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_mipmap_offset" '[Int] (IO Int) where nodeMethod = Godot.Core.Image.get_mipmap_offset {-# NOINLINE bindImage_get_pixel #-} -- | Returns the color of the pixel at @(x, y)@ if the image is locked. If the image is unlocked, it always returns a @Color@ with the value @(0, 0, 0, 1.0)@. This is the same as @method get_pixelv@, but two integer arguments instead of a Vector2 argument. bindImage_get_pixel :: MethodBind bindImage_get_pixel = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_pixel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color of the pixel at @(x, y)@ if the image is locked. If the image is unlocked, it always returns a @Color@ with the value @(0, 0, 0, 1.0)@. This is the same as @method get_pixelv@, but two integer arguments instead of a Vector2 argument. get_pixel :: (Image :< cls, Object :< cls) => cls -> Int -> Int -> IO Color get_pixel cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_pixel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_pixel" '[Int, Int] (IO Color) where nodeMethod = Godot.Core.Image.get_pixel {-# NOINLINE bindImage_get_pixelv #-} -- | Returns the color of the pixel at @src@ if the image is locked. If the image is unlocked, it always returns a @Color@ with the value @(0, 0, 0, 1.0)@. This is the same as @method get_pixel@, but with a Vector2 argument instead of two integer arguments. bindImage_get_pixelv :: MethodBind bindImage_get_pixelv = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_pixelv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color of the pixel at @src@ if the image is locked. If the image is unlocked, it always returns a @Color@ with the value @(0, 0, 0, 1.0)@. This is the same as @method get_pixel@, but with a Vector2 argument instead of two integer arguments. get_pixelv :: (Image :< cls, Object :< cls) => cls -> Vector2 -> IO Color get_pixelv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_pixelv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_pixelv" '[Vector2] (IO Color) where nodeMethod = Godot.Core.Image.get_pixelv {-# NOINLINE bindImage_get_rect #-} -- | Returns a new image that is a copy of the image's area specified with @rect@. bindImage_get_rect :: MethodBind bindImage_get_rect = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a new image that is a copy of the image's area specified with @rect@. get_rect :: (Image :< cls, Object :< cls) => cls -> Rect2 -> IO Image get_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_rect" '[Rect2] (IO Image) where nodeMethod = Godot.Core.Image.get_rect {-# NOINLINE bindImage_get_size #-} -- | Returns the image's size (width and height). bindImage_get_size :: MethodBind bindImage_get_size = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the image's size (width and height). get_size :: (Image :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Image.get_size {-# NOINLINE bindImage_get_used_rect #-} -- | Returns a @Rect2@ enclosing the visible portion of the image, considering each pixel with a non-zero alpha channel as visible. bindImage_get_used_rect :: MethodBind bindImage_get_used_rect = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_used_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @Rect2@ enclosing the visible portion of the image, considering each pixel with a non-zero alpha channel as visible. get_used_rect :: (Image :< cls, Object :< cls) => cls -> IO Rect2 get_used_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_used_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_used_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Image.get_used_rect {-# NOINLINE bindImage_get_width #-} -- | Returns the image's width. bindImage_get_width :: MethodBind bindImage_get_width = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the image's width. get_width :: (Image :< cls, Object :< cls) => cls -> IO Int get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "get_width" '[] (IO Int) where nodeMethod = Godot.Core.Image.get_width {-# NOINLINE bindImage_has_mipmaps #-} -- | Returns @true@ if the image has generated mipmaps. bindImage_has_mipmaps :: MethodBind bindImage_has_mipmaps = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "has_mipmaps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the image has generated mipmaps. has_mipmaps :: (Image :< cls, Object :< cls) => cls -> IO Bool has_mipmaps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_has_mipmaps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "has_mipmaps" '[] (IO Bool) where nodeMethod = Godot.Core.Image.has_mipmaps {-# NOINLINE bindImage_is_compressed #-} -- | Returns @true@ if the image is compressed. bindImage_is_compressed :: MethodBind bindImage_is_compressed = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "is_compressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the image is compressed. is_compressed :: (Image :< cls, Object :< cls) => cls -> IO Bool is_compressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_is_compressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "is_compressed" '[] (IO Bool) where nodeMethod = Godot.Core.Image.is_compressed {-# NOINLINE bindImage_is_empty #-} -- | Returns @true@ if the image has no data. bindImage_is_empty :: MethodBind bindImage_is_empty = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "is_empty" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the image has no data. is_empty :: (Image :< cls, Object :< cls) => cls -> IO Bool is_empty cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_is_empty (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "is_empty" '[] (IO Bool) where nodeMethod = Godot.Core.Image.is_empty {-# NOINLINE bindImage_is_invisible #-} -- | Returns @true@ if all the image's pixels have an alpha value of 0. Returns @false@ if any pixel has an alpha value higher than 0. bindImage_is_invisible :: MethodBind bindImage_is_invisible = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "is_invisible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if all the image's pixels have an alpha value of 0. Returns @false@ if any pixel has an alpha value higher than 0. is_invisible :: (Image :< cls, Object :< cls) => cls -> IO Bool is_invisible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_is_invisible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "is_invisible" '[] (IO Bool) where nodeMethod = Godot.Core.Image.is_invisible {-# NOINLINE bindImage_load #-} -- | Loads an image from file @path@. See @url=https://docs.godotengine.org/en/latest/getting_started/workflow/assets/importing_images.html#supported-image-formats@Supported image formats@/url@ for a list of supported image formats and limitations. bindImage_load :: MethodBind bindImage_load = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "load" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads an image from file @path@. See @url=https://docs.godotengine.org/en/latest/getting_started/workflow/assets/importing_images.html#supported-image-formats@Supported image formats@/url@ for a list of supported image formats and limitations. load :: (Image :< cls, Object :< cls) => cls -> GodotString -> IO Int load cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_load (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "load" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Image.load {-# NOINLINE bindImage_load_jpg_from_buffer #-} -- | Loads an image from the binary contents of a JPEG file. bindImage_load_jpg_from_buffer :: MethodBind bindImage_load_jpg_from_buffer = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "load_jpg_from_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads an image from the binary contents of a JPEG file. load_jpg_from_buffer :: (Image :< cls, Object :< cls) => cls -> PoolByteArray -> IO Int load_jpg_from_buffer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_load_jpg_from_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "load_jpg_from_buffer" '[PoolByteArray] (IO Int) where nodeMethod = Godot.Core.Image.load_jpg_from_buffer {-# NOINLINE bindImage_load_png_from_buffer #-} -- | Loads an image from the binary contents of a PNG file. bindImage_load_png_from_buffer :: MethodBind bindImage_load_png_from_buffer = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "load_png_from_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads an image from the binary contents of a PNG file. load_png_from_buffer :: (Image :< cls, Object :< cls) => cls -> PoolByteArray -> IO Int load_png_from_buffer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_load_png_from_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "load_png_from_buffer" '[PoolByteArray] (IO Int) where nodeMethod = Godot.Core.Image.load_png_from_buffer {-# NOINLINE bindImage_load_webp_from_buffer #-} -- | Loads an image from the binary contents of a WebP file. bindImage_load_webp_from_buffer :: MethodBind bindImage_load_webp_from_buffer = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "load_webp_from_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads an image from the binary contents of a WebP file. load_webp_from_buffer :: (Image :< cls, Object :< cls) => cls -> PoolByteArray -> IO Int load_webp_from_buffer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_load_webp_from_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "load_webp_from_buffer" '[PoolByteArray] (IO Int) where nodeMethod = Godot.Core.Image.load_webp_from_buffer {-# NOINLINE bindImage_lock #-} -- | Locks the data for reading and writing access. Sends an error to the console if the image is not locked when reading or writing a pixel. bindImage_lock :: MethodBind bindImage_lock = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Locks the data for reading and writing access. Sends an error to the console if the image is not locked when reading or writing a pixel. lock :: (Image :< cls, Object :< cls) => cls -> IO () lock cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "lock" '[] (IO ()) where nodeMethod = Godot.Core.Image.lock {-# NOINLINE bindImage_normalmap_to_xy #-} -- | Converts the image's data to represent coordinates on a 3D plane. This is used when the image represents a normalmap. A normalmap can add lots of detail to a 3D surface without increasing the polygon count. bindImage_normalmap_to_xy :: MethodBind bindImage_normalmap_to_xy = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "normalmap_to_xy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Converts the image's data to represent coordinates on a 3D plane. This is used when the image represents a normalmap. A normalmap can add lots of detail to a 3D surface without increasing the polygon count. normalmap_to_xy :: (Image :< cls, Object :< cls) => cls -> IO () normalmap_to_xy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_normalmap_to_xy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "normalmap_to_xy" '[] (IO ()) where nodeMethod = Godot.Core.Image.normalmap_to_xy {-# NOINLINE bindImage_premultiply_alpha #-} -- | Multiplies color values with alpha values. Resulting color values for a pixel are @(color * alpha)/256@. bindImage_premultiply_alpha :: MethodBind bindImage_premultiply_alpha = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "premultiply_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies color values with alpha values. Resulting color values for a pixel are @(color * alpha)/256@. premultiply_alpha :: (Image :< cls, Object :< cls) => cls -> IO () premultiply_alpha cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_premultiply_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "premultiply_alpha" '[] (IO ()) where nodeMethod = Godot.Core.Image.premultiply_alpha {-# NOINLINE bindImage_resize #-} -- | Resizes the image to the given @width@ and @height@. New pixels are calculated using @interpolation@. See @interpolation@ constants. bindImage_resize :: MethodBind bindImage_resize = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "resize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resizes the image to the given @width@ and @height@. New pixels are calculated using @interpolation@. See @interpolation@ constants. resize :: (Image :< cls, Object :< cls) => cls -> Int -> Int -> Maybe Int -> IO () resize cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindImage_resize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "resize" '[Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.Image.resize {-# NOINLINE bindImage_resize_to_po2 #-} -- | Resizes the image to the nearest power of 2 for the width and height. If @square@ is @true@ then set width and height to be the same. bindImage_resize_to_po2 :: MethodBind bindImage_resize_to_po2 = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "resize_to_po2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resizes the image to the nearest power of 2 for the width and height. If @square@ is @true@ then set width and height to be the same. resize_to_po2 :: (Image :< cls, Object :< cls) => cls -> Maybe Bool -> IO () resize_to_po2 cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_resize_to_po2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "resize_to_po2" '[Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Image.resize_to_po2 {-# NOINLINE bindImage_rgbe_to_srgb #-} -- | Converts a standard RGBE (Red Green Blue Exponent) image to an sRGB image. bindImage_rgbe_to_srgb :: MethodBind bindImage_rgbe_to_srgb = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "rgbe_to_srgb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Converts a standard RGBE (Red Green Blue Exponent) image to an sRGB image. rgbe_to_srgb :: (Image :< cls, Object :< cls) => cls -> IO Image rgbe_to_srgb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_rgbe_to_srgb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "rgbe_to_srgb" '[] (IO Image) where nodeMethod = Godot.Core.Image.rgbe_to_srgb {-# NOINLINE bindImage_save_exr #-} -- | Saves the image as an EXR file to @path@. If @grayscale@ is @true@ and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. This function will return @ERR_UNAVAILABLE@ if Godot was compiled without the TinyEXR module. bindImage_save_exr :: MethodBind bindImage_save_exr = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "save_exr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the image as an EXR file to @path@. If @grayscale@ is @true@ and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. This function will return @ERR_UNAVAILABLE@ if Godot was compiled without the TinyEXR module. save_exr :: (Image :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO Int save_exr cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindImage_save_exr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "save_exr" '[GodotString, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.Image.save_exr {-# NOINLINE bindImage_save_png #-} -- | Saves the image as a PNG file to @path@. bindImage_save_png :: MethodBind bindImage_save_png = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "save_png" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the image as a PNG file to @path@. save_png :: (Image :< cls, Object :< cls) => cls -> GodotString -> IO Int save_png cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImage_save_png (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "save_png" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Image.save_png {-# NOINLINE bindImage_set_pixel #-} -- | Sets the @Color@ of the pixel at @(x, y)@ if the image is locked. Example: -- -- @ -- -- var img = Image.new() -- img.create(img_width, img_height, false, Image.FORMAT_RGBA8) -- img.lock() -- img.set_pixel(x, y, color) # Works -- img.unlock() -- img.set_pixel(x, y, color) # Does not have an effect -- -- @ bindImage_set_pixel :: MethodBind bindImage_set_pixel = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "set_pixel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Color@ of the pixel at @(x, y)@ if the image is locked. Example: -- -- @ -- -- var img = Image.new() -- img.create(img_width, img_height, false, Image.FORMAT_RGBA8) -- img.lock() -- img.set_pixel(x, y, color) # Works -- img.unlock() -- img.set_pixel(x, y, color) # Does not have an effect -- -- @ set_pixel :: (Image :< cls, Object :< cls) => cls -> Int -> Int -> Color -> IO () set_pixel cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindImage_set_pixel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "set_pixel" '[Int, Int, Color] (IO ()) where nodeMethod = Godot.Core.Image.set_pixel {-# NOINLINE bindImage_set_pixelv #-} -- | Sets the @Color@ of the pixel at @(dst.x, dst.y)@ if the image is locked. Note that the @dst@ values must be integers. Example: -- -- @ -- -- var img = Image.new() -- img.create(img_width, img_height, false, Image.FORMAT_RGBA8) -- img.lock() -- img.set_pixelv(Vector2(x, y), color) # Works -- img.unlock() -- img.set_pixelv(Vector2(x, y), color) # Does not have an effect -- -- @ bindImage_set_pixelv :: MethodBind bindImage_set_pixelv = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "set_pixelv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Color@ of the pixel at @(dst.x, dst.y)@ if the image is locked. Note that the @dst@ values must be integers. Example: -- -- @ -- -- var img = Image.new() -- img.create(img_width, img_height, false, Image.FORMAT_RGBA8) -- img.lock() -- img.set_pixelv(Vector2(x, y), color) # Works -- img.unlock() -- img.set_pixelv(Vector2(x, y), color) # Does not have an effect -- -- @ set_pixelv :: (Image :< cls, Object :< cls) => cls -> Vector2 -> Color -> IO () set_pixelv cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindImage_set_pixelv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "set_pixelv" '[Vector2, Color] (IO ()) where nodeMethod = Godot.Core.Image.set_pixelv {-# NOINLINE bindImage_shrink_x2 #-} -- | Shrinks the image by a factor of 2. bindImage_shrink_x2 :: MethodBind bindImage_shrink_x2 = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "shrink_x2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shrinks the image by a factor of 2. shrink_x2 :: (Image :< cls, Object :< cls) => cls -> IO () shrink_x2 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_shrink_x2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "shrink_x2" '[] (IO ()) where nodeMethod = Godot.Core.Image.shrink_x2 {-# NOINLINE bindImage_srgb_to_linear #-} -- | Converts the raw data from the sRGB colorspace to a linear scale. bindImage_srgb_to_linear :: MethodBind bindImage_srgb_to_linear = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "srgb_to_linear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Converts the raw data from the sRGB colorspace to a linear scale. srgb_to_linear :: (Image :< cls, Object :< cls) => cls -> IO () srgb_to_linear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_srgb_to_linear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "srgb_to_linear" '[] (IO ()) where nodeMethod = Godot.Core.Image.srgb_to_linear {-# NOINLINE bindImage_unlock #-} -- | Unlocks the data and prevents changes. bindImage_unlock :: MethodBind bindImage_unlock = unsafePerformIO $ withCString "Image" $ \ clsNamePtr -> withCString "unlock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unlocks the data and prevents changes. unlock :: (Image :< cls, Object :< cls) => cls -> IO () unlock cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImage_unlock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Image "unlock" '[] (IO ()) where nodeMethod = Godot.Core.Image.unlock ================================================ FILE: src/Godot/Core/ImageTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ImageTexture (Godot.Core.ImageTexture._STORAGE_RAW, Godot.Core.ImageTexture._STORAGE_COMPRESS_LOSSLESS, Godot.Core.ImageTexture._STORAGE_COMPRESS_LOSSY, Godot.Core.ImageTexture._reload_hook, Godot.Core.ImageTexture.create, Godot.Core.ImageTexture.create_from_image, Godot.Core.ImageTexture.get_format, Godot.Core.ImageTexture.get_lossy_storage_quality, Godot.Core.ImageTexture.get_storage, Godot.Core.ImageTexture.load, Godot.Core.ImageTexture.set_data, Godot.Core.ImageTexture.set_lossy_storage_quality, Godot.Core.ImageTexture.set_size_override, Godot.Core.ImageTexture.set_storage) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() _STORAGE_RAW :: Int _STORAGE_RAW = 0 _STORAGE_COMPRESS_LOSSLESS :: Int _STORAGE_COMPRESS_LOSSLESS = 2 _STORAGE_COMPRESS_LOSSY :: Int _STORAGE_COMPRESS_LOSSY = 1 instance NodeProperty ImageTexture "lossy_quality" Float 'False where nodeProperty = (get_lossy_storage_quality, wrapDroppingSetter set_lossy_storage_quality, Nothing) instance NodeProperty ImageTexture "storage" Int 'False where nodeProperty = (get_storage, wrapDroppingSetter set_storage, Nothing) {-# NOINLINE bindImageTexture__reload_hook #-} bindImageTexture__reload_hook :: MethodBind bindImageTexture__reload_hook = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "_reload_hook" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _reload_hook :: (ImageTexture :< cls, Object :< cls) => cls -> Rid -> IO () _reload_hook cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture__reload_hook (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "_reload_hook" '[Rid] (IO ()) where nodeMethod = Godot.Core.ImageTexture._reload_hook {-# NOINLINE bindImageTexture_create #-} -- | Create a new @ImageTexture@ with @width@ and @height@. -- @format@ is a value from @enum Image.Format@, @flags@ is any combination of @enum Texture.Flags@. bindImageTexture_create :: MethodBind bindImageTexture_create = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Create a new @ImageTexture@ with @width@ and @height@. -- @format@ is a value from @enum Image.Format@, @flags@ is any combination of @enum Texture.Flags@. create :: (ImageTexture :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Maybe Int -> IO () create cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantInt (7)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "create" '[Int, Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.ImageTexture.create {-# NOINLINE bindImageTexture_create_from_image #-} -- | Create a new @ImageTexture@ from an @Image@ with @flags@ from @enum Texture.Flags@. An sRGB to linear color space conversion can take place, according to @enum Image.Format@. bindImageTexture_create_from_image :: MethodBind bindImageTexture_create_from_image = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "create_from_image" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Create a new @ImageTexture@ from an @Image@ with @flags@ from @enum Texture.Flags@. An sRGB to linear color space conversion can take place, according to @enum Image.Format@. create_from_image :: (ImageTexture :< cls, Object :< cls) => cls -> Image -> Maybe Int -> IO () create_from_image cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (7)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_create_from_image (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "create_from_image" '[Image, Maybe Int] (IO ()) where nodeMethod = Godot.Core.ImageTexture.create_from_image {-# NOINLINE bindImageTexture_get_format #-} -- | Returns the format of the @ImageTexture@, one of @enum Image.Format@. bindImageTexture_get_format :: MethodBind bindImageTexture_get_format = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the format of the @ImageTexture@, one of @enum Image.Format@. get_format :: (ImageTexture :< cls, Object :< cls) => cls -> IO Int get_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "get_format" '[] (IO Int) where nodeMethod = Godot.Core.ImageTexture.get_format {-# NOINLINE bindImageTexture_get_lossy_storage_quality #-} -- | The storage quality for @STORAGE_COMPRESS_LOSSY@. bindImageTexture_get_lossy_storage_quality :: MethodBind bindImageTexture_get_lossy_storage_quality = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "get_lossy_storage_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The storage quality for @STORAGE_COMPRESS_LOSSY@. get_lossy_storage_quality :: (ImageTexture :< cls, Object :< cls) => cls -> IO Float get_lossy_storage_quality cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_get_lossy_storage_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "get_lossy_storage_quality" '[] (IO Float) where nodeMethod = Godot.Core.ImageTexture.get_lossy_storage_quality {-# NOINLINE bindImageTexture_get_storage #-} -- | The storage type (raw, lossy, or compressed). bindImageTexture_get_storage :: MethodBind bindImageTexture_get_storage = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "get_storage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The storage type (raw, lossy, or compressed). get_storage :: (ImageTexture :< cls, Object :< cls) => cls -> IO Int get_storage cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_get_storage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "get_storage" '[] (IO Int) where nodeMethod = Godot.Core.ImageTexture.get_storage {-# NOINLINE bindImageTexture_load #-} -- | Load an @ImageTexture@ from a file path. bindImageTexture_load :: MethodBind bindImageTexture_load = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "load" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Load an @ImageTexture@ from a file path. load :: (ImageTexture :< cls, Object :< cls) => cls -> GodotString -> IO Int load cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_load (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "load" '[GodotString] (IO Int) where nodeMethod = Godot.Core.ImageTexture.load {-# NOINLINE bindImageTexture_set_data #-} -- | Sets the @Image@ of this @ImageTexture@. bindImageTexture_set_data :: MethodBind bindImageTexture_set_data = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Image@ of this @ImageTexture@. set_data :: (ImageTexture :< cls, Object :< cls) => cls -> Image -> IO () set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "set_data" '[Image] (IO ()) where nodeMethod = Godot.Core.ImageTexture.set_data {-# NOINLINE bindImageTexture_set_lossy_storage_quality #-} -- | The storage quality for @STORAGE_COMPRESS_LOSSY@. bindImageTexture_set_lossy_storage_quality :: MethodBind bindImageTexture_set_lossy_storage_quality = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "set_lossy_storage_quality" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The storage quality for @STORAGE_COMPRESS_LOSSY@. set_lossy_storage_quality :: (ImageTexture :< cls, Object :< cls) => cls -> Float -> IO () set_lossy_storage_quality cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_set_lossy_storage_quality (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "set_lossy_storage_quality" '[Float] (IO ()) where nodeMethod = Godot.Core.ImageTexture.set_lossy_storage_quality {-# NOINLINE bindImageTexture_set_size_override #-} -- | Resizes the @ImageTexture@ to the specified dimensions. bindImageTexture_set_size_override :: MethodBind bindImageTexture_set_size_override = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "set_size_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resizes the @ImageTexture@ to the specified dimensions. set_size_override :: (ImageTexture :< cls, Object :< cls) => cls -> Vector2 -> IO () set_size_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_set_size_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "set_size_override" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ImageTexture.set_size_override {-# NOINLINE bindImageTexture_set_storage #-} -- | The storage type (raw, lossy, or compressed). bindImageTexture_set_storage :: MethodBind bindImageTexture_set_storage = unsafePerformIO $ withCString "ImageTexture" $ \ clsNamePtr -> withCString "set_storage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The storage type (raw, lossy, or compressed). set_storage :: (ImageTexture :< cls, Object :< cls) => cls -> Int -> IO () set_storage cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImageTexture_set_storage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImageTexture "set_storage" '[Int] (IO ()) where nodeMethod = Godot.Core.ImageTexture.set_storage ================================================ FILE: src/Godot/Core/ImmediateGeometry.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ImmediateGeometry (Godot.Core.ImmediateGeometry.add_sphere, Godot.Core.ImmediateGeometry.add_vertex, Godot.Core.ImmediateGeometry.begin, Godot.Core.ImmediateGeometry.clear, Godot.Core.ImmediateGeometry.end, Godot.Core.ImmediateGeometry.set_color, Godot.Core.ImmediateGeometry.set_normal, Godot.Core.ImmediateGeometry.set_tangent, Godot.Core.ImmediateGeometry.set_uv, Godot.Core.ImmediateGeometry.set_uv2) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.GeometryInstance() {-# NOINLINE bindImmediateGeometry_add_sphere #-} -- | Simple helper to draw an UV sphere with given latitude, longitude and radius. bindImmediateGeometry_add_sphere :: MethodBind bindImmediateGeometry_add_sphere = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "add_sphere" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Simple helper to draw an UV sphere with given latitude, longitude and radius. add_sphere :: (ImmediateGeometry :< cls, Object :< cls) => cls -> Int -> Int -> Float -> Maybe Bool -> IO () add_sphere cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantBool True) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_add_sphere (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "add_sphere" '[Int, Int, Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.add_sphere {-# NOINLINE bindImmediateGeometry_add_vertex #-} -- | Adds a vertex in local coordinate space with the currently set color/uv/etc. bindImmediateGeometry_add_vertex :: MethodBind bindImmediateGeometry_add_vertex = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "add_vertex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a vertex in local coordinate space with the currently set color/uv/etc. add_vertex :: (ImmediateGeometry :< cls, Object :< cls) => cls -> Vector3 -> IO () add_vertex cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_add_vertex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "add_vertex" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.add_vertex {-# NOINLINE bindImmediateGeometry_begin #-} -- | Begin drawing (and optionally pass a texture override). When done call @method end@. For more information on how this works, search for @glBegin()@ and @glEnd()@ references. -- For the type of primitive, see the @enum Mesh.PrimitiveType@ enum. bindImmediateGeometry_begin :: MethodBind bindImmediateGeometry_begin = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Begin drawing (and optionally pass a texture override). When done call @method end@. For more information on how this works, search for @glBegin()@ and @glEnd()@ references. -- For the type of primitive, see the @enum Mesh.PrimitiveType@ enum. begin :: (ImmediateGeometry :< cls, Object :< cls) => cls -> Int -> Maybe Texture -> IO () begin cls arg1 arg2 = withVariantArray [toVariant arg1, maybe VariantNil toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "begin" '[Int, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.begin {-# NOINLINE bindImmediateGeometry_clear #-} -- | Clears everything that was drawn using begin/end. bindImmediateGeometry_clear :: MethodBind bindImmediateGeometry_clear = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears everything that was drawn using begin/end. clear :: (ImmediateGeometry :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "clear" '[] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.clear {-# NOINLINE bindImmediateGeometry_end #-} -- | Ends a drawing context and displays the results. bindImmediateGeometry_end :: MethodBind bindImmediateGeometry_end = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Ends a drawing context and displays the results. end :: (ImmediateGeometry :< cls, Object :< cls) => cls -> IO () end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "end" '[] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.end {-# NOINLINE bindImmediateGeometry_set_color #-} -- | The current drawing color. bindImmediateGeometry_set_color :: MethodBind bindImmediateGeometry_set_color = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current drawing color. set_color :: (ImmediateGeometry :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.set_color {-# NOINLINE bindImmediateGeometry_set_normal #-} -- | The next vertex's normal. bindImmediateGeometry_set_normal :: MethodBind bindImmediateGeometry_set_normal = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "set_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The next vertex's normal. set_normal :: (ImmediateGeometry :< cls, Object :< cls) => cls -> Vector3 -> IO () set_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_set_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "set_normal" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.set_normal {-# NOINLINE bindImmediateGeometry_set_tangent #-} -- | The next vertex's tangent (and binormal facing). bindImmediateGeometry_set_tangent :: MethodBind bindImmediateGeometry_set_tangent = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "set_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The next vertex's tangent (and binormal facing). set_tangent :: (ImmediateGeometry :< cls, Object :< cls) => cls -> Plane -> IO () set_tangent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_set_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "set_tangent" '[Plane] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.set_tangent {-# NOINLINE bindImmediateGeometry_set_uv #-} -- | The next vertex's UV. bindImmediateGeometry_set_uv :: MethodBind bindImmediateGeometry_set_uv = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "set_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The next vertex's UV. set_uv :: (ImmediateGeometry :< cls, Object :< cls) => cls -> Vector2 -> IO () set_uv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_set_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "set_uv" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.set_uv {-# NOINLINE bindImmediateGeometry_set_uv2 #-} -- | The next vertex's second layer UV. bindImmediateGeometry_set_uv2 :: MethodBind bindImmediateGeometry_set_uv2 = unsafePerformIO $ withCString "ImmediateGeometry" $ \ clsNamePtr -> withCString "set_uv2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The next vertex's second layer UV. set_uv2 :: (ImmediateGeometry :< cls, Object :< cls) => cls -> Vector2 -> IO () set_uv2 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindImmediateGeometry_set_uv2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ImmediateGeometry "set_uv2" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ImmediateGeometry.set_uv2 ================================================ FILE: src/Godot/Core/Input.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Input (Godot.Core.Input._CURSOR_MOVE, Godot.Core.Input._CURSOR_ARROW, Godot.Core.Input._CURSOR_IBEAM, Godot.Core.Input._CURSOR_HSPLIT, Godot.Core.Input._CURSOR_DRAG, Godot.Core.Input._CURSOR_BUSY, Godot.Core.Input._MOUSE_MODE_CONFINED, Godot.Core.Input._CURSOR_CROSS, Godot.Core.Input._CURSOR_WAIT, Godot.Core.Input._CURSOR_BDIAGSIZE, Godot.Core.Input._CURSOR_HELP, Godot.Core.Input._MOUSE_MODE_VISIBLE, Godot.Core.Input._CURSOR_CAN_DROP, Godot.Core.Input._MOUSE_MODE_CAPTURED, Godot.Core.Input._CURSOR_POINTING_HAND, Godot.Core.Input._CURSOR_FDIAGSIZE, Godot.Core.Input._CURSOR_HSIZE, Godot.Core.Input._MOUSE_MODE_HIDDEN, Godot.Core.Input._CURSOR_FORBIDDEN, Godot.Core.Input._CURSOR_VSIZE, Godot.Core.Input._CURSOR_VSPLIT, Godot.Core.Input.sig_joy_connection_changed, Godot.Core.Input.action_press, Godot.Core.Input.action_release, Godot.Core.Input.add_joy_mapping, Godot.Core.Input.get_accelerometer, Godot.Core.Input.get_action_strength, Godot.Core.Input.get_connected_joypads, Godot.Core.Input.get_current_cursor_shape, Godot.Core.Input.get_gravity, Godot.Core.Input.get_gyroscope, Godot.Core.Input.get_joy_axis, Godot.Core.Input.get_joy_axis_index_from_string, Godot.Core.Input.get_joy_axis_string, Godot.Core.Input.get_joy_button_index_from_string, Godot.Core.Input.get_joy_button_string, Godot.Core.Input.get_joy_guid, Godot.Core.Input.get_joy_name, Godot.Core.Input.get_joy_vibration_duration, Godot.Core.Input.get_joy_vibration_strength, Godot.Core.Input.get_last_mouse_speed, Godot.Core.Input.get_magnetometer, Godot.Core.Input.get_mouse_button_mask, Godot.Core.Input.get_mouse_mode, Godot.Core.Input.is_action_just_pressed, Godot.Core.Input.is_action_just_released, Godot.Core.Input.is_action_pressed, Godot.Core.Input.is_joy_button_pressed, Godot.Core.Input.is_joy_known, Godot.Core.Input.is_key_pressed, Godot.Core.Input.is_mouse_button_pressed, Godot.Core.Input.joy_connection_changed, Godot.Core.Input.parse_input_event, Godot.Core.Input.remove_joy_mapping, Godot.Core.Input.set_custom_mouse_cursor, Godot.Core.Input.set_default_cursor_shape, Godot.Core.Input.set_mouse_mode, Godot.Core.Input.set_use_accumulated_input, Godot.Core.Input.start_joy_vibration, Godot.Core.Input.stop_joy_vibration, Godot.Core.Input.vibrate_handheld, Godot.Core.Input.warp_mouse_position) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _CURSOR_MOVE :: Int _CURSOR_MOVE = 13 _CURSOR_ARROW :: Int _CURSOR_ARROW = 0 _CURSOR_IBEAM :: Int _CURSOR_IBEAM = 1 _CURSOR_HSPLIT :: Int _CURSOR_HSPLIT = 15 _CURSOR_DRAG :: Int _CURSOR_DRAG = 6 _CURSOR_BUSY :: Int _CURSOR_BUSY = 5 _MOUSE_MODE_CONFINED :: Int _MOUSE_MODE_CONFINED = 3 _CURSOR_CROSS :: Int _CURSOR_CROSS = 3 _CURSOR_WAIT :: Int _CURSOR_WAIT = 4 _CURSOR_BDIAGSIZE :: Int _CURSOR_BDIAGSIZE = 11 _CURSOR_HELP :: Int _CURSOR_HELP = 16 _MOUSE_MODE_VISIBLE :: Int _MOUSE_MODE_VISIBLE = 0 _CURSOR_CAN_DROP :: Int _CURSOR_CAN_DROP = 7 _MOUSE_MODE_CAPTURED :: Int _MOUSE_MODE_CAPTURED = 2 _CURSOR_POINTING_HAND :: Int _CURSOR_POINTING_HAND = 2 _CURSOR_FDIAGSIZE :: Int _CURSOR_FDIAGSIZE = 12 _CURSOR_HSIZE :: Int _CURSOR_HSIZE = 10 _MOUSE_MODE_HIDDEN :: Int _MOUSE_MODE_HIDDEN = 1 _CURSOR_FORBIDDEN :: Int _CURSOR_FORBIDDEN = 8 _CURSOR_VSIZE :: Int _CURSOR_VSIZE = 9 _CURSOR_VSPLIT :: Int _CURSOR_VSPLIT = 14 -- | Emitted when a joypad device has been connected or disconnected. sig_joy_connection_changed :: Godot.Internal.Dispatch.Signal Input sig_joy_connection_changed = Godot.Internal.Dispatch.Signal "joy_connection_changed" instance NodeSignal Input "joy_connection_changed" '[Int, Bool] {-# NOINLINE bindInput_action_press #-} -- | This will simulate pressing the specified action. -- The strength can be used for non-boolean actions, it's ranged between 0 and 1 representing the intensity of the given action. -- __Note:__ This method will not cause any @method Node._input@ calls. It is intended to be used with @method is_action_pressed@ and @method is_action_just_pressed@. If you want to simulate @_input@, use @method parse_input_event@ instead. bindInput_action_press :: MethodBind bindInput_action_press = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "action_press" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This will simulate pressing the specified action. -- The strength can be used for non-boolean actions, it's ranged between 0 and 1 representing the intensity of the given action. -- __Note:__ This method will not cause any @method Node._input@ calls. It is intended to be used with @method is_action_pressed@ and @method is_action_just_pressed@. If you want to simulate @_input@, use @method parse_input_event@ instead. action_press :: (Input :< cls, Object :< cls) => cls -> GodotString -> Maybe Float -> IO () action_press cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantReal (1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInput_action_press (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "action_press" '[GodotString, Maybe Float] (IO ()) where nodeMethod = Godot.Core.Input.action_press {-# NOINLINE bindInput_action_release #-} -- | If the specified action is already pressed, this will release it. bindInput_action_release :: MethodBind bindInput_action_release = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "action_release" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the specified action is already pressed, this will release it. action_release :: (Input :< cls, Object :< cls) => cls -> GodotString -> IO () action_release cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_action_release (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "action_release" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Input.action_release {-# NOINLINE bindInput_add_joy_mapping #-} -- | Adds a new mapping entry (in SDL2 format) to the mapping database. Optionally update already connected devices. bindInput_add_joy_mapping :: MethodBind bindInput_add_joy_mapping = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "add_joy_mapping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new mapping entry (in SDL2 format) to the mapping database. Optionally update already connected devices. add_joy_mapping :: (Input :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO () add_joy_mapping cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInput_add_joy_mapping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "add_joy_mapping" '[GodotString, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Input.add_joy_mapping {-# NOINLINE bindInput_get_accelerometer #-} -- | Returns the acceleration of the device's accelerometer, if the device has one. Otherwise, the method returns @Vector3.ZERO@. -- Note this method returns an empty @Vector3@ when running from the editor even when your device has an accelerometer. You must export your project to a supported device to read values from the accelerometer. -- __Note:__ This method only works on iOS, Android, and UWP. On other platforms, it always returns @Vector3.ZERO@. bindInput_get_accelerometer :: MethodBind bindInput_get_accelerometer = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_accelerometer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the acceleration of the device's accelerometer, if the device has one. Otherwise, the method returns @Vector3.ZERO@. -- Note this method returns an empty @Vector3@ when running from the editor even when your device has an accelerometer. You must export your project to a supported device to read values from the accelerometer. -- __Note:__ This method only works on iOS, Android, and UWP. On other platforms, it always returns @Vector3.ZERO@. get_accelerometer :: (Input :< cls, Object :< cls) => cls -> IO Vector3 get_accelerometer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_accelerometer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_accelerometer" '[] (IO Vector3) where nodeMethod = Godot.Core.Input.get_accelerometer {-# NOINLINE bindInput_get_action_strength #-} -- | Returns a value between 0 and 1 representing the intensity of the given action. In a joypad, for example, the further away the axis (analog sticks or L2, R2 triggers) is from the dead zone, the closer the value will be to 1. If the action is mapped to a control that has no axis as the keyboard, the value returned will be 0 or 1. bindInput_get_action_strength :: MethodBind bindInput_get_action_strength = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_action_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a value between 0 and 1 representing the intensity of the given action. In a joypad, for example, the further away the axis (analog sticks or L2, R2 triggers) is from the dead zone, the closer the value will be to 1. If the action is mapped to a control that has no axis as the keyboard, the value returned will be 0 or 1. get_action_strength :: (Input :< cls, Object :< cls) => cls -> GodotString -> IO Float get_action_strength cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_action_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_action_strength" '[GodotString] (IO Float) where nodeMethod = Godot.Core.Input.get_action_strength {-# NOINLINE bindInput_get_connected_joypads #-} -- | Returns an @Array@ containing the device IDs of all currently connected joypads. bindInput_get_connected_joypads :: MethodBind bindInput_get_connected_joypads = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_connected_joypads" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ containing the device IDs of all currently connected joypads. get_connected_joypads :: (Input :< cls, Object :< cls) => cls -> IO Array get_connected_joypads cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_connected_joypads (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_connected_joypads" '[] (IO Array) where nodeMethod = Godot.Core.Input.get_connected_joypads {-# NOINLINE bindInput_get_current_cursor_shape #-} -- | Returns the currently assigned cursor shape (see @enum CursorShape@). bindInput_get_current_cursor_shape :: MethodBind bindInput_get_current_cursor_shape = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_current_cursor_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the currently assigned cursor shape (see @enum CursorShape@). get_current_cursor_shape :: (Input :< cls, Object :< cls) => cls -> IO Int get_current_cursor_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_current_cursor_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_current_cursor_shape" '[] (IO Int) where nodeMethod = Godot.Core.Input.get_current_cursor_shape {-# NOINLINE bindInput_get_gravity #-} -- | Returns the gravity of the device's accelerometer, if the device has one. Otherwise, the method returns @Vector3.ZERO@. -- __Note:__ This method only works on Android and iOS. On other platforms, it always returns @Vector3.ZERO@. bindInput_get_gravity :: MethodBind bindInput_get_gravity = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the gravity of the device's accelerometer, if the device has one. Otherwise, the method returns @Vector3.ZERO@. -- __Note:__ This method only works on Android and iOS. On other platforms, it always returns @Vector3.ZERO@. get_gravity :: (Input :< cls, Object :< cls) => cls -> IO Vector3 get_gravity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_gravity" '[] (IO Vector3) where nodeMethod = Godot.Core.Input.get_gravity {-# NOINLINE bindInput_get_gyroscope #-} -- | Returns the rotation rate in rad/s around a device's X, Y, and Z axes of the gyroscope, if the device has one. Otherwise, the method returns @Vector3.ZERO@. -- __Note:__ This method only works on Android. On other platforms, it always returns @Vector3.ZERO@. bindInput_get_gyroscope :: MethodBind bindInput_get_gyroscope = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_gyroscope" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the rotation rate in rad/s around a device's X, Y, and Z axes of the gyroscope, if the device has one. Otherwise, the method returns @Vector3.ZERO@. -- __Note:__ This method only works on Android. On other platforms, it always returns @Vector3.ZERO@. get_gyroscope :: (Input :< cls, Object :< cls) => cls -> IO Vector3 get_gyroscope cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_gyroscope (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_gyroscope" '[] (IO Vector3) where nodeMethod = Godot.Core.Input.get_gyroscope {-# NOINLINE bindInput_get_joy_axis #-} -- | Returns the current value of the joypad axis at given index (see @enum JoystickList@). bindInput_get_joy_axis :: MethodBind bindInput_get_joy_axis = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_axis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current value of the joypad axis at given index (see @enum JoystickList@). get_joy_axis :: (Input :< cls, Object :< cls) => cls -> Int -> Int -> IO Float get_joy_axis cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_axis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_axis" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.Input.get_joy_axis {-# NOINLINE bindInput_get_joy_axis_index_from_string #-} -- | Returns the index of the provided axis name. bindInput_get_joy_axis_index_from_string :: MethodBind bindInput_get_joy_axis_index_from_string = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_axis_index_from_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the provided axis name. get_joy_axis_index_from_string :: (Input :< cls, Object :< cls) => cls -> GodotString -> IO Int get_joy_axis_index_from_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_axis_index_from_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_axis_index_from_string" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Input.get_joy_axis_index_from_string {-# NOINLINE bindInput_get_joy_axis_string #-} -- | Receives a @enum JoystickList@ axis and returns its equivalent name as a string. bindInput_get_joy_axis_string :: MethodBind bindInput_get_joy_axis_string = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_axis_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Receives a @enum JoystickList@ axis and returns its equivalent name as a string. get_joy_axis_string :: (Input :< cls, Object :< cls) => cls -> Int -> IO GodotString get_joy_axis_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_axis_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_axis_string" '[Int] (IO GodotString) where nodeMethod = Godot.Core.Input.get_joy_axis_string {-# NOINLINE bindInput_get_joy_button_index_from_string #-} -- | Returns the index of the provided button name. bindInput_get_joy_button_index_from_string :: MethodBind bindInput_get_joy_button_index_from_string = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_button_index_from_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the provided button name. get_joy_button_index_from_string :: (Input :< cls, Object :< cls) => cls -> GodotString -> IO Int get_joy_button_index_from_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_button_index_from_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_button_index_from_string" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Input.get_joy_button_index_from_string {-# NOINLINE bindInput_get_joy_button_string #-} -- | Receives a gamepad button from @enum JoystickList@ and returns its equivalent name as a string. bindInput_get_joy_button_string :: MethodBind bindInput_get_joy_button_string = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_button_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Receives a gamepad button from @enum JoystickList@ and returns its equivalent name as a string. get_joy_button_string :: (Input :< cls, Object :< cls) => cls -> Int -> IO GodotString get_joy_button_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_button_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_button_string" '[Int] (IO GodotString) where nodeMethod = Godot.Core.Input.get_joy_button_string {-# NOINLINE bindInput_get_joy_guid #-} -- | Returns a SDL2-compatible device GUID on platforms that use gamepad remapping. Returns @"Default Gamepad"@ otherwise. bindInput_get_joy_guid :: MethodBind bindInput_get_joy_guid = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_guid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a SDL2-compatible device GUID on platforms that use gamepad remapping. Returns @"Default Gamepad"@ otherwise. get_joy_guid :: (Input :< cls, Object :< cls) => cls -> Int -> IO GodotString get_joy_guid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_guid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_guid" '[Int] (IO GodotString) where nodeMethod = Godot.Core.Input.get_joy_guid {-# NOINLINE bindInput_get_joy_name #-} -- | Returns the name of the joypad at the specified device index. bindInput_get_joy_name :: MethodBind bindInput_get_joy_name = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the joypad at the specified device index. get_joy_name :: (Input :< cls, Object :< cls) => cls -> Int -> IO GodotString get_joy_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.Input.get_joy_name {-# NOINLINE bindInput_get_joy_vibration_duration #-} -- | Returns the duration of the current vibration effect in seconds. bindInput_get_joy_vibration_duration :: MethodBind bindInput_get_joy_vibration_duration = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_vibration_duration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the duration of the current vibration effect in seconds. get_joy_vibration_duration :: (Input :< cls, Object :< cls) => cls -> Int -> IO Float get_joy_vibration_duration cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_vibration_duration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_vibration_duration" '[Int] (IO Float) where nodeMethod = Godot.Core.Input.get_joy_vibration_duration {-# NOINLINE bindInput_get_joy_vibration_strength #-} -- | Returns the strength of the joypad vibration: x is the strength of the weak motor, and y is the strength of the strong motor. bindInput_get_joy_vibration_strength :: MethodBind bindInput_get_joy_vibration_strength = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_joy_vibration_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the strength of the joypad vibration: x is the strength of the weak motor, and y is the strength of the strong motor. get_joy_vibration_strength :: (Input :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_joy_vibration_strength cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_joy_vibration_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_joy_vibration_strength" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Input.get_joy_vibration_strength {-# NOINLINE bindInput_get_last_mouse_speed #-} -- | Returns the mouse speed for the last time the cursor was moved, and this until the next frame where the mouse moves. This means that even if the mouse is not moving, this function will still return the value of the last motion. bindInput_get_last_mouse_speed :: MethodBind bindInput_get_last_mouse_speed = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_last_mouse_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the mouse speed for the last time the cursor was moved, and this until the next frame where the mouse moves. This means that even if the mouse is not moving, this function will still return the value of the last motion. get_last_mouse_speed :: (Input :< cls, Object :< cls) => cls -> IO Vector2 get_last_mouse_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_last_mouse_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_last_mouse_speed" '[] (IO Vector2) where nodeMethod = Godot.Core.Input.get_last_mouse_speed {-# NOINLINE bindInput_get_magnetometer #-} -- | Returns the the magnetic field strength in micro-Tesla for all axes of the device's magnetometer, if the device has one. Otherwise, the method returns @Vector3.ZERO@. -- __Note:__ This method only works on Android and UWP. On other platforms, it always returns @Vector3.ZERO@. bindInput_get_magnetometer :: MethodBind bindInput_get_magnetometer = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_magnetometer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the the magnetic field strength in micro-Tesla for all axes of the device's magnetometer, if the device has one. Otherwise, the method returns @Vector3.ZERO@. -- __Note:__ This method only works on Android and UWP. On other platforms, it always returns @Vector3.ZERO@. get_magnetometer :: (Input :< cls, Object :< cls) => cls -> IO Vector3 get_magnetometer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_magnetometer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_magnetometer" '[] (IO Vector3) where nodeMethod = Godot.Core.Input.get_magnetometer {-# NOINLINE bindInput_get_mouse_button_mask #-} -- | Returns mouse buttons as a bitmask. If multiple mouse buttons are pressed at the same time, the bits are added together. bindInput_get_mouse_button_mask :: MethodBind bindInput_get_mouse_button_mask = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_mouse_button_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns mouse buttons as a bitmask. If multiple mouse buttons are pressed at the same time, the bits are added together. get_mouse_button_mask :: (Input :< cls, Object :< cls) => cls -> IO Int get_mouse_button_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_mouse_button_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_mouse_button_mask" '[] (IO Int) where nodeMethod = Godot.Core.Input.get_mouse_button_mask {-# NOINLINE bindInput_get_mouse_mode #-} -- | Returns the mouse mode. See the constants for more information. bindInput_get_mouse_mode :: MethodBind bindInput_get_mouse_mode = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "get_mouse_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the mouse mode. See the constants for more information. get_mouse_mode :: (Input :< cls, Object :< cls) => cls -> IO Int get_mouse_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInput_get_mouse_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "get_mouse_mode" '[] (IO Int) where nodeMethod = Godot.Core.Input.get_mouse_mode {-# NOINLINE bindInput_is_action_just_pressed #-} -- | Returns @true@ when the user starts pressing the action event, meaning it's @true@ only on the frame that the user pressed down the button. -- This is useful for code that needs to run only once when an action is pressed, instead of every frame while it's pressed. bindInput_is_action_just_pressed :: MethodBind bindInput_is_action_just_pressed = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "is_action_just_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ when the user starts pressing the action event, meaning it's @true@ only on the frame that the user pressed down the button. -- This is useful for code that needs to run only once when an action is pressed, instead of every frame while it's pressed. is_action_just_pressed :: (Input :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_action_just_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_is_action_just_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "is_action_just_pressed" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Input.is_action_just_pressed {-# NOINLINE bindInput_is_action_just_released #-} -- | Returns @true@ when the user stops pressing the action event, meaning it's @true@ only on the frame that the user released the button. bindInput_is_action_just_released :: MethodBind bindInput_is_action_just_released = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "is_action_just_released" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ when the user stops pressing the action event, meaning it's @true@ only on the frame that the user released the button. is_action_just_released :: (Input :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_action_just_released cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_is_action_just_released (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "is_action_just_released" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Input.is_action_just_released {-# NOINLINE bindInput_is_action_pressed #-} -- | Returns @true@ if you are pressing the action event. Note that if an action has multiple buttons assigned and more than one of them is pressed, releasing one button will release the action, even if some other button assigned to this action is still pressed. bindInput_is_action_pressed :: MethodBind bindInput_is_action_pressed = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "is_action_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if you are pressing the action event. Note that if an action has multiple buttons assigned and more than one of them is pressed, releasing one button will release the action, even if some other button assigned to this action is still pressed. is_action_pressed :: (Input :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_action_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_is_action_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "is_action_pressed" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Input.is_action_pressed {-# NOINLINE bindInput_is_joy_button_pressed #-} -- | Returns @true@ if you are pressing the joypad button (see @enum JoystickList@). bindInput_is_joy_button_pressed :: MethodBind bindInput_is_joy_button_pressed = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "is_joy_button_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if you are pressing the joypad button (see @enum JoystickList@). is_joy_button_pressed :: (Input :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool is_joy_button_pressed cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInput_is_joy_button_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "is_joy_button_pressed" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.Input.is_joy_button_pressed {-# NOINLINE bindInput_is_joy_known #-} -- | Returns @true@ if the system knows the specified device. This means that it sets all button and axis indices exactly as defined in @enum JoystickList@. Unknown joypads are not expected to match these constants, but you can still retrieve events from them. bindInput_is_joy_known :: MethodBind bindInput_is_joy_known = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "is_joy_known" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the system knows the specified device. This means that it sets all button and axis indices exactly as defined in @enum JoystickList@. Unknown joypads are not expected to match these constants, but you can still retrieve events from them. is_joy_known :: (Input :< cls, Object :< cls) => cls -> Int -> IO Bool is_joy_known cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_is_joy_known (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "is_joy_known" '[Int] (IO Bool) where nodeMethod = Godot.Core.Input.is_joy_known {-# NOINLINE bindInput_is_key_pressed #-} -- | Returns @true@ if you are pressing the key. You can pass a @enum KeyList@ constant. bindInput_is_key_pressed :: MethodBind bindInput_is_key_pressed = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "is_key_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if you are pressing the key. You can pass a @enum KeyList@ constant. is_key_pressed :: (Input :< cls, Object :< cls) => cls -> Int -> IO Bool is_key_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_is_key_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "is_key_pressed" '[Int] (IO Bool) where nodeMethod = Godot.Core.Input.is_key_pressed {-# NOINLINE bindInput_is_mouse_button_pressed #-} -- | Returns @true@ if you are pressing the mouse button specified with @enum ButtonList@. bindInput_is_mouse_button_pressed :: MethodBind bindInput_is_mouse_button_pressed = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "is_mouse_button_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if you are pressing the mouse button specified with @enum ButtonList@. is_mouse_button_pressed :: (Input :< cls, Object :< cls) => cls -> Int -> IO Bool is_mouse_button_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_is_mouse_button_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "is_mouse_button_pressed" '[Int] (IO Bool) where nodeMethod = Godot.Core.Input.is_mouse_button_pressed {-# NOINLINE bindInput_joy_connection_changed #-} -- | Notifies the @Input@ singleton that a connection has changed, to update the state for the @device@ index. -- This is used internally and should not have to be called from user scripts. See @signal joy_connection_changed@ for the signal emitted when this is triggered internally. bindInput_joy_connection_changed :: MethodBind bindInput_joy_connection_changed = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "joy_connection_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Notifies the @Input@ singleton that a connection has changed, to update the state for the @device@ index. -- This is used internally and should not have to be called from user scripts. See @signal joy_connection_changed@ for the signal emitted when this is triggered internally. joy_connection_changed :: (Input :< cls, Object :< cls) => cls -> Int -> Bool -> GodotString -> GodotString -> IO () joy_connection_changed cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindInput_joy_connection_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "joy_connection_changed" '[Int, Bool, GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.Input.joy_connection_changed {-# NOINLINE bindInput_parse_input_event #-} -- | Feeds an @InputEvent@ to the game. Can be used to artificially trigger input events from code. Also generates @method Node._input@ calls. -- Example: -- -- @ -- -- var a = InputEventAction.new() -- a.action = "ui_cancel" -- a.pressed = true -- Input.parse_input_event(a) -- -- @ bindInput_parse_input_event :: MethodBind bindInput_parse_input_event = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "parse_input_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Feeds an @InputEvent@ to the game. Can be used to artificially trigger input events from code. Also generates @method Node._input@ calls. -- Example: -- -- @ -- -- var a = InputEventAction.new() -- a.action = "ui_cancel" -- a.pressed = true -- Input.parse_input_event(a) -- -- @ parse_input_event :: (Input :< cls, Object :< cls) => cls -> InputEvent -> IO () parse_input_event cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_parse_input_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "parse_input_event" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Input.parse_input_event {-# NOINLINE bindInput_remove_joy_mapping #-} -- | Removes all mappings from the internal database that match the given GUID. bindInput_remove_joy_mapping :: MethodBind bindInput_remove_joy_mapping = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "remove_joy_mapping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all mappings from the internal database that match the given GUID. remove_joy_mapping :: (Input :< cls, Object :< cls) => cls -> GodotString -> IO () remove_joy_mapping cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_remove_joy_mapping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "remove_joy_mapping" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Input.remove_joy_mapping {-# NOINLINE bindInput_set_custom_mouse_cursor #-} -- | Sets a custom mouse cursor image, which is only visible inside the game window. The hotspot can also be specified. Passing @null@ to the image parameter resets to the system cursor. See @enum CursorShape@ for the list of shapes. -- @image@'s size must be lower than 256×256. -- @hotspot@ must be within @image@'s size. -- __Note:__ @AnimatedTexture@s aren't supported as custom mouse cursors. If using an @AnimatedTexture@, only the first frame will be displayed. -- __Note:__ Only images imported with the __Lossless__, __Lossy__ or __Uncompressed__ compression modes are supported. The __Video RAM__ compression mode can't be used for custom cursors. bindInput_set_custom_mouse_cursor :: MethodBind bindInput_set_custom_mouse_cursor = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "set_custom_mouse_cursor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a custom mouse cursor image, which is only visible inside the game window. The hotspot can also be specified. Passing @null@ to the image parameter resets to the system cursor. See @enum CursorShape@ for the list of shapes. -- @image@'s size must be lower than 256×256. -- @hotspot@ must be within @image@'s size. -- __Note:__ @AnimatedTexture@s aren't supported as custom mouse cursors. If using an @AnimatedTexture@, only the first frame will be displayed. -- __Note:__ Only images imported with the __Lossless__, __Lossy__ or __Uncompressed__ compression modes are supported. The __Video RAM__ compression mode can't be used for custom cursors. set_custom_mouse_cursor :: (Input :< cls, Object :< cls) => cls -> Resource -> Maybe Int -> Maybe Vector2 -> IO () set_custom_mouse_cursor cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, defaultedVariant VariantVector2 (V2 0 0) arg3] (\ (arrPtr, len) -> godot_method_bind_call bindInput_set_custom_mouse_cursor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "set_custom_mouse_cursor" '[Resource, Maybe Int, Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.Input.set_custom_mouse_cursor {-# NOINLINE bindInput_set_default_cursor_shape #-} -- | Sets the default cursor shape to be used in the viewport instead of @CURSOR_ARROW@. -- __Note:__ If you want to change the default cursor shape for @Control@'s nodes, use @Control.mouse_default_cursor_shape@ instead. -- __Note:__ This method generates an @InputEventMouseMotion@ to update cursor immediately. bindInput_set_default_cursor_shape :: MethodBind bindInput_set_default_cursor_shape = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "set_default_cursor_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the default cursor shape to be used in the viewport instead of @CURSOR_ARROW@. -- __Note:__ If you want to change the default cursor shape for @Control@'s nodes, use @Control.mouse_default_cursor_shape@ instead. -- __Note:__ This method generates an @InputEventMouseMotion@ to update cursor immediately. set_default_cursor_shape :: (Input :< cls, Object :< cls) => cls -> Maybe Int -> IO () set_default_cursor_shape cls arg1 = withVariantArray [maybe (VariantInt (0)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_set_default_cursor_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "set_default_cursor_shape" '[Maybe Int] (IO ()) where nodeMethod = Godot.Core.Input.set_default_cursor_shape {-# NOINLINE bindInput_set_mouse_mode #-} -- | Sets the mouse mode. See the constants for more information. bindInput_set_mouse_mode :: MethodBind bindInput_set_mouse_mode = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "set_mouse_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the mouse mode. See the constants for more information. set_mouse_mode :: (Input :< cls, Object :< cls) => cls -> Int -> IO () set_mouse_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_set_mouse_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "set_mouse_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Input.set_mouse_mode {-# NOINLINE bindInput_set_use_accumulated_input #-} -- | Enables or disables the accumulation of similar input events sent by the operating system. When input accumulation is enabled, all input events generated during a frame will be merged and emitted when the frame is done rendering. Therefore, this limits the number of input method calls per second to the rendering FPS. -- Input accumulation is enabled by default. It can be disabled to get slightly more precise/reactive input at the cost of increased CPU usage. In applications where drawing freehand lines is required, input accumulation should generally be disabled while the user is drawing the line to get results that closely follow the actual input. bindInput_set_use_accumulated_input :: MethodBind bindInput_set_use_accumulated_input = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "set_use_accumulated_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables the accumulation of similar input events sent by the operating system. When input accumulation is enabled, all input events generated during a frame will be merged and emitted when the frame is done rendering. Therefore, this limits the number of input method calls per second to the rendering FPS. -- Input accumulation is enabled by default. It can be disabled to get slightly more precise/reactive input at the cost of increased CPU usage. In applications where drawing freehand lines is required, input accumulation should generally be disabled while the user is drawing the line to get results that closely follow the actual input. set_use_accumulated_input :: (Input :< cls, Object :< cls) => cls -> Bool -> IO () set_use_accumulated_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_set_use_accumulated_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "set_use_accumulated_input" '[Bool] (IO ()) where nodeMethod = Godot.Core.Input.set_use_accumulated_input {-# NOINLINE bindInput_start_joy_vibration #-} -- | Starts to vibrate the joypad. Joypads usually come with two rumble motors, a strong and a weak one. @weak_magnitude@ is the strength of the weak motor (between 0 and 1) and @strong_magnitude@ is the strength of the strong motor (between 0 and 1). @duration@ is the duration of the effect in seconds (a duration of 0 will try to play the vibration indefinitely). -- __Note:__ Not every hardware is compatible with long effect durations; it is recommended to restart an effect if it has to be played for more than a few seconds. bindInput_start_joy_vibration :: MethodBind bindInput_start_joy_vibration = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "start_joy_vibration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts to vibrate the joypad. Joypads usually come with two rumble motors, a strong and a weak one. @weak_magnitude@ is the strength of the weak motor (between 0 and 1) and @strong_magnitude@ is the strength of the strong motor (between 0 and 1). @duration@ is the duration of the effect in seconds (a duration of 0 will try to play the vibration indefinitely). -- __Note:__ Not every hardware is compatible with long effect durations; it is recommended to restart an effect if it has to be played for more than a few seconds. start_joy_vibration :: (Input :< cls, Object :< cls) => cls -> Int -> Float -> Float -> Maybe Float -> IO () start_joy_vibration cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantReal (0)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindInput_start_joy_vibration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "start_joy_vibration" '[Int, Float, Float, Maybe Float] (IO ()) where nodeMethod = Godot.Core.Input.start_joy_vibration {-# NOINLINE bindInput_stop_joy_vibration #-} -- | Stops the vibration of the joypad. bindInput_stop_joy_vibration :: MethodBind bindInput_stop_joy_vibration = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "stop_joy_vibration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the vibration of the joypad. stop_joy_vibration :: (Input :< cls, Object :< cls) => cls -> Int -> IO () stop_joy_vibration cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_stop_joy_vibration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "stop_joy_vibration" '[Int] (IO ()) where nodeMethod = Godot.Core.Input.stop_joy_vibration {-# NOINLINE bindInput_vibrate_handheld #-} -- | Vibrate Android and iOS devices. -- __Note:__ It needs VIBRATE permission for Android at export settings. iOS does not support duration. bindInput_vibrate_handheld :: MethodBind bindInput_vibrate_handheld = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "vibrate_handheld" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Vibrate Android and iOS devices. -- __Note:__ It needs VIBRATE permission for Android at export settings. iOS does not support duration. vibrate_handheld :: (Input :< cls, Object :< cls) => cls -> Maybe Int -> IO () vibrate_handheld cls arg1 = withVariantArray [maybe (VariantInt (500)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_vibrate_handheld (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "vibrate_handheld" '[Maybe Int] (IO ()) where nodeMethod = Godot.Core.Input.vibrate_handheld {-# NOINLINE bindInput_warp_mouse_position #-} -- | Sets the mouse position to the specified vector. bindInput_warp_mouse_position :: MethodBind bindInput_warp_mouse_position = unsafePerformIO $ withCString "Input" $ \ clsNamePtr -> withCString "warp_mouse_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the mouse position to the specified vector. warp_mouse_position :: (Input :< cls, Object :< cls) => cls -> Vector2 -> IO () warp_mouse_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInput_warp_mouse_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Input "warp_mouse_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Input.warp_mouse_position ================================================ FILE: src/Godot/Core/InputDefault.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputDefault () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Input() ================================================ FILE: src/Godot/Core/InputEvent.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEvent (Godot.Core.InputEvent.accumulate, Godot.Core.InputEvent.as_text, Godot.Core.InputEvent.get_action_strength, Godot.Core.InputEvent.get_device, Godot.Core.InputEvent.is_action, Godot.Core.InputEvent.is_action_pressed, Godot.Core.InputEvent.is_action_released, Godot.Core.InputEvent.is_action_type, Godot.Core.InputEvent.is_echo, Godot.Core.InputEvent.is_pressed, Godot.Core.InputEvent.set_device, Godot.Core.InputEvent.shortcut_match, Godot.Core.InputEvent.xformed_by) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty InputEvent "device" Int 'False where nodeProperty = (get_device, wrapDroppingSetter set_device, Nothing) {-# NOINLINE bindInputEvent_accumulate #-} -- | Returns @true@ if the given input event and this input event can be added together (only for events of type @InputEventMouseMotion@). -- The given input event's position, global position and speed will be copied. The resulting @relative@ is a sum of both events. Both events' modifiers have to be identical. bindInputEvent_accumulate :: MethodBind bindInputEvent_accumulate = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "accumulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given input event and this input event can be added together (only for events of type @InputEventMouseMotion@). -- The given input event's position, global position and speed will be copied. The resulting @relative@ is a sum of both events. Both events' modifiers have to be identical. accumulate :: (InputEvent :< cls, Object :< cls) => cls -> InputEvent -> IO Bool accumulate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_accumulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "accumulate" '[InputEvent] (IO Bool) where nodeMethod = Godot.Core.InputEvent.accumulate {-# NOINLINE bindInputEvent_as_text #-} -- | Returns a @String@ representation of the event. bindInputEvent_as_text :: MethodBind bindInputEvent_as_text = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "as_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @String@ representation of the event. as_text :: (InputEvent :< cls, Object :< cls) => cls -> IO GodotString as_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_as_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "as_text" '[] (IO GodotString) where nodeMethod = Godot.Core.InputEvent.as_text {-# NOINLINE bindInputEvent_get_action_strength #-} -- | Returns a value between 0.0 and 1.0 depending on the given actions' state. Useful for getting the value of events of type @InputEventJoypadMotion@. bindInputEvent_get_action_strength :: MethodBind bindInputEvent_get_action_strength = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "get_action_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a value between 0.0 and 1.0 depending on the given actions' state. Useful for getting the value of events of type @InputEventJoypadMotion@. get_action_strength :: (InputEvent :< cls, Object :< cls) => cls -> GodotString -> IO Float get_action_strength cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_get_action_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "get_action_strength" '[GodotString] (IO Float) where nodeMethod = Godot.Core.InputEvent.get_action_strength {-# NOINLINE bindInputEvent_get_device #-} -- | The event's device ID. -- __Note:__ This device ID will always be @-1@ for emulated mouse input from a touchscreen. This can be used to distinguish emulated mouse input from physical mouse input. bindInputEvent_get_device :: MethodBind bindInputEvent_get_device = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "get_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The event's device ID. -- __Note:__ This device ID will always be @-1@ for emulated mouse input from a touchscreen. This can be used to distinguish emulated mouse input from physical mouse input. get_device :: (InputEvent :< cls, Object :< cls) => cls -> IO Int get_device cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_get_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "get_device" '[] (IO Int) where nodeMethod = Godot.Core.InputEvent.get_device {-# NOINLINE bindInputEvent_is_action #-} -- | Returns @true@ if this input event matches a pre-defined action of any type. bindInputEvent_is_action :: MethodBind bindInputEvent_is_action = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "is_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this input event matches a pre-defined action of any type. is_action :: (InputEvent :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_action cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_is_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "is_action" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.InputEvent.is_action {-# NOINLINE bindInputEvent_is_action_pressed #-} -- | Returns @true@ if the given action is being pressed (and is not an echo event for @InputEventKey@ events, unless @allow_echo@ is @true@). Not relevant for events of type @InputEventMouseMotion@ or @InputEventScreenDrag@. bindInputEvent_is_action_pressed :: MethodBind bindInputEvent_is_action_pressed = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "is_action_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given action is being pressed (and is not an echo event for @InputEventKey@ events, unless @allow_echo@ is @true@). Not relevant for events of type @InputEventMouseMotion@ or @InputEventScreenDrag@. is_action_pressed :: (InputEvent :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO Bool is_action_pressed cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_is_action_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "is_action_pressed" '[GodotString, Maybe Bool] (IO Bool) where nodeMethod = Godot.Core.InputEvent.is_action_pressed {-# NOINLINE bindInputEvent_is_action_released #-} -- | Returns @true@ if the given action is released (i.e. not pressed). Not relevant for events of type @InputEventMouseMotion@ or @InputEventScreenDrag@. bindInputEvent_is_action_released :: MethodBind bindInputEvent_is_action_released = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "is_action_released" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given action is released (i.e. not pressed). Not relevant for events of type @InputEventMouseMotion@ or @InputEventScreenDrag@. is_action_released :: (InputEvent :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_action_released cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_is_action_released (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "is_action_released" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.InputEvent.is_action_released {-# NOINLINE bindInputEvent_is_action_type #-} -- | Returns @true@ if this input event's type is one that can be assigned to an input action. bindInputEvent_is_action_type :: MethodBind bindInputEvent_is_action_type = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "is_action_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this input event's type is one that can be assigned to an input action. is_action_type :: (InputEvent :< cls, Object :< cls) => cls -> IO Bool is_action_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_is_action_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "is_action_type" '[] (IO Bool) where nodeMethod = Godot.Core.InputEvent.is_action_type {-# NOINLINE bindInputEvent_is_echo #-} -- | Returns @true@ if this input event is an echo event (only for events of type @InputEventKey@). bindInputEvent_is_echo :: MethodBind bindInputEvent_is_echo = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "is_echo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this input event is an echo event (only for events of type @InputEventKey@). is_echo :: (InputEvent :< cls, Object :< cls) => cls -> IO Bool is_echo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_is_echo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "is_echo" '[] (IO Bool) where nodeMethod = Godot.Core.InputEvent.is_echo {-# NOINLINE bindInputEvent_is_pressed #-} -- | Returns @true@ if this input event is pressed. Not relevant for events of type @InputEventMouseMotion@ or @InputEventScreenDrag@. bindInputEvent_is_pressed :: MethodBind bindInputEvent_is_pressed = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "is_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this input event is pressed. Not relevant for events of type @InputEventMouseMotion@ or @InputEventScreenDrag@. is_pressed :: (InputEvent :< cls, Object :< cls) => cls -> IO Bool is_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_is_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "is_pressed" '[] (IO Bool) where nodeMethod = Godot.Core.InputEvent.is_pressed {-# NOINLINE bindInputEvent_set_device #-} -- | The event's device ID. -- __Note:__ This device ID will always be @-1@ for emulated mouse input from a touchscreen. This can be used to distinguish emulated mouse input from physical mouse input. bindInputEvent_set_device :: MethodBind bindInputEvent_set_device = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "set_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The event's device ID. -- __Note:__ This device ID will always be @-1@ for emulated mouse input from a touchscreen. This can be used to distinguish emulated mouse input from physical mouse input. set_device :: (InputEvent :< cls, Object :< cls) => cls -> Int -> IO () set_device cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_set_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "set_device" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEvent.set_device {-# NOINLINE bindInputEvent_shortcut_match #-} -- | Returns @true@ if the given input event is checking for the same key (@InputEventKey@), button (@InputEventJoypadButton@) or action (@InputEventAction@). bindInputEvent_shortcut_match :: MethodBind bindInputEvent_shortcut_match = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "shortcut_match" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given input event is checking for the same key (@InputEventKey@), button (@InputEventJoypadButton@) or action (@InputEventAction@). shortcut_match :: (InputEvent :< cls, Object :< cls) => cls -> InputEvent -> IO Bool shortcut_match cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_shortcut_match (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "shortcut_match" '[InputEvent] (IO Bool) where nodeMethod = Godot.Core.InputEvent.shortcut_match {-# NOINLINE bindInputEvent_xformed_by #-} -- | Returns a copy of the given input event which has been offset by @local_ofs@ and transformed by @xform@. Relevant for events of type @InputEventMouseButton@, @InputEventMouseMotion@, @InputEventScreenTouch@, @InputEventScreenDrag@, @InputEventMagnifyGesture@ and @InputEventPanGesture@. bindInputEvent_xformed_by :: MethodBind bindInputEvent_xformed_by = unsafePerformIO $ withCString "InputEvent" $ \ clsNamePtr -> withCString "xformed_by" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a copy of the given input event which has been offset by @local_ofs@ and transformed by @xform@. Relevant for events of type @InputEventMouseButton@, @InputEventMouseMotion@, @InputEventScreenTouch@, @InputEventScreenDrag@, @InputEventMagnifyGesture@ and @InputEventPanGesture@. xformed_by :: (InputEvent :< cls, Object :< cls) => cls -> Transform2d -> Maybe Vector2 -> IO InputEvent xformed_by cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantVector2 (V2 0 0) arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInputEvent_xformed_by (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEvent "xformed_by" '[Transform2d, Maybe Vector2] (IO InputEvent) where nodeMethod = Godot.Core.InputEvent.xformed_by ================================================ FILE: src/Godot/Core/InputEventAction.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventAction (Godot.Core.InputEventAction.is_pressed, Godot.Core.InputEventAction.get_action, Godot.Core.InputEventAction.get_strength, Godot.Core.InputEventAction.set_action, Godot.Core.InputEventAction.set_pressed, Godot.Core.InputEventAction.set_strength) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEvent() instance NodeProperty InputEventAction "action" GodotString 'False where nodeProperty = (get_action, wrapDroppingSetter set_action, Nothing) {-# NOINLINE bindInputEventAction_is_pressed #-} -- | If @true@, the action's state is pressed. If @false@, the action's state is released. bindInputEventAction_is_pressed :: MethodBind bindInputEventAction_is_pressed = unsafePerformIO $ withCString "InputEventAction" $ \ clsNamePtr -> withCString "is_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the action's state is pressed. If @false@, the action's state is released. is_pressed :: (InputEventAction :< cls, Object :< cls) => cls -> IO Bool is_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventAction_is_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventAction "is_pressed" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventAction.is_pressed instance NodeProperty InputEventAction "pressed" Bool 'False where nodeProperty = (is_pressed, wrapDroppingSetter set_pressed, Nothing) instance NodeProperty InputEventAction "strength" Float 'False where nodeProperty = (get_strength, wrapDroppingSetter set_strength, Nothing) {-# NOINLINE bindInputEventAction_get_action #-} -- | The action's name. Actions are accessed via this @String@. bindInputEventAction_get_action :: MethodBind bindInputEventAction_get_action = unsafePerformIO $ withCString "InputEventAction" $ \ clsNamePtr -> withCString "get_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The action's name. Actions are accessed via this @String@. get_action :: (InputEventAction :< cls, Object :< cls) => cls -> IO GodotString get_action cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventAction_get_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventAction "get_action" '[] (IO GodotString) where nodeMethod = Godot.Core.InputEventAction.get_action {-# NOINLINE bindInputEventAction_get_strength #-} -- | The action's strength between 0 and 1. This value is considered as equal to 0 if pressed is @false@. The event strength allows faking analog joypad motion events, by precising how strongly is the joypad axis bent or pressed. bindInputEventAction_get_strength :: MethodBind bindInputEventAction_get_strength = unsafePerformIO $ withCString "InputEventAction" $ \ clsNamePtr -> withCString "get_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The action's strength between 0 and 1. This value is considered as equal to 0 if pressed is @false@. The event strength allows faking analog joypad motion events, by precising how strongly is the joypad axis bent or pressed. get_strength :: (InputEventAction :< cls, Object :< cls) => cls -> IO Float get_strength cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventAction_get_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventAction "get_strength" '[] (IO Float) where nodeMethod = Godot.Core.InputEventAction.get_strength {-# NOINLINE bindInputEventAction_set_action #-} -- | The action's name. Actions are accessed via this @String@. bindInputEventAction_set_action :: MethodBind bindInputEventAction_set_action = unsafePerformIO $ withCString "InputEventAction" $ \ clsNamePtr -> withCString "set_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The action's name. Actions are accessed via this @String@. set_action :: (InputEventAction :< cls, Object :< cls) => cls -> GodotString -> IO () set_action cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventAction_set_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventAction "set_action" '[GodotString] (IO ()) where nodeMethod = Godot.Core.InputEventAction.set_action {-# NOINLINE bindInputEventAction_set_pressed #-} -- | If @true@, the action's state is pressed. If @false@, the action's state is released. bindInputEventAction_set_pressed :: MethodBind bindInputEventAction_set_pressed = unsafePerformIO $ withCString "InputEventAction" $ \ clsNamePtr -> withCString "set_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the action's state is pressed. If @false@, the action's state is released. set_pressed :: (InputEventAction :< cls, Object :< cls) => cls -> Bool -> IO () set_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventAction_set_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventAction "set_pressed" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventAction.set_pressed {-# NOINLINE bindInputEventAction_set_strength #-} -- | The action's strength between 0 and 1. This value is considered as equal to 0 if pressed is @false@. The event strength allows faking analog joypad motion events, by precising how strongly is the joypad axis bent or pressed. bindInputEventAction_set_strength :: MethodBind bindInputEventAction_set_strength = unsafePerformIO $ withCString "InputEventAction" $ \ clsNamePtr -> withCString "set_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The action's strength between 0 and 1. This value is considered as equal to 0 if pressed is @false@. The event strength allows faking analog joypad motion events, by precising how strongly is the joypad axis bent or pressed. set_strength :: (InputEventAction :< cls, Object :< cls) => cls -> Float -> IO () set_strength cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventAction_set_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventAction "set_strength" '[Float] (IO ()) where nodeMethod = Godot.Core.InputEventAction.set_strength ================================================ FILE: src/Godot/Core/InputEventGesture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventGesture (Godot.Core.InputEventGesture.get_position, Godot.Core.InputEventGesture.set_position) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEventWithModifiers() instance NodeProperty InputEventGesture "position" Vector2 'False where nodeProperty = (get_position, wrapDroppingSetter set_position, Nothing) {-# NOINLINE bindInputEventGesture_get_position #-} -- | The local gesture position relative to the @Viewport@. If used in @method Control._gui_input@, the position is relative to the current @Control@ that received this gesture. bindInputEventGesture_get_position :: MethodBind bindInputEventGesture_get_position = unsafePerformIO $ withCString "InputEventGesture" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The local gesture position relative to the @Viewport@. If used in @method Control._gui_input@, the position is relative to the current @Control@ that received this gesture. get_position :: (InputEventGesture :< cls, Object :< cls) => cls -> IO Vector2 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventGesture_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventGesture "get_position" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventGesture.get_position {-# NOINLINE bindInputEventGesture_set_position #-} -- | The local gesture position relative to the @Viewport@. If used in @method Control._gui_input@, the position is relative to the current @Control@ that received this gesture. bindInputEventGesture_set_position :: MethodBind bindInputEventGesture_set_position = unsafePerformIO $ withCString "InputEventGesture" $ \ clsNamePtr -> withCString "set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The local gesture position relative to the @Viewport@. If used in @method Control._gui_input@, the position is relative to the current @Control@ that received this gesture. set_position :: (InputEventGesture :< cls, Object :< cls) => cls -> Vector2 -> IO () set_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventGesture_set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventGesture "set_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventGesture.set_position ================================================ FILE: src/Godot/Core/InputEventJoypadButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventJoypadButton (Godot.Core.InputEventJoypadButton.is_pressed, Godot.Core.InputEventJoypadButton.get_button_index, Godot.Core.InputEventJoypadButton.get_pressure, Godot.Core.InputEventJoypadButton.set_button_index, Godot.Core.InputEventJoypadButton.set_pressed, Godot.Core.InputEventJoypadButton.set_pressure) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEvent() instance NodeProperty InputEventJoypadButton "button_index" Int 'False where nodeProperty = (get_button_index, wrapDroppingSetter set_button_index, Nothing) {-# NOINLINE bindInputEventJoypadButton_is_pressed #-} -- | If @true@, the button's state is pressed. If @false@, the button's state is released. bindInputEventJoypadButton_is_pressed :: MethodBind bindInputEventJoypadButton_is_pressed = unsafePerformIO $ withCString "InputEventJoypadButton" $ \ clsNamePtr -> withCString "is_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button's state is pressed. If @false@, the button's state is released. is_pressed :: (InputEventJoypadButton :< cls, Object :< cls) => cls -> IO Bool is_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadButton_is_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadButton "is_pressed" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventJoypadButton.is_pressed instance NodeProperty InputEventJoypadButton "pressed" Bool 'False where nodeProperty = (is_pressed, wrapDroppingSetter set_pressed, Nothing) instance NodeProperty InputEventJoypadButton "pressure" Float 'False where nodeProperty = (get_pressure, wrapDroppingSetter set_pressure, Nothing) {-# NOINLINE bindInputEventJoypadButton_get_button_index #-} -- | Button identifier. One of the @enum JoystickList@ button constants. bindInputEventJoypadButton_get_button_index :: MethodBind bindInputEventJoypadButton_get_button_index = unsafePerformIO $ withCString "InputEventJoypadButton" $ \ clsNamePtr -> withCString "get_button_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Button identifier. One of the @enum JoystickList@ button constants. get_button_index :: (InputEventJoypadButton :< cls, Object :< cls) => cls -> IO Int get_button_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadButton_get_button_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadButton "get_button_index" '[] (IO Int) where nodeMethod = Godot.Core.InputEventJoypadButton.get_button_index {-# NOINLINE bindInputEventJoypadButton_get_pressure #-} -- | Represents the pressure the user puts on the button with his finger, if the controller supports it. Ranges from @0@ to @1@. bindInputEventJoypadButton_get_pressure :: MethodBind bindInputEventJoypadButton_get_pressure = unsafePerformIO $ withCString "InputEventJoypadButton" $ \ clsNamePtr -> withCString "get_pressure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Represents the pressure the user puts on the button with his finger, if the controller supports it. Ranges from @0@ to @1@. get_pressure :: (InputEventJoypadButton :< cls, Object :< cls) => cls -> IO Float get_pressure cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadButton_get_pressure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadButton "get_pressure" '[] (IO Float) where nodeMethod = Godot.Core.InputEventJoypadButton.get_pressure {-# NOINLINE bindInputEventJoypadButton_set_button_index #-} -- | Button identifier. One of the @enum JoystickList@ button constants. bindInputEventJoypadButton_set_button_index :: MethodBind bindInputEventJoypadButton_set_button_index = unsafePerformIO $ withCString "InputEventJoypadButton" $ \ clsNamePtr -> withCString "set_button_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Button identifier. One of the @enum JoystickList@ button constants. set_button_index :: (InputEventJoypadButton :< cls, Object :< cls) => cls -> Int -> IO () set_button_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadButton_set_button_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadButton "set_button_index" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventJoypadButton.set_button_index {-# NOINLINE bindInputEventJoypadButton_set_pressed #-} -- | If @true@, the button's state is pressed. If @false@, the button's state is released. bindInputEventJoypadButton_set_pressed :: MethodBind bindInputEventJoypadButton_set_pressed = unsafePerformIO $ withCString "InputEventJoypadButton" $ \ clsNamePtr -> withCString "set_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button's state is pressed. If @false@, the button's state is released. set_pressed :: (InputEventJoypadButton :< cls, Object :< cls) => cls -> Bool -> IO () set_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadButton_set_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadButton "set_pressed" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventJoypadButton.set_pressed {-# NOINLINE bindInputEventJoypadButton_set_pressure #-} -- | Represents the pressure the user puts on the button with his finger, if the controller supports it. Ranges from @0@ to @1@. bindInputEventJoypadButton_set_pressure :: MethodBind bindInputEventJoypadButton_set_pressure = unsafePerformIO $ withCString "InputEventJoypadButton" $ \ clsNamePtr -> withCString "set_pressure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Represents the pressure the user puts on the button with his finger, if the controller supports it. Ranges from @0@ to @1@. set_pressure :: (InputEventJoypadButton :< cls, Object :< cls) => cls -> Float -> IO () set_pressure cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadButton_set_pressure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadButton "set_pressure" '[Float] (IO ()) where nodeMethod = Godot.Core.InputEventJoypadButton.set_pressure ================================================ FILE: src/Godot/Core/InputEventJoypadMotion.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventJoypadMotion (Godot.Core.InputEventJoypadMotion.get_axis, Godot.Core.InputEventJoypadMotion.get_axis_value, Godot.Core.InputEventJoypadMotion.set_axis, Godot.Core.InputEventJoypadMotion.set_axis_value) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEvent() instance NodeProperty InputEventJoypadMotion "axis" Int 'False where nodeProperty = (get_axis, wrapDroppingSetter set_axis, Nothing) instance NodeProperty InputEventJoypadMotion "axis_value" Float 'False where nodeProperty = (get_axis_value, wrapDroppingSetter set_axis_value, Nothing) {-# NOINLINE bindInputEventJoypadMotion_get_axis #-} -- | Axis identifier. Use one of the @enum JoystickList@ axis constants. bindInputEventJoypadMotion_get_axis :: MethodBind bindInputEventJoypadMotion_get_axis = unsafePerformIO $ withCString "InputEventJoypadMotion" $ \ clsNamePtr -> withCString "get_axis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Axis identifier. Use one of the @enum JoystickList@ axis constants. get_axis :: (InputEventJoypadMotion :< cls, Object :< cls) => cls -> IO Int get_axis cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadMotion_get_axis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadMotion "get_axis" '[] (IO Int) where nodeMethod = Godot.Core.InputEventJoypadMotion.get_axis {-# NOINLINE bindInputEventJoypadMotion_get_axis_value #-} -- | Current position of the joystick on the given axis. The value ranges from @-1.0@ to @1.0@. A value of @0@ means the axis is in its resting position. bindInputEventJoypadMotion_get_axis_value :: MethodBind bindInputEventJoypadMotion_get_axis_value = unsafePerformIO $ withCString "InputEventJoypadMotion" $ \ clsNamePtr -> withCString "get_axis_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Current position of the joystick on the given axis. The value ranges from @-1.0@ to @1.0@. A value of @0@ means the axis is in its resting position. get_axis_value :: (InputEventJoypadMotion :< cls, Object :< cls) => cls -> IO Float get_axis_value cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadMotion_get_axis_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadMotion "get_axis_value" '[] (IO Float) where nodeMethod = Godot.Core.InputEventJoypadMotion.get_axis_value {-# NOINLINE bindInputEventJoypadMotion_set_axis #-} -- | Axis identifier. Use one of the @enum JoystickList@ axis constants. bindInputEventJoypadMotion_set_axis :: MethodBind bindInputEventJoypadMotion_set_axis = unsafePerformIO $ withCString "InputEventJoypadMotion" $ \ clsNamePtr -> withCString "set_axis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Axis identifier. Use one of the @enum JoystickList@ axis constants. set_axis :: (InputEventJoypadMotion :< cls, Object :< cls) => cls -> Int -> IO () set_axis cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadMotion_set_axis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadMotion "set_axis" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventJoypadMotion.set_axis {-# NOINLINE bindInputEventJoypadMotion_set_axis_value #-} -- | Current position of the joystick on the given axis. The value ranges from @-1.0@ to @1.0@. A value of @0@ means the axis is in its resting position. bindInputEventJoypadMotion_set_axis_value :: MethodBind bindInputEventJoypadMotion_set_axis_value = unsafePerformIO $ withCString "InputEventJoypadMotion" $ \ clsNamePtr -> withCString "set_axis_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Current position of the joystick on the given axis. The value ranges from @-1.0@ to @1.0@. A value of @0@ means the axis is in its resting position. set_axis_value :: (InputEventJoypadMotion :< cls, Object :< cls) => cls -> Float -> IO () set_axis_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventJoypadMotion_set_axis_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventJoypadMotion "set_axis_value" '[Float] (IO ()) where nodeMethod = Godot.Core.InputEventJoypadMotion.set_axis_value ================================================ FILE: src/Godot/Core/InputEventKey.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventKey (Godot.Core.InputEventKey.is_echo, Godot.Core.InputEventKey.is_pressed, Godot.Core.InputEventKey.get_scancode, Godot.Core.InputEventKey.get_scancode_with_modifiers, Godot.Core.InputEventKey.get_unicode, Godot.Core.InputEventKey.set_echo, Godot.Core.InputEventKey.set_pressed, Godot.Core.InputEventKey.set_scancode, Godot.Core.InputEventKey.set_unicode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEventWithModifiers() {-# NOINLINE bindInputEventKey_is_echo #-} -- | If @true@, the key was already pressed before this event. It means the user is holding the key down. bindInputEventKey_is_echo :: MethodBind bindInputEventKey_is_echo = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "is_echo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the key was already pressed before this event. It means the user is holding the key down. is_echo :: (InputEventKey :< cls, Object :< cls) => cls -> IO Bool is_echo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_is_echo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "is_echo" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventKey.is_echo instance NodeProperty InputEventKey "echo" Bool 'False where nodeProperty = (is_echo, wrapDroppingSetter set_echo, Nothing) {-# NOINLINE bindInputEventKey_is_pressed #-} -- | If @true@, the key's state is pressed. If @false@, the key's state is released. bindInputEventKey_is_pressed :: MethodBind bindInputEventKey_is_pressed = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "is_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the key's state is pressed. If @false@, the key's state is released. is_pressed :: (InputEventKey :< cls, Object :< cls) => cls -> IO Bool is_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_is_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "is_pressed" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventKey.is_pressed instance NodeProperty InputEventKey "pressed" Bool 'False where nodeProperty = (is_pressed, wrapDroppingSetter set_pressed, Nothing) instance NodeProperty InputEventKey "scancode" Int 'False where nodeProperty = (get_scancode, wrapDroppingSetter set_scancode, Nothing) instance NodeProperty InputEventKey "unicode" Int 'False where nodeProperty = (get_unicode, wrapDroppingSetter set_unicode, Nothing) {-# NOINLINE bindInputEventKey_get_scancode #-} -- | The key scancode, which corresponds to one of the @enum KeyList@ constants. -- To get a human-readable representation of the @InputEventKey@, use @OS.get_scancode_string(event.scancode)@ where @event@ is the @InputEventKey@. bindInputEventKey_get_scancode :: MethodBind bindInputEventKey_get_scancode = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "get_scancode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The key scancode, which corresponds to one of the @enum KeyList@ constants. -- To get a human-readable representation of the @InputEventKey@, use @OS.get_scancode_string(event.scancode)@ where @event@ is the @InputEventKey@. get_scancode :: (InputEventKey :< cls, Object :< cls) => cls -> IO Int get_scancode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_get_scancode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "get_scancode" '[] (IO Int) where nodeMethod = Godot.Core.InputEventKey.get_scancode {-# NOINLINE bindInputEventKey_get_scancode_with_modifiers #-} -- | Returns the scancode combined with modifier keys such as @Shift@ or @Alt@. See also @InputEventWithModifiers@. -- To get a human-readable representation of the @InputEventKey@ with modifiers, use @OS.get_scancode_string(event.get_scancode_with_modifiers())@ where @event@ is the @InputEventKey@. bindInputEventKey_get_scancode_with_modifiers :: MethodBind bindInputEventKey_get_scancode_with_modifiers = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "get_scancode_with_modifiers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the scancode combined with modifier keys such as @Shift@ or @Alt@. See also @InputEventWithModifiers@. -- To get a human-readable representation of the @InputEventKey@ with modifiers, use @OS.get_scancode_string(event.get_scancode_with_modifiers())@ where @event@ is the @InputEventKey@. get_scancode_with_modifiers :: (InputEventKey :< cls, Object :< cls) => cls -> IO Int get_scancode_with_modifiers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_get_scancode_with_modifiers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "get_scancode_with_modifiers" '[] (IO Int) where nodeMethod = Godot.Core.InputEventKey.get_scancode_with_modifiers {-# NOINLINE bindInputEventKey_get_unicode #-} -- | The key Unicode identifier (when relevant). Unicode identifiers for the composite characters and complex scripts may not be available unless IME input mode is active. See @method OS.set_ime_active@ for more information. bindInputEventKey_get_unicode :: MethodBind bindInputEventKey_get_unicode = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "get_unicode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The key Unicode identifier (when relevant). Unicode identifiers for the composite characters and complex scripts may not be available unless IME input mode is active. See @method OS.set_ime_active@ for more information. get_unicode :: (InputEventKey :< cls, Object :< cls) => cls -> IO Int get_unicode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_get_unicode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "get_unicode" '[] (IO Int) where nodeMethod = Godot.Core.InputEventKey.get_unicode {-# NOINLINE bindInputEventKey_set_echo #-} -- | If @true@, the key was already pressed before this event. It means the user is holding the key down. bindInputEventKey_set_echo :: MethodBind bindInputEventKey_set_echo = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "set_echo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the key was already pressed before this event. It means the user is holding the key down. set_echo :: (InputEventKey :< cls, Object :< cls) => cls -> Bool -> IO () set_echo cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_set_echo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "set_echo" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventKey.set_echo {-# NOINLINE bindInputEventKey_set_pressed #-} -- | If @true@, the key's state is pressed. If @false@, the key's state is released. bindInputEventKey_set_pressed :: MethodBind bindInputEventKey_set_pressed = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "set_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the key's state is pressed. If @false@, the key's state is released. set_pressed :: (InputEventKey :< cls, Object :< cls) => cls -> Bool -> IO () set_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_set_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "set_pressed" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventKey.set_pressed {-# NOINLINE bindInputEventKey_set_scancode #-} -- | The key scancode, which corresponds to one of the @enum KeyList@ constants. -- To get a human-readable representation of the @InputEventKey@, use @OS.get_scancode_string(event.scancode)@ where @event@ is the @InputEventKey@. bindInputEventKey_set_scancode :: MethodBind bindInputEventKey_set_scancode = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "set_scancode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The key scancode, which corresponds to one of the @enum KeyList@ constants. -- To get a human-readable representation of the @InputEventKey@, use @OS.get_scancode_string(event.scancode)@ where @event@ is the @InputEventKey@. set_scancode :: (InputEventKey :< cls, Object :< cls) => cls -> Int -> IO () set_scancode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_set_scancode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "set_scancode" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventKey.set_scancode {-# NOINLINE bindInputEventKey_set_unicode #-} -- | The key Unicode identifier (when relevant). Unicode identifiers for the composite characters and complex scripts may not be available unless IME input mode is active. See @method OS.set_ime_active@ for more information. bindInputEventKey_set_unicode :: MethodBind bindInputEventKey_set_unicode = unsafePerformIO $ withCString "InputEventKey" $ \ clsNamePtr -> withCString "set_unicode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The key Unicode identifier (when relevant). Unicode identifiers for the composite characters and complex scripts may not be available unless IME input mode is active. See @method OS.set_ime_active@ for more information. set_unicode :: (InputEventKey :< cls, Object :< cls) => cls -> Int -> IO () set_unicode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventKey_set_unicode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventKey "set_unicode" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventKey.set_unicode ================================================ FILE: src/Godot/Core/InputEventMIDI.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventMIDI (Godot.Core.InputEventMIDI.get_channel, Godot.Core.InputEventMIDI.get_controller_number, Godot.Core.InputEventMIDI.get_controller_value, Godot.Core.InputEventMIDI.get_instrument, Godot.Core.InputEventMIDI.get_message, Godot.Core.InputEventMIDI.get_pitch, Godot.Core.InputEventMIDI.get_pressure, Godot.Core.InputEventMIDI.get_velocity, Godot.Core.InputEventMIDI.set_channel, Godot.Core.InputEventMIDI.set_controller_number, Godot.Core.InputEventMIDI.set_controller_value, Godot.Core.InputEventMIDI.set_instrument, Godot.Core.InputEventMIDI.set_message, Godot.Core.InputEventMIDI.set_pitch, Godot.Core.InputEventMIDI.set_pressure, Godot.Core.InputEventMIDI.set_velocity) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEvent() instance NodeProperty InputEventMIDI "channel" Int 'False where nodeProperty = (get_channel, wrapDroppingSetter set_channel, Nothing) instance NodeProperty InputEventMIDI "controller_number" Int 'False where nodeProperty = (get_controller_number, wrapDroppingSetter set_controller_number, Nothing) instance NodeProperty InputEventMIDI "controller_value" Int 'False where nodeProperty = (get_controller_value, wrapDroppingSetter set_controller_value, Nothing) instance NodeProperty InputEventMIDI "instrument" Int 'False where nodeProperty = (get_instrument, wrapDroppingSetter set_instrument, Nothing) instance NodeProperty InputEventMIDI "message" Int 'False where nodeProperty = (get_message, wrapDroppingSetter set_message, Nothing) instance NodeProperty InputEventMIDI "pitch" Int 'False where nodeProperty = (get_pitch, wrapDroppingSetter set_pitch, Nothing) instance NodeProperty InputEventMIDI "pressure" Int 'False where nodeProperty = (get_pressure, wrapDroppingSetter set_pressure, Nothing) instance NodeProperty InputEventMIDI "velocity" Int 'False where nodeProperty = (get_velocity, wrapDroppingSetter set_velocity, Nothing) {-# NOINLINE bindInputEventMIDI_get_channel #-} bindInputEventMIDI_get_channel :: MethodBind bindInputEventMIDI_get_channel = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "get_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_channel :: (InputEventMIDI :< cls, Object :< cls) => cls -> IO Int get_channel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_get_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "get_channel" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMIDI.get_channel {-# NOINLINE bindInputEventMIDI_get_controller_number #-} bindInputEventMIDI_get_controller_number :: MethodBind bindInputEventMIDI_get_controller_number = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "get_controller_number" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_controller_number :: (InputEventMIDI :< cls, Object :< cls) => cls -> IO Int get_controller_number cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_get_controller_number (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "get_controller_number" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMIDI.get_controller_number {-# NOINLINE bindInputEventMIDI_get_controller_value #-} bindInputEventMIDI_get_controller_value :: MethodBind bindInputEventMIDI_get_controller_value = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "get_controller_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_controller_value :: (InputEventMIDI :< cls, Object :< cls) => cls -> IO Int get_controller_value cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_get_controller_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "get_controller_value" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMIDI.get_controller_value {-# NOINLINE bindInputEventMIDI_get_instrument #-} bindInputEventMIDI_get_instrument :: MethodBind bindInputEventMIDI_get_instrument = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "get_instrument" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_instrument :: (InputEventMIDI :< cls, Object :< cls) => cls -> IO Int get_instrument cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_get_instrument (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "get_instrument" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMIDI.get_instrument {-# NOINLINE bindInputEventMIDI_get_message #-} bindInputEventMIDI_get_message :: MethodBind bindInputEventMIDI_get_message = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "get_message" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_message :: (InputEventMIDI :< cls, Object :< cls) => cls -> IO Int get_message cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_get_message (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "get_message" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMIDI.get_message {-# NOINLINE bindInputEventMIDI_get_pitch #-} bindInputEventMIDI_get_pitch :: MethodBind bindInputEventMIDI_get_pitch = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "get_pitch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_pitch :: (InputEventMIDI :< cls, Object :< cls) => cls -> IO Int get_pitch cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_get_pitch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "get_pitch" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMIDI.get_pitch {-# NOINLINE bindInputEventMIDI_get_pressure #-} bindInputEventMIDI_get_pressure :: MethodBind bindInputEventMIDI_get_pressure = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "get_pressure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_pressure :: (InputEventMIDI :< cls, Object :< cls) => cls -> IO Int get_pressure cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_get_pressure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "get_pressure" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMIDI.get_pressure {-# NOINLINE bindInputEventMIDI_get_velocity #-} bindInputEventMIDI_get_velocity :: MethodBind bindInputEventMIDI_get_velocity = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "get_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_velocity :: (InputEventMIDI :< cls, Object :< cls) => cls -> IO Int get_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_get_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "get_velocity" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMIDI.get_velocity {-# NOINLINE bindInputEventMIDI_set_channel #-} bindInputEventMIDI_set_channel :: MethodBind bindInputEventMIDI_set_channel = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "set_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_channel :: (InputEventMIDI :< cls, Object :< cls) => cls -> Int -> IO () set_channel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_set_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "set_channel" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMIDI.set_channel {-# NOINLINE bindInputEventMIDI_set_controller_number #-} bindInputEventMIDI_set_controller_number :: MethodBind bindInputEventMIDI_set_controller_number = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "set_controller_number" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_controller_number :: (InputEventMIDI :< cls, Object :< cls) => cls -> Int -> IO () set_controller_number cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_set_controller_number (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "set_controller_number" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMIDI.set_controller_number {-# NOINLINE bindInputEventMIDI_set_controller_value #-} bindInputEventMIDI_set_controller_value :: MethodBind bindInputEventMIDI_set_controller_value = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "set_controller_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_controller_value :: (InputEventMIDI :< cls, Object :< cls) => cls -> Int -> IO () set_controller_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_set_controller_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "set_controller_value" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMIDI.set_controller_value {-# NOINLINE bindInputEventMIDI_set_instrument #-} bindInputEventMIDI_set_instrument :: MethodBind bindInputEventMIDI_set_instrument = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "set_instrument" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_instrument :: (InputEventMIDI :< cls, Object :< cls) => cls -> Int -> IO () set_instrument cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_set_instrument (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "set_instrument" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMIDI.set_instrument {-# NOINLINE bindInputEventMIDI_set_message #-} bindInputEventMIDI_set_message :: MethodBind bindInputEventMIDI_set_message = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "set_message" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_message :: (InputEventMIDI :< cls, Object :< cls) => cls -> Int -> IO () set_message cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_set_message (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "set_message" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMIDI.set_message {-# NOINLINE bindInputEventMIDI_set_pitch #-} bindInputEventMIDI_set_pitch :: MethodBind bindInputEventMIDI_set_pitch = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "set_pitch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_pitch :: (InputEventMIDI :< cls, Object :< cls) => cls -> Int -> IO () set_pitch cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_set_pitch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "set_pitch" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMIDI.set_pitch {-# NOINLINE bindInputEventMIDI_set_pressure #-} bindInputEventMIDI_set_pressure :: MethodBind bindInputEventMIDI_set_pressure = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "set_pressure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_pressure :: (InputEventMIDI :< cls, Object :< cls) => cls -> Int -> IO () set_pressure cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_set_pressure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "set_pressure" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMIDI.set_pressure {-# NOINLINE bindInputEventMIDI_set_velocity #-} bindInputEventMIDI_set_velocity :: MethodBind bindInputEventMIDI_set_velocity = unsafePerformIO $ withCString "InputEventMIDI" $ \ clsNamePtr -> withCString "set_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_velocity :: (InputEventMIDI :< cls, Object :< cls) => cls -> Int -> IO () set_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMIDI_set_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMIDI "set_velocity" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMIDI.set_velocity ================================================ FILE: src/Godot/Core/InputEventMagnifyGesture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventMagnifyGesture (Godot.Core.InputEventMagnifyGesture.get_factor, Godot.Core.InputEventMagnifyGesture.set_factor) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEventGesture() instance NodeProperty InputEventMagnifyGesture "factor" Float 'False where nodeProperty = (get_factor, wrapDroppingSetter set_factor, Nothing) {-# NOINLINE bindInputEventMagnifyGesture_get_factor #-} bindInputEventMagnifyGesture_get_factor :: MethodBind bindInputEventMagnifyGesture_get_factor = unsafePerformIO $ withCString "InputEventMagnifyGesture" $ \ clsNamePtr -> withCString "get_factor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_factor :: (InputEventMagnifyGesture :< cls, Object :< cls) => cls -> IO Float get_factor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMagnifyGesture_get_factor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMagnifyGesture "get_factor" '[] (IO Float) where nodeMethod = Godot.Core.InputEventMagnifyGesture.get_factor {-# NOINLINE bindInputEventMagnifyGesture_set_factor #-} bindInputEventMagnifyGesture_set_factor :: MethodBind bindInputEventMagnifyGesture_set_factor = unsafePerformIO $ withCString "InputEventMagnifyGesture" $ \ clsNamePtr -> withCString "set_factor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_factor :: (InputEventMagnifyGesture :< cls, Object :< cls) => cls -> Float -> IO () set_factor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMagnifyGesture_set_factor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMagnifyGesture "set_factor" '[Float] (IO ()) where nodeMethod = Godot.Core.InputEventMagnifyGesture.set_factor ================================================ FILE: src/Godot/Core/InputEventMouse.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventMouse (Godot.Core.InputEventMouse.get_button_mask, Godot.Core.InputEventMouse.get_global_position, Godot.Core.InputEventMouse.get_position, Godot.Core.InputEventMouse.set_button_mask, Godot.Core.InputEventMouse.set_global_position, Godot.Core.InputEventMouse.set_position) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEventWithModifiers() instance NodeProperty InputEventMouse "button_mask" Int 'False where nodeProperty = (get_button_mask, wrapDroppingSetter set_button_mask, Nothing) instance NodeProperty InputEventMouse "global_position" Vector2 'False where nodeProperty = (get_global_position, wrapDroppingSetter set_global_position, Nothing) instance NodeProperty InputEventMouse "position" Vector2 'False where nodeProperty = (get_position, wrapDroppingSetter set_position, Nothing) {-# NOINLINE bindInputEventMouse_get_button_mask #-} -- | The mouse button mask identifier, one of or a bitwise combination of the @enum ButtonList@ button masks. bindInputEventMouse_get_button_mask :: MethodBind bindInputEventMouse_get_button_mask = unsafePerformIO $ withCString "InputEventMouse" $ \ clsNamePtr -> withCString "get_button_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mouse button mask identifier, one of or a bitwise combination of the @enum ButtonList@ button masks. get_button_mask :: (InputEventMouse :< cls, Object :< cls) => cls -> IO Int get_button_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouse_get_button_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouse "get_button_mask" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMouse.get_button_mask {-# NOINLINE bindInputEventMouse_get_global_position #-} -- | The global mouse position relative to the current @Viewport@ when used in @method Control._gui_input@, otherwise is at 0,0. bindInputEventMouse_get_global_position :: MethodBind bindInputEventMouse_get_global_position = unsafePerformIO $ withCString "InputEventMouse" $ \ clsNamePtr -> withCString "get_global_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global mouse position relative to the current @Viewport@ when used in @method Control._gui_input@, otherwise is at 0,0. get_global_position :: (InputEventMouse :< cls, Object :< cls) => cls -> IO Vector2 get_global_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouse_get_global_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouse "get_global_position" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventMouse.get_global_position {-# NOINLINE bindInputEventMouse_get_position #-} -- | The local mouse position relative to the @Viewport@. If used in @method Control._gui_input@, the position is relative to the current @Control@ which is under the mouse. bindInputEventMouse_get_position :: MethodBind bindInputEventMouse_get_position = unsafePerformIO $ withCString "InputEventMouse" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The local mouse position relative to the @Viewport@. If used in @method Control._gui_input@, the position is relative to the current @Control@ which is under the mouse. get_position :: (InputEventMouse :< cls, Object :< cls) => cls -> IO Vector2 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouse_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouse "get_position" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventMouse.get_position {-# NOINLINE bindInputEventMouse_set_button_mask #-} -- | The mouse button mask identifier, one of or a bitwise combination of the @enum ButtonList@ button masks. bindInputEventMouse_set_button_mask :: MethodBind bindInputEventMouse_set_button_mask = unsafePerformIO $ withCString "InputEventMouse" $ \ clsNamePtr -> withCString "set_button_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mouse button mask identifier, one of or a bitwise combination of the @enum ButtonList@ button masks. set_button_mask :: (InputEventMouse :< cls, Object :< cls) => cls -> Int -> IO () set_button_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouse_set_button_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouse "set_button_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMouse.set_button_mask {-# NOINLINE bindInputEventMouse_set_global_position #-} -- | The global mouse position relative to the current @Viewport@ when used in @method Control._gui_input@, otherwise is at 0,0. bindInputEventMouse_set_global_position :: MethodBind bindInputEventMouse_set_global_position = unsafePerformIO $ withCString "InputEventMouse" $ \ clsNamePtr -> withCString "set_global_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global mouse position relative to the current @Viewport@ when used in @method Control._gui_input@, otherwise is at 0,0. set_global_position :: (InputEventMouse :< cls, Object :< cls) => cls -> Vector2 -> IO () set_global_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouse_set_global_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouse "set_global_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventMouse.set_global_position {-# NOINLINE bindInputEventMouse_set_position #-} -- | The local mouse position relative to the @Viewport@. If used in @method Control._gui_input@, the position is relative to the current @Control@ which is under the mouse. bindInputEventMouse_set_position :: MethodBind bindInputEventMouse_set_position = unsafePerformIO $ withCString "InputEventMouse" $ \ clsNamePtr -> withCString "set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The local mouse position relative to the @Viewport@. If used in @method Control._gui_input@, the position is relative to the current @Control@ which is under the mouse. set_position :: (InputEventMouse :< cls, Object :< cls) => cls -> Vector2 -> IO () set_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouse_set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouse "set_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventMouse.set_position ================================================ FILE: src/Godot/Core/InputEventMouseButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventMouseButton (Godot.Core.InputEventMouseButton.is_pressed, Godot.Core.InputEventMouseButton.get_button_index, Godot.Core.InputEventMouseButton.get_factor, Godot.Core.InputEventMouseButton.is_doubleclick, Godot.Core.InputEventMouseButton.set_button_index, Godot.Core.InputEventMouseButton.set_doubleclick, Godot.Core.InputEventMouseButton.set_factor, Godot.Core.InputEventMouseButton.set_pressed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEventMouse() instance NodeProperty InputEventMouseButton "button_index" Int 'False where nodeProperty = (get_button_index, wrapDroppingSetter set_button_index, Nothing) instance NodeProperty InputEventMouseButton "doubleclick" Bool 'False where nodeProperty = (is_doubleclick, wrapDroppingSetter set_doubleclick, Nothing) instance NodeProperty InputEventMouseButton "factor" Float 'False where nodeProperty = (get_factor, wrapDroppingSetter set_factor, Nothing) {-# NOINLINE bindInputEventMouseButton_is_pressed #-} -- | If @true@, the mouse button's state is pressed. If @false@, the mouse button's state is released. bindInputEventMouseButton_is_pressed :: MethodBind bindInputEventMouseButton_is_pressed = unsafePerformIO $ withCString "InputEventMouseButton" $ \ clsNamePtr -> withCString "is_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the mouse button's state is pressed. If @false@, the mouse button's state is released. is_pressed :: (InputEventMouseButton :< cls, Object :< cls) => cls -> IO Bool is_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseButton_is_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseButton "is_pressed" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventMouseButton.is_pressed instance NodeProperty InputEventMouseButton "pressed" Bool 'False where nodeProperty = (is_pressed, wrapDroppingSetter set_pressed, Nothing) {-# NOINLINE bindInputEventMouseButton_get_button_index #-} -- | The mouse button identifier, one of the @enum ButtonList@ button or button wheel constants. bindInputEventMouseButton_get_button_index :: MethodBind bindInputEventMouseButton_get_button_index = unsafePerformIO $ withCString "InputEventMouseButton" $ \ clsNamePtr -> withCString "get_button_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mouse button identifier, one of the @enum ButtonList@ button or button wheel constants. get_button_index :: (InputEventMouseButton :< cls, Object :< cls) => cls -> IO Int get_button_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseButton_get_button_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseButton "get_button_index" '[] (IO Int) where nodeMethod = Godot.Core.InputEventMouseButton.get_button_index {-# NOINLINE bindInputEventMouseButton_get_factor #-} -- | The amount (or delta) of the event. When used for high-precision scroll events, this indicates the scroll amount (vertical or horizontal). This is only supported on some platforms; the reported sensitivity varies depending on the platform. May be @0@ if not supported. bindInputEventMouseButton_get_factor :: MethodBind bindInputEventMouseButton_get_factor = unsafePerformIO $ withCString "InputEventMouseButton" $ \ clsNamePtr -> withCString "get_factor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount (or delta) of the event. When used for high-precision scroll events, this indicates the scroll amount (vertical or horizontal). This is only supported on some platforms; the reported sensitivity varies depending on the platform. May be @0@ if not supported. get_factor :: (InputEventMouseButton :< cls, Object :< cls) => cls -> IO Float get_factor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseButton_get_factor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseButton "get_factor" '[] (IO Float) where nodeMethod = Godot.Core.InputEventMouseButton.get_factor {-# NOINLINE bindInputEventMouseButton_is_doubleclick #-} -- | If @true@, the mouse button's state is a double-click. bindInputEventMouseButton_is_doubleclick :: MethodBind bindInputEventMouseButton_is_doubleclick = unsafePerformIO $ withCString "InputEventMouseButton" $ \ clsNamePtr -> withCString "is_doubleclick" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the mouse button's state is a double-click. is_doubleclick :: (InputEventMouseButton :< cls, Object :< cls) => cls -> IO Bool is_doubleclick cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseButton_is_doubleclick (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseButton "is_doubleclick" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventMouseButton.is_doubleclick {-# NOINLINE bindInputEventMouseButton_set_button_index #-} -- | The mouse button identifier, one of the @enum ButtonList@ button or button wheel constants. bindInputEventMouseButton_set_button_index :: MethodBind bindInputEventMouseButton_set_button_index = unsafePerformIO $ withCString "InputEventMouseButton" $ \ clsNamePtr -> withCString "set_button_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mouse button identifier, one of the @enum ButtonList@ button or button wheel constants. set_button_index :: (InputEventMouseButton :< cls, Object :< cls) => cls -> Int -> IO () set_button_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseButton_set_button_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseButton "set_button_index" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventMouseButton.set_button_index {-# NOINLINE bindInputEventMouseButton_set_doubleclick #-} -- | If @true@, the mouse button's state is a double-click. bindInputEventMouseButton_set_doubleclick :: MethodBind bindInputEventMouseButton_set_doubleclick = unsafePerformIO $ withCString "InputEventMouseButton" $ \ clsNamePtr -> withCString "set_doubleclick" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the mouse button's state is a double-click. set_doubleclick :: (InputEventMouseButton :< cls, Object :< cls) => cls -> Bool -> IO () set_doubleclick cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseButton_set_doubleclick (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseButton "set_doubleclick" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventMouseButton.set_doubleclick {-# NOINLINE bindInputEventMouseButton_set_factor #-} -- | The amount (or delta) of the event. When used for high-precision scroll events, this indicates the scroll amount (vertical or horizontal). This is only supported on some platforms; the reported sensitivity varies depending on the platform. May be @0@ if not supported. bindInputEventMouseButton_set_factor :: MethodBind bindInputEventMouseButton_set_factor = unsafePerformIO $ withCString "InputEventMouseButton" $ \ clsNamePtr -> withCString "set_factor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount (or delta) of the event. When used for high-precision scroll events, this indicates the scroll amount (vertical or horizontal). This is only supported on some platforms; the reported sensitivity varies depending on the platform. May be @0@ if not supported. set_factor :: (InputEventMouseButton :< cls, Object :< cls) => cls -> Float -> IO () set_factor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseButton_set_factor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseButton "set_factor" '[Float] (IO ()) where nodeMethod = Godot.Core.InputEventMouseButton.set_factor {-# NOINLINE bindInputEventMouseButton_set_pressed #-} -- | If @true@, the mouse button's state is pressed. If @false@, the mouse button's state is released. bindInputEventMouseButton_set_pressed :: MethodBind bindInputEventMouseButton_set_pressed = unsafePerformIO $ withCString "InputEventMouseButton" $ \ clsNamePtr -> withCString "set_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the mouse button's state is pressed. If @false@, the mouse button's state is released. set_pressed :: (InputEventMouseButton :< cls, Object :< cls) => cls -> Bool -> IO () set_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseButton_set_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseButton "set_pressed" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventMouseButton.set_pressed ================================================ FILE: src/Godot/Core/InputEventMouseMotion.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventMouseMotion (Godot.Core.InputEventMouseMotion.get_pressure, Godot.Core.InputEventMouseMotion.get_relative, Godot.Core.InputEventMouseMotion.get_speed, Godot.Core.InputEventMouseMotion.get_tilt, Godot.Core.InputEventMouseMotion.set_pressure, Godot.Core.InputEventMouseMotion.set_relative, Godot.Core.InputEventMouseMotion.set_speed, Godot.Core.InputEventMouseMotion.set_tilt) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEventMouse() instance NodeProperty InputEventMouseMotion "pressure" Float 'False where nodeProperty = (get_pressure, wrapDroppingSetter set_pressure, Nothing) instance NodeProperty InputEventMouseMotion "relative" Vector2 'False where nodeProperty = (get_relative, wrapDroppingSetter set_relative, Nothing) instance NodeProperty InputEventMouseMotion "speed" Vector2 'False where nodeProperty = (get_speed, wrapDroppingSetter set_speed, Nothing) instance NodeProperty InputEventMouseMotion "tilt" Vector2 'False where nodeProperty = (get_tilt, wrapDroppingSetter set_tilt, Nothing) {-# NOINLINE bindInputEventMouseMotion_get_pressure #-} -- | Represents the pressure the user puts on the pen. Ranges from @0.0@ to @1.0@. bindInputEventMouseMotion_get_pressure :: MethodBind bindInputEventMouseMotion_get_pressure = unsafePerformIO $ withCString "InputEventMouseMotion" $ \ clsNamePtr -> withCString "get_pressure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Represents the pressure the user puts on the pen. Ranges from @0.0@ to @1.0@. get_pressure :: (InputEventMouseMotion :< cls, Object :< cls) => cls -> IO Float get_pressure cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseMotion_get_pressure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseMotion "get_pressure" '[] (IO Float) where nodeMethod = Godot.Core.InputEventMouseMotion.get_pressure {-# NOINLINE bindInputEventMouseMotion_get_relative #-} -- | The mouse position relative to the previous position (position at the last frame). -- __Note:__ Since @InputEventMouseMotion@ is only emitted when the mouse moves, the last event won't have a relative position of @Vector2(0, 0)@ when the user stops moving the mouse. bindInputEventMouseMotion_get_relative :: MethodBind bindInputEventMouseMotion_get_relative = unsafePerformIO $ withCString "InputEventMouseMotion" $ \ clsNamePtr -> withCString "get_relative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mouse position relative to the previous position (position at the last frame). -- __Note:__ Since @InputEventMouseMotion@ is only emitted when the mouse moves, the last event won't have a relative position of @Vector2(0, 0)@ when the user stops moving the mouse. get_relative :: (InputEventMouseMotion :< cls, Object :< cls) => cls -> IO Vector2 get_relative cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseMotion_get_relative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseMotion "get_relative" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventMouseMotion.get_relative {-# NOINLINE bindInputEventMouseMotion_get_speed #-} -- | The mouse speed in pixels per second. bindInputEventMouseMotion_get_speed :: MethodBind bindInputEventMouseMotion_get_speed = unsafePerformIO $ withCString "InputEventMouseMotion" $ \ clsNamePtr -> withCString "get_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mouse speed in pixels per second. get_speed :: (InputEventMouseMotion :< cls, Object :< cls) => cls -> IO Vector2 get_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseMotion_get_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseMotion "get_speed" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventMouseMotion.get_speed {-# NOINLINE bindInputEventMouseMotion_get_tilt #-} -- | Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from @-1.0@ to @1.0@ for both axes. bindInputEventMouseMotion_get_tilt :: MethodBind bindInputEventMouseMotion_get_tilt = unsafePerformIO $ withCString "InputEventMouseMotion" $ \ clsNamePtr -> withCString "get_tilt" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from @-1.0@ to @1.0@ for both axes. get_tilt :: (InputEventMouseMotion :< cls, Object :< cls) => cls -> IO Vector2 get_tilt cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseMotion_get_tilt (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseMotion "get_tilt" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventMouseMotion.get_tilt {-# NOINLINE bindInputEventMouseMotion_set_pressure #-} -- | Represents the pressure the user puts on the pen. Ranges from @0.0@ to @1.0@. bindInputEventMouseMotion_set_pressure :: MethodBind bindInputEventMouseMotion_set_pressure = unsafePerformIO $ withCString "InputEventMouseMotion" $ \ clsNamePtr -> withCString "set_pressure" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Represents the pressure the user puts on the pen. Ranges from @0.0@ to @1.0@. set_pressure :: (InputEventMouseMotion :< cls, Object :< cls) => cls -> Float -> IO () set_pressure cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseMotion_set_pressure (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseMotion "set_pressure" '[Float] (IO ()) where nodeMethod = Godot.Core.InputEventMouseMotion.set_pressure {-# NOINLINE bindInputEventMouseMotion_set_relative #-} -- | The mouse position relative to the previous position (position at the last frame). -- __Note:__ Since @InputEventMouseMotion@ is only emitted when the mouse moves, the last event won't have a relative position of @Vector2(0, 0)@ when the user stops moving the mouse. bindInputEventMouseMotion_set_relative :: MethodBind bindInputEventMouseMotion_set_relative = unsafePerformIO $ withCString "InputEventMouseMotion" $ \ clsNamePtr -> withCString "set_relative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mouse position relative to the previous position (position at the last frame). -- __Note:__ Since @InputEventMouseMotion@ is only emitted when the mouse moves, the last event won't have a relative position of @Vector2(0, 0)@ when the user stops moving the mouse. set_relative :: (InputEventMouseMotion :< cls, Object :< cls) => cls -> Vector2 -> IO () set_relative cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseMotion_set_relative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseMotion "set_relative" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventMouseMotion.set_relative {-# NOINLINE bindInputEventMouseMotion_set_speed #-} -- | The mouse speed in pixels per second. bindInputEventMouseMotion_set_speed :: MethodBind bindInputEventMouseMotion_set_speed = unsafePerformIO $ withCString "InputEventMouseMotion" $ \ clsNamePtr -> withCString "set_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mouse speed in pixels per second. set_speed :: (InputEventMouseMotion :< cls, Object :< cls) => cls -> Vector2 -> IO () set_speed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseMotion_set_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseMotion "set_speed" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventMouseMotion.set_speed {-# NOINLINE bindInputEventMouseMotion_set_tilt #-} -- | Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from @-1.0@ to @1.0@ for both axes. bindInputEventMouseMotion_set_tilt :: MethodBind bindInputEventMouseMotion_set_tilt = unsafePerformIO $ withCString "InputEventMouseMotion" $ \ clsNamePtr -> withCString "set_tilt" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from @-1.0@ to @1.0@ for both axes. set_tilt :: (InputEventMouseMotion :< cls, Object :< cls) => cls -> Vector2 -> IO () set_tilt cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventMouseMotion_set_tilt (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventMouseMotion "set_tilt" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventMouseMotion.set_tilt ================================================ FILE: src/Godot/Core/InputEventPanGesture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventPanGesture (Godot.Core.InputEventPanGesture.get_delta, Godot.Core.InputEventPanGesture.set_delta) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEventGesture() instance NodeProperty InputEventPanGesture "delta" Vector2 'False where nodeProperty = (get_delta, wrapDroppingSetter set_delta, Nothing) {-# NOINLINE bindInputEventPanGesture_get_delta #-} bindInputEventPanGesture_get_delta :: MethodBind bindInputEventPanGesture_get_delta = unsafePerformIO $ withCString "InputEventPanGesture" $ \ clsNamePtr -> withCString "get_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_delta :: (InputEventPanGesture :< cls, Object :< cls) => cls -> IO Vector2 get_delta cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventPanGesture_get_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventPanGesture "get_delta" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventPanGesture.get_delta {-# NOINLINE bindInputEventPanGesture_set_delta #-} bindInputEventPanGesture_set_delta :: MethodBind bindInputEventPanGesture_set_delta = unsafePerformIO $ withCString "InputEventPanGesture" $ \ clsNamePtr -> withCString "set_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_delta :: (InputEventPanGesture :< cls, Object :< cls) => cls -> Vector2 -> IO () set_delta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventPanGesture_set_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventPanGesture "set_delta" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventPanGesture.set_delta ================================================ FILE: src/Godot/Core/InputEventScreenDrag.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventScreenDrag (Godot.Core.InputEventScreenDrag.get_index, Godot.Core.InputEventScreenDrag.get_position, Godot.Core.InputEventScreenDrag.get_relative, Godot.Core.InputEventScreenDrag.get_speed, Godot.Core.InputEventScreenDrag.set_index, Godot.Core.InputEventScreenDrag.set_position, Godot.Core.InputEventScreenDrag.set_relative, Godot.Core.InputEventScreenDrag.set_speed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEvent() instance NodeProperty InputEventScreenDrag "index" Int 'False where nodeProperty = (get_index, wrapDroppingSetter set_index, Nothing) instance NodeProperty InputEventScreenDrag "position" Vector2 'False where nodeProperty = (get_position, wrapDroppingSetter set_position, Nothing) instance NodeProperty InputEventScreenDrag "relative" Vector2 'False where nodeProperty = (get_relative, wrapDroppingSetter set_relative, Nothing) instance NodeProperty InputEventScreenDrag "speed" Vector2 'False where nodeProperty = (get_speed, wrapDroppingSetter set_speed, Nothing) {-# NOINLINE bindInputEventScreenDrag_get_index #-} -- | The drag event index in the case of a multi-drag event. bindInputEventScreenDrag_get_index :: MethodBind bindInputEventScreenDrag_get_index = unsafePerformIO $ withCString "InputEventScreenDrag" $ \ clsNamePtr -> withCString "get_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drag event index in the case of a multi-drag event. get_index :: (InputEventScreenDrag :< cls, Object :< cls) => cls -> IO Int get_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenDrag_get_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenDrag "get_index" '[] (IO Int) where nodeMethod = Godot.Core.InputEventScreenDrag.get_index {-# NOINLINE bindInputEventScreenDrag_get_position #-} -- | The drag position. bindInputEventScreenDrag_get_position :: MethodBind bindInputEventScreenDrag_get_position = unsafePerformIO $ withCString "InputEventScreenDrag" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drag position. get_position :: (InputEventScreenDrag :< cls, Object :< cls) => cls -> IO Vector2 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenDrag_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenDrag "get_position" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventScreenDrag.get_position {-# NOINLINE bindInputEventScreenDrag_get_relative #-} -- | The drag position relative to its start position. bindInputEventScreenDrag_get_relative :: MethodBind bindInputEventScreenDrag_get_relative = unsafePerformIO $ withCString "InputEventScreenDrag" $ \ clsNamePtr -> withCString "get_relative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drag position relative to its start position. get_relative :: (InputEventScreenDrag :< cls, Object :< cls) => cls -> IO Vector2 get_relative cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenDrag_get_relative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenDrag "get_relative" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventScreenDrag.get_relative {-# NOINLINE bindInputEventScreenDrag_get_speed #-} -- | The drag speed. bindInputEventScreenDrag_get_speed :: MethodBind bindInputEventScreenDrag_get_speed = unsafePerformIO $ withCString "InputEventScreenDrag" $ \ clsNamePtr -> withCString "get_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drag speed. get_speed :: (InputEventScreenDrag :< cls, Object :< cls) => cls -> IO Vector2 get_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenDrag_get_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenDrag "get_speed" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventScreenDrag.get_speed {-# NOINLINE bindInputEventScreenDrag_set_index #-} -- | The drag event index in the case of a multi-drag event. bindInputEventScreenDrag_set_index :: MethodBind bindInputEventScreenDrag_set_index = unsafePerformIO $ withCString "InputEventScreenDrag" $ \ clsNamePtr -> withCString "set_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drag event index in the case of a multi-drag event. set_index :: (InputEventScreenDrag :< cls, Object :< cls) => cls -> Int -> IO () set_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenDrag_set_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenDrag "set_index" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventScreenDrag.set_index {-# NOINLINE bindInputEventScreenDrag_set_position #-} -- | The drag position. bindInputEventScreenDrag_set_position :: MethodBind bindInputEventScreenDrag_set_position = unsafePerformIO $ withCString "InputEventScreenDrag" $ \ clsNamePtr -> withCString "set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drag position. set_position :: (InputEventScreenDrag :< cls, Object :< cls) => cls -> Vector2 -> IO () set_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenDrag_set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenDrag "set_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventScreenDrag.set_position {-# NOINLINE bindInputEventScreenDrag_set_relative #-} -- | The drag position relative to its start position. bindInputEventScreenDrag_set_relative :: MethodBind bindInputEventScreenDrag_set_relative = unsafePerformIO $ withCString "InputEventScreenDrag" $ \ clsNamePtr -> withCString "set_relative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drag position relative to its start position. set_relative :: (InputEventScreenDrag :< cls, Object :< cls) => cls -> Vector2 -> IO () set_relative cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenDrag_set_relative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenDrag "set_relative" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventScreenDrag.set_relative {-# NOINLINE bindInputEventScreenDrag_set_speed #-} -- | The drag speed. bindInputEventScreenDrag_set_speed :: MethodBind bindInputEventScreenDrag_set_speed = unsafePerformIO $ withCString "InputEventScreenDrag" $ \ clsNamePtr -> withCString "set_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drag speed. set_speed :: (InputEventScreenDrag :< cls, Object :< cls) => cls -> Vector2 -> IO () set_speed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenDrag_set_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenDrag "set_speed" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventScreenDrag.set_speed ================================================ FILE: src/Godot/Core/InputEventScreenTouch.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventScreenTouch (Godot.Core.InputEventScreenTouch.is_pressed, Godot.Core.InputEventScreenTouch.get_index, Godot.Core.InputEventScreenTouch.get_position, Godot.Core.InputEventScreenTouch.set_index, Godot.Core.InputEventScreenTouch.set_position, Godot.Core.InputEventScreenTouch.set_pressed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEvent() instance NodeProperty InputEventScreenTouch "index" Int 'False where nodeProperty = (get_index, wrapDroppingSetter set_index, Nothing) instance NodeProperty InputEventScreenTouch "position" Vector2 'False where nodeProperty = (get_position, wrapDroppingSetter set_position, Nothing) {-# NOINLINE bindInputEventScreenTouch_is_pressed #-} -- | If @true@, the touch's state is pressed. If @false@, the touch's state is released. bindInputEventScreenTouch_is_pressed :: MethodBind bindInputEventScreenTouch_is_pressed = unsafePerformIO $ withCString "InputEventScreenTouch" $ \ clsNamePtr -> withCString "is_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the touch's state is pressed. If @false@, the touch's state is released. is_pressed :: (InputEventScreenTouch :< cls, Object :< cls) => cls -> IO Bool is_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenTouch_is_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenTouch "is_pressed" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventScreenTouch.is_pressed instance NodeProperty InputEventScreenTouch "pressed" Bool 'False where nodeProperty = (is_pressed, wrapDroppingSetter set_pressed, Nothing) {-# NOINLINE bindInputEventScreenTouch_get_index #-} -- | The touch index in the case of a multi-touch event. One index = one finger. bindInputEventScreenTouch_get_index :: MethodBind bindInputEventScreenTouch_get_index = unsafePerformIO $ withCString "InputEventScreenTouch" $ \ clsNamePtr -> withCString "get_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The touch index in the case of a multi-touch event. One index = one finger. get_index :: (InputEventScreenTouch :< cls, Object :< cls) => cls -> IO Int get_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenTouch_get_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenTouch "get_index" '[] (IO Int) where nodeMethod = Godot.Core.InputEventScreenTouch.get_index {-# NOINLINE bindInputEventScreenTouch_get_position #-} -- | The touch position. bindInputEventScreenTouch_get_position :: MethodBind bindInputEventScreenTouch_get_position = unsafePerformIO $ withCString "InputEventScreenTouch" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The touch position. get_position :: (InputEventScreenTouch :< cls, Object :< cls) => cls -> IO Vector2 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenTouch_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenTouch "get_position" '[] (IO Vector2) where nodeMethod = Godot.Core.InputEventScreenTouch.get_position {-# NOINLINE bindInputEventScreenTouch_set_index #-} -- | The touch index in the case of a multi-touch event. One index = one finger. bindInputEventScreenTouch_set_index :: MethodBind bindInputEventScreenTouch_set_index = unsafePerformIO $ withCString "InputEventScreenTouch" $ \ clsNamePtr -> withCString "set_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The touch index in the case of a multi-touch event. One index = one finger. set_index :: (InputEventScreenTouch :< cls, Object :< cls) => cls -> Int -> IO () set_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenTouch_set_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenTouch "set_index" '[Int] (IO ()) where nodeMethod = Godot.Core.InputEventScreenTouch.set_index {-# NOINLINE bindInputEventScreenTouch_set_position #-} -- | The touch position. bindInputEventScreenTouch_set_position :: MethodBind bindInputEventScreenTouch_set_position = unsafePerformIO $ withCString "InputEventScreenTouch" $ \ clsNamePtr -> withCString "set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The touch position. set_position :: (InputEventScreenTouch :< cls, Object :< cls) => cls -> Vector2 -> IO () set_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenTouch_set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenTouch "set_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.InputEventScreenTouch.set_position {-# NOINLINE bindInputEventScreenTouch_set_pressed #-} -- | If @true@, the touch's state is pressed. If @false@, the touch's state is released. bindInputEventScreenTouch_set_pressed :: MethodBind bindInputEventScreenTouch_set_pressed = unsafePerformIO $ withCString "InputEventScreenTouch" $ \ clsNamePtr -> withCString "set_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the touch's state is pressed. If @false@, the touch's state is released. set_pressed :: (InputEventScreenTouch :< cls, Object :< cls) => cls -> Bool -> IO () set_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventScreenTouch_set_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventScreenTouch "set_pressed" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventScreenTouch.set_pressed ================================================ FILE: src/Godot/Core/InputEventWithModifiers.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputEventWithModifiers (Godot.Core.InputEventWithModifiers.get_alt, Godot.Core.InputEventWithModifiers.get_command, Godot.Core.InputEventWithModifiers.get_control, Godot.Core.InputEventWithModifiers.get_metakey, Godot.Core.InputEventWithModifiers.get_shift, Godot.Core.InputEventWithModifiers.set_alt, Godot.Core.InputEventWithModifiers.set_command, Godot.Core.InputEventWithModifiers.set_control, Godot.Core.InputEventWithModifiers.set_metakey, Godot.Core.InputEventWithModifiers.set_shift) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.InputEvent() instance NodeProperty InputEventWithModifiers "alt" Bool 'False where nodeProperty = (get_alt, wrapDroppingSetter set_alt, Nothing) instance NodeProperty InputEventWithModifiers "command" Bool 'False where nodeProperty = (get_command, wrapDroppingSetter set_command, Nothing) instance NodeProperty InputEventWithModifiers "control" Bool 'False where nodeProperty = (get_control, wrapDroppingSetter set_control, Nothing) instance NodeProperty InputEventWithModifiers "meta" Bool 'False where nodeProperty = (get_metakey, wrapDroppingSetter set_metakey, Nothing) instance NodeProperty InputEventWithModifiers "shift" Bool 'False where nodeProperty = (get_shift, wrapDroppingSetter set_shift, Nothing) {-# NOINLINE bindInputEventWithModifiers_get_alt #-} -- | State of the @Alt@ modifier. bindInputEventWithModifiers_get_alt :: MethodBind bindInputEventWithModifiers_get_alt = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "get_alt" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Alt@ modifier. get_alt :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> IO Bool get_alt cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_get_alt (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "get_alt" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventWithModifiers.get_alt {-# NOINLINE bindInputEventWithModifiers_get_command #-} -- | State of the @Command@ modifier. bindInputEventWithModifiers_get_command :: MethodBind bindInputEventWithModifiers_get_command = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "get_command" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Command@ modifier. get_command :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> IO Bool get_command cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_get_command (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "get_command" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventWithModifiers.get_command {-# NOINLINE bindInputEventWithModifiers_get_control #-} -- | State of the @Ctrl@ modifier. bindInputEventWithModifiers_get_control :: MethodBind bindInputEventWithModifiers_get_control = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "get_control" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Ctrl@ modifier. get_control :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> IO Bool get_control cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_get_control (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "get_control" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventWithModifiers.get_control {-# NOINLINE bindInputEventWithModifiers_get_metakey #-} -- | State of the @Meta@ modifier. bindInputEventWithModifiers_get_metakey :: MethodBind bindInputEventWithModifiers_get_metakey = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "get_metakey" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Meta@ modifier. get_metakey :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> IO Bool get_metakey cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_get_metakey (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "get_metakey" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventWithModifiers.get_metakey {-# NOINLINE bindInputEventWithModifiers_get_shift #-} -- | State of the @Shift@ modifier. bindInputEventWithModifiers_get_shift :: MethodBind bindInputEventWithModifiers_get_shift = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "get_shift" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Shift@ modifier. get_shift :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> IO Bool get_shift cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_get_shift (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "get_shift" '[] (IO Bool) where nodeMethod = Godot.Core.InputEventWithModifiers.get_shift {-# NOINLINE bindInputEventWithModifiers_set_alt #-} -- | State of the @Alt@ modifier. bindInputEventWithModifiers_set_alt :: MethodBind bindInputEventWithModifiers_set_alt = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "set_alt" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Alt@ modifier. set_alt :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> Bool -> IO () set_alt cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_set_alt (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "set_alt" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventWithModifiers.set_alt {-# NOINLINE bindInputEventWithModifiers_set_command #-} -- | State of the @Command@ modifier. bindInputEventWithModifiers_set_command :: MethodBind bindInputEventWithModifiers_set_command = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "set_command" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Command@ modifier. set_command :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> Bool -> IO () set_command cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_set_command (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "set_command" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventWithModifiers.set_command {-# NOINLINE bindInputEventWithModifiers_set_control #-} -- | State of the @Ctrl@ modifier. bindInputEventWithModifiers_set_control :: MethodBind bindInputEventWithModifiers_set_control = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "set_control" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Ctrl@ modifier. set_control :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> Bool -> IO () set_control cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_set_control (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "set_control" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventWithModifiers.set_control {-# NOINLINE bindInputEventWithModifiers_set_metakey #-} -- | State of the @Meta@ modifier. bindInputEventWithModifiers_set_metakey :: MethodBind bindInputEventWithModifiers_set_metakey = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "set_metakey" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Meta@ modifier. set_metakey :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> Bool -> IO () set_metakey cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_set_metakey (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "set_metakey" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventWithModifiers.set_metakey {-# NOINLINE bindInputEventWithModifiers_set_shift #-} -- | State of the @Shift@ modifier. bindInputEventWithModifiers_set_shift :: MethodBind bindInputEventWithModifiers_set_shift = unsafePerformIO $ withCString "InputEventWithModifiers" $ \ clsNamePtr -> withCString "set_shift" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | State of the @Shift@ modifier. set_shift :: (InputEventWithModifiers :< cls, Object :< cls) => cls -> Bool -> IO () set_shift cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputEventWithModifiers_set_shift (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputEventWithModifiers "set_shift" '[Bool] (IO ()) where nodeMethod = Godot.Core.InputEventWithModifiers.set_shift ================================================ FILE: src/Godot/Core/InputMap.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InputMap (Godot.Core.InputMap.action_add_event, Godot.Core.InputMap.action_erase_event, Godot.Core.InputMap.action_erase_events, Godot.Core.InputMap.action_has_event, Godot.Core.InputMap.action_set_deadzone, Godot.Core.InputMap.add_action, Godot.Core.InputMap.erase_action, Godot.Core.InputMap.event_is_action, Godot.Core.InputMap.get_action_list, Godot.Core.InputMap.get_actions, Godot.Core.InputMap.has_action, Godot.Core.InputMap.load_from_globals) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindInputMap_action_add_event #-} -- | Adds an @InputEvent@ to an action. This @InputEvent@ will trigger the action. bindInputMap_action_add_event :: MethodBind bindInputMap_action_add_event = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "action_add_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an @InputEvent@ to an action. This @InputEvent@ will trigger the action. action_add_event :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> InputEvent -> IO () action_add_event cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_action_add_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "action_add_event" '[GodotString, InputEvent] (IO ()) where nodeMethod = Godot.Core.InputMap.action_add_event {-# NOINLINE bindInputMap_action_erase_event #-} -- | Removes an @InputEvent@ from an action. bindInputMap_action_erase_event :: MethodBind bindInputMap_action_erase_event = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "action_erase_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes an @InputEvent@ from an action. action_erase_event :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> InputEvent -> IO () action_erase_event cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_action_erase_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "action_erase_event" '[GodotString, InputEvent] (IO ()) where nodeMethod = Godot.Core.InputMap.action_erase_event {-# NOINLINE bindInputMap_action_erase_events #-} -- | Removes all events from an action. bindInputMap_action_erase_events :: MethodBind bindInputMap_action_erase_events = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "action_erase_events" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all events from an action. action_erase_events :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> IO () action_erase_events cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_action_erase_events (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "action_erase_events" '[GodotString] (IO ()) where nodeMethod = Godot.Core.InputMap.action_erase_events {-# NOINLINE bindInputMap_action_has_event #-} -- | Returns @true@ if the action has the given @InputEvent@ associated with it. bindInputMap_action_has_event :: MethodBind bindInputMap_action_has_event = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "action_has_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the action has the given @InputEvent@ associated with it. action_has_event :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> InputEvent -> IO Bool action_has_event cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_action_has_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "action_has_event" '[GodotString, InputEvent] (IO Bool) where nodeMethod = Godot.Core.InputMap.action_has_event {-# NOINLINE bindInputMap_action_set_deadzone #-} -- | Sets a deadzone value for the action. bindInputMap_action_set_deadzone :: MethodBind bindInputMap_action_set_deadzone = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "action_set_deadzone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a deadzone value for the action. action_set_deadzone :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () action_set_deadzone cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_action_set_deadzone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "action_set_deadzone" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.InputMap.action_set_deadzone {-# NOINLINE bindInputMap_add_action #-} -- | Adds an empty action to the @InputMap@ with a configurable @deadzone@. -- An @InputEvent@ can then be added to this action with @method action_add_event@. bindInputMap_add_action :: MethodBind bindInputMap_add_action = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "add_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an empty action to the @InputMap@ with a configurable @deadzone@. -- An @InputEvent@ can then be added to this action with @method action_add_event@. add_action :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> Maybe Float -> IO () add_action cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantReal (0.5)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_add_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "add_action" '[GodotString, Maybe Float] (IO ()) where nodeMethod = Godot.Core.InputMap.add_action {-# NOINLINE bindInputMap_erase_action #-} -- | Removes an action from the @InputMap@. bindInputMap_erase_action :: MethodBind bindInputMap_erase_action = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "erase_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes an action from the @InputMap@. erase_action :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> IO () erase_action cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_erase_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "erase_action" '[GodotString] (IO ()) where nodeMethod = Godot.Core.InputMap.erase_action {-# NOINLINE bindInputMap_event_is_action #-} -- | Returns @true@ if the given event is part of an existing action. This method ignores keyboard modifiers if the given @InputEvent@ is not pressed (for proper release detection). See @method action_has_event@ if you don't want this behavior. bindInputMap_event_is_action :: MethodBind bindInputMap_event_is_action = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "event_is_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given event is part of an existing action. This method ignores keyboard modifiers if the given @InputEvent@ is not pressed (for proper release detection). See @method action_has_event@ if you don't want this behavior. event_is_action :: (InputMap :< cls, Object :< cls) => cls -> InputEvent -> GodotString -> IO Bool event_is_action cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_event_is_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "event_is_action" '[InputEvent, GodotString] (IO Bool) where nodeMethod = Godot.Core.InputMap.event_is_action {-# NOINLINE bindInputMap_get_action_list #-} -- | Returns an array of @InputEvent@s associated with a given action. bindInputMap_get_action_list :: MethodBind bindInputMap_get_action_list = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "get_action_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of @InputEvent@s associated with a given action. get_action_list :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> IO Array get_action_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_get_action_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "get_action_list" '[GodotString] (IO Array) where nodeMethod = Godot.Core.InputMap.get_action_list {-# NOINLINE bindInputMap_get_actions #-} -- | Returns an array of all actions in the @InputMap@. bindInputMap_get_actions :: MethodBind bindInputMap_get_actions = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "get_actions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of all actions in the @InputMap@. get_actions :: (InputMap :< cls, Object :< cls) => cls -> IO Array get_actions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_get_actions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "get_actions" '[] (IO Array) where nodeMethod = Godot.Core.InputMap.get_actions {-# NOINLINE bindInputMap_has_action #-} -- | Returns @true@ if the @InputMap@ has a registered action with the given name. bindInputMap_has_action :: MethodBind bindInputMap_has_action = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "has_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the @InputMap@ has a registered action with the given name. has_action :: (InputMap :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_action cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_has_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "has_action" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.InputMap.has_action {-# NOINLINE bindInputMap_load_from_globals #-} -- | Clears all @InputEventAction@ in the @InputMap@ and load it anew from @ProjectSettings@. bindInputMap_load_from_globals :: MethodBind bindInputMap_load_from_globals = unsafePerformIO $ withCString "InputMap" $ \ clsNamePtr -> withCString "load_from_globals" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all @InputEventAction@ in the @InputMap@ and load it anew from @ProjectSettings@. load_from_globals :: (InputMap :< cls, Object :< cls) => cls -> IO () load_from_globals cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInputMap_load_from_globals (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InputMap "load_from_globals" '[] (IO ()) where nodeMethod = Godot.Core.InputMap.load_from_globals ================================================ FILE: src/Godot/Core/InstancePlaceholder.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InstancePlaceholder (Godot.Core.InstancePlaceholder.create_instance, Godot.Core.InstancePlaceholder.get_instance_path, Godot.Core.InstancePlaceholder.get_stored_values, Godot.Core.InstancePlaceholder.replace_by_instance) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() {-# NOINLINE bindInstancePlaceholder_create_instance #-} bindInstancePlaceholder_create_instance :: MethodBind bindInstancePlaceholder_create_instance = unsafePerformIO $ withCString "InstancePlaceholder" $ \ clsNamePtr -> withCString "create_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr create_instance :: (InstancePlaceholder :< cls, Object :< cls) => cls -> Maybe Bool -> Maybe PackedScene -> IO Node create_instance cls arg1 arg2 = withVariantArray [maybe (VariantBool False) toVariant arg1, maybe VariantNil toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindInstancePlaceholder_create_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InstancePlaceholder "create_instance" '[Maybe Bool, Maybe PackedScene] (IO Node) where nodeMethod = Godot.Core.InstancePlaceholder.create_instance {-# NOINLINE bindInstancePlaceholder_get_instance_path #-} -- | Gets the path to the @PackedScene@ resource file that is loaded by default when calling @method replace_by_instance@. bindInstancePlaceholder_get_instance_path :: MethodBind bindInstancePlaceholder_get_instance_path = unsafePerformIO $ withCString "InstancePlaceholder" $ \ clsNamePtr -> withCString "get_instance_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the path to the @PackedScene@ resource file that is loaded by default when calling @method replace_by_instance@. get_instance_path :: (InstancePlaceholder :< cls, Object :< cls) => cls -> IO GodotString get_instance_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInstancePlaceholder_get_instance_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InstancePlaceholder "get_instance_path" '[] (IO GodotString) where nodeMethod = Godot.Core.InstancePlaceholder.get_instance_path {-# NOINLINE bindInstancePlaceholder_get_stored_values #-} bindInstancePlaceholder_get_stored_values :: MethodBind bindInstancePlaceholder_get_stored_values = unsafePerformIO $ withCString "InstancePlaceholder" $ \ clsNamePtr -> withCString "get_stored_values" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_stored_values :: (InstancePlaceholder :< cls, Object :< cls) => cls -> Maybe Bool -> IO Dictionary get_stored_values cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInstancePlaceholder_get_stored_values (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InstancePlaceholder "get_stored_values" '[Maybe Bool] (IO Dictionary) where nodeMethod = Godot.Core.InstancePlaceholder.get_stored_values {-# NOINLINE bindInstancePlaceholder_replace_by_instance #-} -- | Replaces this placeholder by the scene handed as an argument, or the original scene if no argument is given. As for all resources, the scene is loaded only if it's not loaded already. By manually loading the scene beforehand, delays caused by this function can be avoided. bindInstancePlaceholder_replace_by_instance :: MethodBind bindInstancePlaceholder_replace_by_instance = unsafePerformIO $ withCString "InstancePlaceholder" $ \ clsNamePtr -> withCString "replace_by_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Replaces this placeholder by the scene handed as an argument, or the original scene if no argument is given. As for all resources, the scene is loaded only if it's not loaded already. By manually loading the scene beforehand, delays caused by this function can be avoided. replace_by_instance :: (InstancePlaceholder :< cls, Object :< cls) => cls -> Maybe PackedScene -> IO () replace_by_instance cls arg1 = withVariantArray [maybe VariantNil toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInstancePlaceholder_replace_by_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InstancePlaceholder "replace_by_instance" '[Maybe PackedScene] (IO ()) where nodeMethod = Godot.Core.InstancePlaceholder.replace_by_instance ================================================ FILE: src/Godot/Core/InterpolatedCamera.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.InterpolatedCamera (Godot.Core.InterpolatedCamera.get_speed, Godot.Core.InterpolatedCamera.get_target_path, Godot.Core.InterpolatedCamera.is_interpolation_enabled, Godot.Core.InterpolatedCamera.set_interpolation_enabled, Godot.Core.InterpolatedCamera.set_speed, Godot.Core.InterpolatedCamera.set_target, Godot.Core.InterpolatedCamera.set_target_path) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Camera() instance NodeProperty InterpolatedCamera "enabled" Bool 'False where nodeProperty = (is_interpolation_enabled, wrapDroppingSetter set_interpolation_enabled, Nothing) instance NodeProperty InterpolatedCamera "speed" Float 'False where nodeProperty = (get_speed, wrapDroppingSetter set_speed, Nothing) instance NodeProperty InterpolatedCamera "target" NodePath 'False where nodeProperty = (get_target_path, wrapDroppingSetter set_target_path, Nothing) {-# NOINLINE bindInterpolatedCamera_get_speed #-} -- | How quickly the camera moves toward its target. Higher values will result in tighter camera motion. bindInterpolatedCamera_get_speed :: MethodBind bindInterpolatedCamera_get_speed = unsafePerformIO $ withCString "InterpolatedCamera" $ \ clsNamePtr -> withCString "get_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How quickly the camera moves toward its target. Higher values will result in tighter camera motion. get_speed :: (InterpolatedCamera :< cls, Object :< cls) => cls -> IO Float get_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInterpolatedCamera_get_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InterpolatedCamera "get_speed" '[] (IO Float) where nodeMethod = Godot.Core.InterpolatedCamera.get_speed {-# NOINLINE bindInterpolatedCamera_get_target_path #-} -- | The target's @NodePath@. bindInterpolatedCamera_get_target_path :: MethodBind bindInterpolatedCamera_get_target_path = unsafePerformIO $ withCString "InterpolatedCamera" $ \ clsNamePtr -> withCString "get_target_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The target's @NodePath@. get_target_path :: (InterpolatedCamera :< cls, Object :< cls) => cls -> IO NodePath get_target_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInterpolatedCamera_get_target_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InterpolatedCamera "get_target_path" '[] (IO NodePath) where nodeMethod = Godot.Core.InterpolatedCamera.get_target_path {-# NOINLINE bindInterpolatedCamera_is_interpolation_enabled #-} -- | If @true@, and a target is set, the camera will move automatically. bindInterpolatedCamera_is_interpolation_enabled :: MethodBind bindInterpolatedCamera_is_interpolation_enabled = unsafePerformIO $ withCString "InterpolatedCamera" $ \ clsNamePtr -> withCString "is_interpolation_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, and a target is set, the camera will move automatically. is_interpolation_enabled :: (InterpolatedCamera :< cls, Object :< cls) => cls -> IO Bool is_interpolation_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindInterpolatedCamera_is_interpolation_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InterpolatedCamera "is_interpolation_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.InterpolatedCamera.is_interpolation_enabled {-# NOINLINE bindInterpolatedCamera_set_interpolation_enabled #-} -- | If @true@, and a target is set, the camera will move automatically. bindInterpolatedCamera_set_interpolation_enabled :: MethodBind bindInterpolatedCamera_set_interpolation_enabled = unsafePerformIO $ withCString "InterpolatedCamera" $ \ clsNamePtr -> withCString "set_interpolation_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, and a target is set, the camera will move automatically. set_interpolation_enabled :: (InterpolatedCamera :< cls, Object :< cls) => cls -> Bool -> IO () set_interpolation_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInterpolatedCamera_set_interpolation_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InterpolatedCamera "set_interpolation_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.InterpolatedCamera.set_interpolation_enabled {-# NOINLINE bindInterpolatedCamera_set_speed #-} -- | How quickly the camera moves toward its target. Higher values will result in tighter camera motion. bindInterpolatedCamera_set_speed :: MethodBind bindInterpolatedCamera_set_speed = unsafePerformIO $ withCString "InterpolatedCamera" $ \ clsNamePtr -> withCString "set_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How quickly the camera moves toward its target. Higher values will result in tighter camera motion. set_speed :: (InterpolatedCamera :< cls, Object :< cls) => cls -> Float -> IO () set_speed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInterpolatedCamera_set_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InterpolatedCamera "set_speed" '[Float] (IO ()) where nodeMethod = Godot.Core.InterpolatedCamera.set_speed {-# NOINLINE bindInterpolatedCamera_set_target #-} -- | Sets the node to move toward and orient with. bindInterpolatedCamera_set_target :: MethodBind bindInterpolatedCamera_set_target = unsafePerformIO $ withCString "InterpolatedCamera" $ \ clsNamePtr -> withCString "set_target" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the node to move toward and orient with. set_target :: (InterpolatedCamera :< cls, Object :< cls) => cls -> Object -> IO () set_target cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInterpolatedCamera_set_target (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InterpolatedCamera "set_target" '[Object] (IO ()) where nodeMethod = Godot.Core.InterpolatedCamera.set_target {-# NOINLINE bindInterpolatedCamera_set_target_path #-} -- | The target's @NodePath@. bindInterpolatedCamera_set_target_path :: MethodBind bindInterpolatedCamera_set_target_path = unsafePerformIO $ withCString "InterpolatedCamera" $ \ clsNamePtr -> withCString "set_target_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The target's @NodePath@. set_target_path :: (InterpolatedCamera :< cls, Object :< cls) => cls -> NodePath -> IO () set_target_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindInterpolatedCamera_set_target_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod InterpolatedCamera "set_target_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.InterpolatedCamera.set_target_path ================================================ FILE: src/Godot/Core/ItemList.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ItemList (Godot.Core.ItemList._ICON_MODE_LEFT, Godot.Core.ItemList._SELECT_MULTI, Godot.Core.ItemList._SELECT_SINGLE, Godot.Core.ItemList._ICON_MODE_TOP, Godot.Core.ItemList.sig_item_activated, Godot.Core.ItemList.sig_item_rmb_selected, Godot.Core.ItemList.sig_item_selected, Godot.Core.ItemList.sig_multi_selected, Godot.Core.ItemList.sig_nothing_selected, Godot.Core.ItemList.sig_rmb_clicked, Godot.Core.ItemList._get_items, Godot.Core.ItemList._gui_input, Godot.Core.ItemList._scroll_changed, Godot.Core.ItemList._set_items, Godot.Core.ItemList.add_icon_item, Godot.Core.ItemList.add_item, Godot.Core.ItemList.clear, Godot.Core.ItemList.ensure_current_is_visible, Godot.Core.ItemList.get_allow_reselect, Godot.Core.ItemList.get_allow_rmb_select, Godot.Core.ItemList.get_fixed_column_width, Godot.Core.ItemList.get_fixed_icon_size, Godot.Core.ItemList.get_icon_mode, Godot.Core.ItemList.get_icon_scale, Godot.Core.ItemList.get_item_at_position, Godot.Core.ItemList.get_item_count, Godot.Core.ItemList.get_item_custom_bg_color, Godot.Core.ItemList.get_item_custom_fg_color, Godot.Core.ItemList.get_item_icon, Godot.Core.ItemList.get_item_icon_modulate, Godot.Core.ItemList.get_item_icon_region, Godot.Core.ItemList.get_item_metadata, Godot.Core.ItemList.get_item_text, Godot.Core.ItemList.get_item_tooltip, Godot.Core.ItemList.get_max_columns, Godot.Core.ItemList.get_max_text_lines, Godot.Core.ItemList.get_select_mode, Godot.Core.ItemList.get_selected_items, Godot.Core.ItemList.get_v_scroll, Godot.Core.ItemList.has_auto_height, Godot.Core.ItemList.is_anything_selected, Godot.Core.ItemList.is_item_disabled, Godot.Core.ItemList.is_item_icon_transposed, Godot.Core.ItemList.is_item_selectable, Godot.Core.ItemList.is_item_tooltip_enabled, Godot.Core.ItemList.is_same_column_width, Godot.Core.ItemList.is_selected, Godot.Core.ItemList.move_item, Godot.Core.ItemList.remove_item, Godot.Core.ItemList.select, Godot.Core.ItemList.set_allow_reselect, Godot.Core.ItemList.set_allow_rmb_select, Godot.Core.ItemList.set_auto_height, Godot.Core.ItemList.set_fixed_column_width, Godot.Core.ItemList.set_fixed_icon_size, Godot.Core.ItemList.set_icon_mode, Godot.Core.ItemList.set_icon_scale, Godot.Core.ItemList.set_item_custom_bg_color, Godot.Core.ItemList.set_item_custom_fg_color, Godot.Core.ItemList.set_item_disabled, Godot.Core.ItemList.set_item_icon, Godot.Core.ItemList.set_item_icon_modulate, Godot.Core.ItemList.set_item_icon_region, Godot.Core.ItemList.set_item_icon_transposed, Godot.Core.ItemList.set_item_metadata, Godot.Core.ItemList.set_item_selectable, Godot.Core.ItemList.set_item_text, Godot.Core.ItemList.set_item_tooltip, Godot.Core.ItemList.set_item_tooltip_enabled, Godot.Core.ItemList.set_max_columns, Godot.Core.ItemList.set_max_text_lines, Godot.Core.ItemList.set_same_column_width, Godot.Core.ItemList.set_select_mode, Godot.Core.ItemList.sort_items_by_text, Godot.Core.ItemList.unselect, Godot.Core.ItemList.unselect_all) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _ICON_MODE_LEFT :: Int _ICON_MODE_LEFT = 1 _SELECT_MULTI :: Int _SELECT_MULTI = 1 _SELECT_SINGLE :: Int _SELECT_SINGLE = 0 _ICON_MODE_TOP :: Int _ICON_MODE_TOP = 0 -- | Triggered when specified list item is activated via double-clicking or by pressing Enter. sig_item_activated :: Godot.Internal.Dispatch.Signal ItemList sig_item_activated = Godot.Internal.Dispatch.Signal "item_activated" instance NodeSignal ItemList "item_activated" '[Int] -- | Triggered when specified list item has been selected via right mouse clicking. -- The click position is also provided to allow appropriate popup of context menus at the correct location. -- @allow_rmb_select@ must be enabled. sig_item_rmb_selected :: Godot.Internal.Dispatch.Signal ItemList sig_item_rmb_selected = Godot.Internal.Dispatch.Signal "item_rmb_selected" instance NodeSignal ItemList "item_rmb_selected" '[Int, Vector2] -- | Triggered when specified item has been selected. -- @allow_reselect@ must be enabled to reselect an item. sig_item_selected :: Godot.Internal.Dispatch.Signal ItemList sig_item_selected = Godot.Internal.Dispatch.Signal "item_selected" instance NodeSignal ItemList "item_selected" '[Int] -- | Triggered when a multiple selection is altered on a list allowing multiple selection. sig_multi_selected :: Godot.Internal.Dispatch.Signal ItemList sig_multi_selected = Godot.Internal.Dispatch.Signal "multi_selected" instance NodeSignal ItemList "multi_selected" '[Int, Bool] -- | Triggered when a left mouse click is issued within the rect of the list but on empty space. sig_nothing_selected :: Godot.Internal.Dispatch.Signal ItemList sig_nothing_selected = Godot.Internal.Dispatch.Signal "nothing_selected" instance NodeSignal ItemList "nothing_selected" '[] -- | Triggered when a right mouse click is issued within the rect of the list but on empty space. -- @allow_rmb_select@ must be enabled. sig_rmb_clicked :: Godot.Internal.Dispatch.Signal ItemList sig_rmb_clicked = Godot.Internal.Dispatch.Signal "rmb_clicked" instance NodeSignal ItemList "rmb_clicked" '[Vector2] instance NodeProperty ItemList "allow_reselect" Bool 'False where nodeProperty = (get_allow_reselect, wrapDroppingSetter set_allow_reselect, Nothing) instance NodeProperty ItemList "allow_rmb_select" Bool 'False where nodeProperty = (get_allow_rmb_select, wrapDroppingSetter set_allow_rmb_select, Nothing) instance NodeProperty ItemList "auto_height" Bool 'False where nodeProperty = (has_auto_height, wrapDroppingSetter set_auto_height, Nothing) instance NodeProperty ItemList "fixed_column_width" Int 'False where nodeProperty = (get_fixed_column_width, wrapDroppingSetter set_fixed_column_width, Nothing) instance NodeProperty ItemList "fixed_icon_size" Vector2 'False where nodeProperty = (get_fixed_icon_size, wrapDroppingSetter set_fixed_icon_size, Nothing) instance NodeProperty ItemList "icon_mode" Int 'False where nodeProperty = (get_icon_mode, wrapDroppingSetter set_icon_mode, Nothing) instance NodeProperty ItemList "icon_scale" Float 'False where nodeProperty = (get_icon_scale, wrapDroppingSetter set_icon_scale, Nothing) instance NodeProperty ItemList "items" Array 'False where nodeProperty = (_get_items, wrapDroppingSetter _set_items, Nothing) instance NodeProperty ItemList "max_columns" Int 'False where nodeProperty = (get_max_columns, wrapDroppingSetter set_max_columns, Nothing) instance NodeProperty ItemList "max_text_lines" Int 'False where nodeProperty = (get_max_text_lines, wrapDroppingSetter set_max_text_lines, Nothing) instance NodeProperty ItemList "same_column_width" Bool 'False where nodeProperty = (is_same_column_width, wrapDroppingSetter set_same_column_width, Nothing) instance NodeProperty ItemList "select_mode" Int 'False where nodeProperty = (get_select_mode, wrapDroppingSetter set_select_mode, Nothing) {-# NOINLINE bindItemList__get_items #-} bindItemList__get_items :: MethodBind bindItemList__get_items = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "_get_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_items :: (ItemList :< cls, Object :< cls) => cls -> IO Array _get_items cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList__get_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "_get_items" '[] (IO Array) where nodeMethod = Godot.Core.ItemList._get_items {-# NOINLINE bindItemList__gui_input #-} bindItemList__gui_input :: MethodBind bindItemList__gui_input = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (ItemList :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ItemList._gui_input {-# NOINLINE bindItemList__scroll_changed #-} bindItemList__scroll_changed :: MethodBind bindItemList__scroll_changed = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "_scroll_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _scroll_changed :: (ItemList :< cls, Object :< cls) => cls -> Float -> IO () _scroll_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList__scroll_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "_scroll_changed" '[Float] (IO ()) where nodeMethod = Godot.Core.ItemList._scroll_changed {-# NOINLINE bindItemList__set_items #-} bindItemList__set_items :: MethodBind bindItemList__set_items = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "_set_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_items :: (ItemList :< cls, Object :< cls) => cls -> Array -> IO () _set_items cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList__set_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "_set_items" '[Array] (IO ()) where nodeMethod = Godot.Core.ItemList._set_items {-# NOINLINE bindItemList_add_icon_item #-} -- | Adds an item to the item list with no text, only an icon. bindItemList_add_icon_item :: MethodBind bindItemList_add_icon_item = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "add_icon_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an item to the item list with no text, only an icon. add_icon_item :: (ItemList :< cls, Object :< cls) => cls -> Texture -> Maybe Bool -> IO () add_icon_item cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_add_icon_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "add_icon_item" '[Texture, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.add_icon_item {-# NOINLINE bindItemList_add_item #-} -- | Adds an item to the item list with specified text. Specify an @icon@, or use @null@ as the @icon@ for a list item with no icon. -- If selectable is @true@, the list item will be selectable. bindItemList_add_item :: MethodBind bindItemList_add_item = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "add_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an item to the item list with specified text. Specify an @icon@, or use @null@ as the @icon@ for a list item with no icon. -- If selectable is @true@, the list item will be selectable. add_item :: (ItemList :< cls, Object :< cls) => cls -> GodotString -> Maybe Texture -> Maybe Bool -> IO () add_item cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe VariantNil toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_add_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "add_item" '[GodotString, Maybe Texture, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.add_item {-# NOINLINE bindItemList_clear #-} -- | Removes all items from the list. bindItemList_clear :: MethodBind bindItemList_clear = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all items from the list. clear :: (ItemList :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "clear" '[] (IO ()) where nodeMethod = Godot.Core.ItemList.clear {-# NOINLINE bindItemList_ensure_current_is_visible #-} -- | Ensure current selection is visible, adjusting the scroll position as necessary. bindItemList_ensure_current_is_visible :: MethodBind bindItemList_ensure_current_is_visible = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "ensure_current_is_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Ensure current selection is visible, adjusting the scroll position as necessary. ensure_current_is_visible :: (ItemList :< cls, Object :< cls) => cls -> IO () ensure_current_is_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_ensure_current_is_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "ensure_current_is_visible" '[] (IO ()) where nodeMethod = Godot.Core.ItemList.ensure_current_is_visible {-# NOINLINE bindItemList_get_allow_reselect #-} -- | If @true@, the currently selected item can be selected again. bindItemList_get_allow_reselect :: MethodBind bindItemList_get_allow_reselect = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_allow_reselect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the currently selected item can be selected again. get_allow_reselect :: (ItemList :< cls, Object :< cls) => cls -> IO Bool get_allow_reselect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_allow_reselect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_allow_reselect" '[] (IO Bool) where nodeMethod = Godot.Core.ItemList.get_allow_reselect {-# NOINLINE bindItemList_get_allow_rmb_select #-} -- | If @true@, right mouse button click can select items. bindItemList_get_allow_rmb_select :: MethodBind bindItemList_get_allow_rmb_select = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_allow_rmb_select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, right mouse button click can select items. get_allow_rmb_select :: (ItemList :< cls, Object :< cls) => cls -> IO Bool get_allow_rmb_select cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_allow_rmb_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_allow_rmb_select" '[] (IO Bool) where nodeMethod = Godot.Core.ItemList.get_allow_rmb_select {-# NOINLINE bindItemList_get_fixed_column_width #-} -- | The width all columns will be adjusted to. -- A value of zero disables the adjustment, each item will have a width equal to the width of its content and the columns will have an uneven width. bindItemList_get_fixed_column_width :: MethodBind bindItemList_get_fixed_column_width = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_fixed_column_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The width all columns will be adjusted to. -- A value of zero disables the adjustment, each item will have a width equal to the width of its content and the columns will have an uneven width. get_fixed_column_width :: (ItemList :< cls, Object :< cls) => cls -> IO Int get_fixed_column_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_fixed_column_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_fixed_column_width" '[] (IO Int) where nodeMethod = Godot.Core.ItemList.get_fixed_column_width {-# NOINLINE bindItemList_get_fixed_icon_size #-} -- | The size all icons will be adjusted to. -- If either X or Y component is not greater than zero, icon size won't be affected. bindItemList_get_fixed_icon_size :: MethodBind bindItemList_get_fixed_icon_size = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_fixed_icon_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size all icons will be adjusted to. -- If either X or Y component is not greater than zero, icon size won't be affected. get_fixed_icon_size :: (ItemList :< cls, Object :< cls) => cls -> IO Vector2 get_fixed_icon_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_fixed_icon_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_fixed_icon_size" '[] (IO Vector2) where nodeMethod = Godot.Core.ItemList.get_fixed_icon_size {-# NOINLINE bindItemList_get_icon_mode #-} -- | The icon position, whether above or to the left of the text. See the @enum IconMode@ constants. bindItemList_get_icon_mode :: MethodBind bindItemList_get_icon_mode = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_icon_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The icon position, whether above or to the left of the text. See the @enum IconMode@ constants. get_icon_mode :: (ItemList :< cls, Object :< cls) => cls -> IO Int get_icon_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_icon_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_icon_mode" '[] (IO Int) where nodeMethod = Godot.Core.ItemList.get_icon_mode {-# NOINLINE bindItemList_get_icon_scale #-} -- | The scale of icon applied after @fixed_icon_size@ and transposing takes effect. bindItemList_get_icon_scale :: MethodBind bindItemList_get_icon_scale = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_icon_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The scale of icon applied after @fixed_icon_size@ and transposing takes effect. get_icon_scale :: (ItemList :< cls, Object :< cls) => cls -> IO Float get_icon_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_icon_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_icon_scale" '[] (IO Float) where nodeMethod = Godot.Core.ItemList.get_icon_scale {-# NOINLINE bindItemList_get_item_at_position #-} -- | Returns the item index at the given @position@. -- When there is no item at that point, -1 will be returned if @exact@ is @true@, and the closest item index will be returned otherwise. bindItemList_get_item_at_position :: MethodBind bindItemList_get_item_at_position = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_at_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the item index at the given @position@. -- When there is no item at that point, -1 will be returned if @exact@ is @true@, and the closest item index will be returned otherwise. get_item_at_position :: (ItemList :< cls, Object :< cls) => cls -> Vector2 -> Maybe Bool -> IO Int get_item_at_position cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_at_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_at_position" '[Vector2, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.ItemList.get_item_at_position {-# NOINLINE bindItemList_get_item_count #-} -- | Returns the number of items currently in the list. bindItemList_get_item_count :: MethodBind bindItemList_get_item_count = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of items currently in the list. get_item_count :: (ItemList :< cls, Object :< cls) => cls -> IO Int get_item_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_count" '[] (IO Int) where nodeMethod = Godot.Core.ItemList.get_item_count {-# NOINLINE bindItemList_get_item_custom_bg_color #-} -- | Returns the custom background color of the item specified by @idx@ index. bindItemList_get_item_custom_bg_color :: MethodBind bindItemList_get_item_custom_bg_color = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_custom_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the custom background color of the item specified by @idx@ index. get_item_custom_bg_color :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Color get_item_custom_bg_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_custom_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_custom_bg_color" '[Int] (IO Color) where nodeMethod = Godot.Core.ItemList.get_item_custom_bg_color {-# NOINLINE bindItemList_get_item_custom_fg_color #-} -- | Returns the custom foreground color of the item specified by @idx@ index. bindItemList_get_item_custom_fg_color :: MethodBind bindItemList_get_item_custom_fg_color = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_custom_fg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the custom foreground color of the item specified by @idx@ index. get_item_custom_fg_color :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Color get_item_custom_fg_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_custom_fg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_custom_fg_color" '[Int] (IO Color) where nodeMethod = Godot.Core.ItemList.get_item_custom_fg_color {-# NOINLINE bindItemList_get_item_icon #-} -- | Returns the icon associated with the specified index. bindItemList_get_item_icon :: MethodBind bindItemList_get_item_icon = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the icon associated with the specified index. get_item_icon :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Texture get_item_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_icon" '[Int] (IO Texture) where nodeMethod = Godot.Core.ItemList.get_item_icon {-# NOINLINE bindItemList_get_item_icon_modulate #-} -- | Returns a @Color@ modulating item's icon at the specified index. bindItemList_get_item_icon_modulate :: MethodBind bindItemList_get_item_icon_modulate = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_icon_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @Color@ modulating item's icon at the specified index. get_item_icon_modulate :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Color get_item_icon_modulate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_icon_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_icon_modulate" '[Int] (IO Color) where nodeMethod = Godot.Core.ItemList.get_item_icon_modulate {-# NOINLINE bindItemList_get_item_icon_region #-} -- | Returns the region of item's icon used. The whole icon will be used if the region has no area. bindItemList_get_item_icon_region :: MethodBind bindItemList_get_item_icon_region = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_icon_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the region of item's icon used. The whole icon will be used if the region has no area. get_item_icon_region :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Rect2 get_item_icon_region cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_icon_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_icon_region" '[Int] (IO Rect2) where nodeMethod = Godot.Core.ItemList.get_item_icon_region {-# NOINLINE bindItemList_get_item_metadata #-} -- | Returns the metadata value of the specified index. bindItemList_get_item_metadata :: MethodBind bindItemList_get_item_metadata = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the metadata value of the specified index. get_item_metadata :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_item_metadata cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_metadata" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.ItemList.get_item_metadata {-# NOINLINE bindItemList_get_item_text #-} -- | Returns the text associated with the specified index. bindItemList_get_item_text :: MethodBind bindItemList_get_item_text = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the text associated with the specified index. get_item_text :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO GodotString get_item_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_text" '[Int] (IO GodotString) where nodeMethod = Godot.Core.ItemList.get_item_text {-# NOINLINE bindItemList_get_item_tooltip #-} -- | Returns the tooltip hint associated with the specified index. bindItemList_get_item_tooltip :: MethodBind bindItemList_get_item_tooltip = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_item_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tooltip hint associated with the specified index. get_item_tooltip :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO GodotString get_item_tooltip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_item_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_item_tooltip" '[Int] (IO GodotString) where nodeMethod = Godot.Core.ItemList.get_item_tooltip {-# NOINLINE bindItemList_get_max_columns #-} -- | Maximum columns the list will have. -- If greater than zero, the content will be split among the specified columns. -- A value of zero means unlimited columns, i.e. all items will be put in the same row. bindItemList_get_max_columns :: MethodBind bindItemList_get_max_columns = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_max_columns" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum columns the list will have. -- If greater than zero, the content will be split among the specified columns. -- A value of zero means unlimited columns, i.e. all items will be put in the same row. get_max_columns :: (ItemList :< cls, Object :< cls) => cls -> IO Int get_max_columns cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_max_columns (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_max_columns" '[] (IO Int) where nodeMethod = Godot.Core.ItemList.get_max_columns {-# NOINLINE bindItemList_get_max_text_lines #-} -- | Maximum lines of text allowed in each item. Space will be reserved even when there is not enough lines of text to display. -- __Note:__ This property takes effect only when @icon_mode@ is @ICON_MODE_TOP@. To make the text wrap, @fixed_column_width@ should be greater than zero. bindItemList_get_max_text_lines :: MethodBind bindItemList_get_max_text_lines = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_max_text_lines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum lines of text allowed in each item. Space will be reserved even when there is not enough lines of text to display. -- __Note:__ This property takes effect only when @icon_mode@ is @ICON_MODE_TOP@. To make the text wrap, @fixed_column_width@ should be greater than zero. get_max_text_lines :: (ItemList :< cls, Object :< cls) => cls -> IO Int get_max_text_lines cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_max_text_lines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_max_text_lines" '[] (IO Int) where nodeMethod = Godot.Core.ItemList.get_max_text_lines {-# NOINLINE bindItemList_get_select_mode #-} -- | Allows single or multiple item selection. See the @enum SelectMode@ constants. bindItemList_get_select_mode :: MethodBind bindItemList_get_select_mode = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_select_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows single or multiple item selection. See the @enum SelectMode@ constants. get_select_mode :: (ItemList :< cls, Object :< cls) => cls -> IO Int get_select_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_select_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_select_mode" '[] (IO Int) where nodeMethod = Godot.Core.ItemList.get_select_mode {-# NOINLINE bindItemList_get_selected_items #-} -- | Returns an array with the indexes of the selected items. bindItemList_get_selected_items :: MethodBind bindItemList_get_selected_items = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_selected_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with the indexes of the selected items. get_selected_items :: (ItemList :< cls, Object :< cls) => cls -> IO PoolIntArray get_selected_items cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_selected_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_selected_items" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.ItemList.get_selected_items {-# NOINLINE bindItemList_get_v_scroll #-} -- | Returns the @Object@ ID associated with the list. bindItemList_get_v_scroll :: MethodBind bindItemList_get_v_scroll = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "get_v_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Object@ ID associated with the list. get_v_scroll :: (ItemList :< cls, Object :< cls) => cls -> IO VScrollBar get_v_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_get_v_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "get_v_scroll" '[] (IO VScrollBar) where nodeMethod = Godot.Core.ItemList.get_v_scroll {-# NOINLINE bindItemList_has_auto_height #-} -- | If @true@, the control will automatically resize the height to fit its content. bindItemList_has_auto_height :: MethodBind bindItemList_has_auto_height = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "has_auto_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the control will automatically resize the height to fit its content. has_auto_height :: (ItemList :< cls, Object :< cls) => cls -> IO Bool has_auto_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_has_auto_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "has_auto_height" '[] (IO Bool) where nodeMethod = Godot.Core.ItemList.has_auto_height {-# NOINLINE bindItemList_is_anything_selected #-} -- | Returns @true@ if one or more items are selected. bindItemList_is_anything_selected :: MethodBind bindItemList_is_anything_selected = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "is_anything_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if one or more items are selected. is_anything_selected :: (ItemList :< cls, Object :< cls) => cls -> IO Bool is_anything_selected cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_is_anything_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "is_anything_selected" '[] (IO Bool) where nodeMethod = Godot.Core.ItemList.is_anything_selected {-# NOINLINE bindItemList_is_item_disabled #-} -- | Returns @true@ if the item at the specified index is disabled. bindItemList_is_item_disabled :: MethodBind bindItemList_is_item_disabled = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "is_item_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item at the specified index is disabled. is_item_disabled :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_is_item_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "is_item_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.ItemList.is_item_disabled {-# NOINLINE bindItemList_is_item_icon_transposed #-} -- | Returns @true@ if the item icon will be drawn transposed, i.e. the X and Y axes are swapped. bindItemList_is_item_icon_transposed :: MethodBind bindItemList_is_item_icon_transposed = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "is_item_icon_transposed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item icon will be drawn transposed, i.e. the X and Y axes are swapped. is_item_icon_transposed :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_icon_transposed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_is_item_icon_transposed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "is_item_icon_transposed" '[Int] (IO Bool) where nodeMethod = Godot.Core.ItemList.is_item_icon_transposed {-# NOINLINE bindItemList_is_item_selectable #-} -- | Returns @true@ if the item at the specified index is selectable. bindItemList_is_item_selectable :: MethodBind bindItemList_is_item_selectable = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "is_item_selectable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item at the specified index is selectable. is_item_selectable :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_selectable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_is_item_selectable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "is_item_selectable" '[Int] (IO Bool) where nodeMethod = Godot.Core.ItemList.is_item_selectable {-# NOINLINE bindItemList_is_item_tooltip_enabled #-} -- | Returns @true@ if the tooltip is enabled for specified item index. bindItemList_is_item_tooltip_enabled :: MethodBind bindItemList_is_item_tooltip_enabled = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "is_item_tooltip_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the tooltip is enabled for specified item index. is_item_tooltip_enabled :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_tooltip_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_is_item_tooltip_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "is_item_tooltip_enabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.ItemList.is_item_tooltip_enabled {-# NOINLINE bindItemList_is_same_column_width #-} -- | Whether all columns will have the same width. -- If @true@, the width is equal to the largest column width of all columns. bindItemList_is_same_column_width :: MethodBind bindItemList_is_same_column_width = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "is_same_column_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Whether all columns will have the same width. -- If @true@, the width is equal to the largest column width of all columns. is_same_column_width :: (ItemList :< cls, Object :< cls) => cls -> IO Bool is_same_column_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_is_same_column_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "is_same_column_width" '[] (IO Bool) where nodeMethod = Godot.Core.ItemList.is_same_column_width {-# NOINLINE bindItemList_is_selected #-} -- | Returns @true@ if the item at the specified index is currently selected. bindItemList_is_selected :: MethodBind bindItemList_is_selected = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "is_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item at the specified index is currently selected. is_selected :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO Bool is_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_is_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "is_selected" '[Int] (IO Bool) where nodeMethod = Godot.Core.ItemList.is_selected {-# NOINLINE bindItemList_move_item #-} -- | Moves item from index @from_idx@ to @to_idx@. bindItemList_move_item :: MethodBind bindItemList_move_item = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "move_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves item from index @from_idx@ to @to_idx@. move_item :: (ItemList :< cls, Object :< cls) => cls -> Int -> Int -> IO () move_item cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_move_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "move_item" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.ItemList.move_item {-# NOINLINE bindItemList_remove_item #-} -- | Removes the item specified by @idx@ index from the list. bindItemList_remove_item :: MethodBind bindItemList_remove_item = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "remove_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the item specified by @idx@ index from the list. remove_item :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO () remove_item cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_remove_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "remove_item" '[Int] (IO ()) where nodeMethod = Godot.Core.ItemList.remove_item {-# NOINLINE bindItemList_select #-} -- | Select the item at the specified index. -- __Note:__ This method does not trigger the item selection signal. bindItemList_select :: MethodBind bindItemList_select = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Select the item at the specified index. -- __Note:__ This method does not trigger the item selection signal. select :: (ItemList :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO () select cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "select" '[Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.select {-# NOINLINE bindItemList_set_allow_reselect #-} -- | If @true@, the currently selected item can be selected again. bindItemList_set_allow_reselect :: MethodBind bindItemList_set_allow_reselect = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_allow_reselect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the currently selected item can be selected again. set_allow_reselect :: (ItemList :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_reselect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_allow_reselect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_allow_reselect" '[Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.set_allow_reselect {-# NOINLINE bindItemList_set_allow_rmb_select #-} -- | If @true@, right mouse button click can select items. bindItemList_set_allow_rmb_select :: MethodBind bindItemList_set_allow_rmb_select = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_allow_rmb_select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, right mouse button click can select items. set_allow_rmb_select :: (ItemList :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_rmb_select cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_allow_rmb_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_allow_rmb_select" '[Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.set_allow_rmb_select {-# NOINLINE bindItemList_set_auto_height #-} -- | If @true@, the control will automatically resize the height to fit its content. bindItemList_set_auto_height :: MethodBind bindItemList_set_auto_height = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_auto_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the control will automatically resize the height to fit its content. set_auto_height :: (ItemList :< cls, Object :< cls) => cls -> Bool -> IO () set_auto_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_auto_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_auto_height" '[Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.set_auto_height {-# NOINLINE bindItemList_set_fixed_column_width #-} -- | The width all columns will be adjusted to. -- A value of zero disables the adjustment, each item will have a width equal to the width of its content and the columns will have an uneven width. bindItemList_set_fixed_column_width :: MethodBind bindItemList_set_fixed_column_width = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_fixed_column_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The width all columns will be adjusted to. -- A value of zero disables the adjustment, each item will have a width equal to the width of its content and the columns will have an uneven width. set_fixed_column_width :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO () set_fixed_column_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_fixed_column_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_fixed_column_width" '[Int] (IO ()) where nodeMethod = Godot.Core.ItemList.set_fixed_column_width {-# NOINLINE bindItemList_set_fixed_icon_size #-} -- | The size all icons will be adjusted to. -- If either X or Y component is not greater than zero, icon size won't be affected. bindItemList_set_fixed_icon_size :: MethodBind bindItemList_set_fixed_icon_size = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_fixed_icon_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size all icons will be adjusted to. -- If either X or Y component is not greater than zero, icon size won't be affected. set_fixed_icon_size :: (ItemList :< cls, Object :< cls) => cls -> Vector2 -> IO () set_fixed_icon_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_fixed_icon_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_fixed_icon_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ItemList.set_fixed_icon_size {-# NOINLINE bindItemList_set_icon_mode #-} -- | The icon position, whether above or to the left of the text. See the @enum IconMode@ constants. bindItemList_set_icon_mode :: MethodBind bindItemList_set_icon_mode = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_icon_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The icon position, whether above or to the left of the text. See the @enum IconMode@ constants. set_icon_mode :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO () set_icon_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_icon_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_icon_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.ItemList.set_icon_mode {-# NOINLINE bindItemList_set_icon_scale #-} -- | The scale of icon applied after @fixed_icon_size@ and transposing takes effect. bindItemList_set_icon_scale :: MethodBind bindItemList_set_icon_scale = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_icon_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The scale of icon applied after @fixed_icon_size@ and transposing takes effect. set_icon_scale :: (ItemList :< cls, Object :< cls) => cls -> Float -> IO () set_icon_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_icon_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_icon_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.ItemList.set_icon_scale {-# NOINLINE bindItemList_set_item_custom_bg_color #-} -- | Sets the background color of the item specified by @idx@ index to the specified @Color@. -- -- @ -- -- var some_string = "Some text" -- some_string.set_item_custom_bg_color(0,Color(1, 0, 0, 1) # This will set the background color of the first item of the control to red. -- -- @ bindItemList_set_item_custom_bg_color :: MethodBind bindItemList_set_item_custom_bg_color = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_custom_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the background color of the item specified by @idx@ index to the specified @Color@. -- -- @ -- -- var some_string = "Some text" -- some_string.set_item_custom_bg_color(0,Color(1, 0, 0, 1) # This will set the background color of the first item of the control to red. -- -- @ set_item_custom_bg_color :: (ItemList :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_item_custom_bg_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_custom_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_custom_bg_color" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_custom_bg_color {-# NOINLINE bindItemList_set_item_custom_fg_color #-} -- | Sets the foreground color of the item specified by @idx@ index to the specified @Color@. -- -- @ -- -- var some_string = "Some text" -- some_string.set_item_custom_fg_color(0,Color(1, 0, 0, 1) # This will set the foreground color of the first item of the control to red. -- -- @ bindItemList_set_item_custom_fg_color :: MethodBind bindItemList_set_item_custom_fg_color = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_custom_fg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the foreground color of the item specified by @idx@ index to the specified @Color@. -- -- @ -- -- var some_string = "Some text" -- some_string.set_item_custom_fg_color(0,Color(1, 0, 0, 1) # This will set the foreground color of the first item of the control to red. -- -- @ set_item_custom_fg_color :: (ItemList :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_item_custom_fg_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_custom_fg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_custom_fg_color" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_custom_fg_color {-# NOINLINE bindItemList_set_item_disabled #-} -- | Disables (or enables) the item at the specified index. -- Disabled items cannot be selected and do not trigger activation signals (when double-clicking or pressing Enter). bindItemList_set_item_disabled :: MethodBind bindItemList_set_item_disabled = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables (or enables) the item at the specified index. -- Disabled items cannot be selected and do not trigger activation signals (when double-clicking or pressing Enter). set_item_disabled :: (ItemList :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_disabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_disabled {-# NOINLINE bindItemList_set_item_icon #-} -- | Sets (or replaces) the icon's @Texture@ associated with the specified index. bindItemList_set_item_icon :: MethodBind bindItemList_set_item_icon = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets (or replaces) the icon's @Texture@ associated with the specified index. set_item_icon :: (ItemList :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_item_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_icon" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_icon {-# NOINLINE bindItemList_set_item_icon_modulate #-} -- | Sets a modulating @Color@ of the item associated with the specified index. bindItemList_set_item_icon_modulate :: MethodBind bindItemList_set_item_icon_modulate = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_icon_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a modulating @Color@ of the item associated with the specified index. set_item_icon_modulate :: (ItemList :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_item_icon_modulate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_icon_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_icon_modulate" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_icon_modulate {-# NOINLINE bindItemList_set_item_icon_region #-} -- | Sets the region of item's icon used. The whole icon will be used if the region has no area. bindItemList_set_item_icon_region :: MethodBind bindItemList_set_item_icon_region = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_icon_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the region of item's icon used. The whole icon will be used if the region has no area. set_item_icon_region :: (ItemList :< cls, Object :< cls) => cls -> Int -> Rect2 -> IO () set_item_icon_region cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_icon_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_icon_region" '[Int, Rect2] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_icon_region {-# NOINLINE bindItemList_set_item_icon_transposed #-} -- | Sets whether the item icon will be drawn transposed. bindItemList_set_item_icon_transposed :: MethodBind bindItemList_set_item_icon_transposed = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_icon_transposed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the item icon will be drawn transposed. set_item_icon_transposed :: (ItemList :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_icon_transposed cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_icon_transposed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_icon_transposed" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_icon_transposed {-# NOINLINE bindItemList_set_item_metadata #-} -- | Sets a value (of any type) to be stored with the item associated with the specified index. bindItemList_set_item_metadata :: MethodBind bindItemList_set_item_metadata = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a value (of any type) to be stored with the item associated with the specified index. set_item_metadata :: (ItemList :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_item_metadata cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_metadata" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_metadata {-# NOINLINE bindItemList_set_item_selectable #-} -- | Allows or disallows selection of the item associated with the specified index. bindItemList_set_item_selectable :: MethodBind bindItemList_set_item_selectable = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_selectable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows or disallows selection of the item associated with the specified index. set_item_selectable :: (ItemList :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_selectable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_selectable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_selectable" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_selectable {-# NOINLINE bindItemList_set_item_text #-} -- | Sets text of the item associated with the specified index. bindItemList_set_item_text :: MethodBind bindItemList_set_item_text = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets text of the item associated with the specified index. set_item_text :: (ItemList :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_item_text cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_text" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_text {-# NOINLINE bindItemList_set_item_tooltip #-} -- | Sets the tooltip hint for the item associated with the specified index. bindItemList_set_item_tooltip :: MethodBind bindItemList_set_item_tooltip = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tooltip hint for the item associated with the specified index. set_item_tooltip :: (ItemList :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_item_tooltip cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_tooltip" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_tooltip {-# NOINLINE bindItemList_set_item_tooltip_enabled #-} -- | Sets whether the tooltip hint is enabled for specified item index. bindItemList_set_item_tooltip_enabled :: MethodBind bindItemList_set_item_tooltip_enabled = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_item_tooltip_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the tooltip hint is enabled for specified item index. set_item_tooltip_enabled :: (ItemList :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_tooltip_enabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_item_tooltip_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_item_tooltip_enabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.set_item_tooltip_enabled {-# NOINLINE bindItemList_set_max_columns #-} -- | Maximum columns the list will have. -- If greater than zero, the content will be split among the specified columns. -- A value of zero means unlimited columns, i.e. all items will be put in the same row. bindItemList_set_max_columns :: MethodBind bindItemList_set_max_columns = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_max_columns" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum columns the list will have. -- If greater than zero, the content will be split among the specified columns. -- A value of zero means unlimited columns, i.e. all items will be put in the same row. set_max_columns :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO () set_max_columns cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_max_columns (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_max_columns" '[Int] (IO ()) where nodeMethod = Godot.Core.ItemList.set_max_columns {-# NOINLINE bindItemList_set_max_text_lines #-} -- | Maximum lines of text allowed in each item. Space will be reserved even when there is not enough lines of text to display. -- __Note:__ This property takes effect only when @icon_mode@ is @ICON_MODE_TOP@. To make the text wrap, @fixed_column_width@ should be greater than zero. bindItemList_set_max_text_lines :: MethodBind bindItemList_set_max_text_lines = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_max_text_lines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum lines of text allowed in each item. Space will be reserved even when there is not enough lines of text to display. -- __Note:__ This property takes effect only when @icon_mode@ is @ICON_MODE_TOP@. To make the text wrap, @fixed_column_width@ should be greater than zero. set_max_text_lines :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO () set_max_text_lines cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_max_text_lines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_max_text_lines" '[Int] (IO ()) where nodeMethod = Godot.Core.ItemList.set_max_text_lines {-# NOINLINE bindItemList_set_same_column_width #-} -- | Whether all columns will have the same width. -- If @true@, the width is equal to the largest column width of all columns. bindItemList_set_same_column_width :: MethodBind bindItemList_set_same_column_width = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_same_column_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Whether all columns will have the same width. -- If @true@, the width is equal to the largest column width of all columns. set_same_column_width :: (ItemList :< cls, Object :< cls) => cls -> Bool -> IO () set_same_column_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_same_column_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_same_column_width" '[Bool] (IO ()) where nodeMethod = Godot.Core.ItemList.set_same_column_width {-# NOINLINE bindItemList_set_select_mode #-} -- | Allows single or multiple item selection. See the @enum SelectMode@ constants. bindItemList_set_select_mode :: MethodBind bindItemList_set_select_mode = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "set_select_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows single or multiple item selection. See the @enum SelectMode@ constants. set_select_mode :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO () set_select_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_set_select_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "set_select_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.ItemList.set_select_mode {-# NOINLINE bindItemList_sort_items_by_text #-} -- | Sorts items in the list by their text. bindItemList_sort_items_by_text :: MethodBind bindItemList_sort_items_by_text = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "sort_items_by_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sorts items in the list by their text. sort_items_by_text :: (ItemList :< cls, Object :< cls) => cls -> IO () sort_items_by_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_sort_items_by_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "sort_items_by_text" '[] (IO ()) where nodeMethod = Godot.Core.ItemList.sort_items_by_text {-# NOINLINE bindItemList_unselect #-} -- | Ensures the item associated with the specified index is not selected. bindItemList_unselect :: MethodBind bindItemList_unselect = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "unselect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Ensures the item associated with the specified index is not selected. unselect :: (ItemList :< cls, Object :< cls) => cls -> Int -> IO () unselect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_unselect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "unselect" '[Int] (IO ()) where nodeMethod = Godot.Core.ItemList.unselect {-# NOINLINE bindItemList_unselect_all #-} -- | Ensures there are no items selected. bindItemList_unselect_all :: MethodBind bindItemList_unselect_all = unsafePerformIO $ withCString "ItemList" $ \ clsNamePtr -> withCString "unselect_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Ensures there are no items selected. unselect_all :: (ItemList :< cls, Object :< cls) => cls -> IO () unselect_all cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindItemList_unselect_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ItemList "unselect_all" '[] (IO ()) where nodeMethod = Godot.Core.ItemList.unselect_all ================================================ FILE: src/Godot/Core/JSON.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.JSON (Godot.Core.JSON.parse, Godot.Core.JSON.print) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindJSON_parse #-} -- | Parses a JSON-encoded string and returns a @JSONParseResult@ containing the result. bindJSON_parse :: MethodBind bindJSON_parse = unsafePerformIO $ withCString "_JSON" $ \ clsNamePtr -> withCString "parse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Parses a JSON-encoded string and returns a @JSONParseResult@ containing the result. parse :: (JSON :< cls, Object :< cls) => cls -> GodotString -> IO JSONParseResult parse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJSON_parse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSON "parse" '[GodotString] (IO JSONParseResult) where nodeMethod = Godot.Core.JSON.parse {-# NOINLINE bindJSON_print #-} -- | Converts a @Variant@ var to JSON text and returns the result. Useful for serializing data to store or send over the network. -- __Note:__ The JSON specification does not define integer or float types, but only a @i@number@/i@ type. Therefore, converting a Variant to JSON text will convert all numerical values to @float@ types. -- Use @indent@ parameter to pretty print the output. -- __Example output:__ -- -- @ -- -- ## JSON.print(my_dictionary) -- {"name":"my_dictionary","version":"1.0.0","entities":@{"name":"entity_0","value":"value_0"},{"name":"entity_1","value":"value_1"}@} -- -- ## JSON.print(my_dictionary, "\t") -- { -- "name": "my_dictionary", -- "version": "1.0.0", -- "entities": @ -- { -- "name": "entity_0", -- "value": "value_0" -- }, -- { -- "name": "entity_1", -- "value": "value_1" -- } -- @ -- } -- -- @ bindJSON_print :: MethodBind bindJSON_print = unsafePerformIO $ withCString "_JSON" $ \ clsNamePtr -> withCString "print" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Converts a @Variant@ var to JSON text and returns the result. Useful for serializing data to store or send over the network. -- __Note:__ The JSON specification does not define integer or float types, but only a @i@number@/i@ type. Therefore, converting a Variant to JSON text will convert all numerical values to @float@ types. -- Use @indent@ parameter to pretty print the output. -- __Example output:__ -- -- @ -- -- ## JSON.print(my_dictionary) -- {"name":"my_dictionary","version":"1.0.0","entities":@{"name":"entity_0","value":"value_0"},{"name":"entity_1","value":"value_1"}@} -- -- ## JSON.print(my_dictionary, "\t") -- { -- "name": "my_dictionary", -- "version": "1.0.0", -- "entities": @ -- { -- "name": "entity_0", -- "value": "value_0" -- }, -- { -- "name": "entity_1", -- "value": "value_1" -- } -- @ -- } -- -- @ print :: (JSON :< cls, Object :< cls) => cls -> GodotVariant -> Maybe GodotString -> Maybe Bool -> IO GodotString print cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindJSON_print (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSON "print" '[GodotVariant, Maybe GodotString, Maybe Bool] (IO GodotString) where nodeMethod = Godot.Core.JSON.print ================================================ FILE: src/Godot/Core/JSONParseResult.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.JSONParseResult (Godot.Core.JSONParseResult.get_error, Godot.Core.JSONParseResult.get_error_line, Godot.Core.JSONParseResult.get_error_string, Godot.Core.JSONParseResult.get_result, Godot.Core.JSONParseResult.set_error, Godot.Core.JSONParseResult.set_error_line, Godot.Core.JSONParseResult.set_error_string, Godot.Core.JSONParseResult.set_result) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty JSONParseResult "error" Int 'False where nodeProperty = (get_error, wrapDroppingSetter set_error, Nothing) instance NodeProperty JSONParseResult "error_line" Int 'False where nodeProperty = (get_error_line, wrapDroppingSetter set_error_line, Nothing) instance NodeProperty JSONParseResult "error_string" GodotString 'False where nodeProperty = (get_error_string, wrapDroppingSetter set_error_string, Nothing) instance NodeProperty JSONParseResult "result" GodotVariant 'False where nodeProperty = (get_result, wrapDroppingSetter set_result, Nothing) {-# NOINLINE bindJSONParseResult_get_error #-} -- | The error type if the JSON source was not successfully parsed. See the @enum Error@ constants. bindJSONParseResult_get_error :: MethodBind bindJSONParseResult_get_error = unsafePerformIO $ withCString "JSONParseResult" $ \ clsNamePtr -> withCString "get_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The error type if the JSON source was not successfully parsed. See the @enum Error@ constants. get_error :: (JSONParseResult :< cls, Object :< cls) => cls -> IO Int get_error cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJSONParseResult_get_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONParseResult "get_error" '[] (IO Int) where nodeMethod = Godot.Core.JSONParseResult.get_error {-# NOINLINE bindJSONParseResult_get_error_line #-} -- | The line number where the error occurred if the JSON source was not successfully parsed. bindJSONParseResult_get_error_line :: MethodBind bindJSONParseResult_get_error_line = unsafePerformIO $ withCString "JSONParseResult" $ \ clsNamePtr -> withCString "get_error_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line number where the error occurred if the JSON source was not successfully parsed. get_error_line :: (JSONParseResult :< cls, Object :< cls) => cls -> IO Int get_error_line cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJSONParseResult_get_error_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONParseResult "get_error_line" '[] (IO Int) where nodeMethod = Godot.Core.JSONParseResult.get_error_line {-# NOINLINE bindJSONParseResult_get_error_string #-} -- | The error message if the JSON source was not successfully parsed. See the @enum Error@ constants. bindJSONParseResult_get_error_string :: MethodBind bindJSONParseResult_get_error_string = unsafePerformIO $ withCString "JSONParseResult" $ \ clsNamePtr -> withCString "get_error_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The error message if the JSON source was not successfully parsed. See the @enum Error@ constants. get_error_string :: (JSONParseResult :< cls, Object :< cls) => cls -> IO GodotString get_error_string cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJSONParseResult_get_error_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONParseResult "get_error_string" '[] (IO GodotString) where nodeMethod = Godot.Core.JSONParseResult.get_error_string {-# NOINLINE bindJSONParseResult_get_result #-} -- | A @Variant@ containing the parsed JSON. Use @method @GDScript.typeof@ or the @is@ keyword to check if it is what you expect. For example, if the JSON source starts with curly braces (@{}@), a @Dictionary@ will be returned. If the JSON source starts with brackets (@@@@), an @Array@ will be returned. -- __Note:__ The JSON specification does not define integer or float types, but only a @i@number@/i@ type. Therefore, parsing a JSON text will convert all numerical values to @float@ types. -- __Note:__ JSON objects do not preserve key order like Godot dictionaries, thus, you should not rely on keys being in a certain order if a dictionary is constructed from JSON. In contrast, JSON arrays retain the order of their elements: -- -- @ -- -- var p = JSON.parse('@"hello", "world", "!"@') -- if typeof(p.result) == TYPE_ARRAY: -- print(p.result@0@) # Prints "hello" -- else: -- push_error("Unexpected results.") -- -- @ bindJSONParseResult_get_result :: MethodBind bindJSONParseResult_get_result = unsafePerformIO $ withCString "JSONParseResult" $ \ clsNamePtr -> withCString "get_result" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Variant@ containing the parsed JSON. Use @method @GDScript.typeof@ or the @is@ keyword to check if it is what you expect. For example, if the JSON source starts with curly braces (@{}@), a @Dictionary@ will be returned. If the JSON source starts with brackets (@@@@), an @Array@ will be returned. -- __Note:__ The JSON specification does not define integer or float types, but only a @i@number@/i@ type. Therefore, parsing a JSON text will convert all numerical values to @float@ types. -- __Note:__ JSON objects do not preserve key order like Godot dictionaries, thus, you should not rely on keys being in a certain order if a dictionary is constructed from JSON. In contrast, JSON arrays retain the order of their elements: -- -- @ -- -- var p = JSON.parse('@"hello", "world", "!"@') -- if typeof(p.result) == TYPE_ARRAY: -- print(p.result@0@) # Prints "hello" -- else: -- push_error("Unexpected results.") -- -- @ get_result :: (JSONParseResult :< cls, Object :< cls) => cls -> IO GodotVariant get_result cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJSONParseResult_get_result (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONParseResult "get_result" '[] (IO GodotVariant) where nodeMethod = Godot.Core.JSONParseResult.get_result {-# NOINLINE bindJSONParseResult_set_error #-} -- | The error type if the JSON source was not successfully parsed. See the @enum Error@ constants. bindJSONParseResult_set_error :: MethodBind bindJSONParseResult_set_error = unsafePerformIO $ withCString "JSONParseResult" $ \ clsNamePtr -> withCString "set_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The error type if the JSON source was not successfully parsed. See the @enum Error@ constants. set_error :: (JSONParseResult :< cls, Object :< cls) => cls -> Int -> IO () set_error cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJSONParseResult_set_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONParseResult "set_error" '[Int] (IO ()) where nodeMethod = Godot.Core.JSONParseResult.set_error {-# NOINLINE bindJSONParseResult_set_error_line #-} -- | The line number where the error occurred if the JSON source was not successfully parsed. bindJSONParseResult_set_error_line :: MethodBind bindJSONParseResult_set_error_line = unsafePerformIO $ withCString "JSONParseResult" $ \ clsNamePtr -> withCString "set_error_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line number where the error occurred if the JSON source was not successfully parsed. set_error_line :: (JSONParseResult :< cls, Object :< cls) => cls -> Int -> IO () set_error_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJSONParseResult_set_error_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONParseResult "set_error_line" '[Int] (IO ()) where nodeMethod = Godot.Core.JSONParseResult.set_error_line {-# NOINLINE bindJSONParseResult_set_error_string #-} -- | The error message if the JSON source was not successfully parsed. See the @enum Error@ constants. bindJSONParseResult_set_error_string :: MethodBind bindJSONParseResult_set_error_string = unsafePerformIO $ withCString "JSONParseResult" $ \ clsNamePtr -> withCString "set_error_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The error message if the JSON source was not successfully parsed. See the @enum Error@ constants. set_error_string :: (JSONParseResult :< cls, Object :< cls) => cls -> GodotString -> IO () set_error_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJSONParseResult_set_error_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONParseResult "set_error_string" '[GodotString] (IO ()) where nodeMethod = Godot.Core.JSONParseResult.set_error_string {-# NOINLINE bindJSONParseResult_set_result #-} -- | A @Variant@ containing the parsed JSON. Use @method @GDScript.typeof@ or the @is@ keyword to check if it is what you expect. For example, if the JSON source starts with curly braces (@{}@), a @Dictionary@ will be returned. If the JSON source starts with brackets (@@@@), an @Array@ will be returned. -- __Note:__ The JSON specification does not define integer or float types, but only a @i@number@/i@ type. Therefore, parsing a JSON text will convert all numerical values to @float@ types. -- __Note:__ JSON objects do not preserve key order like Godot dictionaries, thus, you should not rely on keys being in a certain order if a dictionary is constructed from JSON. In contrast, JSON arrays retain the order of their elements: -- -- @ -- -- var p = JSON.parse('@"hello", "world", "!"@') -- if typeof(p.result) == TYPE_ARRAY: -- print(p.result@0@) # Prints "hello" -- else: -- push_error("Unexpected results.") -- -- @ bindJSONParseResult_set_result :: MethodBind bindJSONParseResult_set_result = unsafePerformIO $ withCString "JSONParseResult" $ \ clsNamePtr -> withCString "set_result" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Variant@ containing the parsed JSON. Use @method @GDScript.typeof@ or the @is@ keyword to check if it is what you expect. For example, if the JSON source starts with curly braces (@{}@), a @Dictionary@ will be returned. If the JSON source starts with brackets (@@@@), an @Array@ will be returned. -- __Note:__ The JSON specification does not define integer or float types, but only a @i@number@/i@ type. Therefore, parsing a JSON text will convert all numerical values to @float@ types. -- __Note:__ JSON objects do not preserve key order like Godot dictionaries, thus, you should not rely on keys being in a certain order if a dictionary is constructed from JSON. In contrast, JSON arrays retain the order of their elements: -- -- @ -- -- var p = JSON.parse('@"hello", "world", "!"@') -- if typeof(p.result) == TYPE_ARRAY: -- print(p.result@0@) # Prints "hello" -- else: -- push_error("Unexpected results.") -- -- @ set_result :: (JSONParseResult :< cls, Object :< cls) => cls -> GodotVariant -> IO () set_result cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJSONParseResult_set_result (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONParseResult "set_result" '[GodotVariant] (IO ()) where nodeMethod = Godot.Core.JSONParseResult.set_result ================================================ FILE: src/Godot/Core/JSONRPC.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.JSONRPC (Godot.Core.JSONRPC._METHOD_NOT_FOUND, Godot.Core.JSONRPC._INTERNAL_ERROR, Godot.Core.JSONRPC._INVALID_REQUEST, Godot.Core.JSONRPC._PARSE_ERROR, Godot.Core.JSONRPC._INVALID_PARAMS, Godot.Core.JSONRPC.make_notification, Godot.Core.JSONRPC.make_request, Godot.Core.JSONRPC.make_response, Godot.Core.JSONRPC.make_response_error, Godot.Core.JSONRPC.process_action, Godot.Core.JSONRPC.process_string, Godot.Core.JSONRPC.set_scope) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _METHOD_NOT_FOUND :: Int _METHOD_NOT_FOUND = -32601 _INTERNAL_ERROR :: Int _INTERNAL_ERROR = -32603 _INVALID_REQUEST :: Int _INVALID_REQUEST = -32600 _PARSE_ERROR :: Int _PARSE_ERROR = -32700 _INVALID_PARAMS :: Int _INVALID_PARAMS = -32602 {-# NOINLINE bindJSONRPC_make_notification #-} bindJSONRPC_make_notification :: MethodBind bindJSONRPC_make_notification = unsafePerformIO $ withCString "JSONRPC" $ \ clsNamePtr -> withCString "make_notification" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr make_notification :: (JSONRPC :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO Dictionary make_notification cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindJSONRPC_make_notification (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONRPC "make_notification" '[GodotString, GodotVariant] (IO Dictionary) where nodeMethod = Godot.Core.JSONRPC.make_notification {-# NOINLINE bindJSONRPC_make_request #-} bindJSONRPC_make_request :: MethodBind bindJSONRPC_make_request = unsafePerformIO $ withCString "JSONRPC" $ \ clsNamePtr -> withCString "make_request" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr make_request :: (JSONRPC :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> GodotVariant -> IO Dictionary make_request cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindJSONRPC_make_request (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONRPC "make_request" '[GodotString, GodotVariant, GodotVariant] (IO Dictionary) where nodeMethod = Godot.Core.JSONRPC.make_request {-# NOINLINE bindJSONRPC_make_response #-} bindJSONRPC_make_response :: MethodBind bindJSONRPC_make_response = unsafePerformIO $ withCString "JSONRPC" $ \ clsNamePtr -> withCString "make_response" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr make_response :: (JSONRPC :< cls, Object :< cls) => cls -> GodotVariant -> GodotVariant -> IO Dictionary make_response cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindJSONRPC_make_response (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONRPC "make_response" '[GodotVariant, GodotVariant] (IO Dictionary) where nodeMethod = Godot.Core.JSONRPC.make_response {-# NOINLINE bindJSONRPC_make_response_error #-} bindJSONRPC_make_response_error :: MethodBind bindJSONRPC_make_response_error = unsafePerformIO $ withCString "JSONRPC" $ \ clsNamePtr -> withCString "make_response_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr make_response_error :: (JSONRPC :< cls, Object :< cls) => cls -> Int -> GodotString -> Maybe GodotVariant -> IO Dictionary make_response_error cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindJSONRPC_make_response_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONRPC "make_response_error" '[Int, GodotString, Maybe GodotVariant] (IO Dictionary) where nodeMethod = Godot.Core.JSONRPC.make_response_error {-# NOINLINE bindJSONRPC_process_action #-} bindJSONRPC_process_action :: MethodBind bindJSONRPC_process_action = unsafePerformIO $ withCString "JSONRPC" $ \ clsNamePtr -> withCString "process_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr process_action :: (JSONRPC :< cls, Object :< cls) => cls -> GodotVariant -> Maybe Bool -> IO GodotVariant process_action cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindJSONRPC_process_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONRPC "process_action" '[GodotVariant, Maybe Bool] (IO GodotVariant) where nodeMethod = Godot.Core.JSONRPC.process_action {-# NOINLINE bindJSONRPC_process_string #-} bindJSONRPC_process_string :: MethodBind bindJSONRPC_process_string = unsafePerformIO $ withCString "JSONRPC" $ \ clsNamePtr -> withCString "process_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr process_string :: (JSONRPC :< cls, Object :< cls) => cls -> GodotString -> IO GodotString process_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJSONRPC_process_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONRPC "process_string" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.JSONRPC.process_string {-# NOINLINE bindJSONRPC_set_scope #-} bindJSONRPC_set_scope :: MethodBind bindJSONRPC_set_scope = unsafePerformIO $ withCString "JSONRPC" $ \ clsNamePtr -> withCString "set_scope" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_scope :: (JSONRPC :< cls, Object :< cls) => cls -> GodotString -> Object -> IO () set_scope cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindJSONRPC_set_scope (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JSONRPC "set_scope" '[GodotString, Object] (IO ()) where nodeMethod = Godot.Core.JSONRPC.set_scope ================================================ FILE: src/Godot/Core/JavaClass.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.JavaClass () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() ================================================ FILE: src/Godot/Core/JavaClassWrapper.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.JavaClassWrapper (Godot.Core.JavaClassWrapper.wrap) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindJavaClassWrapper_wrap #-} bindJavaClassWrapper_wrap :: MethodBind bindJavaClassWrapper_wrap = unsafePerformIO $ withCString "JavaClassWrapper" $ \ clsNamePtr -> withCString "wrap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr wrap :: (JavaClassWrapper :< cls, Object :< cls) => cls -> GodotString -> IO JavaClass wrap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJavaClassWrapper_wrap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JavaClassWrapper "wrap" '[GodotString] (IO JavaClass) where nodeMethod = Godot.Core.JavaClassWrapper.wrap ================================================ FILE: src/Godot/Core/JavaScript.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.JavaScript (Godot.Core.JavaScript.eval) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindJavaScript_eval #-} -- | Execute the string @code@ as JavaScript code within the browser window. This is a call to the actual global JavaScript function @eval()@. -- If @use_global_execution_context@ is @true@, the code will be evaluated in the global execution context. Otherwise, it is evaluated in the execution context of a function within the engine's runtime environment. bindJavaScript_eval :: MethodBind bindJavaScript_eval = unsafePerformIO $ withCString "JavaScript" $ \ clsNamePtr -> withCString "eval" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Execute the string @code@ as JavaScript code within the browser window. This is a call to the actual global JavaScript function @eval()@. -- If @use_global_execution_context@ is @true@, the code will be evaluated in the global execution context. Otherwise, it is evaluated in the execution context of a function within the engine's runtime environment. eval :: (JavaScript :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO GodotVariant eval cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindJavaScript_eval (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod JavaScript "eval" '[GodotString, Maybe Bool] (IO GodotVariant) where nodeMethod = Godot.Core.JavaScript.eval ================================================ FILE: src/Godot/Core/Joint.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Joint (Godot.Core.Joint.get_exclude_nodes_from_collision, Godot.Core.Joint.get_node_a, Godot.Core.Joint.get_node_b, Godot.Core.Joint.get_solver_priority, Godot.Core.Joint.set_exclude_nodes_from_collision, Godot.Core.Joint.set_node_a, Godot.Core.Joint.set_node_b, Godot.Core.Joint.set_solver_priority) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty Joint "collision/exclude_nodes" Bool 'False where nodeProperty = (get_exclude_nodes_from_collision, wrapDroppingSetter set_exclude_nodes_from_collision, Nothing) instance NodeProperty Joint "nodes/node_a" NodePath 'False where nodeProperty = (get_node_a, wrapDroppingSetter set_node_a, Nothing) instance NodeProperty Joint "nodes/node_b" NodePath 'False where nodeProperty = (get_node_b, wrapDroppingSetter set_node_b, Nothing) instance NodeProperty Joint "solver/priority" Int 'False where nodeProperty = (get_solver_priority, wrapDroppingSetter set_solver_priority, Nothing) {-# NOINLINE bindJoint_get_exclude_nodes_from_collision #-} -- | If @true@, the two bodies of the nodes are not able to collide with each other. bindJoint_get_exclude_nodes_from_collision :: MethodBind bindJoint_get_exclude_nodes_from_collision = unsafePerformIO $ withCString "Joint" $ \ clsNamePtr -> withCString "get_exclude_nodes_from_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the two bodies of the nodes are not able to collide with each other. get_exclude_nodes_from_collision :: (Joint :< cls, Object :< cls) => cls -> IO Bool get_exclude_nodes_from_collision cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJoint_get_exclude_nodes_from_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint "get_exclude_nodes_from_collision" '[] (IO Bool) where nodeMethod = Godot.Core.Joint.get_exclude_nodes_from_collision {-# NOINLINE bindJoint_get_node_a #-} -- | The node attached to the first side (A) of the joint. bindJoint_get_node_a :: MethodBind bindJoint_get_node_a = unsafePerformIO $ withCString "Joint" $ \ clsNamePtr -> withCString "get_node_a" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node attached to the first side (A) of the joint. get_node_a :: (Joint :< cls, Object :< cls) => cls -> IO NodePath get_node_a cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJoint_get_node_a (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint "get_node_a" '[] (IO NodePath) where nodeMethod = Godot.Core.Joint.get_node_a {-# NOINLINE bindJoint_get_node_b #-} -- | The node attached to the second side (B) of the joint. bindJoint_get_node_b :: MethodBind bindJoint_get_node_b = unsafePerformIO $ withCString "Joint" $ \ clsNamePtr -> withCString "get_node_b" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node attached to the second side (B) of the joint. get_node_b :: (Joint :< cls, Object :< cls) => cls -> IO NodePath get_node_b cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJoint_get_node_b (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint "get_node_b" '[] (IO NodePath) where nodeMethod = Godot.Core.Joint.get_node_b {-# NOINLINE bindJoint_get_solver_priority #-} -- | The priority used to define which solver is executed first for multiple joints. The lower the value, the higher the priority. bindJoint_get_solver_priority :: MethodBind bindJoint_get_solver_priority = unsafePerformIO $ withCString "Joint" $ \ clsNamePtr -> withCString "get_solver_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The priority used to define which solver is executed first for multiple joints. The lower the value, the higher the priority. get_solver_priority :: (Joint :< cls, Object :< cls) => cls -> IO Int get_solver_priority cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJoint_get_solver_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint "get_solver_priority" '[] (IO Int) where nodeMethod = Godot.Core.Joint.get_solver_priority {-# NOINLINE bindJoint_set_exclude_nodes_from_collision #-} -- | If @true@, the two bodies of the nodes are not able to collide with each other. bindJoint_set_exclude_nodes_from_collision :: MethodBind bindJoint_set_exclude_nodes_from_collision = unsafePerformIO $ withCString "Joint" $ \ clsNamePtr -> withCString "set_exclude_nodes_from_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the two bodies of the nodes are not able to collide with each other. set_exclude_nodes_from_collision :: (Joint :< cls, Object :< cls) => cls -> Bool -> IO () set_exclude_nodes_from_collision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJoint_set_exclude_nodes_from_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint "set_exclude_nodes_from_collision" '[Bool] (IO ()) where nodeMethod = Godot.Core.Joint.set_exclude_nodes_from_collision {-# NOINLINE bindJoint_set_node_a #-} -- | The node attached to the first side (A) of the joint. bindJoint_set_node_a :: MethodBind bindJoint_set_node_a = unsafePerformIO $ withCString "Joint" $ \ clsNamePtr -> withCString "set_node_a" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node attached to the first side (A) of the joint. set_node_a :: (Joint :< cls, Object :< cls) => cls -> NodePath -> IO () set_node_a cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJoint_set_node_a (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint "set_node_a" '[NodePath] (IO ()) where nodeMethod = Godot.Core.Joint.set_node_a {-# NOINLINE bindJoint_set_node_b #-} -- | The node attached to the second side (B) of the joint. bindJoint_set_node_b :: MethodBind bindJoint_set_node_b = unsafePerformIO $ withCString "Joint" $ \ clsNamePtr -> withCString "set_node_b" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node attached to the second side (B) of the joint. set_node_b :: (Joint :< cls, Object :< cls) => cls -> NodePath -> IO () set_node_b cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJoint_set_node_b (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint "set_node_b" '[NodePath] (IO ()) where nodeMethod = Godot.Core.Joint.set_node_b {-# NOINLINE bindJoint_set_solver_priority #-} -- | The priority used to define which solver is executed first for multiple joints. The lower the value, the higher the priority. bindJoint_set_solver_priority :: MethodBind bindJoint_set_solver_priority = unsafePerformIO $ withCString "Joint" $ \ clsNamePtr -> withCString "set_solver_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The priority used to define which solver is executed first for multiple joints. The lower the value, the higher the priority. set_solver_priority :: (Joint :< cls, Object :< cls) => cls -> Int -> IO () set_solver_priority cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJoint_set_solver_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint "set_solver_priority" '[Int] (IO ()) where nodeMethod = Godot.Core.Joint.set_solver_priority ================================================ FILE: src/Godot/Core/Joint2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Joint2D (Godot.Core.Joint2D.get_bias, Godot.Core.Joint2D.get_exclude_nodes_from_collision, Godot.Core.Joint2D.get_node_a, Godot.Core.Joint2D.get_node_b, Godot.Core.Joint2D.set_bias, Godot.Core.Joint2D.set_exclude_nodes_from_collision, Godot.Core.Joint2D.set_node_a, Godot.Core.Joint2D.set_node_b) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty Joint2D "bias" Float 'False where nodeProperty = (get_bias, wrapDroppingSetter set_bias, Nothing) instance NodeProperty Joint2D "disable_collision" Bool 'False where nodeProperty = (get_exclude_nodes_from_collision, wrapDroppingSetter set_exclude_nodes_from_collision, Nothing) instance NodeProperty Joint2D "node_a" NodePath 'False where nodeProperty = (get_node_a, wrapDroppingSetter set_node_a, Nothing) instance NodeProperty Joint2D "node_b" NodePath 'False where nodeProperty = (get_node_b, wrapDroppingSetter set_node_b, Nothing) {-# NOINLINE bindJoint2D_get_bias #-} -- | When @node_a@ and @node_b@ move in different directions the @bias@ controls how fast the joint pulls them back to their original position. The lower the @bias@ the more the two bodies can pull on the joint. bindJoint2D_get_bias :: MethodBind bindJoint2D_get_bias = unsafePerformIO $ withCString "Joint2D" $ \ clsNamePtr -> withCString "get_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When @node_a@ and @node_b@ move in different directions the @bias@ controls how fast the joint pulls them back to their original position. The lower the @bias@ the more the two bodies can pull on the joint. get_bias :: (Joint2D :< cls, Object :< cls) => cls -> IO Float get_bias cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJoint2D_get_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint2D "get_bias" '[] (IO Float) where nodeMethod = Godot.Core.Joint2D.get_bias {-# NOINLINE bindJoint2D_get_exclude_nodes_from_collision #-} -- | If @true@, @node_a@ and @node_b@ can not collide. bindJoint2D_get_exclude_nodes_from_collision :: MethodBind bindJoint2D_get_exclude_nodes_from_collision = unsafePerformIO $ withCString "Joint2D" $ \ clsNamePtr -> withCString "get_exclude_nodes_from_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @node_a@ and @node_b@ can not collide. get_exclude_nodes_from_collision :: (Joint2D :< cls, Object :< cls) => cls -> IO Bool get_exclude_nodes_from_collision cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJoint2D_get_exclude_nodes_from_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint2D "get_exclude_nodes_from_collision" '[] (IO Bool) where nodeMethod = Godot.Core.Joint2D.get_exclude_nodes_from_collision {-# NOINLINE bindJoint2D_get_node_a #-} -- | The first body attached to the joint. Must derive from @PhysicsBody2D@. bindJoint2D_get_node_a :: MethodBind bindJoint2D_get_node_a = unsafePerformIO $ withCString "Joint2D" $ \ clsNamePtr -> withCString "get_node_a" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The first body attached to the joint. Must derive from @PhysicsBody2D@. get_node_a :: (Joint2D :< cls, Object :< cls) => cls -> IO NodePath get_node_a cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJoint2D_get_node_a (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint2D "get_node_a" '[] (IO NodePath) where nodeMethod = Godot.Core.Joint2D.get_node_a {-# NOINLINE bindJoint2D_get_node_b #-} -- | The second body attached to the joint. Must derive from @PhysicsBody2D@. bindJoint2D_get_node_b :: MethodBind bindJoint2D_get_node_b = unsafePerformIO $ withCString "Joint2D" $ \ clsNamePtr -> withCString "get_node_b" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The second body attached to the joint. Must derive from @PhysicsBody2D@. get_node_b :: (Joint2D :< cls, Object :< cls) => cls -> IO NodePath get_node_b cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindJoint2D_get_node_b (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint2D "get_node_b" '[] (IO NodePath) where nodeMethod = Godot.Core.Joint2D.get_node_b {-# NOINLINE bindJoint2D_set_bias #-} -- | When @node_a@ and @node_b@ move in different directions the @bias@ controls how fast the joint pulls them back to their original position. The lower the @bias@ the more the two bodies can pull on the joint. bindJoint2D_set_bias :: MethodBind bindJoint2D_set_bias = unsafePerformIO $ withCString "Joint2D" $ \ clsNamePtr -> withCString "set_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When @node_a@ and @node_b@ move in different directions the @bias@ controls how fast the joint pulls them back to their original position. The lower the @bias@ the more the two bodies can pull on the joint. set_bias :: (Joint2D :< cls, Object :< cls) => cls -> Float -> IO () set_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJoint2D_set_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint2D "set_bias" '[Float] (IO ()) where nodeMethod = Godot.Core.Joint2D.set_bias {-# NOINLINE bindJoint2D_set_exclude_nodes_from_collision #-} -- | If @true@, @node_a@ and @node_b@ can not collide. bindJoint2D_set_exclude_nodes_from_collision :: MethodBind bindJoint2D_set_exclude_nodes_from_collision = unsafePerformIO $ withCString "Joint2D" $ \ clsNamePtr -> withCString "set_exclude_nodes_from_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @node_a@ and @node_b@ can not collide. set_exclude_nodes_from_collision :: (Joint2D :< cls, Object :< cls) => cls -> Bool -> IO () set_exclude_nodes_from_collision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJoint2D_set_exclude_nodes_from_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint2D "set_exclude_nodes_from_collision" '[Bool] (IO ()) where nodeMethod = Godot.Core.Joint2D.set_exclude_nodes_from_collision {-# NOINLINE bindJoint2D_set_node_a #-} -- | The first body attached to the joint. Must derive from @PhysicsBody2D@. bindJoint2D_set_node_a :: MethodBind bindJoint2D_set_node_a = unsafePerformIO $ withCString "Joint2D" $ \ clsNamePtr -> withCString "set_node_a" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The first body attached to the joint. Must derive from @PhysicsBody2D@. set_node_a :: (Joint2D :< cls, Object :< cls) => cls -> NodePath -> IO () set_node_a cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJoint2D_set_node_a (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint2D "set_node_a" '[NodePath] (IO ()) where nodeMethod = Godot.Core.Joint2D.set_node_a {-# NOINLINE bindJoint2D_set_node_b #-} -- | The second body attached to the joint. Must derive from @PhysicsBody2D@. bindJoint2D_set_node_b :: MethodBind bindJoint2D_set_node_b = unsafePerformIO $ withCString "Joint2D" $ \ clsNamePtr -> withCString "set_node_b" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The second body attached to the joint. Must derive from @PhysicsBody2D@. set_node_b :: (Joint2D :< cls, Object :< cls) => cls -> NodePath -> IO () set_node_b cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindJoint2D_set_node_b (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Joint2D "set_node_b" '[NodePath] (IO ()) where nodeMethod = Godot.Core.Joint2D.set_node_b ================================================ FILE: src/Godot/Core/KinematicBody.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.KinematicBody (Godot.Core.KinematicBody.get_axis_lock, Godot.Core.KinematicBody.get_floor_normal, Godot.Core.KinematicBody.get_floor_velocity, Godot.Core.KinematicBody.get_safe_margin, Godot.Core.KinematicBody.get_slide_collision, Godot.Core.KinematicBody.get_slide_count, Godot.Core.KinematicBody.is_on_ceiling, Godot.Core.KinematicBody.is_on_floor, Godot.Core.KinematicBody.is_on_wall, Godot.Core.KinematicBody.move_and_collide, Godot.Core.KinematicBody.move_and_slide, Godot.Core.KinematicBody.move_and_slide_with_snap, Godot.Core.KinematicBody.set_axis_lock, Godot.Core.KinematicBody.set_safe_margin, Godot.Core.KinematicBody.test_move) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsBody() instance NodeProperty KinematicBody "collision/safe_margin" Float 'False where nodeProperty = (get_safe_margin, wrapDroppingSetter set_safe_margin, Nothing) instance NodeProperty KinematicBody "move_lock_x" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_axis_lock, wrapIndexedSetter 1 set_axis_lock, Nothing) instance NodeProperty KinematicBody "move_lock_y" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_axis_lock, wrapIndexedSetter 2 set_axis_lock, Nothing) instance NodeProperty KinematicBody "move_lock_z" Bool 'False where nodeProperty = (wrapIndexedGetter 4 get_axis_lock, wrapIndexedSetter 4 set_axis_lock, Nothing) {-# NOINLINE bindKinematicBody_get_axis_lock #-} -- | Returns @true@ if the specified @axis@ is locked. See also @move_lock_x@, @move_lock_y@ and @move_lock_z@. bindKinematicBody_get_axis_lock :: MethodBind bindKinematicBody_get_axis_lock = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "get_axis_lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified @axis@ is locked. See also @move_lock_x@, @move_lock_y@ and @move_lock_z@. get_axis_lock :: (KinematicBody :< cls, Object :< cls) => cls -> Int -> IO Bool get_axis_lock cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_get_axis_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "get_axis_lock" '[Int] (IO Bool) where nodeMethod = Godot.Core.KinematicBody.get_axis_lock {-# NOINLINE bindKinematicBody_get_floor_normal #-} -- | Returns the surface normal of the floor at the last collision point. Only valid after calling @method move_and_slide@ or @method move_and_slide_with_snap@ and when @method is_on_floor@ returns @true@. bindKinematicBody_get_floor_normal :: MethodBind bindKinematicBody_get_floor_normal = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "get_floor_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the surface normal of the floor at the last collision point. Only valid after calling @method move_and_slide@ or @method move_and_slide_with_snap@ and when @method is_on_floor@ returns @true@. get_floor_normal :: (KinematicBody :< cls, Object :< cls) => cls -> IO Vector3 get_floor_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_get_floor_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "get_floor_normal" '[] (IO Vector3) where nodeMethod = Godot.Core.KinematicBody.get_floor_normal {-# NOINLINE bindKinematicBody_get_floor_velocity #-} -- | Returns the linear velocity of the floor at the last collision point. Only valid after calling @method move_and_slide@ or @method move_and_slide_with_snap@ and when @method is_on_floor@ returns @true@. bindKinematicBody_get_floor_velocity :: MethodBind bindKinematicBody_get_floor_velocity = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "get_floor_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the linear velocity of the floor at the last collision point. Only valid after calling @method move_and_slide@ or @method move_and_slide_with_snap@ and when @method is_on_floor@ returns @true@. get_floor_velocity :: (KinematicBody :< cls, Object :< cls) => cls -> IO Vector3 get_floor_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_get_floor_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "get_floor_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.KinematicBody.get_floor_velocity {-# NOINLINE bindKinematicBody_get_safe_margin #-} -- | If the body is at least this close to another body, this body will consider them to be colliding. bindKinematicBody_get_safe_margin :: MethodBind bindKinematicBody_get_safe_margin = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "get_safe_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the body is at least this close to another body, this body will consider them to be colliding. get_safe_margin :: (KinematicBody :< cls, Object :< cls) => cls -> IO Float get_safe_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_get_safe_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "get_safe_margin" '[] (IO Float) where nodeMethod = Godot.Core.KinematicBody.get_safe_margin {-# NOINLINE bindKinematicBody_get_slide_collision #-} -- | Returns a @KinematicCollision@, which contains information about a collision that occurred during the last @method move_and_slide@ call. Since the body can collide several times in a single call to @method move_and_slide@, you must specify the index of the collision in the range 0 to (@method get_slide_count@ - 1). bindKinematicBody_get_slide_collision :: MethodBind bindKinematicBody_get_slide_collision = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "get_slide_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @KinematicCollision@, which contains information about a collision that occurred during the last @method move_and_slide@ call. Since the body can collide several times in a single call to @method move_and_slide@, you must specify the index of the collision in the range 0 to (@method get_slide_count@ - 1). get_slide_collision :: (KinematicBody :< cls, Object :< cls) => cls -> Int -> IO KinematicCollision get_slide_collision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_get_slide_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "get_slide_collision" '[Int] (IO KinematicCollision) where nodeMethod = Godot.Core.KinematicBody.get_slide_collision {-# NOINLINE bindKinematicBody_get_slide_count #-} -- | Returns the number of times the body collided and changed direction during the last call to @method move_and_slide@. bindKinematicBody_get_slide_count :: MethodBind bindKinematicBody_get_slide_count = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "get_slide_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of times the body collided and changed direction during the last call to @method move_and_slide@. get_slide_count :: (KinematicBody :< cls, Object :< cls) => cls -> IO Int get_slide_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_get_slide_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "get_slide_count" '[] (IO Int) where nodeMethod = Godot.Core.KinematicBody.get_slide_count {-# NOINLINE bindKinematicBody_is_on_ceiling #-} -- | Returns @true@ if the body is on the ceiling. Only updates when calling @method move_and_slide@. bindKinematicBody_is_on_ceiling :: MethodBind bindKinematicBody_is_on_ceiling = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "is_on_ceiling" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the body is on the ceiling. Only updates when calling @method move_and_slide@. is_on_ceiling :: (KinematicBody :< cls, Object :< cls) => cls -> IO Bool is_on_ceiling cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_is_on_ceiling (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "is_on_ceiling" '[] (IO Bool) where nodeMethod = Godot.Core.KinematicBody.is_on_ceiling {-# NOINLINE bindKinematicBody_is_on_floor #-} -- | Returns @true@ if the body is on the floor. Only updates when calling @method move_and_slide@. bindKinematicBody_is_on_floor :: MethodBind bindKinematicBody_is_on_floor = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "is_on_floor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the body is on the floor. Only updates when calling @method move_and_slide@. is_on_floor :: (KinematicBody :< cls, Object :< cls) => cls -> IO Bool is_on_floor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_is_on_floor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "is_on_floor" '[] (IO Bool) where nodeMethod = Godot.Core.KinematicBody.is_on_floor {-# NOINLINE bindKinematicBody_is_on_wall #-} -- | Returns @true@ if the body is on a wall. Only updates when calling @method move_and_slide@. bindKinematicBody_is_on_wall :: MethodBind bindKinematicBody_is_on_wall = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "is_on_wall" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the body is on a wall. Only updates when calling @method move_and_slide@. is_on_wall :: (KinematicBody :< cls, Object :< cls) => cls -> IO Bool is_on_wall cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_is_on_wall (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "is_on_wall" '[] (IO Bool) where nodeMethod = Godot.Core.KinematicBody.is_on_wall {-# NOINLINE bindKinematicBody_move_and_collide #-} -- | Moves the body along the vector @rel_vec@. The body will stop if it collides. Returns a @KinematicCollision@, which contains information about the collision. -- If @test_only@ is @true@, the body does not move but the would-be collision information is given. bindKinematicBody_move_and_collide :: MethodBind bindKinematicBody_move_and_collide = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "move_and_collide" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the body along the vector @rel_vec@. The body will stop if it collides. Returns a @KinematicCollision@, which contains information about the collision. -- If @test_only@ is @true@, the body does not move but the would-be collision information is given. move_and_collide :: (KinematicBody :< cls, Object :< cls) => cls -> Vector3 -> Maybe Bool -> Maybe Bool -> Maybe Bool -> IO KinematicCollision move_and_collide cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2, maybe (VariantBool True) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_move_and_collide (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "move_and_collide" '[Vector3, Maybe Bool, Maybe Bool, Maybe Bool] (IO KinematicCollision) where nodeMethod = Godot.Core.KinematicBody.move_and_collide {-# NOINLINE bindKinematicBody_move_and_slide #-} -- | Moves the body along a vector. If the body collides with another, it will slide along the other body rather than stop immediately. If the other body is a @KinematicBody@ or @RigidBody@, it will also be affected by the motion of the other body. You can use this to make moving or rotating platforms, or to make nodes push other nodes. -- This method should be used in @method Node._physics_process@ (or in a method called by @method Node._physics_process@), as it uses the physics step's @delta@ value automatically in calculations. Otherwise, the simulation will run at an incorrect speed. -- @linear_velocity@ is the velocity vector (typically meters per second). Unlike in @method move_and_collide@, you should @i@not@/i@ multiply it by @delta@ — the physics engine handles applying the velocity. -- @up_direction@ is the up direction, used to determine what is a wall and what is a floor or a ceiling. If set to the default value of @Vector3(0, 0, 0)@, everything is considered a wall. -- If @stop_on_slope@ is @true@, body will not slide on slopes when you include gravity in @linear_velocity@ and the body is standing still. -- If the body collides, it will change direction a maximum of @max_slides@ times before it stops. -- @floor_max_angle@ is the maximum angle (in radians) where a slope is still considered a floor (or a ceiling), rather than a wall. The default value equals 45 degrees. -- If @infinite_inertia@ is @true@, body will be able to push @RigidBody@ nodes, but it won't also detect any collisions with them. If @false@, it will interact with @RigidBody@ nodes like with @StaticBody@. -- Returns the @linear_velocity@ vector, rotated and/or scaled if a slide collision occurred. To get detailed information about collisions that occurred, use @method get_slide_collision@. bindKinematicBody_move_and_slide :: MethodBind bindKinematicBody_move_and_slide = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "move_and_slide" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the body along a vector. If the body collides with another, it will slide along the other body rather than stop immediately. If the other body is a @KinematicBody@ or @RigidBody@, it will also be affected by the motion of the other body. You can use this to make moving or rotating platforms, or to make nodes push other nodes. -- This method should be used in @method Node._physics_process@ (or in a method called by @method Node._physics_process@), as it uses the physics step's @delta@ value automatically in calculations. Otherwise, the simulation will run at an incorrect speed. -- @linear_velocity@ is the velocity vector (typically meters per second). Unlike in @method move_and_collide@, you should @i@not@/i@ multiply it by @delta@ — the physics engine handles applying the velocity. -- @up_direction@ is the up direction, used to determine what is a wall and what is a floor or a ceiling. If set to the default value of @Vector3(0, 0, 0)@, everything is considered a wall. -- If @stop_on_slope@ is @true@, body will not slide on slopes when you include gravity in @linear_velocity@ and the body is standing still. -- If the body collides, it will change direction a maximum of @max_slides@ times before it stops. -- @floor_max_angle@ is the maximum angle (in radians) where a slope is still considered a floor (or a ceiling), rather than a wall. The default value equals 45 degrees. -- If @infinite_inertia@ is @true@, body will be able to push @RigidBody@ nodes, but it won't also detect any collisions with them. If @false@, it will interact with @RigidBody@ nodes like with @StaticBody@. -- Returns the @linear_velocity@ vector, rotated and/or scaled if a slide collision occurred. To get detailed information about collisions that occurred, use @method get_slide_collision@. move_and_slide :: (KinematicBody :< cls, Object :< cls) => cls -> Vector3 -> Maybe Vector3 -> Maybe Bool -> Maybe Int -> Maybe Float -> Maybe Bool -> IO Vector3 move_and_slide cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, defaultedVariant VariantVector3 (V3 0 0 0) arg2, maybe (VariantBool False) toVariant arg3, maybe (VariantInt (4)) toVariant arg4, maybe (VariantReal (0.785398)) toVariant arg5, maybe (VariantBool True) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_move_and_slide (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "move_and_slide" '[Vector3, Maybe Vector3, Maybe Bool, Maybe Int, Maybe Float, Maybe Bool] (IO Vector3) where nodeMethod = Godot.Core.KinematicBody.move_and_slide {-# NOINLINE bindKinematicBody_move_and_slide_with_snap #-} -- | Moves the body while keeping it attached to slopes. Similar to @method move_and_slide@. -- As long as the @snap@ vector is in contact with the ground, the body will remain attached to the surface. This means you must disable snap in order to jump, for example. You can do this by setting @snap@ to @(0, 0, 0)@ or by using @method move_and_slide@ instead. bindKinematicBody_move_and_slide_with_snap :: MethodBind bindKinematicBody_move_and_slide_with_snap = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "move_and_slide_with_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the body while keeping it attached to slopes. Similar to @method move_and_slide@. -- As long as the @snap@ vector is in contact with the ground, the body will remain attached to the surface. This means you must disable snap in order to jump, for example. You can do this by setting @snap@ to @(0, 0, 0)@ or by using @method move_and_slide@ instead. move_and_slide_with_snap :: (KinematicBody :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Maybe Vector3 -> Maybe Bool -> Maybe Int -> Maybe Float -> Maybe Bool -> IO Vector3 move_and_slide_with_snap cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantVector3 (V3 0 0 0) arg3, maybe (VariantBool False) toVariant arg4, maybe (VariantInt (4)) toVariant arg5, maybe (VariantReal (0.785398)) toVariant arg6, maybe (VariantBool True) toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_move_and_slide_with_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "move_and_slide_with_snap" '[Vector3, Vector3, Maybe Vector3, Maybe Bool, Maybe Int, Maybe Float, Maybe Bool] (IO Vector3) where nodeMethod = Godot.Core.KinematicBody.move_and_slide_with_snap {-# NOINLINE bindKinematicBody_set_axis_lock #-} -- | Locks or unlocks the specified @axis@ depending on the value of @lock@. See also @move_lock_x@, @move_lock_y@ and @move_lock_z@. bindKinematicBody_set_axis_lock :: MethodBind bindKinematicBody_set_axis_lock = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "set_axis_lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Locks or unlocks the specified @axis@ depending on the value of @lock@. See also @move_lock_x@, @move_lock_y@ and @move_lock_z@. set_axis_lock :: (KinematicBody :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_axis_lock cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_set_axis_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "set_axis_lock" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.KinematicBody.set_axis_lock {-# NOINLINE bindKinematicBody_set_safe_margin #-} -- | If the body is at least this close to another body, this body will consider them to be colliding. bindKinematicBody_set_safe_margin :: MethodBind bindKinematicBody_set_safe_margin = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "set_safe_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the body is at least this close to another body, this body will consider them to be colliding. set_safe_margin :: (KinematicBody :< cls, Object :< cls) => cls -> Float -> IO () set_safe_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_set_safe_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "set_safe_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.KinematicBody.set_safe_margin {-# NOINLINE bindKinematicBody_test_move #-} -- | Checks for collisions without moving the body. Virtually sets the node's position, scale and rotation to that of the given @Transform@, then tries to move the body along the vector @rel_vec@. Returns @true@ if a collision would occur. bindKinematicBody_test_move :: MethodBind bindKinematicBody_test_move = unsafePerformIO $ withCString "KinematicBody" $ \ clsNamePtr -> withCString "test_move" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks for collisions without moving the body. Virtually sets the node's position, scale and rotation to that of the given @Transform@, then tries to move the body along the vector @rel_vec@. Returns @true@ if a collision would occur. test_move :: (KinematicBody :< cls, Object :< cls) => cls -> Transform -> Vector3 -> Maybe Bool -> IO Bool test_move cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody_test_move (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody "test_move" '[Transform, Vector3, Maybe Bool] (IO Bool) where nodeMethod = Godot.Core.KinematicBody.test_move ================================================ FILE: src/Godot/Core/KinematicBody2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.KinematicBody2D (Godot.Core.KinematicBody2D._direct_state_changed, Godot.Core.KinematicBody2D.get_floor_normal, Godot.Core.KinematicBody2D.get_floor_velocity, Godot.Core.KinematicBody2D.get_safe_margin, Godot.Core.KinematicBody2D.get_slide_collision, Godot.Core.KinematicBody2D.get_slide_count, Godot.Core.KinematicBody2D.is_on_ceiling, Godot.Core.KinematicBody2D.is_on_floor, Godot.Core.KinematicBody2D.is_on_wall, Godot.Core.KinematicBody2D.is_sync_to_physics_enabled, Godot.Core.KinematicBody2D.move_and_collide, Godot.Core.KinematicBody2D.move_and_slide, Godot.Core.KinematicBody2D.move_and_slide_with_snap, Godot.Core.KinematicBody2D.set_safe_margin, Godot.Core.KinematicBody2D.set_sync_to_physics, Godot.Core.KinematicBody2D.test_move) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsBody2D() instance NodeProperty KinematicBody2D "collision/safe_margin" Float 'False where nodeProperty = (get_safe_margin, wrapDroppingSetter set_safe_margin, Nothing) instance NodeProperty KinematicBody2D "motion/sync_to_physics" Bool 'False where nodeProperty = (is_sync_to_physics_enabled, wrapDroppingSetter set_sync_to_physics, Nothing) {-# NOINLINE bindKinematicBody2D__direct_state_changed #-} bindKinematicBody2D__direct_state_changed :: MethodBind bindKinematicBody2D__direct_state_changed = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "_direct_state_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _direct_state_changed :: (KinematicBody2D :< cls, Object :< cls) => cls -> Object -> IO () _direct_state_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D__direct_state_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "_direct_state_changed" '[Object] (IO ()) where nodeMethod = Godot.Core.KinematicBody2D._direct_state_changed {-# NOINLINE bindKinematicBody2D_get_floor_normal #-} -- | Returns the surface normal of the floor at the last collision point. Only valid after calling @method move_and_slide@ or @method move_and_slide_with_snap@ and when @method is_on_floor@ returns @true@. bindKinematicBody2D_get_floor_normal :: MethodBind bindKinematicBody2D_get_floor_normal = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "get_floor_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the surface normal of the floor at the last collision point. Only valid after calling @method move_and_slide@ or @method move_and_slide_with_snap@ and when @method is_on_floor@ returns @true@. get_floor_normal :: (KinematicBody2D :< cls, Object :< cls) => cls -> IO Vector2 get_floor_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_get_floor_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "get_floor_normal" '[] (IO Vector2) where nodeMethod = Godot.Core.KinematicBody2D.get_floor_normal {-# NOINLINE bindKinematicBody2D_get_floor_velocity #-} -- | Returns the linear velocity of the floor at the last collision point. Only valid after calling @method move_and_slide@ or @method move_and_slide_with_snap@ and when @method is_on_floor@ returns @true@. bindKinematicBody2D_get_floor_velocity :: MethodBind bindKinematicBody2D_get_floor_velocity = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "get_floor_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the linear velocity of the floor at the last collision point. Only valid after calling @method move_and_slide@ or @method move_and_slide_with_snap@ and when @method is_on_floor@ returns @true@. get_floor_velocity :: (KinematicBody2D :< cls, Object :< cls) => cls -> IO Vector2 get_floor_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_get_floor_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "get_floor_velocity" '[] (IO Vector2) where nodeMethod = Godot.Core.KinematicBody2D.get_floor_velocity {-# NOINLINE bindKinematicBody2D_get_safe_margin #-} -- | If the body is at least this close to another body, this body will consider them to be colliding. bindKinematicBody2D_get_safe_margin :: MethodBind bindKinematicBody2D_get_safe_margin = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "get_safe_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the body is at least this close to another body, this body will consider them to be colliding. get_safe_margin :: (KinematicBody2D :< cls, Object :< cls) => cls -> IO Float get_safe_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_get_safe_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "get_safe_margin" '[] (IO Float) where nodeMethod = Godot.Core.KinematicBody2D.get_safe_margin {-# NOINLINE bindKinematicBody2D_get_slide_collision #-} -- | Returns a @KinematicCollision2D@, which contains information about a collision that occurred during the last @method move_and_slide@ call. Since the body can collide several times in a single call to @method move_and_slide@, you must specify the index of the collision in the range 0 to (@method get_slide_count@ - 1). -- __Example usage:__ -- -- @ -- -- for i in get_slide_count(): -- var collision = get_slide_collision(i) -- print("Collided with: ", collision.collider.name) -- -- @ bindKinematicBody2D_get_slide_collision :: MethodBind bindKinematicBody2D_get_slide_collision = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "get_slide_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @KinematicCollision2D@, which contains information about a collision that occurred during the last @method move_and_slide@ call. Since the body can collide several times in a single call to @method move_and_slide@, you must specify the index of the collision in the range 0 to (@method get_slide_count@ - 1). -- __Example usage:__ -- -- @ -- -- for i in get_slide_count(): -- var collision = get_slide_collision(i) -- print("Collided with: ", collision.collider.name) -- -- @ get_slide_collision :: (KinematicBody2D :< cls, Object :< cls) => cls -> Int -> IO KinematicCollision2D get_slide_collision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_get_slide_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "get_slide_collision" '[Int] (IO KinematicCollision2D) where nodeMethod = Godot.Core.KinematicBody2D.get_slide_collision {-# NOINLINE bindKinematicBody2D_get_slide_count #-} -- | Returns the number of times the body collided and changed direction during the last call to @method move_and_slide@. bindKinematicBody2D_get_slide_count :: MethodBind bindKinematicBody2D_get_slide_count = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "get_slide_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of times the body collided and changed direction during the last call to @method move_and_slide@. get_slide_count :: (KinematicBody2D :< cls, Object :< cls) => cls -> IO Int get_slide_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_get_slide_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "get_slide_count" '[] (IO Int) where nodeMethod = Godot.Core.KinematicBody2D.get_slide_count {-# NOINLINE bindKinematicBody2D_is_on_ceiling #-} -- | Returns @true@ if the body is on the ceiling. Only updates when calling @method move_and_slide@. bindKinematicBody2D_is_on_ceiling :: MethodBind bindKinematicBody2D_is_on_ceiling = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "is_on_ceiling" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the body is on the ceiling. Only updates when calling @method move_and_slide@. is_on_ceiling :: (KinematicBody2D :< cls, Object :< cls) => cls -> IO Bool is_on_ceiling cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_is_on_ceiling (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "is_on_ceiling" '[] (IO Bool) where nodeMethod = Godot.Core.KinematicBody2D.is_on_ceiling {-# NOINLINE bindKinematicBody2D_is_on_floor #-} -- | Returns @true@ if the body is on the floor. Only updates when calling @method move_and_slide@. bindKinematicBody2D_is_on_floor :: MethodBind bindKinematicBody2D_is_on_floor = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "is_on_floor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the body is on the floor. Only updates when calling @method move_and_slide@. is_on_floor :: (KinematicBody2D :< cls, Object :< cls) => cls -> IO Bool is_on_floor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_is_on_floor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "is_on_floor" '[] (IO Bool) where nodeMethod = Godot.Core.KinematicBody2D.is_on_floor {-# NOINLINE bindKinematicBody2D_is_on_wall #-} -- | Returns @true@ if the body is on a wall. Only updates when calling @method move_and_slide@. bindKinematicBody2D_is_on_wall :: MethodBind bindKinematicBody2D_is_on_wall = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "is_on_wall" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the body is on a wall. Only updates when calling @method move_and_slide@. is_on_wall :: (KinematicBody2D :< cls, Object :< cls) => cls -> IO Bool is_on_wall cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_is_on_wall (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "is_on_wall" '[] (IO Bool) where nodeMethod = Godot.Core.KinematicBody2D.is_on_wall {-# NOINLINE bindKinematicBody2D_is_sync_to_physics_enabled #-} -- | If @true@, the body's movement will be synchronized to the physics frame. This is useful when animating movement via @AnimationPlayer@, for example on moving platforms. Do __not__ use together with @method move_and_slide@ or @method move_and_collide@ functions. bindKinematicBody2D_is_sync_to_physics_enabled :: MethodBind bindKinematicBody2D_is_sync_to_physics_enabled = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "is_sync_to_physics_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body's movement will be synchronized to the physics frame. This is useful when animating movement via @AnimationPlayer@, for example on moving platforms. Do __not__ use together with @method move_and_slide@ or @method move_and_collide@ functions. is_sync_to_physics_enabled :: (KinematicBody2D :< cls, Object :< cls) => cls -> IO Bool is_sync_to_physics_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_is_sync_to_physics_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "is_sync_to_physics_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.KinematicBody2D.is_sync_to_physics_enabled {-# NOINLINE bindKinematicBody2D_move_and_collide #-} -- | Moves the body along the vector @rel_vec@. The body will stop if it collides. Returns a @KinematicCollision2D@, which contains information about the collision. -- If @test_only@ is @true@, the body does not move but the would-be collision information is given. bindKinematicBody2D_move_and_collide :: MethodBind bindKinematicBody2D_move_and_collide = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "move_and_collide" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the body along the vector @rel_vec@. The body will stop if it collides. Returns a @KinematicCollision2D@, which contains information about the collision. -- If @test_only@ is @true@, the body does not move but the would-be collision information is given. move_and_collide :: (KinematicBody2D :< cls, Object :< cls) => cls -> Vector2 -> Maybe Bool -> Maybe Bool -> Maybe Bool -> IO KinematicCollision2D move_and_collide cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2, maybe (VariantBool True) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_move_and_collide (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "move_and_collide" '[Vector2, Maybe Bool, Maybe Bool, Maybe Bool] (IO KinematicCollision2D) where nodeMethod = Godot.Core.KinematicBody2D.move_and_collide {-# NOINLINE bindKinematicBody2D_move_and_slide #-} -- | Moves the body along a vector. If the body collides with another, it will slide along the other body rather than stop immediately. If the other body is a @KinematicBody2D@ or @RigidBody2D@, it will also be affected by the motion of the other body. You can use this to make moving or rotating platforms, or to make nodes push other nodes. -- This method should be used in @method Node._physics_process@ (or in a method called by @method Node._physics_process@), as it uses the physics step's @delta@ value automatically in calculations. Otherwise, the simulation will run at an incorrect speed. -- @linear_velocity@ is the velocity vector in pixels per second. Unlike in @method move_and_collide@, you should @i@not@/i@ multiply it by @delta@ — the physics engine handles applying the velocity. -- @up_direction@ is the up direction, used to determine what is a wall and what is a floor or a ceiling. If set to the default value of @Vector2(0, 0)@, everything is considered a wall. This is useful for topdown games. -- If @stop_on_slope@ is @true@, body will not slide on slopes when you include gravity in @linear_velocity@ and the body is standing still. -- If the body collides, it will change direction a maximum of @max_slides@ times before it stops. -- @floor_max_angle@ is the maximum angle (in radians) where a slope is still considered a floor (or a ceiling), rather than a wall. The default value equals 45 degrees. -- If @infinite_inertia@ is @true@, body will be able to push @RigidBody2D@ nodes, but it won't also detect any collisions with them. If @false@, it will interact with @RigidBody2D@ nodes like with @StaticBody2D@. -- Returns the @linear_velocity@ vector, rotated and/or scaled if a slide collision occurred. To get detailed information about collisions that occurred, use @method get_slide_collision@. bindKinematicBody2D_move_and_slide :: MethodBind bindKinematicBody2D_move_and_slide = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "move_and_slide" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the body along a vector. If the body collides with another, it will slide along the other body rather than stop immediately. If the other body is a @KinematicBody2D@ or @RigidBody2D@, it will also be affected by the motion of the other body. You can use this to make moving or rotating platforms, or to make nodes push other nodes. -- This method should be used in @method Node._physics_process@ (or in a method called by @method Node._physics_process@), as it uses the physics step's @delta@ value automatically in calculations. Otherwise, the simulation will run at an incorrect speed. -- @linear_velocity@ is the velocity vector in pixels per second. Unlike in @method move_and_collide@, you should @i@not@/i@ multiply it by @delta@ — the physics engine handles applying the velocity. -- @up_direction@ is the up direction, used to determine what is a wall and what is a floor or a ceiling. If set to the default value of @Vector2(0, 0)@, everything is considered a wall. This is useful for topdown games. -- If @stop_on_slope@ is @true@, body will not slide on slopes when you include gravity in @linear_velocity@ and the body is standing still. -- If the body collides, it will change direction a maximum of @max_slides@ times before it stops. -- @floor_max_angle@ is the maximum angle (in radians) where a slope is still considered a floor (or a ceiling), rather than a wall. The default value equals 45 degrees. -- If @infinite_inertia@ is @true@, body will be able to push @RigidBody2D@ nodes, but it won't also detect any collisions with them. If @false@, it will interact with @RigidBody2D@ nodes like with @StaticBody2D@. -- Returns the @linear_velocity@ vector, rotated and/or scaled if a slide collision occurred. To get detailed information about collisions that occurred, use @method get_slide_collision@. move_and_slide :: (KinematicBody2D :< cls, Object :< cls) => cls -> Vector2 -> Maybe Vector2 -> Maybe Bool -> Maybe Int -> Maybe Float -> Maybe Bool -> IO Vector2 move_and_slide cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, defaultedVariant VariantVector2 (V2 0 0) arg2, maybe (VariantBool False) toVariant arg3, maybe (VariantInt (4)) toVariant arg4, maybe (VariantReal (0.785398)) toVariant arg5, maybe (VariantBool True) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_move_and_slide (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "move_and_slide" '[Vector2, Maybe Vector2, Maybe Bool, Maybe Int, Maybe Float, Maybe Bool] (IO Vector2) where nodeMethod = Godot.Core.KinematicBody2D.move_and_slide {-# NOINLINE bindKinematicBody2D_move_and_slide_with_snap #-} -- | Moves the body while keeping it attached to slopes. Similar to @method move_and_slide@. -- As long as the @snap@ vector is in contact with the ground, the body will remain attached to the surface. This means you must disable snap in order to jump, for example. You can do this by setting @snap@ to @(0, 0)@ or by using @method move_and_slide@ instead. bindKinematicBody2D_move_and_slide_with_snap :: MethodBind bindKinematicBody2D_move_and_slide_with_snap = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "move_and_slide_with_snap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the body while keeping it attached to slopes. Similar to @method move_and_slide@. -- As long as the @snap@ vector is in contact with the ground, the body will remain attached to the surface. This means you must disable snap in order to jump, for example. You can do this by setting @snap@ to @(0, 0)@ or by using @method move_and_slide@ instead. move_and_slide_with_snap :: (KinematicBody2D :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Maybe Vector2 -> Maybe Bool -> Maybe Int -> Maybe Float -> Maybe Bool -> IO Vector2 move_and_slide_with_snap cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantVector2 (V2 0 0) arg3, maybe (VariantBool False) toVariant arg4, maybe (VariantInt (4)) toVariant arg5, maybe (VariantReal (0.785398)) toVariant arg6, maybe (VariantBool True) toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_move_and_slide_with_snap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "move_and_slide_with_snap" '[Vector2, Vector2, Maybe Vector2, Maybe Bool, Maybe Int, Maybe Float, Maybe Bool] (IO Vector2) where nodeMethod = Godot.Core.KinematicBody2D.move_and_slide_with_snap {-# NOINLINE bindKinematicBody2D_set_safe_margin #-} -- | If the body is at least this close to another body, this body will consider them to be colliding. bindKinematicBody2D_set_safe_margin :: MethodBind bindKinematicBody2D_set_safe_margin = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "set_safe_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If the body is at least this close to another body, this body will consider them to be colliding. set_safe_margin :: (KinematicBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_safe_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_set_safe_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "set_safe_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.KinematicBody2D.set_safe_margin {-# NOINLINE bindKinematicBody2D_set_sync_to_physics #-} -- | If @true@, the body's movement will be synchronized to the physics frame. This is useful when animating movement via @AnimationPlayer@, for example on moving platforms. Do __not__ use together with @method move_and_slide@ or @method move_and_collide@ functions. bindKinematicBody2D_set_sync_to_physics :: MethodBind bindKinematicBody2D_set_sync_to_physics = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "set_sync_to_physics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body's movement will be synchronized to the physics frame. This is useful when animating movement via @AnimationPlayer@, for example on moving platforms. Do __not__ use together with @method move_and_slide@ or @method move_and_collide@ functions. set_sync_to_physics :: (KinematicBody2D :< cls, Object :< cls) => cls -> Bool -> IO () set_sync_to_physics cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_set_sync_to_physics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "set_sync_to_physics" '[Bool] (IO ()) where nodeMethod = Godot.Core.KinematicBody2D.set_sync_to_physics {-# NOINLINE bindKinematicBody2D_test_move #-} -- | Checks for collisions without moving the body. Virtually sets the node's position, scale and rotation to that of the given @Transform2D@, then tries to move the body along the vector @rel_vec@. Returns @true@ if a collision would occur. bindKinematicBody2D_test_move :: MethodBind bindKinematicBody2D_test_move = unsafePerformIO $ withCString "KinematicBody2D" $ \ clsNamePtr -> withCString "test_move" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks for collisions without moving the body. Virtually sets the node's position, scale and rotation to that of the given @Transform2D@, then tries to move the body along the vector @rel_vec@. Returns @true@ if a collision would occur. test_move :: (KinematicBody2D :< cls, Object :< cls) => cls -> Transform2d -> Vector2 -> Maybe Bool -> IO Bool test_move cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicBody2D_test_move (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicBody2D "test_move" '[Transform2d, Vector2, Maybe Bool] (IO Bool) where nodeMethod = Godot.Core.KinematicBody2D.test_move ================================================ FILE: src/Godot/Core/KinematicCollision.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.KinematicCollision (Godot.Core.KinematicCollision.get_collider, Godot.Core.KinematicCollision.get_collider_id, Godot.Core.KinematicCollision.get_collider_metadata, Godot.Core.KinematicCollision.get_collider_shape, Godot.Core.KinematicCollision.get_collider_shape_index, Godot.Core.KinematicCollision.get_collider_velocity, Godot.Core.KinematicCollision.get_local_shape, Godot.Core.KinematicCollision.get_normal, Godot.Core.KinematicCollision.get_position, Godot.Core.KinematicCollision.get_remainder, Godot.Core.KinematicCollision.get_travel) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty KinematicCollision "collider" Object 'True where nodeProperty = (get_collider, (), Nothing) instance NodeProperty KinematicCollision "collider_id" Int 'True where nodeProperty = (get_collider_id, (), Nothing) instance NodeProperty KinematicCollision "collider_metadata" GodotVariant 'True where nodeProperty = (get_collider_metadata, (), Nothing) instance NodeProperty KinematicCollision "collider_shape" Object 'True where nodeProperty = (get_collider_shape, (), Nothing) instance NodeProperty KinematicCollision "collider_shape_index" Int 'True where nodeProperty = (get_collider_shape_index, (), Nothing) instance NodeProperty KinematicCollision "collider_velocity" Vector3 'True where nodeProperty = (get_collider_velocity, (), Nothing) instance NodeProperty KinematicCollision "local_shape" Object 'True where nodeProperty = (get_local_shape, (), Nothing) instance NodeProperty KinematicCollision "normal" Vector3 'True where nodeProperty = (get_normal, (), Nothing) instance NodeProperty KinematicCollision "position" Vector3 'True where nodeProperty = (get_position, (), Nothing) instance NodeProperty KinematicCollision "remainder" Vector3 'True where nodeProperty = (get_remainder, (), Nothing) instance NodeProperty KinematicCollision "travel" Vector3 'True where nodeProperty = (get_travel, (), Nothing) {-# NOINLINE bindKinematicCollision_get_collider #-} -- | The colliding body. bindKinematicCollision_get_collider :: MethodBind bindKinematicCollision_get_collider = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_collider" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body. get_collider :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Object get_collider cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_collider (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_collider" '[] (IO Object) where nodeMethod = Godot.Core.KinematicCollision.get_collider {-# NOINLINE bindKinematicCollision_get_collider_id #-} -- | The colliding body's unique instance ID. See @method Object.get_instance_id@. bindKinematicCollision_get_collider_id :: MethodBind bindKinematicCollision_get_collider_id = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_collider_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body's unique instance ID. See @method Object.get_instance_id@. get_collider_id :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Int get_collider_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_collider_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_collider_id" '[] (IO Int) where nodeMethod = Godot.Core.KinematicCollision.get_collider_id {-# NOINLINE bindKinematicCollision_get_collider_metadata #-} -- | The colliding body's metadata. See @Object@. bindKinematicCollision_get_collider_metadata :: MethodBind bindKinematicCollision_get_collider_metadata = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_collider_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body's metadata. See @Object@. get_collider_metadata :: (KinematicCollision :< cls, Object :< cls) => cls -> IO GodotVariant get_collider_metadata cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_collider_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_collider_metadata" '[] (IO GodotVariant) where nodeMethod = Godot.Core.KinematicCollision.get_collider_metadata {-# NOINLINE bindKinematicCollision_get_collider_shape #-} -- | The colliding body's shape. bindKinematicCollision_get_collider_shape :: MethodBind bindKinematicCollision_get_collider_shape = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_collider_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body's shape. get_collider_shape :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Object get_collider_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_collider_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_collider_shape" '[] (IO Object) where nodeMethod = Godot.Core.KinematicCollision.get_collider_shape {-# NOINLINE bindKinematicCollision_get_collider_shape_index #-} -- | The colliding shape's index. See @CollisionObject@. bindKinematicCollision_get_collider_shape_index :: MethodBind bindKinematicCollision_get_collider_shape_index = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_collider_shape_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding shape's index. See @CollisionObject@. get_collider_shape_index :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Int get_collider_shape_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_collider_shape_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_collider_shape_index" '[] (IO Int) where nodeMethod = Godot.Core.KinematicCollision.get_collider_shape_index {-# NOINLINE bindKinematicCollision_get_collider_velocity #-} -- | The colliding object's velocity. bindKinematicCollision_get_collider_velocity :: MethodBind bindKinematicCollision_get_collider_velocity = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_collider_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding object's velocity. get_collider_velocity :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Vector3 get_collider_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_collider_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_collider_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.KinematicCollision.get_collider_velocity {-# NOINLINE bindKinematicCollision_get_local_shape #-} -- | The moving object's colliding shape. bindKinematicCollision_get_local_shape :: MethodBind bindKinematicCollision_get_local_shape = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_local_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The moving object's colliding shape. get_local_shape :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Object get_local_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_local_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_local_shape" '[] (IO Object) where nodeMethod = Godot.Core.KinematicCollision.get_local_shape {-# NOINLINE bindKinematicCollision_get_normal #-} -- | The colliding body's shape's normal at the point of collision. bindKinematicCollision_get_normal :: MethodBind bindKinematicCollision_get_normal = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body's shape's normal at the point of collision. get_normal :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Vector3 get_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_normal" '[] (IO Vector3) where nodeMethod = Godot.Core.KinematicCollision.get_normal {-# NOINLINE bindKinematicCollision_get_position #-} -- | The point of collision, in global coordinates. bindKinematicCollision_get_position :: MethodBind bindKinematicCollision_get_position = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The point of collision, in global coordinates. get_position :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Vector3 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_position" '[] (IO Vector3) where nodeMethod = Godot.Core.KinematicCollision.get_position {-# NOINLINE bindKinematicCollision_get_remainder #-} -- | The moving object's remaining movement vector. bindKinematicCollision_get_remainder :: MethodBind bindKinematicCollision_get_remainder = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_remainder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The moving object's remaining movement vector. get_remainder :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Vector3 get_remainder cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_remainder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_remainder" '[] (IO Vector3) where nodeMethod = Godot.Core.KinematicCollision.get_remainder {-# NOINLINE bindKinematicCollision_get_travel #-} -- | The distance the moving object traveled before collision. bindKinematicCollision_get_travel :: MethodBind bindKinematicCollision_get_travel = unsafePerformIO $ withCString "KinematicCollision" $ \ clsNamePtr -> withCString "get_travel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance the moving object traveled before collision. get_travel :: (KinematicCollision :< cls, Object :< cls) => cls -> IO Vector3 get_travel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision_get_travel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision "get_travel" '[] (IO Vector3) where nodeMethod = Godot.Core.KinematicCollision.get_travel ================================================ FILE: src/Godot/Core/KinematicCollision2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.KinematicCollision2D (Godot.Core.KinematicCollision2D.get_collider, Godot.Core.KinematicCollision2D.get_collider_id, Godot.Core.KinematicCollision2D.get_collider_metadata, Godot.Core.KinematicCollision2D.get_collider_shape, Godot.Core.KinematicCollision2D.get_collider_shape_index, Godot.Core.KinematicCollision2D.get_collider_velocity, Godot.Core.KinematicCollision2D.get_local_shape, Godot.Core.KinematicCollision2D.get_normal, Godot.Core.KinematicCollision2D.get_position, Godot.Core.KinematicCollision2D.get_remainder, Godot.Core.KinematicCollision2D.get_travel) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty KinematicCollision2D "collider" Object 'True where nodeProperty = (get_collider, (), Nothing) instance NodeProperty KinematicCollision2D "collider_id" Int 'True where nodeProperty = (get_collider_id, (), Nothing) instance NodeProperty KinematicCollision2D "collider_metadata" GodotVariant 'True where nodeProperty = (get_collider_metadata, (), Nothing) instance NodeProperty KinematicCollision2D "collider_shape" Object 'True where nodeProperty = (get_collider_shape, (), Nothing) instance NodeProperty KinematicCollision2D "collider_shape_index" Int 'True where nodeProperty = (get_collider_shape_index, (), Nothing) instance NodeProperty KinematicCollision2D "collider_velocity" Vector2 'True where nodeProperty = (get_collider_velocity, (), Nothing) instance NodeProperty KinematicCollision2D "local_shape" Object 'True where nodeProperty = (get_local_shape, (), Nothing) instance NodeProperty KinematicCollision2D "normal" Vector2 'True where nodeProperty = (get_normal, (), Nothing) instance NodeProperty KinematicCollision2D "position" Vector2 'True where nodeProperty = (get_position, (), Nothing) instance NodeProperty KinematicCollision2D "remainder" Vector2 'True where nodeProperty = (get_remainder, (), Nothing) instance NodeProperty KinematicCollision2D "travel" Vector2 'True where nodeProperty = (get_travel, (), Nothing) {-# NOINLINE bindKinematicCollision2D_get_collider #-} -- | The colliding body. bindKinematicCollision2D_get_collider :: MethodBind bindKinematicCollision2D_get_collider = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_collider" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body. get_collider :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Object get_collider cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_collider (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_collider" '[] (IO Object) where nodeMethod = Godot.Core.KinematicCollision2D.get_collider {-# NOINLINE bindKinematicCollision2D_get_collider_id #-} -- | The colliding body's unique instance ID. See @method Object.get_instance_id@. bindKinematicCollision2D_get_collider_id :: MethodBind bindKinematicCollision2D_get_collider_id = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_collider_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body's unique instance ID. See @method Object.get_instance_id@. get_collider_id :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Int get_collider_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_collider_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_collider_id" '[] (IO Int) where nodeMethod = Godot.Core.KinematicCollision2D.get_collider_id {-# NOINLINE bindKinematicCollision2D_get_collider_metadata #-} -- | The colliding body's metadata. See @Object@. bindKinematicCollision2D_get_collider_metadata :: MethodBind bindKinematicCollision2D_get_collider_metadata = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_collider_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body's metadata. See @Object@. get_collider_metadata :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO GodotVariant get_collider_metadata cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_collider_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_collider_metadata" '[] (IO GodotVariant) where nodeMethod = Godot.Core.KinematicCollision2D.get_collider_metadata {-# NOINLINE bindKinematicCollision2D_get_collider_shape #-} -- | The colliding body's shape. bindKinematicCollision2D_get_collider_shape :: MethodBind bindKinematicCollision2D_get_collider_shape = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_collider_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body's shape. get_collider_shape :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Object get_collider_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_collider_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_collider_shape" '[] (IO Object) where nodeMethod = Godot.Core.KinematicCollision2D.get_collider_shape {-# NOINLINE bindKinematicCollision2D_get_collider_shape_index #-} -- | The colliding shape's index. See @CollisionObject2D@. bindKinematicCollision2D_get_collider_shape_index :: MethodBind bindKinematicCollision2D_get_collider_shape_index = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_collider_shape_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding shape's index. See @CollisionObject2D@. get_collider_shape_index :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Int get_collider_shape_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_collider_shape_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_collider_shape_index" '[] (IO Int) where nodeMethod = Godot.Core.KinematicCollision2D.get_collider_shape_index {-# NOINLINE bindKinematicCollision2D_get_collider_velocity #-} -- | The colliding object's velocity. bindKinematicCollision2D_get_collider_velocity :: MethodBind bindKinematicCollision2D_get_collider_velocity = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_collider_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding object's velocity. get_collider_velocity :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Vector2 get_collider_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_collider_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_collider_velocity" '[] (IO Vector2) where nodeMethod = Godot.Core.KinematicCollision2D.get_collider_velocity {-# NOINLINE bindKinematicCollision2D_get_local_shape #-} -- | The moving object's colliding shape. bindKinematicCollision2D_get_local_shape :: MethodBind bindKinematicCollision2D_get_local_shape = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_local_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The moving object's colliding shape. get_local_shape :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Object get_local_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_local_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_local_shape" '[] (IO Object) where nodeMethod = Godot.Core.KinematicCollision2D.get_local_shape {-# NOINLINE bindKinematicCollision2D_get_normal #-} -- | The colliding body's shape's normal at the point of collision. bindKinematicCollision2D_get_normal :: MethodBind bindKinematicCollision2D_get_normal = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The colliding body's shape's normal at the point of collision. get_normal :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Vector2 get_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_normal" '[] (IO Vector2) where nodeMethod = Godot.Core.KinematicCollision2D.get_normal {-# NOINLINE bindKinematicCollision2D_get_position #-} -- | The point of collision, in global coordinates. bindKinematicCollision2D_get_position :: MethodBind bindKinematicCollision2D_get_position = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The point of collision, in global coordinates. get_position :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Vector2 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_position" '[] (IO Vector2) where nodeMethod = Godot.Core.KinematicCollision2D.get_position {-# NOINLINE bindKinematicCollision2D_get_remainder #-} -- | The moving object's remaining movement vector. bindKinematicCollision2D_get_remainder :: MethodBind bindKinematicCollision2D_get_remainder = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_remainder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The moving object's remaining movement vector. get_remainder :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Vector2 get_remainder cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_remainder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_remainder" '[] (IO Vector2) where nodeMethod = Godot.Core.KinematicCollision2D.get_remainder {-# NOINLINE bindKinematicCollision2D_get_travel #-} -- | The distance the moving object traveled before collision. bindKinematicCollision2D_get_travel :: MethodBind bindKinematicCollision2D_get_travel = unsafePerformIO $ withCString "KinematicCollision2D" $ \ clsNamePtr -> withCString "get_travel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance the moving object traveled before collision. get_travel :: (KinematicCollision2D :< cls, Object :< cls) => cls -> IO Vector2 get_travel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindKinematicCollision2D_get_travel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod KinematicCollision2D "get_travel" '[] (IO Vector2) where nodeMethod = Godot.Core.KinematicCollision2D.get_travel ================================================ FILE: src/Godot/Core/Label.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Label (Godot.Core.Label._VALIGN_TOP, Godot.Core.Label._ALIGN_RIGHT, Godot.Core.Label._ALIGN_FILL, Godot.Core.Label._VALIGN_FILL, Godot.Core.Label._VALIGN_CENTER, Godot.Core.Label._VALIGN_BOTTOM, Godot.Core.Label._ALIGN_LEFT, Godot.Core.Label._ALIGN_CENTER, Godot.Core.Label.get_align, Godot.Core.Label.get_line_count, Godot.Core.Label.get_line_height, Godot.Core.Label.get_lines_skipped, Godot.Core.Label.get_max_lines_visible, Godot.Core.Label.get_percent_visible, Godot.Core.Label.get_text, Godot.Core.Label.get_total_character_count, Godot.Core.Label.get_valign, Godot.Core.Label.get_visible_characters, Godot.Core.Label.get_visible_line_count, Godot.Core.Label.has_autowrap, Godot.Core.Label.is_clipping_text, Godot.Core.Label.is_uppercase, Godot.Core.Label.set_align, Godot.Core.Label.set_autowrap, Godot.Core.Label.set_clip_text, Godot.Core.Label.set_lines_skipped, Godot.Core.Label.set_max_lines_visible, Godot.Core.Label.set_percent_visible, Godot.Core.Label.set_text, Godot.Core.Label.set_uppercase, Godot.Core.Label.set_valign, Godot.Core.Label.set_visible_characters) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _VALIGN_TOP :: Int _VALIGN_TOP = 0 _ALIGN_RIGHT :: Int _ALIGN_RIGHT = 2 _ALIGN_FILL :: Int _ALIGN_FILL = 3 _VALIGN_FILL :: Int _VALIGN_FILL = 3 _VALIGN_CENTER :: Int _VALIGN_CENTER = 1 _VALIGN_BOTTOM :: Int _VALIGN_BOTTOM = 2 _ALIGN_LEFT :: Int _ALIGN_LEFT = 0 _ALIGN_CENTER :: Int _ALIGN_CENTER = 1 instance NodeProperty Label "align" Int 'False where nodeProperty = (get_align, wrapDroppingSetter set_align, Nothing) instance NodeProperty Label "autowrap" Bool 'False where nodeProperty = (has_autowrap, wrapDroppingSetter set_autowrap, Nothing) instance NodeProperty Label "clip_text" Bool 'False where nodeProperty = (is_clipping_text, wrapDroppingSetter set_clip_text, Nothing) instance NodeProperty Label "lines_skipped" Int 'False where nodeProperty = (get_lines_skipped, wrapDroppingSetter set_lines_skipped, Nothing) instance NodeProperty Label "max_lines_visible" Int 'False where nodeProperty = (get_max_lines_visible, wrapDroppingSetter set_max_lines_visible, Nothing) instance NodeProperty Label "percent_visible" Float 'False where nodeProperty = (get_percent_visible, wrapDroppingSetter set_percent_visible, Nothing) instance NodeProperty Label "text" GodotString 'False where nodeProperty = (get_text, wrapDroppingSetter set_text, Nothing) instance NodeProperty Label "uppercase" Bool 'False where nodeProperty = (is_uppercase, wrapDroppingSetter set_uppercase, Nothing) instance NodeProperty Label "valign" Int 'False where nodeProperty = (get_valign, wrapDroppingSetter set_valign, Nothing) instance NodeProperty Label "visible_characters" Int 'False where nodeProperty = (get_visible_characters, wrapDroppingSetter set_visible_characters, Nothing) {-# NOINLINE bindLabel_get_align #-} -- | Controls the text's horizontal align. Supports left, center, right, and fill, or justify. Set it to one of the @enum Align@ constants. bindLabel_get_align :: MethodBind bindLabel_get_align = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the text's horizontal align. Supports left, center, right, and fill, or justify. Set it to one of the @enum Align@ constants. get_align :: (Label :< cls, Object :< cls) => cls -> IO Int get_align cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_align" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_align {-# NOINLINE bindLabel_get_line_count #-} -- | Returns the amount of lines of text the Label has. bindLabel_get_line_count :: MethodBind bindLabel_get_line_count = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_line_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of lines of text the Label has. get_line_count :: (Label :< cls, Object :< cls) => cls -> IO Int get_line_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_line_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_line_count" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_line_count {-# NOINLINE bindLabel_get_line_height #-} -- | Returns the font size in pixels. bindLabel_get_line_height :: MethodBind bindLabel_get_line_height = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_line_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the font size in pixels. get_line_height :: (Label :< cls, Object :< cls) => cls -> IO Int get_line_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_line_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_line_height" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_line_height {-# NOINLINE bindLabel_get_lines_skipped #-} -- | The node ignores the first @lines_skipped@ lines before it starts to display text. bindLabel_get_lines_skipped :: MethodBind bindLabel_get_lines_skipped = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_lines_skipped" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node ignores the first @lines_skipped@ lines before it starts to display text. get_lines_skipped :: (Label :< cls, Object :< cls) => cls -> IO Int get_lines_skipped cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_lines_skipped (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_lines_skipped" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_lines_skipped {-# NOINLINE bindLabel_get_max_lines_visible #-} -- | Limits the lines of text the node shows on screen. bindLabel_get_max_lines_visible :: MethodBind bindLabel_get_max_lines_visible = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_max_lines_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Limits the lines of text the node shows on screen. get_max_lines_visible :: (Label :< cls, Object :< cls) => cls -> IO Int get_max_lines_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_max_lines_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_max_lines_visible" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_max_lines_visible {-# NOINLINE bindLabel_get_percent_visible #-} -- | Limits the amount of visible characters. If you set @percent_visible@ to 0.5, only up to half of the text's characters will display on screen. Useful to animate the text in a dialog box. bindLabel_get_percent_visible :: MethodBind bindLabel_get_percent_visible = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_percent_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Limits the amount of visible characters. If you set @percent_visible@ to 0.5, only up to half of the text's characters will display on screen. Useful to animate the text in a dialog box. get_percent_visible :: (Label :< cls, Object :< cls) => cls -> IO Float get_percent_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_percent_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_percent_visible" '[] (IO Float) where nodeMethod = Godot.Core.Label.get_percent_visible {-# NOINLINE bindLabel_get_text #-} -- | The text to display on screen. bindLabel_get_text :: MethodBind bindLabel_get_text = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The text to display on screen. get_text :: (Label :< cls, Object :< cls) => cls -> IO GodotString get_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_text" '[] (IO GodotString) where nodeMethod = Godot.Core.Label.get_text {-# NOINLINE bindLabel_get_total_character_count #-} -- | Returns the total number of printable characters in the text (excluding spaces and newlines). bindLabel_get_total_character_count :: MethodBind bindLabel_get_total_character_count = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_total_character_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total number of printable characters in the text (excluding spaces and newlines). get_total_character_count :: (Label :< cls, Object :< cls) => cls -> IO Int get_total_character_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_total_character_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_total_character_count" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_total_character_count {-# NOINLINE bindLabel_get_valign #-} -- | Controls the text's vertical align. Supports top, center, bottom, and fill. Set it to one of the @enum VAlign@ constants. bindLabel_get_valign :: MethodBind bindLabel_get_valign = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_valign" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the text's vertical align. Supports top, center, bottom, and fill. Set it to one of the @enum VAlign@ constants. get_valign :: (Label :< cls, Object :< cls) => cls -> IO Int get_valign cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_valign (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_valign" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_valign {-# NOINLINE bindLabel_get_visible_characters #-} -- | Restricts the number of characters to display. Set to -1 to disable. bindLabel_get_visible_characters :: MethodBind bindLabel_get_visible_characters = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_visible_characters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Restricts the number of characters to display. Set to -1 to disable. get_visible_characters :: (Label :< cls, Object :< cls) => cls -> IO Int get_visible_characters cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_visible_characters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_visible_characters" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_visible_characters {-# NOINLINE bindLabel_get_visible_line_count #-} -- | Returns the number of lines shown. Useful if the @Label@'s height cannot currently display all lines. bindLabel_get_visible_line_count :: MethodBind bindLabel_get_visible_line_count = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "get_visible_line_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of lines shown. Useful if the @Label@'s height cannot currently display all lines. get_visible_line_count :: (Label :< cls, Object :< cls) => cls -> IO Int get_visible_line_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_get_visible_line_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "get_visible_line_count" '[] (IO Int) where nodeMethod = Godot.Core.Label.get_visible_line_count {-# NOINLINE bindLabel_has_autowrap #-} -- | If @true@, wraps the text inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text. bindLabel_has_autowrap :: MethodBind bindLabel_has_autowrap = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "has_autowrap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, wraps the text inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text. has_autowrap :: (Label :< cls, Object :< cls) => cls -> IO Bool has_autowrap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_has_autowrap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "has_autowrap" '[] (IO Bool) where nodeMethod = Godot.Core.Label.has_autowrap {-# NOINLINE bindLabel_is_clipping_text #-} -- | If @true@, the Label only shows the text that fits inside its bounding rectangle. It also lets you scale the node down freely. bindLabel_is_clipping_text :: MethodBind bindLabel_is_clipping_text = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "is_clipping_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the Label only shows the text that fits inside its bounding rectangle. It also lets you scale the node down freely. is_clipping_text :: (Label :< cls, Object :< cls) => cls -> IO Bool is_clipping_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_is_clipping_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "is_clipping_text" '[] (IO Bool) where nodeMethod = Godot.Core.Label.is_clipping_text {-# NOINLINE bindLabel_is_uppercase #-} -- | If @true@, all the text displays as UPPERCASE. bindLabel_is_uppercase :: MethodBind bindLabel_is_uppercase = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "is_uppercase" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, all the text displays as UPPERCASE. is_uppercase :: (Label :< cls, Object :< cls) => cls -> IO Bool is_uppercase cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_is_uppercase (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "is_uppercase" '[] (IO Bool) where nodeMethod = Godot.Core.Label.is_uppercase {-# NOINLINE bindLabel_set_align #-} -- | Controls the text's horizontal align. Supports left, center, right, and fill, or justify. Set it to one of the @enum Align@ constants. bindLabel_set_align :: MethodBind bindLabel_set_align = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the text's horizontal align. Supports left, center, right, and fill, or justify. Set it to one of the @enum Align@ constants. set_align :: (Label :< cls, Object :< cls) => cls -> Int -> IO () set_align cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_align" '[Int] (IO ()) where nodeMethod = Godot.Core.Label.set_align {-# NOINLINE bindLabel_set_autowrap #-} -- | If @true@, wraps the text inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text. bindLabel_set_autowrap :: MethodBind bindLabel_set_autowrap = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_autowrap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, wraps the text inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text. set_autowrap :: (Label :< cls, Object :< cls) => cls -> Bool -> IO () set_autowrap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_autowrap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_autowrap" '[Bool] (IO ()) where nodeMethod = Godot.Core.Label.set_autowrap {-# NOINLINE bindLabel_set_clip_text #-} -- | If @true@, the Label only shows the text that fits inside its bounding rectangle. It also lets you scale the node down freely. bindLabel_set_clip_text :: MethodBind bindLabel_set_clip_text = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_clip_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the Label only shows the text that fits inside its bounding rectangle. It also lets you scale the node down freely. set_clip_text :: (Label :< cls, Object :< cls) => cls -> Bool -> IO () set_clip_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_clip_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_clip_text" '[Bool] (IO ()) where nodeMethod = Godot.Core.Label.set_clip_text {-# NOINLINE bindLabel_set_lines_skipped #-} -- | The node ignores the first @lines_skipped@ lines before it starts to display text. bindLabel_set_lines_skipped :: MethodBind bindLabel_set_lines_skipped = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_lines_skipped" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node ignores the first @lines_skipped@ lines before it starts to display text. set_lines_skipped :: (Label :< cls, Object :< cls) => cls -> Int -> IO () set_lines_skipped cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_lines_skipped (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_lines_skipped" '[Int] (IO ()) where nodeMethod = Godot.Core.Label.set_lines_skipped {-# NOINLINE bindLabel_set_max_lines_visible #-} -- | Limits the lines of text the node shows on screen. bindLabel_set_max_lines_visible :: MethodBind bindLabel_set_max_lines_visible = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_max_lines_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Limits the lines of text the node shows on screen. set_max_lines_visible :: (Label :< cls, Object :< cls) => cls -> Int -> IO () set_max_lines_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_max_lines_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_max_lines_visible" '[Int] (IO ()) where nodeMethod = Godot.Core.Label.set_max_lines_visible {-# NOINLINE bindLabel_set_percent_visible #-} -- | Limits the amount of visible characters. If you set @percent_visible@ to 0.5, only up to half of the text's characters will display on screen. Useful to animate the text in a dialog box. bindLabel_set_percent_visible :: MethodBind bindLabel_set_percent_visible = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_percent_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Limits the amount of visible characters. If you set @percent_visible@ to 0.5, only up to half of the text's characters will display on screen. Useful to animate the text in a dialog box. set_percent_visible :: (Label :< cls, Object :< cls) => cls -> Float -> IO () set_percent_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_percent_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_percent_visible" '[Float] (IO ()) where nodeMethod = Godot.Core.Label.set_percent_visible {-# NOINLINE bindLabel_set_text #-} -- | The text to display on screen. bindLabel_set_text :: MethodBind bindLabel_set_text = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The text to display on screen. set_text :: (Label :< cls, Object :< cls) => cls -> GodotString -> IO () set_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Label.set_text {-# NOINLINE bindLabel_set_uppercase #-} -- | If @true@, all the text displays as UPPERCASE. bindLabel_set_uppercase :: MethodBind bindLabel_set_uppercase = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_uppercase" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, all the text displays as UPPERCASE. set_uppercase :: (Label :< cls, Object :< cls) => cls -> Bool -> IO () set_uppercase cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_uppercase (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_uppercase" '[Bool] (IO ()) where nodeMethod = Godot.Core.Label.set_uppercase {-# NOINLINE bindLabel_set_valign #-} -- | Controls the text's vertical align. Supports top, center, bottom, and fill. Set it to one of the @enum VAlign@ constants. bindLabel_set_valign :: MethodBind bindLabel_set_valign = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_valign" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the text's vertical align. Supports top, center, bottom, and fill. Set it to one of the @enum VAlign@ constants. set_valign :: (Label :< cls, Object :< cls) => cls -> Int -> IO () set_valign cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_valign (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_valign" '[Int] (IO ()) where nodeMethod = Godot.Core.Label.set_valign {-# NOINLINE bindLabel_set_visible_characters #-} -- | Restricts the number of characters to display. Set to -1 to disable. bindLabel_set_visible_characters :: MethodBind bindLabel_set_visible_characters = unsafePerformIO $ withCString "Label" $ \ clsNamePtr -> withCString "set_visible_characters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Restricts the number of characters to display. Set to -1 to disable. set_visible_characters :: (Label :< cls, Object :< cls) => cls -> Int -> IO () set_visible_characters cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLabel_set_visible_characters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Label "set_visible_characters" '[Int] (IO ()) where nodeMethod = Godot.Core.Label.set_visible_characters ================================================ FILE: src/Godot/Core/LargeTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.LargeTexture (Godot.Core.LargeTexture._get_data, Godot.Core.LargeTexture._set_data, Godot.Core.LargeTexture.add_piece, Godot.Core.LargeTexture.clear, Godot.Core.LargeTexture.get_piece_count, Godot.Core.LargeTexture.get_piece_offset, Godot.Core.LargeTexture.get_piece_texture, Godot.Core.LargeTexture.set_piece_offset, Godot.Core.LargeTexture.set_piece_texture, Godot.Core.LargeTexture.set_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty LargeTexture "_data" Array 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) {-# NOINLINE bindLargeTexture__get_data #-} bindLargeTexture__get_data :: MethodBind bindLargeTexture__get_data = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_data :: (LargeTexture :< cls, Object :< cls) => cls -> IO Array _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "_get_data" '[] (IO Array) where nodeMethod = Godot.Core.LargeTexture._get_data {-# NOINLINE bindLargeTexture__set_data #-} bindLargeTexture__set_data :: MethodBind bindLargeTexture__set_data = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_data :: (LargeTexture :< cls, Object :< cls) => cls -> Array -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "_set_data" '[Array] (IO ()) where nodeMethod = Godot.Core.LargeTexture._set_data {-# NOINLINE bindLargeTexture_add_piece #-} -- | Adds @texture@ to this @LargeTexture@, starting on offset @ofs@. bindLargeTexture_add_piece :: MethodBind bindLargeTexture_add_piece = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "add_piece" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds @texture@ to this @LargeTexture@, starting on offset @ofs@. add_piece :: (LargeTexture :< cls, Object :< cls) => cls -> Vector2 -> Texture -> IO Int add_piece cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture_add_piece (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "add_piece" '[Vector2, Texture] (IO Int) where nodeMethod = Godot.Core.LargeTexture.add_piece {-# NOINLINE bindLargeTexture_clear #-} -- | Clears the @LargeTexture@. bindLargeTexture_clear :: MethodBind bindLargeTexture_clear = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the @LargeTexture@. clear :: (LargeTexture :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "clear" '[] (IO ()) where nodeMethod = Godot.Core.LargeTexture.clear {-# NOINLINE bindLargeTexture_get_piece_count #-} -- | Returns the number of pieces currently in this @LargeTexture@. bindLargeTexture_get_piece_count :: MethodBind bindLargeTexture_get_piece_count = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "get_piece_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of pieces currently in this @LargeTexture@. get_piece_count :: (LargeTexture :< cls, Object :< cls) => cls -> IO Int get_piece_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture_get_piece_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "get_piece_count" '[] (IO Int) where nodeMethod = Godot.Core.LargeTexture.get_piece_count {-# NOINLINE bindLargeTexture_get_piece_offset #-} -- | Returns the offset of the piece with the index @idx@. bindLargeTexture_get_piece_offset :: MethodBind bindLargeTexture_get_piece_offset = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "get_piece_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the offset of the piece with the index @idx@. get_piece_offset :: (LargeTexture :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_piece_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture_get_piece_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "get_piece_offset" '[Int] (IO Vector2) where nodeMethod = Godot.Core.LargeTexture.get_piece_offset {-# NOINLINE bindLargeTexture_get_piece_texture #-} -- | Returns the @Texture@ of the piece with the index @idx@. bindLargeTexture_get_piece_texture :: MethodBind bindLargeTexture_get_piece_texture = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "get_piece_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Texture@ of the piece with the index @idx@. get_piece_texture :: (LargeTexture :< cls, Object :< cls) => cls -> Int -> IO Texture get_piece_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture_get_piece_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "get_piece_texture" '[Int] (IO Texture) where nodeMethod = Godot.Core.LargeTexture.get_piece_texture {-# NOINLINE bindLargeTexture_set_piece_offset #-} -- | Sets the offset of the piece with the index @idx@ to @ofs@. bindLargeTexture_set_piece_offset :: MethodBind bindLargeTexture_set_piece_offset = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "set_piece_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the offset of the piece with the index @idx@ to @ofs@. set_piece_offset :: (LargeTexture :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_piece_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture_set_piece_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "set_piece_offset" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.LargeTexture.set_piece_offset {-# NOINLINE bindLargeTexture_set_piece_texture #-} -- | Sets the @Texture@ of the piece with index @idx@ to @texture@. bindLargeTexture_set_piece_texture :: MethodBind bindLargeTexture_set_piece_texture = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "set_piece_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Texture@ of the piece with index @idx@ to @texture@. set_piece_texture :: (LargeTexture :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_piece_texture cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture_set_piece_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "set_piece_texture" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.LargeTexture.set_piece_texture {-# NOINLINE bindLargeTexture_set_size #-} -- | Sets the size of this @LargeTexture@. bindLargeTexture_set_size :: MethodBind bindLargeTexture_set_size = unsafePerformIO $ withCString "LargeTexture" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of this @LargeTexture@. set_size :: (LargeTexture :< cls, Object :< cls) => cls -> Vector2 -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLargeTexture_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LargeTexture "set_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.LargeTexture.set_size ================================================ FILE: src/Godot/Core/Light.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Light (Godot.Core.Light._PARAM_SHADOW_NORMAL_BIAS, Godot.Core.Light._PARAM_SHADOW_SPLIT_2_OFFSET, Godot.Core.Light._PARAM_SPECULAR, Godot.Core.Light._PARAM_SHADOW_SPLIT_1_OFFSET, Godot.Core.Light._PARAM_INDIRECT_ENERGY, Godot.Core.Light._PARAM_RANGE, Godot.Core.Light._PARAM_SPOT_ATTENUATION, Godot.Core.Light._PARAM_SHADOW_MAX_DISTANCE, Godot.Core.Light._PARAM_MAX, Godot.Core.Light._PARAM_SHADOW_BIAS_SPLIT_SCALE, Godot.Core.Light._BAKE_DISABLED, Godot.Core.Light._PARAM_ATTENUATION, Godot.Core.Light._PARAM_ENERGY, Godot.Core.Light._PARAM_SHADOW_SPLIT_3_OFFSET, Godot.Core.Light._BAKE_INDIRECT, Godot.Core.Light._PARAM_SHADOW_BIAS, Godot.Core.Light._BAKE_ALL, Godot.Core.Light._PARAM_CONTACT_SHADOW_SIZE, Godot.Core.Light._PARAM_SPOT_ANGLE, Godot.Core.Light.get_bake_mode, Godot.Core.Light.get_color, Godot.Core.Light.get_cull_mask, Godot.Core.Light.get_param, Godot.Core.Light.get_shadow_color, Godot.Core.Light.get_shadow_reverse_cull_face, Godot.Core.Light.has_shadow, Godot.Core.Light.is_editor_only, Godot.Core.Light.is_negative, Godot.Core.Light.set_bake_mode, Godot.Core.Light.set_color, Godot.Core.Light.set_cull_mask, Godot.Core.Light.set_editor_only, Godot.Core.Light.set_negative, Godot.Core.Light.set_param, Godot.Core.Light.set_shadow, Godot.Core.Light.set_shadow_color, Godot.Core.Light.set_shadow_reverse_cull_face) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualInstance() _PARAM_SHADOW_NORMAL_BIAS :: Int _PARAM_SHADOW_NORMAL_BIAS = 12 _PARAM_SHADOW_SPLIT_2_OFFSET :: Int _PARAM_SHADOW_SPLIT_2_OFFSET = 10 _PARAM_SPECULAR :: Int _PARAM_SPECULAR = 2 _PARAM_SHADOW_SPLIT_1_OFFSET :: Int _PARAM_SHADOW_SPLIT_1_OFFSET = 9 _PARAM_INDIRECT_ENERGY :: Int _PARAM_INDIRECT_ENERGY = 1 _PARAM_RANGE :: Int _PARAM_RANGE = 3 _PARAM_SPOT_ATTENUATION :: Int _PARAM_SPOT_ATTENUATION = 6 _PARAM_SHADOW_MAX_DISTANCE :: Int _PARAM_SHADOW_MAX_DISTANCE = 8 _PARAM_MAX :: Int _PARAM_MAX = 15 _PARAM_SHADOW_BIAS_SPLIT_SCALE :: Int _PARAM_SHADOW_BIAS_SPLIT_SCALE = 14 _BAKE_DISABLED :: Int _BAKE_DISABLED = 0 _PARAM_ATTENUATION :: Int _PARAM_ATTENUATION = 4 _PARAM_ENERGY :: Int _PARAM_ENERGY = 0 _PARAM_SHADOW_SPLIT_3_OFFSET :: Int _PARAM_SHADOW_SPLIT_3_OFFSET = 11 _BAKE_INDIRECT :: Int _BAKE_INDIRECT = 1 _PARAM_SHADOW_BIAS :: Int _PARAM_SHADOW_BIAS = 13 _BAKE_ALL :: Int _BAKE_ALL = 2 _PARAM_CONTACT_SHADOW_SIZE :: Int _PARAM_CONTACT_SHADOW_SIZE = 7 _PARAM_SPOT_ANGLE :: Int _PARAM_SPOT_ANGLE = 5 instance NodeProperty Light "editor_only" Bool 'False where nodeProperty = (is_editor_only, wrapDroppingSetter set_editor_only, Nothing) instance NodeProperty Light "light_bake_mode" Int 'False where nodeProperty = (get_bake_mode, wrapDroppingSetter set_bake_mode, Nothing) instance NodeProperty Light "light_color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) instance NodeProperty Light "light_cull_mask" Int 'False where nodeProperty = (get_cull_mask, wrapDroppingSetter set_cull_mask, Nothing) instance NodeProperty Light "light_energy" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param, wrapIndexedSetter 0 set_param, Nothing) instance NodeProperty Light "light_indirect_energy" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param, wrapIndexedSetter 1 set_param, Nothing) instance NodeProperty Light "light_negative" Bool 'False where nodeProperty = (is_negative, wrapDroppingSetter set_negative, Nothing) instance NodeProperty Light "light_specular" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param, wrapIndexedSetter 2 set_param, Nothing) instance NodeProperty Light "shadow_bias" Float 'False where nodeProperty = (wrapIndexedGetter 13 get_param, wrapIndexedSetter 13 set_param, Nothing) instance NodeProperty Light "shadow_color" Color 'False where nodeProperty = (get_shadow_color, wrapDroppingSetter set_shadow_color, Nothing) instance NodeProperty Light "shadow_contact" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param, wrapIndexedSetter 7 set_param, Nothing) instance NodeProperty Light "shadow_enabled" Bool 'False where nodeProperty = (has_shadow, wrapDroppingSetter set_shadow, Nothing) instance NodeProperty Light "shadow_reverse_cull_face" Bool 'False where nodeProperty = (get_shadow_reverse_cull_face, wrapDroppingSetter set_shadow_reverse_cull_face, Nothing) {-# NOINLINE bindLight_get_bake_mode #-} -- | The light's bake mode. See @enum BakeMode@. bindLight_get_bake_mode :: MethodBind bindLight_get_bake_mode = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "get_bake_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light's bake mode. See @enum BakeMode@. get_bake_mode :: (Light :< cls, Object :< cls) => cls -> IO Int get_bake_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight_get_bake_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "get_bake_mode" '[] (IO Int) where nodeMethod = Godot.Core.Light.get_bake_mode {-# NOINLINE bindLight_get_color #-} -- | The light's color. An @i@overbright@/i@ color can be used to achieve a result equivalent to increasing the light's @light_energy@. bindLight_get_color :: MethodBind bindLight_get_color = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light's color. An @i@overbright@/i@ color can be used to achieve a result equivalent to increasing the light's @light_energy@. get_color :: (Light :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "get_color" '[] (IO Color) where nodeMethod = Godot.Core.Light.get_color {-# NOINLINE bindLight_get_cull_mask #-} -- | The light will affect objects in the selected layers. bindLight_get_cull_mask :: MethodBind bindLight_get_cull_mask = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "get_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light will affect objects in the selected layers. get_cull_mask :: (Light :< cls, Object :< cls) => cls -> IO Int get_cull_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight_get_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "get_cull_mask" '[] (IO Int) where nodeMethod = Godot.Core.Light.get_cull_mask {-# NOINLINE bindLight_get_param #-} -- | Returns the value of the specified @enum Light.Param@ parameter. bindLight_get_param :: MethodBind bindLight_get_param = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the specified @enum Light.Param@ parameter. get_param :: (Light :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.Light.get_param {-# NOINLINE bindLight_get_shadow_color #-} -- | The color of shadows cast by this light. bindLight_get_shadow_color :: MethodBind bindLight_get_shadow_color = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "get_shadow_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color of shadows cast by this light. get_shadow_color :: (Light :< cls, Object :< cls) => cls -> IO Color get_shadow_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight_get_shadow_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "get_shadow_color" '[] (IO Color) where nodeMethod = Godot.Core.Light.get_shadow_color {-# NOINLINE bindLight_get_shadow_reverse_cull_face #-} -- | If @true@, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double-sided shadows with @GeometryInstance.SHADOW_CASTING_SETTING_DOUBLE_SIDED@. bindLight_get_shadow_reverse_cull_face :: MethodBind bindLight_get_shadow_reverse_cull_face = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "get_shadow_reverse_cull_face" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double-sided shadows with @GeometryInstance.SHADOW_CASTING_SETTING_DOUBLE_SIDED@. get_shadow_reverse_cull_face :: (Light :< cls, Object :< cls) => cls -> IO Bool get_shadow_reverse_cull_face cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight_get_shadow_reverse_cull_face (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "get_shadow_reverse_cull_face" '[] (IO Bool) where nodeMethod = Godot.Core.Light.get_shadow_reverse_cull_face {-# NOINLINE bindLight_has_shadow #-} -- | If @true@, the light will cast shadows. bindLight_has_shadow :: MethodBind bindLight_has_shadow = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "has_shadow" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the light will cast shadows. has_shadow :: (Light :< cls, Object :< cls) => cls -> IO Bool has_shadow cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight_has_shadow (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "has_shadow" '[] (IO Bool) where nodeMethod = Godot.Core.Light.has_shadow {-# NOINLINE bindLight_is_editor_only #-} -- | If @true@, the light only appears in the editor and will not be visible at runtime. bindLight_is_editor_only :: MethodBind bindLight_is_editor_only = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "is_editor_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the light only appears in the editor and will not be visible at runtime. is_editor_only :: (Light :< cls, Object :< cls) => cls -> IO Bool is_editor_only cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight_is_editor_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "is_editor_only" '[] (IO Bool) where nodeMethod = Godot.Core.Light.is_editor_only {-# NOINLINE bindLight_is_negative #-} -- | If @true@, the light's effect is reversed, darkening areas and casting bright shadows. bindLight_is_negative :: MethodBind bindLight_is_negative = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "is_negative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the light's effect is reversed, darkening areas and casting bright shadows. is_negative :: (Light :< cls, Object :< cls) => cls -> IO Bool is_negative cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight_is_negative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "is_negative" '[] (IO Bool) where nodeMethod = Godot.Core.Light.is_negative {-# NOINLINE bindLight_set_bake_mode #-} -- | The light's bake mode. See @enum BakeMode@. bindLight_set_bake_mode :: MethodBind bindLight_set_bake_mode = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_bake_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light's bake mode. See @enum BakeMode@. set_bake_mode :: (Light :< cls, Object :< cls) => cls -> Int -> IO () set_bake_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_bake_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_bake_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Light.set_bake_mode {-# NOINLINE bindLight_set_color #-} -- | The light's color. An @i@overbright@/i@ color can be used to achieve a result equivalent to increasing the light's @light_energy@. bindLight_set_color :: MethodBind bindLight_set_color = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light's color. An @i@overbright@/i@ color can be used to achieve a result equivalent to increasing the light's @light_energy@. set_color :: (Light :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Light.set_color {-# NOINLINE bindLight_set_cull_mask #-} -- | The light will affect objects in the selected layers. bindLight_set_cull_mask :: MethodBind bindLight_set_cull_mask = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light will affect objects in the selected layers. set_cull_mask :: (Light :< cls, Object :< cls) => cls -> Int -> IO () set_cull_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_cull_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.Light.set_cull_mask {-# NOINLINE bindLight_set_editor_only #-} -- | If @true@, the light only appears in the editor and will not be visible at runtime. bindLight_set_editor_only :: MethodBind bindLight_set_editor_only = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_editor_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the light only appears in the editor and will not be visible at runtime. set_editor_only :: (Light :< cls, Object :< cls) => cls -> Bool -> IO () set_editor_only cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_editor_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_editor_only" '[Bool] (IO ()) where nodeMethod = Godot.Core.Light.set_editor_only {-# NOINLINE bindLight_set_negative #-} -- | If @true@, the light's effect is reversed, darkening areas and casting bright shadows. bindLight_set_negative :: MethodBind bindLight_set_negative = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_negative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the light's effect is reversed, darkening areas and casting bright shadows. set_negative :: (Light :< cls, Object :< cls) => cls -> Bool -> IO () set_negative cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_negative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_negative" '[Bool] (IO ()) where nodeMethod = Godot.Core.Light.set_negative {-# NOINLINE bindLight_set_param #-} -- | Sets the value of the specified @enum Light.Param@ parameter. bindLight_set_param :: MethodBind bindLight_set_param = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value of the specified @enum Light.Param@ parameter. set_param :: (Light :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.Light.set_param {-# NOINLINE bindLight_set_shadow #-} -- | If @true@, the light will cast shadows. bindLight_set_shadow :: MethodBind bindLight_set_shadow = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_shadow" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the light will cast shadows. set_shadow :: (Light :< cls, Object :< cls) => cls -> Bool -> IO () set_shadow cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_shadow (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_shadow" '[Bool] (IO ()) where nodeMethod = Godot.Core.Light.set_shadow {-# NOINLINE bindLight_set_shadow_color #-} -- | The color of shadows cast by this light. bindLight_set_shadow_color :: MethodBind bindLight_set_shadow_color = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_shadow_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color of shadows cast by this light. set_shadow_color :: (Light :< cls, Object :< cls) => cls -> Color -> IO () set_shadow_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_shadow_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_shadow_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Light.set_shadow_color {-# NOINLINE bindLight_set_shadow_reverse_cull_face #-} -- | If @true@, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double-sided shadows with @GeometryInstance.SHADOW_CASTING_SETTING_DOUBLE_SIDED@. bindLight_set_shadow_reverse_cull_face :: MethodBind bindLight_set_shadow_reverse_cull_face = unsafePerformIO $ withCString "Light" $ \ clsNamePtr -> withCString "set_shadow_reverse_cull_face" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double-sided shadows with @GeometryInstance.SHADOW_CASTING_SETTING_DOUBLE_SIDED@. set_shadow_reverse_cull_face :: (Light :< cls, Object :< cls) => cls -> Bool -> IO () set_shadow_reverse_cull_face cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight_set_shadow_reverse_cull_face (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light "set_shadow_reverse_cull_face" '[Bool] (IO ()) where nodeMethod = Godot.Core.Light.set_shadow_reverse_cull_face ================================================ FILE: src/Godot/Core/Light2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Light2D (Godot.Core.Light2D._SHADOW_FILTER_PCF7, Godot.Core.Light2D._MODE_ADD, Godot.Core.Light2D._MODE_SUB, Godot.Core.Light2D._SHADOW_FILTER_PCF5, Godot.Core.Light2D._SHADOW_FILTER_NONE, Godot.Core.Light2D._SHADOW_FILTER_PCF9, Godot.Core.Light2D._MODE_MASK, Godot.Core.Light2D._MODE_MIX, Godot.Core.Light2D._SHADOW_FILTER_PCF3, Godot.Core.Light2D._SHADOW_FILTER_PCF13, Godot.Core.Light2D.get_color, Godot.Core.Light2D.get_energy, Godot.Core.Light2D.get_height, Godot.Core.Light2D.get_item_cull_mask, Godot.Core.Light2D.get_item_shadow_cull_mask, Godot.Core.Light2D.get_layer_range_max, Godot.Core.Light2D.get_layer_range_min, Godot.Core.Light2D.get_mode, Godot.Core.Light2D.get_shadow_buffer_size, Godot.Core.Light2D.get_shadow_color, Godot.Core.Light2D.get_shadow_filter, Godot.Core.Light2D.get_shadow_gradient_length, Godot.Core.Light2D.get_shadow_smooth, Godot.Core.Light2D.get_texture, Godot.Core.Light2D.get_texture_offset, Godot.Core.Light2D.get_texture_scale, Godot.Core.Light2D.get_z_range_max, Godot.Core.Light2D.get_z_range_min, Godot.Core.Light2D.is_editor_only, Godot.Core.Light2D.is_enabled, Godot.Core.Light2D.is_shadow_enabled, Godot.Core.Light2D.set_color, Godot.Core.Light2D.set_editor_only, Godot.Core.Light2D.set_enabled, Godot.Core.Light2D.set_energy, Godot.Core.Light2D.set_height, Godot.Core.Light2D.set_item_cull_mask, Godot.Core.Light2D.set_item_shadow_cull_mask, Godot.Core.Light2D.set_layer_range_max, Godot.Core.Light2D.set_layer_range_min, Godot.Core.Light2D.set_mode, Godot.Core.Light2D.set_shadow_buffer_size, Godot.Core.Light2D.set_shadow_color, Godot.Core.Light2D.set_shadow_enabled, Godot.Core.Light2D.set_shadow_filter, Godot.Core.Light2D.set_shadow_gradient_length, Godot.Core.Light2D.set_shadow_smooth, Godot.Core.Light2D.set_texture, Godot.Core.Light2D.set_texture_offset, Godot.Core.Light2D.set_texture_scale, Godot.Core.Light2D.set_z_range_max, Godot.Core.Light2D.set_z_range_min) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _SHADOW_FILTER_PCF7 :: Int _SHADOW_FILTER_PCF7 = 3 _MODE_ADD :: Int _MODE_ADD = 0 _MODE_SUB :: Int _MODE_SUB = 1 _SHADOW_FILTER_PCF5 :: Int _SHADOW_FILTER_PCF5 = 2 _SHADOW_FILTER_NONE :: Int _SHADOW_FILTER_NONE = 0 _SHADOW_FILTER_PCF9 :: Int _SHADOW_FILTER_PCF9 = 4 _MODE_MASK :: Int _MODE_MASK = 3 _MODE_MIX :: Int _MODE_MIX = 2 _SHADOW_FILTER_PCF3 :: Int _SHADOW_FILTER_PCF3 = 1 _SHADOW_FILTER_PCF13 :: Int _SHADOW_FILTER_PCF13 = 5 instance NodeProperty Light2D "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) instance NodeProperty Light2D "editor_only" Bool 'False where nodeProperty = (is_editor_only, wrapDroppingSetter set_editor_only, Nothing) instance NodeProperty Light2D "enabled" Bool 'False where nodeProperty = (is_enabled, wrapDroppingSetter set_enabled, Nothing) instance NodeProperty Light2D "energy" Float 'False where nodeProperty = (get_energy, wrapDroppingSetter set_energy, Nothing) instance NodeProperty Light2D "mode" Int 'False where nodeProperty = (get_mode, wrapDroppingSetter set_mode, Nothing) instance NodeProperty Light2D "offset" Vector2 'False where nodeProperty = (get_texture_offset, wrapDroppingSetter set_texture_offset, Nothing) instance NodeProperty Light2D "range_height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty Light2D "range_item_cull_mask" Int 'False where nodeProperty = (get_item_cull_mask, wrapDroppingSetter set_item_cull_mask, Nothing) instance NodeProperty Light2D "range_layer_max" Int 'False where nodeProperty = (get_layer_range_max, wrapDroppingSetter set_layer_range_max, Nothing) instance NodeProperty Light2D "range_layer_min" Int 'False where nodeProperty = (get_layer_range_min, wrapDroppingSetter set_layer_range_min, Nothing) instance NodeProperty Light2D "range_z_max" Int 'False where nodeProperty = (get_z_range_max, wrapDroppingSetter set_z_range_max, Nothing) instance NodeProperty Light2D "range_z_min" Int 'False where nodeProperty = (get_z_range_min, wrapDroppingSetter set_z_range_min, Nothing) instance NodeProperty Light2D "shadow_buffer_size" Int 'False where nodeProperty = (get_shadow_buffer_size, wrapDroppingSetter set_shadow_buffer_size, Nothing) instance NodeProperty Light2D "shadow_color" Color 'False where nodeProperty = (get_shadow_color, wrapDroppingSetter set_shadow_color, Nothing) instance NodeProperty Light2D "shadow_enabled" Bool 'False where nodeProperty = (is_shadow_enabled, wrapDroppingSetter set_shadow_enabled, Nothing) instance NodeProperty Light2D "shadow_filter" Int 'False where nodeProperty = (get_shadow_filter, wrapDroppingSetter set_shadow_filter, Nothing) instance NodeProperty Light2D "shadow_filter_smooth" Float 'False where nodeProperty = (get_shadow_smooth, wrapDroppingSetter set_shadow_smooth, Nothing) instance NodeProperty Light2D "shadow_gradient_length" Float 'False where nodeProperty = (get_shadow_gradient_length, wrapDroppingSetter set_shadow_gradient_length, Nothing) instance NodeProperty Light2D "shadow_item_cull_mask" Int 'False where nodeProperty = (get_item_shadow_cull_mask, wrapDroppingSetter set_item_shadow_cull_mask, Nothing) instance NodeProperty Light2D "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) instance NodeProperty Light2D "texture_scale" Float 'False where nodeProperty = (get_texture_scale, wrapDroppingSetter set_texture_scale, Nothing) {-# NOINLINE bindLight2D_get_color #-} -- | The Light2D's @Color@. bindLight2D_get_color :: MethodBind bindLight2D_get_color = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Light2D's @Color@. get_color :: (Light2D :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_color" '[] (IO Color) where nodeMethod = Godot.Core.Light2D.get_color {-# NOINLINE bindLight2D_get_energy #-} -- | The Light2D's energy value. The larger the value, the stronger the light. bindLight2D_get_energy :: MethodBind bindLight2D_get_energy = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Light2D's energy value. The larger the value, the stronger the light. get_energy :: (Light2D :< cls, Object :< cls) => cls -> IO Float get_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_energy" '[] (IO Float) where nodeMethod = Godot.Core.Light2D.get_energy {-# NOINLINE bindLight2D_get_height #-} -- | The height of the Light2D. Used with 2D normal mapping. bindLight2D_get_height :: MethodBind bindLight2D_get_height = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The height of the Light2D. Used with 2D normal mapping. get_height :: (Light2D :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_height" '[] (IO Float) where nodeMethod = Godot.Core.Light2D.get_height {-# NOINLINE bindLight2D_get_item_cull_mask #-} -- | The layer mask. Only objects with a matching mask will be affected by the Light2D. bindLight2D_get_item_cull_mask :: MethodBind bindLight2D_get_item_cull_mask = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_item_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer mask. Only objects with a matching mask will be affected by the Light2D. get_item_cull_mask :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_item_cull_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_item_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_item_cull_mask" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_item_cull_mask {-# NOINLINE bindLight2D_get_item_shadow_cull_mask #-} -- | The shadow mask. Used with @LightOccluder2D@ to cast shadows. Only occluders with a matching light mask will cast shadows. bindLight2D_get_item_shadow_cull_mask :: MethodBind bindLight2D_get_item_shadow_cull_mask = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_item_shadow_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shadow mask. Used with @LightOccluder2D@ to cast shadows. Only occluders with a matching light mask will cast shadows. get_item_shadow_cull_mask :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_item_shadow_cull_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_item_shadow_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_item_shadow_cull_mask" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_item_shadow_cull_mask {-# NOINLINE bindLight2D_get_layer_range_max #-} -- | Maximum layer value of objects that are affected by the Light2D. bindLight2D_get_layer_range_max :: MethodBind bindLight2D_get_layer_range_max = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_layer_range_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum layer value of objects that are affected by the Light2D. get_layer_range_max :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_layer_range_max cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_layer_range_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_layer_range_max" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_layer_range_max {-# NOINLINE bindLight2D_get_layer_range_min #-} -- | Minimum layer value of objects that are affected by the Light2D. bindLight2D_get_layer_range_min :: MethodBind bindLight2D_get_layer_range_min = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_layer_range_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Minimum layer value of objects that are affected by the Light2D. get_layer_range_min :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_layer_range_min cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_layer_range_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_layer_range_min" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_layer_range_min {-# NOINLINE bindLight2D_get_mode #-} -- | The Light2D's mode. See @enum Mode@ constants for values. bindLight2D_get_mode :: MethodBind bindLight2D_get_mode = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Light2D's mode. See @enum Mode@ constants for values. get_mode :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_mode" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_mode {-# NOINLINE bindLight2D_get_shadow_buffer_size #-} -- | Shadow buffer size. bindLight2D_get_shadow_buffer_size :: MethodBind bindLight2D_get_shadow_buffer_size = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_shadow_buffer_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shadow buffer size. get_shadow_buffer_size :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_shadow_buffer_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_shadow_buffer_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_shadow_buffer_size" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_shadow_buffer_size {-# NOINLINE bindLight2D_get_shadow_color #-} -- | @Color@ of shadows cast by the Light2D. bindLight2D_get_shadow_color :: MethodBind bindLight2D_get_shadow_color = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_shadow_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Color@ of shadows cast by the Light2D. get_shadow_color :: (Light2D :< cls, Object :< cls) => cls -> IO Color get_shadow_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_shadow_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_shadow_color" '[] (IO Color) where nodeMethod = Godot.Core.Light2D.get_shadow_color {-# NOINLINE bindLight2D_get_shadow_filter #-} -- | Shadow filter type. See @enum ShadowFilter@ for possible values. bindLight2D_get_shadow_filter :: MethodBind bindLight2D_get_shadow_filter = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_shadow_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shadow filter type. See @enum ShadowFilter@ for possible values. get_shadow_filter :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_shadow_filter cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_shadow_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_shadow_filter" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_shadow_filter {-# NOINLINE bindLight2D_get_shadow_gradient_length #-} -- | Smooth shadow gradient length. bindLight2D_get_shadow_gradient_length :: MethodBind bindLight2D_get_shadow_gradient_length = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_shadow_gradient_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Smooth shadow gradient length. get_shadow_gradient_length :: (Light2D :< cls, Object :< cls) => cls -> IO Float get_shadow_gradient_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_shadow_gradient_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_shadow_gradient_length" '[] (IO Float) where nodeMethod = Godot.Core.Light2D.get_shadow_gradient_length {-# NOINLINE bindLight2D_get_shadow_smooth #-} -- | Smoothing value for shadows. bindLight2D_get_shadow_smooth :: MethodBind bindLight2D_get_shadow_smooth = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_shadow_smooth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Smoothing value for shadows. get_shadow_smooth :: (Light2D :< cls, Object :< cls) => cls -> IO Float get_shadow_smooth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_shadow_smooth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_shadow_smooth" '[] (IO Float) where nodeMethod = Godot.Core.Light2D.get_shadow_smooth {-# NOINLINE bindLight2D_get_texture #-} -- | @Texture@ used for the Light2D's appearance. bindLight2D_get_texture :: MethodBind bindLight2D_get_texture = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ used for the Light2D's appearance. get_texture :: (Light2D :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.Light2D.get_texture {-# NOINLINE bindLight2D_get_texture_offset #-} -- | The offset of the Light2D's @texture@. bindLight2D_get_texture_offset :: MethodBind bindLight2D_get_texture_offset = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_texture_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The offset of the Light2D's @texture@. get_texture_offset :: (Light2D :< cls, Object :< cls) => cls -> IO Vector2 get_texture_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_texture_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_texture_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.Light2D.get_texture_offset {-# NOINLINE bindLight2D_get_texture_scale #-} -- | The @texture@'s scale factor. bindLight2D_get_texture_scale :: MethodBind bindLight2D_get_texture_scale = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_texture_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @texture@'s scale factor. get_texture_scale :: (Light2D :< cls, Object :< cls) => cls -> IO Float get_texture_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_texture_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_texture_scale" '[] (IO Float) where nodeMethod = Godot.Core.Light2D.get_texture_scale {-# NOINLINE bindLight2D_get_z_range_max #-} -- | Maximum @z@ value of objects that are affected by the Light2D. bindLight2D_get_z_range_max :: MethodBind bindLight2D_get_z_range_max = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_z_range_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum @z@ value of objects that are affected by the Light2D. get_z_range_max :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_z_range_max cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_z_range_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_z_range_max" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_z_range_max {-# NOINLINE bindLight2D_get_z_range_min #-} -- | Minimum @z@ value of objects that are affected by the Light2D. bindLight2D_get_z_range_min :: MethodBind bindLight2D_get_z_range_min = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "get_z_range_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Minimum @z@ value of objects that are affected by the Light2D. get_z_range_min :: (Light2D :< cls, Object :< cls) => cls -> IO Int get_z_range_min cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_get_z_range_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "get_z_range_min" '[] (IO Int) where nodeMethod = Godot.Core.Light2D.get_z_range_min {-# NOINLINE bindLight2D_is_editor_only #-} -- | If @true@, Light2D will only appear when editing the scene. bindLight2D_is_editor_only :: MethodBind bindLight2D_is_editor_only = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "is_editor_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, Light2D will only appear when editing the scene. is_editor_only :: (Light2D :< cls, Object :< cls) => cls -> IO Bool is_editor_only cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_is_editor_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "is_editor_only" '[] (IO Bool) where nodeMethod = Godot.Core.Light2D.is_editor_only {-# NOINLINE bindLight2D_is_enabled #-} -- | If @true@, Light2D will emit light. bindLight2D_is_enabled :: MethodBind bindLight2D_is_enabled = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "is_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, Light2D will emit light. is_enabled :: (Light2D :< cls, Object :< cls) => cls -> IO Bool is_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_is_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "is_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Light2D.is_enabled {-# NOINLINE bindLight2D_is_shadow_enabled #-} -- | If @true@, the Light2D will cast shadows. bindLight2D_is_shadow_enabled :: MethodBind bindLight2D_is_shadow_enabled = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "is_shadow_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the Light2D will cast shadows. is_shadow_enabled :: (Light2D :< cls, Object :< cls) => cls -> IO Bool is_shadow_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_is_shadow_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "is_shadow_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Light2D.is_shadow_enabled {-# NOINLINE bindLight2D_set_color #-} -- | The Light2D's @Color@. bindLight2D_set_color :: MethodBind bindLight2D_set_color = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Light2D's @Color@. set_color :: (Light2D :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Light2D.set_color {-# NOINLINE bindLight2D_set_editor_only #-} -- | If @true@, Light2D will only appear when editing the scene. bindLight2D_set_editor_only :: MethodBind bindLight2D_set_editor_only = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_editor_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, Light2D will only appear when editing the scene. set_editor_only :: (Light2D :< cls, Object :< cls) => cls -> Bool -> IO () set_editor_only cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_editor_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_editor_only" '[Bool] (IO ()) where nodeMethod = Godot.Core.Light2D.set_editor_only {-# NOINLINE bindLight2D_set_enabled #-} -- | If @true@, Light2D will emit light. bindLight2D_set_enabled :: MethodBind bindLight2D_set_enabled = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, Light2D will emit light. set_enabled :: (Light2D :< cls, Object :< cls) => cls -> Bool -> IO () set_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Light2D.set_enabled {-# NOINLINE bindLight2D_set_energy #-} -- | The Light2D's energy value. The larger the value, the stronger the light. bindLight2D_set_energy :: MethodBind bindLight2D_set_energy = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Light2D's energy value. The larger the value, the stronger the light. set_energy :: (Light2D :< cls, Object :< cls) => cls -> Float -> IO () set_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.Light2D.set_energy {-# NOINLINE bindLight2D_set_height #-} -- | The height of the Light2D. Used with 2D normal mapping. bindLight2D_set_height :: MethodBind bindLight2D_set_height = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The height of the Light2D. Used with 2D normal mapping. set_height :: (Light2D :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.Light2D.set_height {-# NOINLINE bindLight2D_set_item_cull_mask #-} -- | The layer mask. Only objects with a matching mask will be affected by the Light2D. bindLight2D_set_item_cull_mask :: MethodBind bindLight2D_set_item_cull_mask = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_item_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer mask. Only objects with a matching mask will be affected by the Light2D. set_item_cull_mask :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_item_cull_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_item_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_item_cull_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_item_cull_mask {-# NOINLINE bindLight2D_set_item_shadow_cull_mask #-} -- | The shadow mask. Used with @LightOccluder2D@ to cast shadows. Only occluders with a matching light mask will cast shadows. bindLight2D_set_item_shadow_cull_mask :: MethodBind bindLight2D_set_item_shadow_cull_mask = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_item_shadow_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shadow mask. Used with @LightOccluder2D@ to cast shadows. Only occluders with a matching light mask will cast shadows. set_item_shadow_cull_mask :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_item_shadow_cull_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_item_shadow_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_item_shadow_cull_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_item_shadow_cull_mask {-# NOINLINE bindLight2D_set_layer_range_max #-} -- | Maximum layer value of objects that are affected by the Light2D. bindLight2D_set_layer_range_max :: MethodBind bindLight2D_set_layer_range_max = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_layer_range_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum layer value of objects that are affected by the Light2D. set_layer_range_max :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_layer_range_max cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_layer_range_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_layer_range_max" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_layer_range_max {-# NOINLINE bindLight2D_set_layer_range_min #-} -- | Minimum layer value of objects that are affected by the Light2D. bindLight2D_set_layer_range_min :: MethodBind bindLight2D_set_layer_range_min = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_layer_range_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Minimum layer value of objects that are affected by the Light2D. set_layer_range_min :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_layer_range_min cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_layer_range_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_layer_range_min" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_layer_range_min {-# NOINLINE bindLight2D_set_mode #-} -- | The Light2D's mode. See @enum Mode@ constants for values. bindLight2D_set_mode :: MethodBind bindLight2D_set_mode = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The Light2D's mode. See @enum Mode@ constants for values. set_mode :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_mode {-# NOINLINE bindLight2D_set_shadow_buffer_size #-} -- | Shadow buffer size. bindLight2D_set_shadow_buffer_size :: MethodBind bindLight2D_set_shadow_buffer_size = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_shadow_buffer_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shadow buffer size. set_shadow_buffer_size :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_shadow_buffer_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_shadow_buffer_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_shadow_buffer_size" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_shadow_buffer_size {-# NOINLINE bindLight2D_set_shadow_color #-} -- | @Color@ of shadows cast by the Light2D. bindLight2D_set_shadow_color :: MethodBind bindLight2D_set_shadow_color = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_shadow_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Color@ of shadows cast by the Light2D. set_shadow_color :: (Light2D :< cls, Object :< cls) => cls -> Color -> IO () set_shadow_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_shadow_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_shadow_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Light2D.set_shadow_color {-# NOINLINE bindLight2D_set_shadow_enabled #-} -- | If @true@, the Light2D will cast shadows. bindLight2D_set_shadow_enabled :: MethodBind bindLight2D_set_shadow_enabled = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_shadow_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the Light2D will cast shadows. set_shadow_enabled :: (Light2D :< cls, Object :< cls) => cls -> Bool -> IO () set_shadow_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_shadow_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_shadow_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Light2D.set_shadow_enabled {-# NOINLINE bindLight2D_set_shadow_filter #-} -- | Shadow filter type. See @enum ShadowFilter@ for possible values. bindLight2D_set_shadow_filter :: MethodBind bindLight2D_set_shadow_filter = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_shadow_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shadow filter type. See @enum ShadowFilter@ for possible values. set_shadow_filter :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_shadow_filter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_shadow_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_shadow_filter" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_shadow_filter {-# NOINLINE bindLight2D_set_shadow_gradient_length #-} -- | Smooth shadow gradient length. bindLight2D_set_shadow_gradient_length :: MethodBind bindLight2D_set_shadow_gradient_length = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_shadow_gradient_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Smooth shadow gradient length. set_shadow_gradient_length :: (Light2D :< cls, Object :< cls) => cls -> Float -> IO () set_shadow_gradient_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_shadow_gradient_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_shadow_gradient_length" '[Float] (IO ()) where nodeMethod = Godot.Core.Light2D.set_shadow_gradient_length {-# NOINLINE bindLight2D_set_shadow_smooth #-} -- | Smoothing value for shadows. bindLight2D_set_shadow_smooth :: MethodBind bindLight2D_set_shadow_smooth = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_shadow_smooth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Smoothing value for shadows. set_shadow_smooth :: (Light2D :< cls, Object :< cls) => cls -> Float -> IO () set_shadow_smooth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_shadow_smooth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_shadow_smooth" '[Float] (IO ()) where nodeMethod = Godot.Core.Light2D.set_shadow_smooth {-# NOINLINE bindLight2D_set_texture #-} -- | @Texture@ used for the Light2D's appearance. bindLight2D_set_texture :: MethodBind bindLight2D_set_texture = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ used for the Light2D's appearance. set_texture :: (Light2D :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.Light2D.set_texture {-# NOINLINE bindLight2D_set_texture_offset #-} -- | The offset of the Light2D's @texture@. bindLight2D_set_texture_offset :: MethodBind bindLight2D_set_texture_offset = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_texture_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The offset of the Light2D's @texture@. set_texture_offset :: (Light2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_texture_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_texture_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_texture_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Light2D.set_texture_offset {-# NOINLINE bindLight2D_set_texture_scale #-} -- | The @texture@'s scale factor. bindLight2D_set_texture_scale :: MethodBind bindLight2D_set_texture_scale = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_texture_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @texture@'s scale factor. set_texture_scale :: (Light2D :< cls, Object :< cls) => cls -> Float -> IO () set_texture_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_texture_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_texture_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.Light2D.set_texture_scale {-# NOINLINE bindLight2D_set_z_range_max #-} -- | Maximum @z@ value of objects that are affected by the Light2D. bindLight2D_set_z_range_max :: MethodBind bindLight2D_set_z_range_max = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_z_range_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum @z@ value of objects that are affected by the Light2D. set_z_range_max :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_z_range_max cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_z_range_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_z_range_max" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_z_range_max {-# NOINLINE bindLight2D_set_z_range_min #-} -- | Minimum @z@ value of objects that are affected by the Light2D. bindLight2D_set_z_range_min :: MethodBind bindLight2D_set_z_range_min = unsafePerformIO $ withCString "Light2D" $ \ clsNamePtr -> withCString "set_z_range_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Minimum @z@ value of objects that are affected by the Light2D. set_z_range_min :: (Light2D :< cls, Object :< cls) => cls -> Int -> IO () set_z_range_min cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLight2D_set_z_range_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Light2D "set_z_range_min" '[Int] (IO ()) where nodeMethod = Godot.Core.Light2D.set_z_range_min ================================================ FILE: src/Godot/Core/LightOccluder2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.LightOccluder2D (Godot.Core.LightOccluder2D._poly_changed, Godot.Core.LightOccluder2D.get_occluder_light_mask, Godot.Core.LightOccluder2D.get_occluder_polygon, Godot.Core.LightOccluder2D.set_occluder_light_mask, Godot.Core.LightOccluder2D.set_occluder_polygon) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty LightOccluder2D "light_mask" Int 'False where nodeProperty = (get_occluder_light_mask, wrapDroppingSetter set_occluder_light_mask, Nothing) instance NodeProperty LightOccluder2D "occluder" OccluderPolygon2D 'False where nodeProperty = (get_occluder_polygon, wrapDroppingSetter set_occluder_polygon, Nothing) {-# NOINLINE bindLightOccluder2D__poly_changed #-} bindLightOccluder2D__poly_changed :: MethodBind bindLightOccluder2D__poly_changed = unsafePerformIO $ withCString "LightOccluder2D" $ \ clsNamePtr -> withCString "_poly_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _poly_changed :: (LightOccluder2D :< cls, Object :< cls) => cls -> IO () _poly_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLightOccluder2D__poly_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LightOccluder2D "_poly_changed" '[] (IO ()) where nodeMethod = Godot.Core.LightOccluder2D._poly_changed {-# NOINLINE bindLightOccluder2D_get_occluder_light_mask #-} -- | The LightOccluder2D's light mask. The LightOccluder2D will cast shadows only from Light2D(s) that have the same light mask(s). bindLightOccluder2D_get_occluder_light_mask :: MethodBind bindLightOccluder2D_get_occluder_light_mask = unsafePerformIO $ withCString "LightOccluder2D" $ \ clsNamePtr -> withCString "get_occluder_light_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The LightOccluder2D's light mask. The LightOccluder2D will cast shadows only from Light2D(s) that have the same light mask(s). get_occluder_light_mask :: (LightOccluder2D :< cls, Object :< cls) => cls -> IO Int get_occluder_light_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLightOccluder2D_get_occluder_light_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LightOccluder2D "get_occluder_light_mask" '[] (IO Int) where nodeMethod = Godot.Core.LightOccluder2D.get_occluder_light_mask {-# NOINLINE bindLightOccluder2D_get_occluder_polygon #-} -- | The @OccluderPolygon2D@ used to compute the shadow. bindLightOccluder2D_get_occluder_polygon :: MethodBind bindLightOccluder2D_get_occluder_polygon = unsafePerformIO $ withCString "LightOccluder2D" $ \ clsNamePtr -> withCString "get_occluder_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @OccluderPolygon2D@ used to compute the shadow. get_occluder_polygon :: (LightOccluder2D :< cls, Object :< cls) => cls -> IO OccluderPolygon2D get_occluder_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLightOccluder2D_get_occluder_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LightOccluder2D "get_occluder_polygon" '[] (IO OccluderPolygon2D) where nodeMethod = Godot.Core.LightOccluder2D.get_occluder_polygon {-# NOINLINE bindLightOccluder2D_set_occluder_light_mask #-} -- | The LightOccluder2D's light mask. The LightOccluder2D will cast shadows only from Light2D(s) that have the same light mask(s). bindLightOccluder2D_set_occluder_light_mask :: MethodBind bindLightOccluder2D_set_occluder_light_mask = unsafePerformIO $ withCString "LightOccluder2D" $ \ clsNamePtr -> withCString "set_occluder_light_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The LightOccluder2D's light mask. The LightOccluder2D will cast shadows only from Light2D(s) that have the same light mask(s). set_occluder_light_mask :: (LightOccluder2D :< cls, Object :< cls) => cls -> Int -> IO () set_occluder_light_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLightOccluder2D_set_occluder_light_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LightOccluder2D "set_occluder_light_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.LightOccluder2D.set_occluder_light_mask {-# NOINLINE bindLightOccluder2D_set_occluder_polygon #-} -- | The @OccluderPolygon2D@ used to compute the shadow. bindLightOccluder2D_set_occluder_polygon :: MethodBind bindLightOccluder2D_set_occluder_polygon = unsafePerformIO $ withCString "LightOccluder2D" $ \ clsNamePtr -> withCString "set_occluder_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @OccluderPolygon2D@ used to compute the shadow. set_occluder_polygon :: (LightOccluder2D :< cls, Object :< cls) => cls -> OccluderPolygon2D -> IO () set_occluder_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLightOccluder2D_set_occluder_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LightOccluder2D "set_occluder_polygon" '[OccluderPolygon2D] (IO ()) where nodeMethod = Godot.Core.LightOccluder2D.set_occluder_polygon ================================================ FILE: src/Godot/Core/Line2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Line2D (Godot.Core.Line2D._LINE_JOINT_ROUND, Godot.Core.Line2D._LINE_TEXTURE_NONE, Godot.Core.Line2D._LINE_CAP_ROUND, Godot.Core.Line2D._LINE_CAP_NONE, Godot.Core.Line2D._LINE_TEXTURE_TILE, Godot.Core.Line2D._LINE_JOINT_BEVEL, Godot.Core.Line2D._LINE_JOINT_SHARP, Godot.Core.Line2D._LINE_TEXTURE_STRETCH, Godot.Core.Line2D._LINE_CAP_BOX, Godot.Core.Line2D._curve_changed, Godot.Core.Line2D._gradient_changed, Godot.Core.Line2D.add_point, Godot.Core.Line2D.clear_points, Godot.Core.Line2D.get_antialiased, Godot.Core.Line2D.get_begin_cap_mode, Godot.Core.Line2D.get_curve, Godot.Core.Line2D.get_default_color, Godot.Core.Line2D.get_end_cap_mode, Godot.Core.Line2D.get_gradient, Godot.Core.Line2D.get_joint_mode, Godot.Core.Line2D.get_point_count, Godot.Core.Line2D.get_point_position, Godot.Core.Line2D.get_points, Godot.Core.Line2D.get_round_precision, Godot.Core.Line2D.get_sharp_limit, Godot.Core.Line2D.get_texture, Godot.Core.Line2D.get_texture_mode, Godot.Core.Line2D.get_width, Godot.Core.Line2D.remove_point, Godot.Core.Line2D.set_antialiased, Godot.Core.Line2D.set_begin_cap_mode, Godot.Core.Line2D.set_curve, Godot.Core.Line2D.set_default_color, Godot.Core.Line2D.set_end_cap_mode, Godot.Core.Line2D.set_gradient, Godot.Core.Line2D.set_joint_mode, Godot.Core.Line2D.set_point_position, Godot.Core.Line2D.set_points, Godot.Core.Line2D.set_round_precision, Godot.Core.Line2D.set_sharp_limit, Godot.Core.Line2D.set_texture, Godot.Core.Line2D.set_texture_mode, Godot.Core.Line2D.set_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _LINE_JOINT_ROUND :: Int _LINE_JOINT_ROUND = 2 _LINE_TEXTURE_NONE :: Int _LINE_TEXTURE_NONE = 0 _LINE_CAP_ROUND :: Int _LINE_CAP_ROUND = 2 _LINE_CAP_NONE :: Int _LINE_CAP_NONE = 0 _LINE_TEXTURE_TILE :: Int _LINE_TEXTURE_TILE = 1 _LINE_JOINT_BEVEL :: Int _LINE_JOINT_BEVEL = 1 _LINE_JOINT_SHARP :: Int _LINE_JOINT_SHARP = 0 _LINE_TEXTURE_STRETCH :: Int _LINE_TEXTURE_STRETCH = 2 _LINE_CAP_BOX :: Int _LINE_CAP_BOX = 1 instance NodeProperty Line2D "antialiased" Bool 'False where nodeProperty = (get_antialiased, wrapDroppingSetter set_antialiased, Nothing) instance NodeProperty Line2D "begin_cap_mode" Int 'False where nodeProperty = (get_begin_cap_mode, wrapDroppingSetter set_begin_cap_mode, Nothing) instance NodeProperty Line2D "default_color" Color 'False where nodeProperty = (get_default_color, wrapDroppingSetter set_default_color, Nothing) instance NodeProperty Line2D "end_cap_mode" Int 'False where nodeProperty = (get_end_cap_mode, wrapDroppingSetter set_end_cap_mode, Nothing) instance NodeProperty Line2D "gradient" Gradient 'False where nodeProperty = (get_gradient, wrapDroppingSetter set_gradient, Nothing) instance NodeProperty Line2D "joint_mode" Int 'False where nodeProperty = (get_joint_mode, wrapDroppingSetter set_joint_mode, Nothing) instance NodeProperty Line2D "points" PoolVector2Array 'False where nodeProperty = (get_points, wrapDroppingSetter set_points, Nothing) instance NodeProperty Line2D "round_precision" Int 'False where nodeProperty = (get_round_precision, wrapDroppingSetter set_round_precision, Nothing) instance NodeProperty Line2D "sharp_limit" Float 'False where nodeProperty = (get_sharp_limit, wrapDroppingSetter set_sharp_limit, Nothing) instance NodeProperty Line2D "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) instance NodeProperty Line2D "texture_mode" Int 'False where nodeProperty = (get_texture_mode, wrapDroppingSetter set_texture_mode, Nothing) instance NodeProperty Line2D "width" Float 'False where nodeProperty = (get_width, wrapDroppingSetter set_width, Nothing) instance NodeProperty Line2D "width_curve" Curve 'False where nodeProperty = (get_curve, wrapDroppingSetter set_curve, Nothing) {-# NOINLINE bindLine2D__curve_changed #-} bindLine2D__curve_changed :: MethodBind bindLine2D__curve_changed = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "_curve_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _curve_changed :: (Line2D :< cls, Object :< cls) => cls -> IO () _curve_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D__curve_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "_curve_changed" '[] (IO ()) where nodeMethod = Godot.Core.Line2D._curve_changed {-# NOINLINE bindLine2D__gradient_changed #-} bindLine2D__gradient_changed :: MethodBind bindLine2D__gradient_changed = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "_gradient_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gradient_changed :: (Line2D :< cls, Object :< cls) => cls -> IO () _gradient_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D__gradient_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "_gradient_changed" '[] (IO ()) where nodeMethod = Godot.Core.Line2D._gradient_changed {-# NOINLINE bindLine2D_add_point #-} -- | Adds a point at the @position@. Appends the point at the end of the line. -- If @at_position@ is given, the point is inserted before the point number @at_position@, moving that point (and every point after) after the inserted point. If @at_position@ is not given, or is an illegal value (@at_position < 0@ or @at_position >= @method get_point_count@@), the point will be appended at the end of the point list. bindLine2D_add_point :: MethodBind bindLine2D_add_point = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "add_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a point at the @position@. Appends the point at the end of the line. -- If @at_position@ is given, the point is inserted before the point number @at_position@, moving that point (and every point after) after the inserted point. If @at_position@ is not given, or is an illegal value (@at_position < 0@ or @at_position >= @method get_point_count@@), the point will be appended at the end of the point list. add_point :: (Line2D :< cls, Object :< cls) => cls -> Vector2 -> Maybe Int -> IO () add_point cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_add_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "add_point" '[Vector2, Maybe Int] (IO ()) where nodeMethod = Godot.Core.Line2D.add_point {-# NOINLINE bindLine2D_clear_points #-} -- | Removes all points from the line. bindLine2D_clear_points :: MethodBind bindLine2D_clear_points = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "clear_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all points from the line. clear_points :: (Line2D :< cls, Object :< cls) => cls -> IO () clear_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_clear_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "clear_points" '[] (IO ()) where nodeMethod = Godot.Core.Line2D.clear_points {-# NOINLINE bindLine2D_get_antialiased #-} -- | If @true@, the line's border will be anti-aliased. bindLine2D_get_antialiased :: MethodBind bindLine2D_get_antialiased = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_antialiased" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the line's border will be anti-aliased. get_antialiased :: (Line2D :< cls, Object :< cls) => cls -> IO Bool get_antialiased cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_antialiased (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_antialiased" '[] (IO Bool) where nodeMethod = Godot.Core.Line2D.get_antialiased {-# NOINLINE bindLine2D_get_begin_cap_mode #-} -- | Controls the style of the line's first point. Use @enum LineCapMode@ constants. bindLine2D_get_begin_cap_mode :: MethodBind bindLine2D_get_begin_cap_mode = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_begin_cap_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the style of the line's first point. Use @enum LineCapMode@ constants. get_begin_cap_mode :: (Line2D :< cls, Object :< cls) => cls -> IO Int get_begin_cap_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_begin_cap_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_begin_cap_mode" '[] (IO Int) where nodeMethod = Godot.Core.Line2D.get_begin_cap_mode {-# NOINLINE bindLine2D_get_curve #-} -- | The line's width varies with the curve. The original width is simply multiply by the value of the Curve. bindLine2D_get_curve :: MethodBind bindLine2D_get_curve = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's width varies with the curve. The original width is simply multiply by the value of the Curve. get_curve :: (Line2D :< cls, Object :< cls) => cls -> IO Curve get_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_curve" '[] (IO Curve) where nodeMethod = Godot.Core.Line2D.get_curve {-# NOINLINE bindLine2D_get_default_color #-} -- | The line's color. Will not be used if a gradient is set. bindLine2D_get_default_color :: MethodBind bindLine2D_get_default_color = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_default_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's color. Will not be used if a gradient is set. get_default_color :: (Line2D :< cls, Object :< cls) => cls -> IO Color get_default_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_default_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_default_color" '[] (IO Color) where nodeMethod = Godot.Core.Line2D.get_default_color {-# NOINLINE bindLine2D_get_end_cap_mode #-} -- | Controls the style of the line's last point. Use @enum LineCapMode@ constants. bindLine2D_get_end_cap_mode :: MethodBind bindLine2D_get_end_cap_mode = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_end_cap_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the style of the line's last point. Use @enum LineCapMode@ constants. get_end_cap_mode :: (Line2D :< cls, Object :< cls) => cls -> IO Int get_end_cap_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_end_cap_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_end_cap_mode" '[] (IO Int) where nodeMethod = Godot.Core.Line2D.get_end_cap_mode {-# NOINLINE bindLine2D_get_gradient #-} -- | The gradient is drawn through the whole line from start to finish. The default color will not be used if a gradient is set. bindLine2D_get_gradient :: MethodBind bindLine2D_get_gradient = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_gradient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The gradient is drawn through the whole line from start to finish. The default color will not be used if a gradient is set. get_gradient :: (Line2D :< cls, Object :< cls) => cls -> IO Gradient get_gradient cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_gradient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_gradient" '[] (IO Gradient) where nodeMethod = Godot.Core.Line2D.get_gradient {-# NOINLINE bindLine2D_get_joint_mode #-} -- | The style for the points between the start and the end. bindLine2D_get_joint_mode :: MethodBind bindLine2D_get_joint_mode = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_joint_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The style for the points between the start and the end. get_joint_mode :: (Line2D :< cls, Object :< cls) => cls -> IO Int get_joint_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_joint_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_joint_mode" '[] (IO Int) where nodeMethod = Godot.Core.Line2D.get_joint_mode {-# NOINLINE bindLine2D_get_point_count #-} -- | Returns the Line2D's amount of points. bindLine2D_get_point_count :: MethodBind bindLine2D_get_point_count = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the Line2D's amount of points. get_point_count :: (Line2D :< cls, Object :< cls) => cls -> IO Int get_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_point_count" '[] (IO Int) where nodeMethod = Godot.Core.Line2D.get_point_count {-# NOINLINE bindLine2D_get_point_position #-} -- | Returns point @i@'s position. bindLine2D_get_point_position :: MethodBind bindLine2D_get_point_position = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns point @i@'s position. get_point_position :: (Line2D :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_point_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_point_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Line2D.get_point_position {-# NOINLINE bindLine2D_get_points #-} -- | The points that form the lines. The line is drawn between every point set in this array. Points are interpreted as local vectors. bindLine2D_get_points :: MethodBind bindLine2D_get_points = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The points that form the lines. The line is drawn between every point set in this array. Points are interpreted as local vectors. get_points :: (Line2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_points cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_points" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.Line2D.get_points {-# NOINLINE bindLine2D_get_round_precision #-} -- | The smoothness of the rounded joints and caps. This is only used if a cap or joint is set as round. bindLine2D_get_round_precision :: MethodBind bindLine2D_get_round_precision = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_round_precision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The smoothness of the rounded joints and caps. This is only used if a cap or joint is set as round. get_round_precision :: (Line2D :< cls, Object :< cls) => cls -> IO Int get_round_precision cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_round_precision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_round_precision" '[] (IO Int) where nodeMethod = Godot.Core.Line2D.get_round_precision {-# NOINLINE bindLine2D_get_sharp_limit #-} -- | The direction difference in radians between vector points. This value is only used if @joint mode@ is set to @LINE_JOINT_SHARP@. bindLine2D_get_sharp_limit :: MethodBind bindLine2D_get_sharp_limit = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_sharp_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The direction difference in radians between vector points. This value is only used if @joint mode@ is set to @LINE_JOINT_SHARP@. get_sharp_limit :: (Line2D :< cls, Object :< cls) => cls -> IO Float get_sharp_limit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_sharp_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_sharp_limit" '[] (IO Float) where nodeMethod = Godot.Core.Line2D.get_sharp_limit {-# NOINLINE bindLine2D_get_texture #-} -- | The texture used for the line's texture. Uses @texture_mode@ for drawing style. bindLine2D_get_texture :: MethodBind bindLine2D_get_texture = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture used for the line's texture. Uses @texture_mode@ for drawing style. get_texture :: (Line2D :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.Line2D.get_texture {-# NOINLINE bindLine2D_get_texture_mode #-} -- | The style to render the @texture@ on the line. Use @enum LineTextureMode@ constants. bindLine2D_get_texture_mode :: MethodBind bindLine2D_get_texture_mode = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_texture_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The style to render the @texture@ on the line. Use @enum LineTextureMode@ constants. get_texture_mode :: (Line2D :< cls, Object :< cls) => cls -> IO Int get_texture_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_texture_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_texture_mode" '[] (IO Int) where nodeMethod = Godot.Core.Line2D.get_texture_mode {-# NOINLINE bindLine2D_get_width #-} -- | The line's width. bindLine2D_get_width :: MethodBind bindLine2D_get_width = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's width. get_width :: (Line2D :< cls, Object :< cls) => cls -> IO Float get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "get_width" '[] (IO Float) where nodeMethod = Godot.Core.Line2D.get_width {-# NOINLINE bindLine2D_remove_point #-} -- | Removes the point at index @i@ from the line. bindLine2D_remove_point :: MethodBind bindLine2D_remove_point = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "remove_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the point at index @i@ from the line. remove_point :: (Line2D :< cls, Object :< cls) => cls -> Int -> IO () remove_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_remove_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "remove_point" '[Int] (IO ()) where nodeMethod = Godot.Core.Line2D.remove_point {-# NOINLINE bindLine2D_set_antialiased #-} -- | If @true@, the line's border will be anti-aliased. bindLine2D_set_antialiased :: MethodBind bindLine2D_set_antialiased = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_antialiased" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the line's border will be anti-aliased. set_antialiased :: (Line2D :< cls, Object :< cls) => cls -> Bool -> IO () set_antialiased cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_antialiased (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_antialiased" '[Bool] (IO ()) where nodeMethod = Godot.Core.Line2D.set_antialiased {-# NOINLINE bindLine2D_set_begin_cap_mode #-} -- | Controls the style of the line's first point. Use @enum LineCapMode@ constants. bindLine2D_set_begin_cap_mode :: MethodBind bindLine2D_set_begin_cap_mode = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_begin_cap_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the style of the line's first point. Use @enum LineCapMode@ constants. set_begin_cap_mode :: (Line2D :< cls, Object :< cls) => cls -> Int -> IO () set_begin_cap_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_begin_cap_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_begin_cap_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Line2D.set_begin_cap_mode {-# NOINLINE bindLine2D_set_curve #-} -- | The line's width varies with the curve. The original width is simply multiply by the value of the Curve. bindLine2D_set_curve :: MethodBind bindLine2D_set_curve = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's width varies with the curve. The original width is simply multiply by the value of the Curve. set_curve :: (Line2D :< cls, Object :< cls) => cls -> Curve -> IO () set_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_curve" '[Curve] (IO ()) where nodeMethod = Godot.Core.Line2D.set_curve {-# NOINLINE bindLine2D_set_default_color #-} -- | The line's color. Will not be used if a gradient is set. bindLine2D_set_default_color :: MethodBind bindLine2D_set_default_color = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_default_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's color. Will not be used if a gradient is set. set_default_color :: (Line2D :< cls, Object :< cls) => cls -> Color -> IO () set_default_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_default_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_default_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Line2D.set_default_color {-# NOINLINE bindLine2D_set_end_cap_mode #-} -- | Controls the style of the line's last point. Use @enum LineCapMode@ constants. bindLine2D_set_end_cap_mode :: MethodBind bindLine2D_set_end_cap_mode = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_end_cap_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the style of the line's last point. Use @enum LineCapMode@ constants. set_end_cap_mode :: (Line2D :< cls, Object :< cls) => cls -> Int -> IO () set_end_cap_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_end_cap_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_end_cap_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Line2D.set_end_cap_mode {-# NOINLINE bindLine2D_set_gradient #-} -- | The gradient is drawn through the whole line from start to finish. The default color will not be used if a gradient is set. bindLine2D_set_gradient :: MethodBind bindLine2D_set_gradient = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_gradient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The gradient is drawn through the whole line from start to finish. The default color will not be used if a gradient is set. set_gradient :: (Line2D :< cls, Object :< cls) => cls -> Gradient -> IO () set_gradient cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_gradient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_gradient" '[Gradient] (IO ()) where nodeMethod = Godot.Core.Line2D.set_gradient {-# NOINLINE bindLine2D_set_joint_mode #-} -- | The style for the points between the start and the end. bindLine2D_set_joint_mode :: MethodBind bindLine2D_set_joint_mode = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_joint_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The style for the points between the start and the end. set_joint_mode :: (Line2D :< cls, Object :< cls) => cls -> Int -> IO () set_joint_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_joint_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_joint_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Line2D.set_joint_mode {-# NOINLINE bindLine2D_set_point_position #-} -- | Overwrites the position in point @i@ with the supplied @position@. bindLine2D_set_point_position :: MethodBind bindLine2D_set_point_position = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_point_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overwrites the position in point @i@ with the supplied @position@. set_point_position :: (Line2D :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_point_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_point_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_point_position" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.Line2D.set_point_position {-# NOINLINE bindLine2D_set_points #-} -- | The points that form the lines. The line is drawn between every point set in this array. Points are interpreted as local vectors. bindLine2D_set_points :: MethodBind bindLine2D_set_points = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_points" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The points that form the lines. The line is drawn between every point set in this array. Points are interpreted as local vectors. set_points :: (Line2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_points cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_points (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_points" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.Line2D.set_points {-# NOINLINE bindLine2D_set_round_precision #-} -- | The smoothness of the rounded joints and caps. This is only used if a cap or joint is set as round. bindLine2D_set_round_precision :: MethodBind bindLine2D_set_round_precision = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_round_precision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The smoothness of the rounded joints and caps. This is only used if a cap or joint is set as round. set_round_precision :: (Line2D :< cls, Object :< cls) => cls -> Int -> IO () set_round_precision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_round_precision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_round_precision" '[Int] (IO ()) where nodeMethod = Godot.Core.Line2D.set_round_precision {-# NOINLINE bindLine2D_set_sharp_limit #-} -- | The direction difference in radians between vector points. This value is only used if @joint mode@ is set to @LINE_JOINT_SHARP@. bindLine2D_set_sharp_limit :: MethodBind bindLine2D_set_sharp_limit = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_sharp_limit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The direction difference in radians between vector points. This value is only used if @joint mode@ is set to @LINE_JOINT_SHARP@. set_sharp_limit :: (Line2D :< cls, Object :< cls) => cls -> Float -> IO () set_sharp_limit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_sharp_limit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_sharp_limit" '[Float] (IO ()) where nodeMethod = Godot.Core.Line2D.set_sharp_limit {-# NOINLINE bindLine2D_set_texture #-} -- | The texture used for the line's texture. Uses @texture_mode@ for drawing style. bindLine2D_set_texture :: MethodBind bindLine2D_set_texture = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture used for the line's texture. Uses @texture_mode@ for drawing style. set_texture :: (Line2D :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.Line2D.set_texture {-# NOINLINE bindLine2D_set_texture_mode #-} -- | The style to render the @texture@ on the line. Use @enum LineTextureMode@ constants. bindLine2D_set_texture_mode :: MethodBind bindLine2D_set_texture_mode = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_texture_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The style to render the @texture@ on the line. Use @enum LineTextureMode@ constants. set_texture_mode :: (Line2D :< cls, Object :< cls) => cls -> Int -> IO () set_texture_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_texture_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_texture_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Line2D.set_texture_mode {-# NOINLINE bindLine2D_set_width #-} -- | The line's width. bindLine2D_set_width :: MethodBind bindLine2D_set_width = unsafePerformIO $ withCString "Line2D" $ \ clsNamePtr -> withCString "set_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's width. set_width :: (Line2D :< cls, Object :< cls) => cls -> Float -> IO () set_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLine2D_set_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Line2D "set_width" '[Float] (IO ()) where nodeMethod = Godot.Core.Line2D.set_width ================================================ FILE: src/Godot/Core/LineEdit.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.LineEdit (Godot.Core.LineEdit._MENU_PASTE, Godot.Core.LineEdit._ALIGN_RIGHT, Godot.Core.LineEdit._ALIGN_FILL, Godot.Core.LineEdit._MENU_CLEAR, Godot.Core.LineEdit._MENU_MAX, Godot.Core.LineEdit._MENU_REDO, Godot.Core.LineEdit._MENU_COPY, Godot.Core.LineEdit._MENU_UNDO, Godot.Core.LineEdit._MENU_SELECT_ALL, Godot.Core.LineEdit._MENU_CUT, Godot.Core.LineEdit._ALIGN_LEFT, Godot.Core.LineEdit._ALIGN_CENTER, Godot.Core.LineEdit.sig_text_change_rejected, Godot.Core.LineEdit.sig_text_changed, Godot.Core.LineEdit.sig_text_entered, Godot.Core.LineEdit._editor_settings_changed, Godot.Core.LineEdit._gui_input, Godot.Core.LineEdit._text_changed, Godot.Core.LineEdit._toggle_draw_caret, Godot.Core.LineEdit.append_at_cursor, Godot.Core.LineEdit.clear, Godot.Core.LineEdit.cursor_get_blink_enabled, Godot.Core.LineEdit.cursor_get_blink_speed, Godot.Core.LineEdit.cursor_set_blink_enabled, Godot.Core.LineEdit.cursor_set_blink_speed, Godot.Core.LineEdit.deselect, Godot.Core.LineEdit.get_align, Godot.Core.LineEdit.get_cursor_position, Godot.Core.LineEdit.get_expand_to_text_length, Godot.Core.LineEdit.get_max_length, Godot.Core.LineEdit.get_menu, Godot.Core.LineEdit.get_placeholder, Godot.Core.LineEdit.get_placeholder_alpha, Godot.Core.LineEdit.get_right_icon, Godot.Core.LineEdit.get_secret_character, Godot.Core.LineEdit.get_text, Godot.Core.LineEdit.is_clear_button_enabled, Godot.Core.LineEdit.is_context_menu_enabled, Godot.Core.LineEdit.is_editable, Godot.Core.LineEdit.is_secret, Godot.Core.LineEdit.is_selecting_enabled, Godot.Core.LineEdit.is_shortcut_keys_enabled, Godot.Core.LineEdit.menu_option, Godot.Core.LineEdit.select, Godot.Core.LineEdit.select_all, Godot.Core.LineEdit.set_align, Godot.Core.LineEdit.set_clear_button_enabled, Godot.Core.LineEdit.set_context_menu_enabled, Godot.Core.LineEdit.set_cursor_position, Godot.Core.LineEdit.set_editable, Godot.Core.LineEdit.set_expand_to_text_length, Godot.Core.LineEdit.set_max_length, Godot.Core.LineEdit.set_placeholder, Godot.Core.LineEdit.set_placeholder_alpha, Godot.Core.LineEdit.set_right_icon, Godot.Core.LineEdit.set_secret, Godot.Core.LineEdit.set_secret_character, Godot.Core.LineEdit.set_selecting_enabled, Godot.Core.LineEdit.set_shortcut_keys_enabled, Godot.Core.LineEdit.set_text) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _MENU_PASTE :: Int _MENU_PASTE = 2 _ALIGN_RIGHT :: Int _ALIGN_RIGHT = 2 _ALIGN_FILL :: Int _ALIGN_FILL = 3 _MENU_CLEAR :: Int _MENU_CLEAR = 3 _MENU_MAX :: Int _MENU_MAX = 7 _MENU_REDO :: Int _MENU_REDO = 6 _MENU_COPY :: Int _MENU_COPY = 1 _MENU_UNDO :: Int _MENU_UNDO = 5 _MENU_SELECT_ALL :: Int _MENU_SELECT_ALL = 4 _MENU_CUT :: Int _MENU_CUT = 0 _ALIGN_LEFT :: Int _ALIGN_LEFT = 0 _ALIGN_CENTER :: Int _ALIGN_CENTER = 1 -- | Emitted when trying to append text that would overflow the @max_length@. sig_text_change_rejected :: Godot.Internal.Dispatch.Signal LineEdit sig_text_change_rejected = Godot.Internal.Dispatch.Signal "text_change_rejected" instance NodeSignal LineEdit "text_change_rejected" '[] -- | Emitted when the text changes. sig_text_changed :: Godot.Internal.Dispatch.Signal LineEdit sig_text_changed = Godot.Internal.Dispatch.Signal "text_changed" instance NodeSignal LineEdit "text_changed" '[GodotString] -- | Emitted when the user presses @KEY_ENTER@ on the @LineEdit@. sig_text_entered :: Godot.Internal.Dispatch.Signal LineEdit sig_text_entered = Godot.Internal.Dispatch.Signal "text_entered" instance NodeSignal LineEdit "text_entered" '[GodotString] instance NodeProperty LineEdit "align" Int 'False where nodeProperty = (get_align, wrapDroppingSetter set_align, Nothing) instance NodeProperty LineEdit "caret_blink" Bool 'False where nodeProperty = (cursor_get_blink_enabled, wrapDroppingSetter cursor_set_blink_enabled, Nothing) instance NodeProperty LineEdit "caret_blink_speed" Float 'False where nodeProperty = (cursor_get_blink_speed, wrapDroppingSetter cursor_set_blink_speed, Nothing) instance NodeProperty LineEdit "caret_position" Int 'False where nodeProperty = (get_cursor_position, wrapDroppingSetter set_cursor_position, Nothing) instance NodeProperty LineEdit "clear_button_enabled" Bool 'False where nodeProperty = (is_clear_button_enabled, wrapDroppingSetter set_clear_button_enabled, Nothing) instance NodeProperty LineEdit "context_menu_enabled" Bool 'False where nodeProperty = (is_context_menu_enabled, wrapDroppingSetter set_context_menu_enabled, Nothing) instance NodeProperty LineEdit "editable" Bool 'False where nodeProperty = (is_editable, wrapDroppingSetter set_editable, Nothing) instance NodeProperty LineEdit "expand_to_text_length" Bool 'False where nodeProperty = (get_expand_to_text_length, wrapDroppingSetter set_expand_to_text_length, Nothing) instance NodeProperty LineEdit "max_length" Int 'False where nodeProperty = (get_max_length, wrapDroppingSetter set_max_length, Nothing) instance NodeProperty LineEdit "placeholder_alpha" Float 'False where nodeProperty = (get_placeholder_alpha, wrapDroppingSetter set_placeholder_alpha, Nothing) instance NodeProperty LineEdit "placeholder_text" GodotString 'False where nodeProperty = (get_placeholder, wrapDroppingSetter set_placeholder, Nothing) instance NodeProperty LineEdit "right_icon" Texture 'False where nodeProperty = (get_right_icon, wrapDroppingSetter set_right_icon, Nothing) instance NodeProperty LineEdit "secret" Bool 'False where nodeProperty = (is_secret, wrapDroppingSetter set_secret, Nothing) instance NodeProperty LineEdit "secret_character" GodotString 'False where nodeProperty = (get_secret_character, wrapDroppingSetter set_secret_character, Nothing) instance NodeProperty LineEdit "selecting_enabled" Bool 'False where nodeProperty = (is_selecting_enabled, wrapDroppingSetter set_selecting_enabled, Nothing) instance NodeProperty LineEdit "shortcut_keys_enabled" Bool 'False where nodeProperty = (is_shortcut_keys_enabled, wrapDroppingSetter set_shortcut_keys_enabled, Nothing) instance NodeProperty LineEdit "text" GodotString 'False where nodeProperty = (get_text, wrapDroppingSetter set_text, Nothing) {-# NOINLINE bindLineEdit__editor_settings_changed #-} bindLineEdit__editor_settings_changed :: MethodBind bindLineEdit__editor_settings_changed = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "_editor_settings_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _editor_settings_changed :: (LineEdit :< cls, Object :< cls) => cls -> IO () _editor_settings_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit__editor_settings_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "_editor_settings_changed" '[] (IO ()) where nodeMethod = Godot.Core.LineEdit._editor_settings_changed {-# NOINLINE bindLineEdit__gui_input #-} bindLineEdit__gui_input :: MethodBind bindLineEdit__gui_input = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (LineEdit :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.LineEdit._gui_input {-# NOINLINE bindLineEdit__text_changed #-} bindLineEdit__text_changed :: MethodBind bindLineEdit__text_changed = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "_text_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _text_changed :: (LineEdit :< cls, Object :< cls) => cls -> IO () _text_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit__text_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "_text_changed" '[] (IO ()) where nodeMethod = Godot.Core.LineEdit._text_changed {-# NOINLINE bindLineEdit__toggle_draw_caret #-} bindLineEdit__toggle_draw_caret :: MethodBind bindLineEdit__toggle_draw_caret = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "_toggle_draw_caret" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _toggle_draw_caret :: (LineEdit :< cls, Object :< cls) => cls -> IO () _toggle_draw_caret cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit__toggle_draw_caret (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "_toggle_draw_caret" '[] (IO ()) where nodeMethod = Godot.Core.LineEdit._toggle_draw_caret {-# NOINLINE bindLineEdit_append_at_cursor #-} -- | Adds @text@ after the cursor. If the resulting value is longer than @max_length@, nothing happens. bindLineEdit_append_at_cursor :: MethodBind bindLineEdit_append_at_cursor = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "append_at_cursor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds @text@ after the cursor. If the resulting value is longer than @max_length@, nothing happens. append_at_cursor :: (LineEdit :< cls, Object :< cls) => cls -> GodotString -> IO () append_at_cursor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_append_at_cursor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "append_at_cursor" '[GodotString] (IO ()) where nodeMethod = Godot.Core.LineEdit.append_at_cursor {-# NOINLINE bindLineEdit_clear #-} -- | Erases the @LineEdit@'s @text@. bindLineEdit_clear :: MethodBind bindLineEdit_clear = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Erases the @LineEdit@'s @text@. clear :: (LineEdit :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "clear" '[] (IO ()) where nodeMethod = Godot.Core.LineEdit.clear {-# NOINLINE bindLineEdit_cursor_get_blink_enabled #-} -- | If @true@, the caret (visual cursor) blinks. bindLineEdit_cursor_get_blink_enabled :: MethodBind bindLineEdit_cursor_get_blink_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "cursor_get_blink_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the caret (visual cursor) blinks. cursor_get_blink_enabled :: (LineEdit :< cls, Object :< cls) => cls -> IO Bool cursor_get_blink_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_cursor_get_blink_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "cursor_get_blink_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.LineEdit.cursor_get_blink_enabled {-# NOINLINE bindLineEdit_cursor_get_blink_speed #-} -- | Duration (in seconds) of a caret's blinking cycle. bindLineEdit_cursor_get_blink_speed :: MethodBind bindLineEdit_cursor_get_blink_speed = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "cursor_get_blink_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Duration (in seconds) of a caret's blinking cycle. cursor_get_blink_speed :: (LineEdit :< cls, Object :< cls) => cls -> IO Float cursor_get_blink_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_cursor_get_blink_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "cursor_get_blink_speed" '[] (IO Float) where nodeMethod = Godot.Core.LineEdit.cursor_get_blink_speed {-# NOINLINE bindLineEdit_cursor_set_blink_enabled #-} -- | If @true@, the caret (visual cursor) blinks. bindLineEdit_cursor_set_blink_enabled :: MethodBind bindLineEdit_cursor_set_blink_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "cursor_set_blink_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the caret (visual cursor) blinks. cursor_set_blink_enabled :: (LineEdit :< cls, Object :< cls) => cls -> Bool -> IO () cursor_set_blink_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_cursor_set_blink_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "cursor_set_blink_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.LineEdit.cursor_set_blink_enabled {-# NOINLINE bindLineEdit_cursor_set_blink_speed #-} -- | Duration (in seconds) of a caret's blinking cycle. bindLineEdit_cursor_set_blink_speed :: MethodBind bindLineEdit_cursor_set_blink_speed = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "cursor_set_blink_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Duration (in seconds) of a caret's blinking cycle. cursor_set_blink_speed :: (LineEdit :< cls, Object :< cls) => cls -> Float -> IO () cursor_set_blink_speed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_cursor_set_blink_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "cursor_set_blink_speed" '[Float] (IO ()) where nodeMethod = Godot.Core.LineEdit.cursor_set_blink_speed {-# NOINLINE bindLineEdit_deselect #-} -- | Clears the current selection. bindLineEdit_deselect :: MethodBind bindLineEdit_deselect = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "deselect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the current selection. deselect :: (LineEdit :< cls, Object :< cls) => cls -> IO () deselect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_deselect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "deselect" '[] (IO ()) where nodeMethod = Godot.Core.LineEdit.deselect {-# NOINLINE bindLineEdit_get_align #-} -- | Text alignment as defined in the @enum Align@ enum. bindLineEdit_get_align :: MethodBind bindLineEdit_get_align = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Text alignment as defined in the @enum Align@ enum. get_align :: (LineEdit :< cls, Object :< cls) => cls -> IO Int get_align cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_align" '[] (IO Int) where nodeMethod = Godot.Core.LineEdit.get_align {-# NOINLINE bindLineEdit_get_cursor_position #-} -- | The cursor's position inside the @LineEdit@. When set, the text may scroll to accommodate it. bindLineEdit_get_cursor_position :: MethodBind bindLineEdit_get_cursor_position = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_cursor_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The cursor's position inside the @LineEdit@. When set, the text may scroll to accommodate it. get_cursor_position :: (LineEdit :< cls, Object :< cls) => cls -> IO Int get_cursor_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_cursor_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_cursor_position" '[] (IO Int) where nodeMethod = Godot.Core.LineEdit.get_cursor_position {-# NOINLINE bindLineEdit_get_expand_to_text_length #-} -- | If @true@, the @LineEdit@ width will increase to stay longer than the @text@. It will __not__ compress if the @text@ is shortened. bindLineEdit_get_expand_to_text_length :: MethodBind bindLineEdit_get_expand_to_text_length = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_expand_to_text_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @LineEdit@ width will increase to stay longer than the @text@. It will __not__ compress if the @text@ is shortened. get_expand_to_text_length :: (LineEdit :< cls, Object :< cls) => cls -> IO Bool get_expand_to_text_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_expand_to_text_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_expand_to_text_length" '[] (IO Bool) where nodeMethod = Godot.Core.LineEdit.get_expand_to_text_length {-# NOINLINE bindLineEdit_get_max_length #-} -- | Maximum amount of characters that can be entered inside the @LineEdit@. If @0@, there is no limit. bindLineEdit_get_max_length :: MethodBind bindLineEdit_get_max_length = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_max_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum amount of characters that can be entered inside the @LineEdit@. If @0@, there is no limit. get_max_length :: (LineEdit :< cls, Object :< cls) => cls -> IO Int get_max_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_max_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_max_length" '[] (IO Int) where nodeMethod = Godot.Core.LineEdit.get_max_length {-# NOINLINE bindLineEdit_get_menu #-} -- | Returns the @PopupMenu@ of this @LineEdit@. By default, this menu is displayed when right-clicking on the @LineEdit@. bindLineEdit_get_menu :: MethodBind bindLineEdit_get_menu = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_menu" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @PopupMenu@ of this @LineEdit@. By default, this menu is displayed when right-clicking on the @LineEdit@. get_menu :: (LineEdit :< cls, Object :< cls) => cls -> IO PopupMenu get_menu cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_menu (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_menu" '[] (IO PopupMenu) where nodeMethod = Godot.Core.LineEdit.get_menu {-# NOINLINE bindLineEdit_get_placeholder #-} -- | Text shown when the @LineEdit@ is empty. It is __not__ the @LineEdit@'s default value (see @text@). bindLineEdit_get_placeholder :: MethodBind bindLineEdit_get_placeholder = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_placeholder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Text shown when the @LineEdit@ is empty. It is __not__ the @LineEdit@'s default value (see @text@). get_placeholder :: (LineEdit :< cls, Object :< cls) => cls -> IO GodotString get_placeholder cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_placeholder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_placeholder" '[] (IO GodotString) where nodeMethod = Godot.Core.LineEdit.get_placeholder {-# NOINLINE bindLineEdit_get_placeholder_alpha #-} -- | Opacity of the @placeholder_text@. From @0@ to @1@. bindLineEdit_get_placeholder_alpha :: MethodBind bindLineEdit_get_placeholder_alpha = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_placeholder_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opacity of the @placeholder_text@. From @0@ to @1@. get_placeholder_alpha :: (LineEdit :< cls, Object :< cls) => cls -> IO Float get_placeholder_alpha cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_placeholder_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_placeholder_alpha" '[] (IO Float) where nodeMethod = Godot.Core.LineEdit.get_placeholder_alpha {-# NOINLINE bindLineEdit_get_right_icon #-} -- | Sets the icon that will appear in the right end of the @LineEdit@ if there's no @text@, or always, if @clear_button_enabled@ is set to @false@. bindLineEdit_get_right_icon :: MethodBind bindLineEdit_get_right_icon = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_right_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the icon that will appear in the right end of the @LineEdit@ if there's no @text@, or always, if @clear_button_enabled@ is set to @false@. get_right_icon :: (LineEdit :< cls, Object :< cls) => cls -> IO Texture get_right_icon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_right_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_right_icon" '[] (IO Texture) where nodeMethod = Godot.Core.LineEdit.get_right_icon {-# NOINLINE bindLineEdit_get_secret_character #-} -- | The character to use to mask secret input (defaults to "*"). Only a single character can be used as the secret character. bindLineEdit_get_secret_character :: MethodBind bindLineEdit_get_secret_character = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_secret_character" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The character to use to mask secret input (defaults to "*"). Only a single character can be used as the secret character. get_secret_character :: (LineEdit :< cls, Object :< cls) => cls -> IO GodotString get_secret_character cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_secret_character (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_secret_character" '[] (IO GodotString) where nodeMethod = Godot.Core.LineEdit.get_secret_character {-# NOINLINE bindLineEdit_get_text #-} -- | String value of the @LineEdit@. -- __Note:__ Changing text using this property won't emit the @signal text_changed@ signal. bindLineEdit_get_text :: MethodBind bindLineEdit_get_text = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | String value of the @LineEdit@. -- __Note:__ Changing text using this property won't emit the @signal text_changed@ signal. get_text :: (LineEdit :< cls, Object :< cls) => cls -> IO GodotString get_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "get_text" '[] (IO GodotString) where nodeMethod = Godot.Core.LineEdit.get_text {-# NOINLINE bindLineEdit_is_clear_button_enabled #-} -- | If @true@, the @LineEdit@ will show a clear button if @text@ is not empty, which can be used to clear the text quickly. bindLineEdit_is_clear_button_enabled :: MethodBind bindLineEdit_is_clear_button_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "is_clear_button_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @LineEdit@ will show a clear button if @text@ is not empty, which can be used to clear the text quickly. is_clear_button_enabled :: (LineEdit :< cls, Object :< cls) => cls -> IO Bool is_clear_button_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_is_clear_button_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "is_clear_button_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.LineEdit.is_clear_button_enabled {-# NOINLINE bindLineEdit_is_context_menu_enabled #-} -- | If @true@, the context menu will appear when right-clicked. bindLineEdit_is_context_menu_enabled :: MethodBind bindLineEdit_is_context_menu_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "is_context_menu_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the context menu will appear when right-clicked. is_context_menu_enabled :: (LineEdit :< cls, Object :< cls) => cls -> IO Bool is_context_menu_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_is_context_menu_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "is_context_menu_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.LineEdit.is_context_menu_enabled {-# NOINLINE bindLineEdit_is_editable #-} -- | If @false@, existing text cannot be modified and new text cannot be added. bindLineEdit_is_editable :: MethodBind bindLineEdit_is_editable = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "is_editable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @false@, existing text cannot be modified and new text cannot be added. is_editable :: (LineEdit :< cls, Object :< cls) => cls -> IO Bool is_editable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_is_editable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "is_editable" '[] (IO Bool) where nodeMethod = Godot.Core.LineEdit.is_editable {-# NOINLINE bindLineEdit_is_secret #-} -- | If @true@, every character is replaced with the secret character (see @secret_character@). bindLineEdit_is_secret :: MethodBind bindLineEdit_is_secret = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "is_secret" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, every character is replaced with the secret character (see @secret_character@). is_secret :: (LineEdit :< cls, Object :< cls) => cls -> IO Bool is_secret cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_is_secret (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "is_secret" '[] (IO Bool) where nodeMethod = Godot.Core.LineEdit.is_secret {-# NOINLINE bindLineEdit_is_selecting_enabled #-} -- | If @false@, it's impossible to select the text using mouse nor keyboard. bindLineEdit_is_selecting_enabled :: MethodBind bindLineEdit_is_selecting_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "is_selecting_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @false@, it's impossible to select the text using mouse nor keyboard. is_selecting_enabled :: (LineEdit :< cls, Object :< cls) => cls -> IO Bool is_selecting_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_is_selecting_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "is_selecting_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.LineEdit.is_selecting_enabled {-# NOINLINE bindLineEdit_is_shortcut_keys_enabled #-} -- | If @false@, using shortcuts will be disabled. bindLineEdit_is_shortcut_keys_enabled :: MethodBind bindLineEdit_is_shortcut_keys_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "is_shortcut_keys_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @false@, using shortcuts will be disabled. is_shortcut_keys_enabled :: (LineEdit :< cls, Object :< cls) => cls -> IO Bool is_shortcut_keys_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_is_shortcut_keys_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "is_shortcut_keys_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.LineEdit.is_shortcut_keys_enabled {-# NOINLINE bindLineEdit_menu_option #-} -- | Executes a given action as defined in the @enum MenuItems@ enum. bindLineEdit_menu_option :: MethodBind bindLineEdit_menu_option = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "menu_option" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Executes a given action as defined in the @enum MenuItems@ enum. menu_option :: (LineEdit :< cls, Object :< cls) => cls -> Int -> IO () menu_option cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_menu_option (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "menu_option" '[Int] (IO ()) where nodeMethod = Godot.Core.LineEdit.menu_option {-# NOINLINE bindLineEdit_select #-} -- | Selects characters inside @LineEdit@ between @from@ and @to@. By default, @from@ is at the beginning and @to@ at the end. -- -- @ -- -- text = "Welcome" -- select() # Will select "Welcome". -- select(4) # Will select "ome". -- select(2, 5) # Will select "lco". -- -- @ bindLineEdit_select :: MethodBind bindLineEdit_select = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Selects characters inside @LineEdit@ between @from@ and @to@. By default, @from@ is at the beginning and @to@ at the end. -- -- @ -- -- text = "Welcome" -- select() # Will select "Welcome". -- select(4) # Will select "ome". -- select(2, 5) # Will select "lco". -- -- @ select :: (LineEdit :< cls, Object :< cls) => cls -> Maybe Int -> Maybe Int -> IO () select cls arg1 arg2 = withVariantArray [maybe (VariantInt (0)) toVariant arg1, maybe (VariantInt (-1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "select" '[Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.LineEdit.select {-# NOINLINE bindLineEdit_select_all #-} -- | Selects the whole @String@. bindLineEdit_select_all :: MethodBind bindLineEdit_select_all = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "select_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Selects the whole @String@. select_all :: (LineEdit :< cls, Object :< cls) => cls -> IO () select_all cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_select_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "select_all" '[] (IO ()) where nodeMethod = Godot.Core.LineEdit.select_all {-# NOINLINE bindLineEdit_set_align #-} -- | Text alignment as defined in the @enum Align@ enum. bindLineEdit_set_align :: MethodBind bindLineEdit_set_align = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Text alignment as defined in the @enum Align@ enum. set_align :: (LineEdit :< cls, Object :< cls) => cls -> Int -> IO () set_align cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_align" '[Int] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_align {-# NOINLINE bindLineEdit_set_clear_button_enabled #-} -- | If @true@, the @LineEdit@ will show a clear button if @text@ is not empty, which can be used to clear the text quickly. bindLineEdit_set_clear_button_enabled :: MethodBind bindLineEdit_set_clear_button_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_clear_button_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @LineEdit@ will show a clear button if @text@ is not empty, which can be used to clear the text quickly. set_clear_button_enabled :: (LineEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_clear_button_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_clear_button_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_clear_button_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_clear_button_enabled {-# NOINLINE bindLineEdit_set_context_menu_enabled #-} -- | If @true@, the context menu will appear when right-clicked. bindLineEdit_set_context_menu_enabled :: MethodBind bindLineEdit_set_context_menu_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_context_menu_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the context menu will appear when right-clicked. set_context_menu_enabled :: (LineEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_context_menu_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_context_menu_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_context_menu_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_context_menu_enabled {-# NOINLINE bindLineEdit_set_cursor_position #-} -- | The cursor's position inside the @LineEdit@. When set, the text may scroll to accommodate it. bindLineEdit_set_cursor_position :: MethodBind bindLineEdit_set_cursor_position = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_cursor_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The cursor's position inside the @LineEdit@. When set, the text may scroll to accommodate it. set_cursor_position :: (LineEdit :< cls, Object :< cls) => cls -> Int -> IO () set_cursor_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_cursor_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_cursor_position" '[Int] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_cursor_position {-# NOINLINE bindLineEdit_set_editable #-} -- | If @false@, existing text cannot be modified and new text cannot be added. bindLineEdit_set_editable :: MethodBind bindLineEdit_set_editable = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_editable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @false@, existing text cannot be modified and new text cannot be added. set_editable :: (LineEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_editable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_editable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_editable" '[Bool] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_editable {-# NOINLINE bindLineEdit_set_expand_to_text_length #-} -- | If @true@, the @LineEdit@ width will increase to stay longer than the @text@. It will __not__ compress if the @text@ is shortened. bindLineEdit_set_expand_to_text_length :: MethodBind bindLineEdit_set_expand_to_text_length = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_expand_to_text_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @LineEdit@ width will increase to stay longer than the @text@. It will __not__ compress if the @text@ is shortened. set_expand_to_text_length :: (LineEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_expand_to_text_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_expand_to_text_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_expand_to_text_length" '[Bool] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_expand_to_text_length {-# NOINLINE bindLineEdit_set_max_length #-} -- | Maximum amount of characters that can be entered inside the @LineEdit@. If @0@, there is no limit. bindLineEdit_set_max_length :: MethodBind bindLineEdit_set_max_length = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_max_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum amount of characters that can be entered inside the @LineEdit@. If @0@, there is no limit. set_max_length :: (LineEdit :< cls, Object :< cls) => cls -> Int -> IO () set_max_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_max_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_max_length" '[Int] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_max_length {-# NOINLINE bindLineEdit_set_placeholder #-} -- | Text shown when the @LineEdit@ is empty. It is __not__ the @LineEdit@'s default value (see @text@). bindLineEdit_set_placeholder :: MethodBind bindLineEdit_set_placeholder = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_placeholder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Text shown when the @LineEdit@ is empty. It is __not__ the @LineEdit@'s default value (see @text@). set_placeholder :: (LineEdit :< cls, Object :< cls) => cls -> GodotString -> IO () set_placeholder cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_placeholder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_placeholder" '[GodotString] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_placeholder {-# NOINLINE bindLineEdit_set_placeholder_alpha #-} -- | Opacity of the @placeholder_text@. From @0@ to @1@. bindLineEdit_set_placeholder_alpha :: MethodBind bindLineEdit_set_placeholder_alpha = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_placeholder_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opacity of the @placeholder_text@. From @0@ to @1@. set_placeholder_alpha :: (LineEdit :< cls, Object :< cls) => cls -> Float -> IO () set_placeholder_alpha cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_placeholder_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_placeholder_alpha" '[Float] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_placeholder_alpha {-# NOINLINE bindLineEdit_set_right_icon #-} -- | Sets the icon that will appear in the right end of the @LineEdit@ if there's no @text@, or always, if @clear_button_enabled@ is set to @false@. bindLineEdit_set_right_icon :: MethodBind bindLineEdit_set_right_icon = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_right_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the icon that will appear in the right end of the @LineEdit@ if there's no @text@, or always, if @clear_button_enabled@ is set to @false@. set_right_icon :: (LineEdit :< cls, Object :< cls) => cls -> Texture -> IO () set_right_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_right_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_right_icon" '[Texture] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_right_icon {-# NOINLINE bindLineEdit_set_secret #-} -- | If @true@, every character is replaced with the secret character (see @secret_character@). bindLineEdit_set_secret :: MethodBind bindLineEdit_set_secret = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_secret" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, every character is replaced with the secret character (see @secret_character@). set_secret :: (LineEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_secret cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_secret (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_secret" '[Bool] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_secret {-# NOINLINE bindLineEdit_set_secret_character #-} -- | The character to use to mask secret input (defaults to "*"). Only a single character can be used as the secret character. bindLineEdit_set_secret_character :: MethodBind bindLineEdit_set_secret_character = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_secret_character" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The character to use to mask secret input (defaults to "*"). Only a single character can be used as the secret character. set_secret_character :: (LineEdit :< cls, Object :< cls) => cls -> GodotString -> IO () set_secret_character cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_secret_character (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_secret_character" '[GodotString] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_secret_character {-# NOINLINE bindLineEdit_set_selecting_enabled #-} -- | If @false@, it's impossible to select the text using mouse nor keyboard. bindLineEdit_set_selecting_enabled :: MethodBind bindLineEdit_set_selecting_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_selecting_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @false@, it's impossible to select the text using mouse nor keyboard. set_selecting_enabled :: (LineEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_selecting_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_selecting_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_selecting_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_selecting_enabled {-# NOINLINE bindLineEdit_set_shortcut_keys_enabled #-} -- | If @false@, using shortcuts will be disabled. bindLineEdit_set_shortcut_keys_enabled :: MethodBind bindLineEdit_set_shortcut_keys_enabled = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_shortcut_keys_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @false@, using shortcuts will be disabled. set_shortcut_keys_enabled :: (LineEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_shortcut_keys_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_shortcut_keys_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_shortcut_keys_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_shortcut_keys_enabled {-# NOINLINE bindLineEdit_set_text #-} -- | String value of the @LineEdit@. -- __Note:__ Changing text using this property won't emit the @signal text_changed@ signal. bindLineEdit_set_text :: MethodBind bindLineEdit_set_text = unsafePerformIO $ withCString "LineEdit" $ \ clsNamePtr -> withCString "set_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | String value of the @LineEdit@. -- __Note:__ Changing text using this property won't emit the @signal text_changed@ signal. set_text :: (LineEdit :< cls, Object :< cls) => cls -> GodotString -> IO () set_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineEdit_set_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineEdit "set_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.LineEdit.set_text ================================================ FILE: src/Godot/Core/LineShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.LineShape2D (Godot.Core.LineShape2D.get_d, Godot.Core.LineShape2D.get_normal, Godot.Core.LineShape2D.set_d, Godot.Core.LineShape2D.set_normal) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape2D() instance NodeProperty LineShape2D "d" Float 'False where nodeProperty = (get_d, wrapDroppingSetter set_d, Nothing) instance NodeProperty LineShape2D "normal" Vector2 'False where nodeProperty = (get_normal, wrapDroppingSetter set_normal, Nothing) {-# NOINLINE bindLineShape2D_get_d #-} -- | The line's distance from the origin. bindLineShape2D_get_d :: MethodBind bindLineShape2D_get_d = unsafePerformIO $ withCString "LineShape2D" $ \ clsNamePtr -> withCString "get_d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's distance from the origin. get_d :: (LineShape2D :< cls, Object :< cls) => cls -> IO Float get_d cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineShape2D_get_d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineShape2D "get_d" '[] (IO Float) where nodeMethod = Godot.Core.LineShape2D.get_d {-# NOINLINE bindLineShape2D_get_normal #-} -- | The line's normal. bindLineShape2D_get_normal :: MethodBind bindLineShape2D_get_normal = unsafePerformIO $ withCString "LineShape2D" $ \ clsNamePtr -> withCString "get_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's normal. get_normal :: (LineShape2D :< cls, Object :< cls) => cls -> IO Vector2 get_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLineShape2D_get_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineShape2D "get_normal" '[] (IO Vector2) where nodeMethod = Godot.Core.LineShape2D.get_normal {-# NOINLINE bindLineShape2D_set_d #-} -- | The line's distance from the origin. bindLineShape2D_set_d :: MethodBind bindLineShape2D_set_d = unsafePerformIO $ withCString "LineShape2D" $ \ clsNamePtr -> withCString "set_d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's distance from the origin. set_d :: (LineShape2D :< cls, Object :< cls) => cls -> Float -> IO () set_d cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineShape2D_set_d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineShape2D "set_d" '[Float] (IO ()) where nodeMethod = Godot.Core.LineShape2D.set_d {-# NOINLINE bindLineShape2D_set_normal #-} -- | The line's normal. bindLineShape2D_set_normal :: MethodBind bindLineShape2D_set_normal = unsafePerformIO $ withCString "LineShape2D" $ \ clsNamePtr -> withCString "set_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's normal. set_normal :: (LineShape2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLineShape2D_set_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LineShape2D "set_normal" '[Vector2] (IO ()) where nodeMethod = Godot.Core.LineShape2D.set_normal ================================================ FILE: src/Godot/Core/LinkButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.LinkButton (Godot.Core.LinkButton._UNDERLINE_MODE_ALWAYS, Godot.Core.LinkButton._UNDERLINE_MODE_NEVER, Godot.Core.LinkButton._UNDERLINE_MODE_ON_HOVER, Godot.Core.LinkButton.get_text, Godot.Core.LinkButton.get_underline_mode, Godot.Core.LinkButton.set_text, Godot.Core.LinkButton.set_underline_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.BaseButton() _UNDERLINE_MODE_ALWAYS :: Int _UNDERLINE_MODE_ALWAYS = 0 _UNDERLINE_MODE_NEVER :: Int _UNDERLINE_MODE_NEVER = 2 _UNDERLINE_MODE_ON_HOVER :: Int _UNDERLINE_MODE_ON_HOVER = 1 instance NodeProperty LinkButton "text" GodotString 'False where nodeProperty = (get_text, wrapDroppingSetter set_text, Nothing) instance NodeProperty LinkButton "underline" Int 'False where nodeProperty = (get_underline_mode, wrapDroppingSetter set_underline_mode, Nothing) {-# NOINLINE bindLinkButton_get_text #-} -- | The button's text that will be displayed inside the button's area. bindLinkButton_get_text :: MethodBind bindLinkButton_get_text = unsafePerformIO $ withCString "LinkButton" $ \ clsNamePtr -> withCString "get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's text that will be displayed inside the button's area. get_text :: (LinkButton :< cls, Object :< cls) => cls -> IO GodotString get_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLinkButton_get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LinkButton "get_text" '[] (IO GodotString) where nodeMethod = Godot.Core.LinkButton.get_text {-# NOINLINE bindLinkButton_get_underline_mode #-} -- | Determines when to show the underline. See @enum UnderlineMode@ for options. bindLinkButton_get_underline_mode :: MethodBind bindLinkButton_get_underline_mode = unsafePerformIO $ withCString "LinkButton" $ \ clsNamePtr -> withCString "get_underline_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines when to show the underline. See @enum UnderlineMode@ for options. get_underline_mode :: (LinkButton :< cls, Object :< cls) => cls -> IO Int get_underline_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindLinkButton_get_underline_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LinkButton "get_underline_mode" '[] (IO Int) where nodeMethod = Godot.Core.LinkButton.get_underline_mode {-# NOINLINE bindLinkButton_set_text #-} -- | The button's text that will be displayed inside the button's area. bindLinkButton_set_text :: MethodBind bindLinkButton_set_text = unsafePerformIO $ withCString "LinkButton" $ \ clsNamePtr -> withCString "set_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's text that will be displayed inside the button's area. set_text :: (LinkButton :< cls, Object :< cls) => cls -> GodotString -> IO () set_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLinkButton_set_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LinkButton "set_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.LinkButton.set_text {-# NOINLINE bindLinkButton_set_underline_mode #-} -- | Determines when to show the underline. See @enum UnderlineMode@ for options. bindLinkButton_set_underline_mode :: MethodBind bindLinkButton_set_underline_mode = unsafePerformIO $ withCString "LinkButton" $ \ clsNamePtr -> withCString "set_underline_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines when to show the underline. See @enum UnderlineMode@ for options. set_underline_mode :: (LinkButton :< cls, Object :< cls) => cls -> Int -> IO () set_underline_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindLinkButton_set_underline_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod LinkButton "set_underline_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.LinkButton.set_underline_mode ================================================ FILE: src/Godot/Core/Listener.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Listener (Godot.Core.Listener.clear_current, Godot.Core.Listener.get_listener_transform, Godot.Core.Listener.is_current, Godot.Core.Listener.make_current) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() {-# NOINLINE bindListener_clear_current #-} -- | Disables the listener to use the current camera's listener instead. bindListener_clear_current :: MethodBind bindListener_clear_current = unsafePerformIO $ withCString "Listener" $ \ clsNamePtr -> withCString "clear_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables the listener to use the current camera's listener instead. clear_current :: (Listener :< cls, Object :< cls) => cls -> IO () clear_current cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindListener_clear_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Listener "clear_current" '[] (IO ()) where nodeMethod = Godot.Core.Listener.clear_current {-# NOINLINE bindListener_get_listener_transform #-} -- | Returns the listener's global orthonormalized @Transform@. bindListener_get_listener_transform :: MethodBind bindListener_get_listener_transform = unsafePerformIO $ withCString "Listener" $ \ clsNamePtr -> withCString "get_listener_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the listener's global orthonormalized @Transform@. get_listener_transform :: (Listener :< cls, Object :< cls) => cls -> IO Transform get_listener_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindListener_get_listener_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Listener "get_listener_transform" '[] (IO Transform) where nodeMethod = Godot.Core.Listener.get_listener_transform {-# NOINLINE bindListener_is_current #-} -- | Returns @true@ if the listener was made current using @method make_current@, @false@ otherwise. -- __Note:__ There may be more than one Listener marked as "current" in the scene tree, but only the one that was made current last will be used. bindListener_is_current :: MethodBind bindListener_is_current = unsafePerformIO $ withCString "Listener" $ \ clsNamePtr -> withCString "is_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the listener was made current using @method make_current@, @false@ otherwise. -- __Note:__ There may be more than one Listener marked as "current" in the scene tree, but only the one that was made current last will be used. is_current :: (Listener :< cls, Object :< cls) => cls -> IO Bool is_current cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindListener_is_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Listener "is_current" '[] (IO Bool) where nodeMethod = Godot.Core.Listener.is_current {-# NOINLINE bindListener_make_current #-} -- | Enables the listener. This will override the current camera's listener. bindListener_make_current :: MethodBind bindListener_make_current = unsafePerformIO $ withCString "Listener" $ \ clsNamePtr -> withCString "make_current" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables the listener. This will override the current camera's listener. make_current :: (Listener :< cls, Object :< cls) => cls -> IO () make_current cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindListener_make_current (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Listener "make_current" '[] (IO ()) where nodeMethod = Godot.Core.Listener.make_current ================================================ FILE: src/Godot/Core/MainLoop.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MainLoop (Godot.Core.MainLoop._NOTIFICATION_WM_ABOUT, Godot.Core.MainLoop._NOTIFICATION_APP_PAUSED, Godot.Core.MainLoop._NOTIFICATION_WM_GO_BACK_REQUEST, Godot.Core.MainLoop._NOTIFICATION_WM_QUIT_REQUEST, Godot.Core.MainLoop._NOTIFICATION_WM_FOCUS_IN, Godot.Core.MainLoop._NOTIFICATION_WM_MOUSE_EXIT, Godot.Core.MainLoop._NOTIFICATION_TRANSLATION_CHANGED, Godot.Core.MainLoop._NOTIFICATION_WM_FOCUS_OUT, Godot.Core.MainLoop._NOTIFICATION_OS_MEMORY_WARNING, Godot.Core.MainLoop._NOTIFICATION_WM_UNFOCUS_REQUEST, Godot.Core.MainLoop._NOTIFICATION_OS_IME_UPDATE, Godot.Core.MainLoop._NOTIFICATION_APP_RESUMED, Godot.Core.MainLoop._NOTIFICATION_WM_MOUSE_ENTER, Godot.Core.MainLoop._NOTIFICATION_CRASH, Godot.Core.MainLoop.sig_on_request_permissions_result, Godot.Core.MainLoop._drop_files, Godot.Core.MainLoop._finalize, Godot.Core.MainLoop._global_menu_action, Godot.Core.MainLoop._idle, Godot.Core.MainLoop._initialize, Godot.Core.MainLoop._input_event, Godot.Core.MainLoop._input_text, Godot.Core.MainLoop._iteration, Godot.Core.MainLoop.finish, Godot.Core.MainLoop.idle, Godot.Core.MainLoop.init, Godot.Core.MainLoop.input_event, Godot.Core.MainLoop.input_text, Godot.Core.MainLoop.iteration) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _NOTIFICATION_WM_ABOUT :: Int _NOTIFICATION_WM_ABOUT = 1011 _NOTIFICATION_APP_PAUSED :: Int _NOTIFICATION_APP_PAUSED = 1015 _NOTIFICATION_WM_GO_BACK_REQUEST :: Int _NOTIFICATION_WM_GO_BACK_REQUEST = 1007 _NOTIFICATION_WM_QUIT_REQUEST :: Int _NOTIFICATION_WM_QUIT_REQUEST = 1006 _NOTIFICATION_WM_FOCUS_IN :: Int _NOTIFICATION_WM_FOCUS_IN = 1004 _NOTIFICATION_WM_MOUSE_EXIT :: Int _NOTIFICATION_WM_MOUSE_EXIT = 1003 _NOTIFICATION_TRANSLATION_CHANGED :: Int _NOTIFICATION_TRANSLATION_CHANGED = 1010 _NOTIFICATION_WM_FOCUS_OUT :: Int _NOTIFICATION_WM_FOCUS_OUT = 1005 _NOTIFICATION_OS_MEMORY_WARNING :: Int _NOTIFICATION_OS_MEMORY_WARNING = 1009 _NOTIFICATION_WM_UNFOCUS_REQUEST :: Int _NOTIFICATION_WM_UNFOCUS_REQUEST = 1008 _NOTIFICATION_OS_IME_UPDATE :: Int _NOTIFICATION_OS_IME_UPDATE = 1013 _NOTIFICATION_APP_RESUMED :: Int _NOTIFICATION_APP_RESUMED = 1014 _NOTIFICATION_WM_MOUSE_ENTER :: Int _NOTIFICATION_WM_MOUSE_ENTER = 1002 _NOTIFICATION_CRASH :: Int _NOTIFICATION_CRASH = 1012 -- | Emitted when a user responds to a permission request. sig_on_request_permissions_result :: Godot.Internal.Dispatch.Signal MainLoop sig_on_request_permissions_result = Godot.Internal.Dispatch.Signal "on_request_permissions_result" instance NodeSignal MainLoop "on_request_permissions_result" '[GodotString, Bool] {-# NOINLINE bindMainLoop__drop_files #-} -- | Called when files are dragged from the OS file manager and dropped in the game window. The arguments are a list of file paths and the identifier of the screen where the drag originated. bindMainLoop__drop_files :: MethodBind bindMainLoop__drop_files = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "_drop_files" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when files are dragged from the OS file manager and dropped in the game window. The arguments are a list of file paths and the identifier of the screen where the drag originated. _drop_files :: (MainLoop :< cls, Object :< cls) => cls -> PoolStringArray -> Int -> IO () _drop_files cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop__drop_files (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "_drop_files" '[PoolStringArray, Int] (IO ()) where nodeMethod = Godot.Core.MainLoop._drop_files {-# NOINLINE bindMainLoop__finalize #-} -- | Called before the program exits. bindMainLoop__finalize :: MethodBind bindMainLoop__finalize = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "_finalize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called before the program exits. _finalize :: (MainLoop :< cls, Object :< cls) => cls -> IO () _finalize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop__finalize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "_finalize" '[] (IO ()) where nodeMethod = Godot.Core.MainLoop._finalize {-# NOINLINE bindMainLoop__global_menu_action #-} -- | Called when the user performs an action in the system global menu (e.g. the Mac OS menu bar). bindMainLoop__global_menu_action :: MethodBind bindMainLoop__global_menu_action = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "_global_menu_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when the user performs an action in the system global menu (e.g. the Mac OS menu bar). _global_menu_action :: (MainLoop :< cls, Object :< cls) => cls -> GodotVariant -> GodotVariant -> IO () _global_menu_action cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop__global_menu_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "_global_menu_action" '[GodotVariant, GodotVariant] (IO ()) where nodeMethod = Godot.Core.MainLoop._global_menu_action {-# NOINLINE bindMainLoop__idle #-} -- | Called each idle frame with the time since the last idle frame as argument (in seconds). Equivalent to @method Node._process@. -- If implemented, the method must return a boolean value. @true@ ends the main loop, while @false@ lets it proceed to the next frame. bindMainLoop__idle :: MethodBind bindMainLoop__idle = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "_idle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called each idle frame with the time since the last idle frame as argument (in seconds). Equivalent to @method Node._process@. -- If implemented, the method must return a boolean value. @true@ ends the main loop, while @false@ lets it proceed to the next frame. _idle :: (MainLoop :< cls, Object :< cls) => cls -> Float -> IO Bool _idle cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop__idle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "_idle" '[Float] (IO Bool) where nodeMethod = Godot.Core.MainLoop._idle {-# NOINLINE bindMainLoop__initialize #-} -- | Called once during initialization. bindMainLoop__initialize :: MethodBind bindMainLoop__initialize = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "_initialize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called once during initialization. _initialize :: (MainLoop :< cls, Object :< cls) => cls -> IO () _initialize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop__initialize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "_initialize" '[] (IO ()) where nodeMethod = Godot.Core.MainLoop._initialize {-# NOINLINE bindMainLoop__input_event #-} -- | Called whenever an @InputEvent@ is received by the main loop. bindMainLoop__input_event :: MethodBind bindMainLoop__input_event = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "_input_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called whenever an @InputEvent@ is received by the main loop. _input_event :: (MainLoop :< cls, Object :< cls) => cls -> InputEvent -> IO () _input_event cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop__input_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "_input_event" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.MainLoop._input_event {-# NOINLINE bindMainLoop__input_text #-} -- | Deprecated callback, does not do anything. Use @method _input_event@ to parse text input. Will be removed in Godot 4.0. bindMainLoop__input_text :: MethodBind bindMainLoop__input_text = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "_input_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deprecated callback, does not do anything. Use @method _input_event@ to parse text input. Will be removed in Godot 4.0. _input_text :: (MainLoop :< cls, Object :< cls) => cls -> GodotString -> IO () _input_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop__input_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "_input_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.MainLoop._input_text {-# NOINLINE bindMainLoop__iteration #-} -- | Called each physics frame with the time since the last physics frame as argument (in seconds). Equivalent to @method Node._physics_process@. -- If implemented, the method must return a boolean value. @true@ ends the main loop, while @false@ lets it proceed to the next frame. bindMainLoop__iteration :: MethodBind bindMainLoop__iteration = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "_iteration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called each physics frame with the time since the last physics frame as argument (in seconds). Equivalent to @method Node._physics_process@. -- If implemented, the method must return a boolean value. @true@ ends the main loop, while @false@ lets it proceed to the next frame. _iteration :: (MainLoop :< cls, Object :< cls) => cls -> Float -> IO Bool _iteration cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop__iteration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "_iteration" '[Float] (IO Bool) where nodeMethod = Godot.Core.MainLoop._iteration {-# NOINLINE bindMainLoop_finish #-} -- | Should not be called manually, override @method _finalize@ instead. Will be removed in Godot 4.0. bindMainLoop_finish :: MethodBind bindMainLoop_finish = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "finish" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Should not be called manually, override @method _finalize@ instead. Will be removed in Godot 4.0. finish :: (MainLoop :< cls, Object :< cls) => cls -> IO () finish cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop_finish (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "finish" '[] (IO ()) where nodeMethod = Godot.Core.MainLoop.finish {-# NOINLINE bindMainLoop_idle #-} -- | Should not be called manually, override @method _idle@ instead. Will be removed in Godot 4.0. bindMainLoop_idle :: MethodBind bindMainLoop_idle = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "idle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Should not be called manually, override @method _idle@ instead. Will be removed in Godot 4.0. idle :: (MainLoop :< cls, Object :< cls) => cls -> Float -> IO Bool idle cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop_idle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "idle" '[Float] (IO Bool) where nodeMethod = Godot.Core.MainLoop.idle {-# NOINLINE bindMainLoop_init #-} -- | Should not be called manually, override @method _initialize@ instead. Will be removed in Godot 4.0. bindMainLoop_init :: MethodBind bindMainLoop_init = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "init" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Should not be called manually, override @method _initialize@ instead. Will be removed in Godot 4.0. init :: (MainLoop :< cls, Object :< cls) => cls -> IO () init cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop_init (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "init" '[] (IO ()) where nodeMethod = Godot.Core.MainLoop.init {-# NOINLINE bindMainLoop_input_event #-} -- | Should not be called manually, override @method _input_event@ instead. Will be removed in Godot 4.0. bindMainLoop_input_event :: MethodBind bindMainLoop_input_event = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "input_event" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Should not be called manually, override @method _input_event@ instead. Will be removed in Godot 4.0. input_event :: (MainLoop :< cls, Object :< cls) => cls -> InputEvent -> IO () input_event cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop_input_event (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "input_event" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.MainLoop.input_event {-# NOINLINE bindMainLoop_input_text #-} -- | Should not be called manually, override @method _input_text@ instead. Will be removed in Godot 4.0. bindMainLoop_input_text :: MethodBind bindMainLoop_input_text = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "input_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Should not be called manually, override @method _input_text@ instead. Will be removed in Godot 4.0. input_text :: (MainLoop :< cls, Object :< cls) => cls -> GodotString -> IO () input_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop_input_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "input_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.MainLoop.input_text {-# NOINLINE bindMainLoop_iteration #-} -- | Should not be called manually, override @method _iteration@ instead. Will be removed in Godot 4.0. bindMainLoop_iteration :: MethodBind bindMainLoop_iteration = unsafePerformIO $ withCString "MainLoop" $ \ clsNamePtr -> withCString "iteration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Should not be called manually, override @method _iteration@ instead. Will be removed in Godot 4.0. iteration :: (MainLoop :< cls, Object :< cls) => cls -> Float -> IO Bool iteration cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMainLoop_iteration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MainLoop "iteration" '[Float] (IO Bool) where nodeMethod = Godot.Core.MainLoop.iteration ================================================ FILE: src/Godot/Core/MarginContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MarginContainer () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() ================================================ FILE: src/Godot/Core/Marshalls.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Marshalls (Godot.Core.Marshalls.base64_to_raw, Godot.Core.Marshalls.base64_to_utf8, Godot.Core.Marshalls.base64_to_variant, Godot.Core.Marshalls.raw_to_base64, Godot.Core.Marshalls.utf8_to_base64, Godot.Core.Marshalls.variant_to_base64) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindMarshalls_base64_to_raw #-} -- | Returns a decoded @PoolByteArray@ corresponding to the Base64-encoded string @base64_str@. bindMarshalls_base64_to_raw :: MethodBind bindMarshalls_base64_to_raw = unsafePerformIO $ withCString "_Marshalls" $ \ clsNamePtr -> withCString "base64_to_raw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a decoded @PoolByteArray@ corresponding to the Base64-encoded string @base64_str@. base64_to_raw :: (Marshalls :< cls, Object :< cls) => cls -> GodotString -> IO PoolByteArray base64_to_raw cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMarshalls_base64_to_raw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Marshalls "base64_to_raw" '[GodotString] (IO PoolByteArray) where nodeMethod = Godot.Core.Marshalls.base64_to_raw {-# NOINLINE bindMarshalls_base64_to_utf8 #-} -- | Returns a decoded string corresponding to the Base64-encoded string @base64_str@. bindMarshalls_base64_to_utf8 :: MethodBind bindMarshalls_base64_to_utf8 = unsafePerformIO $ withCString "_Marshalls" $ \ clsNamePtr -> withCString "base64_to_utf8" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a decoded string corresponding to the Base64-encoded string @base64_str@. base64_to_utf8 :: (Marshalls :< cls, Object :< cls) => cls -> GodotString -> IO GodotString base64_to_utf8 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMarshalls_base64_to_utf8 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Marshalls "base64_to_utf8" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.Marshalls.base64_to_utf8 {-# NOINLINE bindMarshalls_base64_to_variant #-} -- | Returns a decoded @Variant@ corresponding to the Base64-encoded string @base64_str@. If @allow_objects@ is @true@, decoding objects is allowed. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. bindMarshalls_base64_to_variant :: MethodBind bindMarshalls_base64_to_variant = unsafePerformIO $ withCString "_Marshalls" $ \ clsNamePtr -> withCString "base64_to_variant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a decoded @Variant@ corresponding to the Base64-encoded string @base64_str@. If @allow_objects@ is @true@, decoding objects is allowed. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. base64_to_variant :: (Marshalls :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO GodotVariant base64_to_variant cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMarshalls_base64_to_variant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Marshalls "base64_to_variant" '[GodotString, Maybe Bool] (IO GodotVariant) where nodeMethod = Godot.Core.Marshalls.base64_to_variant {-# NOINLINE bindMarshalls_raw_to_base64 #-} -- | Returns a Base64-encoded string of a given @PoolByteArray@. bindMarshalls_raw_to_base64 :: MethodBind bindMarshalls_raw_to_base64 = unsafePerformIO $ withCString "_Marshalls" $ \ clsNamePtr -> withCString "raw_to_base64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a Base64-encoded string of a given @PoolByteArray@. raw_to_base64 :: (Marshalls :< cls, Object :< cls) => cls -> PoolByteArray -> IO GodotString raw_to_base64 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMarshalls_raw_to_base64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Marshalls "raw_to_base64" '[PoolByteArray] (IO GodotString) where nodeMethod = Godot.Core.Marshalls.raw_to_base64 {-# NOINLINE bindMarshalls_utf8_to_base64 #-} -- | Returns a Base64-encoded string of the UTF-8 string @utf8_str@. bindMarshalls_utf8_to_base64 :: MethodBind bindMarshalls_utf8_to_base64 = unsafePerformIO $ withCString "_Marshalls" $ \ clsNamePtr -> withCString "utf8_to_base64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a Base64-encoded string of the UTF-8 string @utf8_str@. utf8_to_base64 :: (Marshalls :< cls, Object :< cls) => cls -> GodotString -> IO GodotString utf8_to_base64 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMarshalls_utf8_to_base64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Marshalls "utf8_to_base64" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.Marshalls.utf8_to_base64 {-# NOINLINE bindMarshalls_variant_to_base64 #-} -- | Returns a Base64-encoded string of the @Variant@ @variant@. If @full_objects@ is @true@, encoding objects is allowed (and can potentially include code). bindMarshalls_variant_to_base64 :: MethodBind bindMarshalls_variant_to_base64 = unsafePerformIO $ withCString "_Marshalls" $ \ clsNamePtr -> withCString "variant_to_base64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a Base64-encoded string of the @Variant@ @variant@. If @full_objects@ is @true@, encoding objects is allowed (and can potentially include code). variant_to_base64 :: (Marshalls :< cls, Object :< cls) => cls -> GodotVariant -> Maybe Bool -> IO GodotString variant_to_base64 cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMarshalls_variant_to_base64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Marshalls "variant_to_base64" '[GodotVariant, Maybe Bool] (IO GodotString) where nodeMethod = Godot.Core.Marshalls.variant_to_base64 ================================================ FILE: src/Godot/Core/Material.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Material (Godot.Core.Material._RENDER_PRIORITY_MAX, Godot.Core.Material._RENDER_PRIORITY_MIN, Godot.Core.Material.get_next_pass, Godot.Core.Material.get_render_priority, Godot.Core.Material.set_next_pass, Godot.Core.Material.set_render_priority) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _RENDER_PRIORITY_MAX :: Int _RENDER_PRIORITY_MAX = 127 _RENDER_PRIORITY_MIN :: Int _RENDER_PRIORITY_MIN = -128 instance NodeProperty Material "next_pass" Material 'False where nodeProperty = (get_next_pass, wrapDroppingSetter set_next_pass, Nothing) instance NodeProperty Material "render_priority" Int 'False where nodeProperty = (get_render_priority, wrapDroppingSetter set_render_priority, Nothing) {-# NOINLINE bindMaterial_get_next_pass #-} -- | Sets the @Material@ to be used for the next pass. This renders the object again using a different material. -- __Note:__ only applies to @SpatialMaterial@s and @ShaderMaterial@s with type "Spatial". bindMaterial_get_next_pass :: MethodBind bindMaterial_get_next_pass = unsafePerformIO $ withCString "Material" $ \ clsNamePtr -> withCString "get_next_pass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Material@ to be used for the next pass. This renders the object again using a different material. -- __Note:__ only applies to @SpatialMaterial@s and @ShaderMaterial@s with type "Spatial". get_next_pass :: (Material :< cls, Object :< cls) => cls -> IO Material get_next_pass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMaterial_get_next_pass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Material "get_next_pass" '[] (IO Material) where nodeMethod = Godot.Core.Material.get_next_pass {-# NOINLINE bindMaterial_get_render_priority #-} -- | Sets the render priority for transparent objects in 3D scenes. Higher priority objects will be sorted in front of lower priority objects. -- __Note:__ this only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority). bindMaterial_get_render_priority :: MethodBind bindMaterial_get_render_priority = unsafePerformIO $ withCString "Material" $ \ clsNamePtr -> withCString "get_render_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the render priority for transparent objects in 3D scenes. Higher priority objects will be sorted in front of lower priority objects. -- __Note:__ this only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority). get_render_priority :: (Material :< cls, Object :< cls) => cls -> IO Int get_render_priority cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMaterial_get_render_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Material "get_render_priority" '[] (IO Int) where nodeMethod = Godot.Core.Material.get_render_priority {-# NOINLINE bindMaterial_set_next_pass #-} -- | Sets the @Material@ to be used for the next pass. This renders the object again using a different material. -- __Note:__ only applies to @SpatialMaterial@s and @ShaderMaterial@s with type "Spatial". bindMaterial_set_next_pass :: MethodBind bindMaterial_set_next_pass = unsafePerformIO $ withCString "Material" $ \ clsNamePtr -> withCString "set_next_pass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Material@ to be used for the next pass. This renders the object again using a different material. -- __Note:__ only applies to @SpatialMaterial@s and @ShaderMaterial@s with type "Spatial". set_next_pass :: (Material :< cls, Object :< cls) => cls -> Material -> IO () set_next_pass cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMaterial_set_next_pass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Material "set_next_pass" '[Material] (IO ()) where nodeMethod = Godot.Core.Material.set_next_pass {-# NOINLINE bindMaterial_set_render_priority #-} -- | Sets the render priority for transparent objects in 3D scenes. Higher priority objects will be sorted in front of lower priority objects. -- __Note:__ this only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority). bindMaterial_set_render_priority :: MethodBind bindMaterial_set_render_priority = unsafePerformIO $ withCString "Material" $ \ clsNamePtr -> withCString "set_render_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the render priority for transparent objects in 3D scenes. Higher priority objects will be sorted in front of lower priority objects. -- __Note:__ this only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority). set_render_priority :: (Material :< cls, Object :< cls) => cls -> Int -> IO () set_render_priority cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMaterial_set_render_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Material "set_render_priority" '[Int] (IO ()) where nodeMethod = Godot.Core.Material.set_render_priority ================================================ FILE: src/Godot/Core/MenuButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MenuButton (Godot.Core.MenuButton.sig_about_to_show, Godot.Core.MenuButton._get_items, Godot.Core.MenuButton._set_items, Godot.Core.MenuButton._unhandled_key_input, Godot.Core.MenuButton.get_popup, Godot.Core.MenuButton.is_switch_on_hover, Godot.Core.MenuButton.set_disable_shortcuts, Godot.Core.MenuButton.set_switch_on_hover) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Button() -- | Emitted when @PopupMenu@ of this MenuButton is about to show. sig_about_to_show :: Godot.Internal.Dispatch.Signal MenuButton sig_about_to_show = Godot.Internal.Dispatch.Signal "about_to_show" instance NodeSignal MenuButton "about_to_show" '[] instance NodeProperty MenuButton "items" Array 'False where nodeProperty = (_get_items, wrapDroppingSetter _set_items, Nothing) instance NodeProperty MenuButton "switch_on_hover" Bool 'False where nodeProperty = (is_switch_on_hover, wrapDroppingSetter set_switch_on_hover, Nothing) {-# NOINLINE bindMenuButton__get_items #-} bindMenuButton__get_items :: MethodBind bindMenuButton__get_items = unsafePerformIO $ withCString "MenuButton" $ \ clsNamePtr -> withCString "_get_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_items :: (MenuButton :< cls, Object :< cls) => cls -> IO Array _get_items cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMenuButton__get_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MenuButton "_get_items" '[] (IO Array) where nodeMethod = Godot.Core.MenuButton._get_items {-# NOINLINE bindMenuButton__set_items #-} bindMenuButton__set_items :: MethodBind bindMenuButton__set_items = unsafePerformIO $ withCString "MenuButton" $ \ clsNamePtr -> withCString "_set_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_items :: (MenuButton :< cls, Object :< cls) => cls -> Array -> IO () _set_items cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMenuButton__set_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MenuButton "_set_items" '[Array] (IO ()) where nodeMethod = Godot.Core.MenuButton._set_items {-# NOINLINE bindMenuButton__unhandled_key_input #-} bindMenuButton__unhandled_key_input :: MethodBind bindMenuButton__unhandled_key_input = unsafePerformIO $ withCString "MenuButton" $ \ clsNamePtr -> withCString "_unhandled_key_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _unhandled_key_input :: (MenuButton :< cls, Object :< cls) => cls -> InputEvent -> IO () _unhandled_key_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMenuButton__unhandled_key_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MenuButton "_unhandled_key_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.MenuButton._unhandled_key_input {-# NOINLINE bindMenuButton_get_popup #-} -- | Returns the @PopupMenu@ contained in this button. bindMenuButton_get_popup :: MethodBind bindMenuButton_get_popup = unsafePerformIO $ withCString "MenuButton" $ \ clsNamePtr -> withCString "get_popup" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @PopupMenu@ contained in this button. get_popup :: (MenuButton :< cls, Object :< cls) => cls -> IO PopupMenu get_popup cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMenuButton_get_popup (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MenuButton "get_popup" '[] (IO PopupMenu) where nodeMethod = Godot.Core.MenuButton.get_popup {-# NOINLINE bindMenuButton_is_switch_on_hover #-} -- | If @true@, when the cursor hovers above another @MenuButton@ within the same parent which also has @switch_on_hover@ enabled, it will close the current @MenuButton@ and open the other one. bindMenuButton_is_switch_on_hover :: MethodBind bindMenuButton_is_switch_on_hover = unsafePerformIO $ withCString "MenuButton" $ \ clsNamePtr -> withCString "is_switch_on_hover" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, when the cursor hovers above another @MenuButton@ within the same parent which also has @switch_on_hover@ enabled, it will close the current @MenuButton@ and open the other one. is_switch_on_hover :: (MenuButton :< cls, Object :< cls) => cls -> IO Bool is_switch_on_hover cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMenuButton_is_switch_on_hover (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MenuButton "is_switch_on_hover" '[] (IO Bool) where nodeMethod = Godot.Core.MenuButton.is_switch_on_hover {-# NOINLINE bindMenuButton_set_disable_shortcuts #-} -- | If @true@, shortcuts are disabled and cannot be used to trigger the button. bindMenuButton_set_disable_shortcuts :: MethodBind bindMenuButton_set_disable_shortcuts = unsafePerformIO $ withCString "MenuButton" $ \ clsNamePtr -> withCString "set_disable_shortcuts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, shortcuts are disabled and cannot be used to trigger the button. set_disable_shortcuts :: (MenuButton :< cls, Object :< cls) => cls -> Bool -> IO () set_disable_shortcuts cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMenuButton_set_disable_shortcuts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MenuButton "set_disable_shortcuts" '[Bool] (IO ()) where nodeMethod = Godot.Core.MenuButton.set_disable_shortcuts {-# NOINLINE bindMenuButton_set_switch_on_hover #-} -- | If @true@, when the cursor hovers above another @MenuButton@ within the same parent which also has @switch_on_hover@ enabled, it will close the current @MenuButton@ and open the other one. bindMenuButton_set_switch_on_hover :: MethodBind bindMenuButton_set_switch_on_hover = unsafePerformIO $ withCString "MenuButton" $ \ clsNamePtr -> withCString "set_switch_on_hover" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, when the cursor hovers above another @MenuButton@ within the same parent which also has @switch_on_hover@ enabled, it will close the current @MenuButton@ and open the other one. set_switch_on_hover :: (MenuButton :< cls, Object :< cls) => cls -> Bool -> IO () set_switch_on_hover cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMenuButton_set_switch_on_hover (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MenuButton "set_switch_on_hover" '[Bool] (IO ()) where nodeMethod = Godot.Core.MenuButton.set_switch_on_hover ================================================ FILE: src/Godot/Core/Mesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Mesh (Godot.Core.Mesh._ARRAY_COMPRESS_WEIGHTS, Godot.Core.Mesh._ARRAY_FLAG_USE_16_BIT_BONES, Godot.Core.Mesh._ARRAY_FORMAT_INDEX, Godot.Core.Mesh._ARRAY_COMPRESS_TANGENT, Godot.Core.Mesh._ARRAY_COMPRESS_NORMAL, Godot.Core.Mesh._ARRAY_FORMAT_COLOR, Godot.Core.Mesh._ARRAY_FORMAT_TEX_UV, Godot.Core.Mesh._ARRAY_COMPRESS_VERTEX, Godot.Core.Mesh._ARRAY_FORMAT_VERTEX, Godot.Core.Mesh._ARRAY_COMPRESS_TEX_UV, Godot.Core.Mesh._ARRAY_COMPRESS_BASE, Godot.Core.Mesh._ARRAY_COMPRESS_BONES, Godot.Core.Mesh._ARRAY_MAX, Godot.Core.Mesh._ARRAY_NORMAL, Godot.Core.Mesh._ARRAY_FORMAT_TEX_UV2, Godot.Core.Mesh._ARRAY_INDEX, Godot.Core.Mesh._ARRAY_COLOR, Godot.Core.Mesh._PRIMITIVE_TRIANGLE_STRIP, Godot.Core.Mesh._PRIMITIVE_TRIANGLES, Godot.Core.Mesh._ARRAY_TEX_UV, Godot.Core.Mesh._BLEND_SHAPE_MODE_NORMALIZED, Godot.Core.Mesh._PRIMITIVE_LINE_LOOP, Godot.Core.Mesh._PRIMITIVE_TRIANGLE_FAN, Godot.Core.Mesh._ARRAY_FORMAT_NORMAL, Godot.Core.Mesh._ARRAY_TEX_UV2, Godot.Core.Mesh._ARRAY_COMPRESS_DEFAULT, Godot.Core.Mesh._ARRAY_FORMAT_BONES, Godot.Core.Mesh._ARRAY_COMPRESS_COLOR, Godot.Core.Mesh._ARRAY_WEIGHTS, Godot.Core.Mesh._ARRAY_TANGENT, Godot.Core.Mesh._ARRAY_COMPRESS_TEX_UV2, Godot.Core.Mesh._PRIMITIVE_LINE_STRIP, Godot.Core.Mesh._PRIMITIVE_LINES, Godot.Core.Mesh._ARRAY_BONES, Godot.Core.Mesh._BLEND_SHAPE_MODE_RELATIVE, Godot.Core.Mesh._ARRAY_VERTEX, Godot.Core.Mesh._ARRAY_FLAG_USE_2D_VERTICES, Godot.Core.Mesh._ARRAY_COMPRESS_INDEX, Godot.Core.Mesh._ARRAY_FORMAT_WEIGHTS, Godot.Core.Mesh._ARRAY_FORMAT_TANGENT, Godot.Core.Mesh._PRIMITIVE_POINTS, Godot.Core.Mesh.create_convex_shape, Godot.Core.Mesh.create_outline, Godot.Core.Mesh.create_trimesh_shape, Godot.Core.Mesh.generate_triangle_mesh, Godot.Core.Mesh.get_aabb, Godot.Core.Mesh.get_faces, Godot.Core.Mesh.get_lightmap_size_hint, Godot.Core.Mesh.get_surface_count, Godot.Core.Mesh.set_lightmap_size_hint, Godot.Core.Mesh.surface_get_arrays, Godot.Core.Mesh.surface_get_blend_shape_arrays, Godot.Core.Mesh.surface_get_material, Godot.Core.Mesh.surface_set_material) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _ARRAY_COMPRESS_WEIGHTS :: Int _ARRAY_COMPRESS_WEIGHTS = 65536 _ARRAY_FLAG_USE_16_BIT_BONES :: Int _ARRAY_FLAG_USE_16_BIT_BONES = 524288 _ARRAY_FORMAT_INDEX :: Int _ARRAY_FORMAT_INDEX = 256 _ARRAY_COMPRESS_TANGENT :: Int _ARRAY_COMPRESS_TANGENT = 2048 _ARRAY_COMPRESS_NORMAL :: Int _ARRAY_COMPRESS_NORMAL = 1024 _ARRAY_FORMAT_COLOR :: Int _ARRAY_FORMAT_COLOR = 8 _ARRAY_FORMAT_TEX_UV :: Int _ARRAY_FORMAT_TEX_UV = 16 _ARRAY_COMPRESS_VERTEX :: Int _ARRAY_COMPRESS_VERTEX = 512 _ARRAY_FORMAT_VERTEX :: Int _ARRAY_FORMAT_VERTEX = 1 _ARRAY_COMPRESS_TEX_UV :: Int _ARRAY_COMPRESS_TEX_UV = 8192 _ARRAY_COMPRESS_BASE :: Int _ARRAY_COMPRESS_BASE = 9 _ARRAY_COMPRESS_BONES :: Int _ARRAY_COMPRESS_BONES = 32768 _ARRAY_MAX :: Int _ARRAY_MAX = 9 _ARRAY_NORMAL :: Int _ARRAY_NORMAL = 1 _ARRAY_FORMAT_TEX_UV2 :: Int _ARRAY_FORMAT_TEX_UV2 = 32 _ARRAY_INDEX :: Int _ARRAY_INDEX = 8 _ARRAY_COLOR :: Int _ARRAY_COLOR = 3 _PRIMITIVE_TRIANGLE_STRIP :: Int _PRIMITIVE_TRIANGLE_STRIP = 5 _PRIMITIVE_TRIANGLES :: Int _PRIMITIVE_TRIANGLES = 4 _ARRAY_TEX_UV :: Int _ARRAY_TEX_UV = 4 _BLEND_SHAPE_MODE_NORMALIZED :: Int _BLEND_SHAPE_MODE_NORMALIZED = 0 _PRIMITIVE_LINE_LOOP :: Int _PRIMITIVE_LINE_LOOP = 3 _PRIMITIVE_TRIANGLE_FAN :: Int _PRIMITIVE_TRIANGLE_FAN = 6 _ARRAY_FORMAT_NORMAL :: Int _ARRAY_FORMAT_NORMAL = 2 _ARRAY_TEX_UV2 :: Int _ARRAY_TEX_UV2 = 5 _ARRAY_COMPRESS_DEFAULT :: Int _ARRAY_COMPRESS_DEFAULT = 97280 _ARRAY_FORMAT_BONES :: Int _ARRAY_FORMAT_BONES = 64 _ARRAY_COMPRESS_COLOR :: Int _ARRAY_COMPRESS_COLOR = 4096 _ARRAY_WEIGHTS :: Int _ARRAY_WEIGHTS = 7 _ARRAY_TANGENT :: Int _ARRAY_TANGENT = 2 _ARRAY_COMPRESS_TEX_UV2 :: Int _ARRAY_COMPRESS_TEX_UV2 = 16384 _PRIMITIVE_LINE_STRIP :: Int _PRIMITIVE_LINE_STRIP = 2 _PRIMITIVE_LINES :: Int _PRIMITIVE_LINES = 1 _ARRAY_BONES :: Int _ARRAY_BONES = 6 _BLEND_SHAPE_MODE_RELATIVE :: Int _BLEND_SHAPE_MODE_RELATIVE = 1 _ARRAY_VERTEX :: Int _ARRAY_VERTEX = 0 _ARRAY_FLAG_USE_2D_VERTICES :: Int _ARRAY_FLAG_USE_2D_VERTICES = 262144 _ARRAY_COMPRESS_INDEX :: Int _ARRAY_COMPRESS_INDEX = 131072 _ARRAY_FORMAT_WEIGHTS :: Int _ARRAY_FORMAT_WEIGHTS = 128 _ARRAY_FORMAT_TANGENT :: Int _ARRAY_FORMAT_TANGENT = 4 _PRIMITIVE_POINTS :: Int _PRIMITIVE_POINTS = 0 instance NodeProperty Mesh "lightmap_size_hint" Vector2 'False where nodeProperty = (get_lightmap_size_hint, wrapDroppingSetter set_lightmap_size_hint, Nothing) {-# NOINLINE bindMesh_create_convex_shape #-} -- | Calculate a @ConvexPolygonShape@ from the mesh. bindMesh_create_convex_shape :: MethodBind bindMesh_create_convex_shape = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "create_convex_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calculate a @ConvexPolygonShape@ from the mesh. create_convex_shape :: (Mesh :< cls, Object :< cls) => cls -> IO Shape create_convex_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_create_convex_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "create_convex_shape" '[] (IO Shape) where nodeMethod = Godot.Core.Mesh.create_convex_shape {-# NOINLINE bindMesh_create_outline #-} -- | Calculate an outline mesh at a defined offset (margin) from the original mesh. -- __Note:__ This method typically returns the vertices in reverse order (e.g. clockwise to counterclockwise). bindMesh_create_outline :: MethodBind bindMesh_create_outline = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "create_outline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calculate an outline mesh at a defined offset (margin) from the original mesh. -- __Note:__ This method typically returns the vertices in reverse order (e.g. clockwise to counterclockwise). create_outline :: (Mesh :< cls, Object :< cls) => cls -> Float -> IO Mesh create_outline cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_create_outline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "create_outline" '[Float] (IO Mesh) where nodeMethod = Godot.Core.Mesh.create_outline {-# NOINLINE bindMesh_create_trimesh_shape #-} -- | Calculate a @ConcavePolygonShape@ from the mesh. bindMesh_create_trimesh_shape :: MethodBind bindMesh_create_trimesh_shape = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "create_trimesh_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calculate a @ConcavePolygonShape@ from the mesh. create_trimesh_shape :: (Mesh :< cls, Object :< cls) => cls -> IO Shape create_trimesh_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_create_trimesh_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "create_trimesh_shape" '[] (IO Shape) where nodeMethod = Godot.Core.Mesh.create_trimesh_shape {-# NOINLINE bindMesh_generate_triangle_mesh #-} -- | Generate a @TriangleMesh@ from the mesh. bindMesh_generate_triangle_mesh :: MethodBind bindMesh_generate_triangle_mesh = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "generate_triangle_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generate a @TriangleMesh@ from the mesh. generate_triangle_mesh :: (Mesh :< cls, Object :< cls) => cls -> IO TriangleMesh generate_triangle_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_generate_triangle_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "generate_triangle_mesh" '[] (IO TriangleMesh) where nodeMethod = Godot.Core.Mesh.generate_triangle_mesh {-# NOINLINE bindMesh_get_aabb #-} -- | Returns the smallest @AABB@ enclosing this mesh in local space. Not affected by @custom_aabb@. See also @method VisualInstance.get_transformed_aabb@. -- __Note:__ This is only implemented for @ArrayMesh@ and @PrimitiveMesh@. bindMesh_get_aabb :: MethodBind bindMesh_get_aabb = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "get_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the smallest @AABB@ enclosing this mesh in local space. Not affected by @custom_aabb@. See also @method VisualInstance.get_transformed_aabb@. -- __Note:__ This is only implemented for @ArrayMesh@ and @PrimitiveMesh@. get_aabb :: (Mesh :< cls, Object :< cls) => cls -> IO Aabb get_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_get_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "get_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.Mesh.get_aabb {-# NOINLINE bindMesh_get_faces #-} -- | Returns all the vertices that make up the faces of the mesh. Each three vertices represent one triangle. bindMesh_get_faces :: MethodBind bindMesh_get_faces = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "get_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the vertices that make up the faces of the mesh. Each three vertices represent one triangle. get_faces :: (Mesh :< cls, Object :< cls) => cls -> IO PoolVector3Array get_faces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_get_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "get_faces" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.Mesh.get_faces {-# NOINLINE bindMesh_get_lightmap_size_hint #-} -- | Sets a hint to be used for lightmap resolution in @BakedLightmap@. Overrides @BakedLightmap.bake_default_texels_per_unit@. bindMesh_get_lightmap_size_hint :: MethodBind bindMesh_get_lightmap_size_hint = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "get_lightmap_size_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a hint to be used for lightmap resolution in @BakedLightmap@. Overrides @BakedLightmap.bake_default_texels_per_unit@. get_lightmap_size_hint :: (Mesh :< cls, Object :< cls) => cls -> IO Vector2 get_lightmap_size_hint cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_get_lightmap_size_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "get_lightmap_size_hint" '[] (IO Vector2) where nodeMethod = Godot.Core.Mesh.get_lightmap_size_hint {-# NOINLINE bindMesh_get_surface_count #-} -- | Returns the amount of surfaces that the @Mesh@ holds. bindMesh_get_surface_count :: MethodBind bindMesh_get_surface_count = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "get_surface_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of surfaces that the @Mesh@ holds. get_surface_count :: (Mesh :< cls, Object :< cls) => cls -> IO Int get_surface_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_get_surface_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "get_surface_count" '[] (IO Int) where nodeMethod = Godot.Core.Mesh.get_surface_count {-# NOINLINE bindMesh_set_lightmap_size_hint #-} -- | Sets a hint to be used for lightmap resolution in @BakedLightmap@. Overrides @BakedLightmap.bake_default_texels_per_unit@. bindMesh_set_lightmap_size_hint :: MethodBind bindMesh_set_lightmap_size_hint = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "set_lightmap_size_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a hint to be used for lightmap resolution in @BakedLightmap@. Overrides @BakedLightmap.bake_default_texels_per_unit@. set_lightmap_size_hint :: (Mesh :< cls, Object :< cls) => cls -> Vector2 -> IO () set_lightmap_size_hint cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_set_lightmap_size_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "set_lightmap_size_hint" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Mesh.set_lightmap_size_hint {-# NOINLINE bindMesh_surface_get_arrays #-} -- | Returns the arrays for the vertices, normals, uvs, etc. that make up the requested surface (see @method ArrayMesh.add_surface_from_arrays@). bindMesh_surface_get_arrays :: MethodBind bindMesh_surface_get_arrays = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "surface_get_arrays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the arrays for the vertices, normals, uvs, etc. that make up the requested surface (see @method ArrayMesh.add_surface_from_arrays@). surface_get_arrays :: (Mesh :< cls, Object :< cls) => cls -> Int -> IO Array surface_get_arrays cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_surface_get_arrays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "surface_get_arrays" '[Int] (IO Array) where nodeMethod = Godot.Core.Mesh.surface_get_arrays {-# NOINLINE bindMesh_surface_get_blend_shape_arrays #-} -- | Returns the blend shape arrays for the requested surface. bindMesh_surface_get_blend_shape_arrays :: MethodBind bindMesh_surface_get_blend_shape_arrays = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "surface_get_blend_shape_arrays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the blend shape arrays for the requested surface. surface_get_blend_shape_arrays :: (Mesh :< cls, Object :< cls) => cls -> Int -> IO Array surface_get_blend_shape_arrays cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_surface_get_blend_shape_arrays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "surface_get_blend_shape_arrays" '[Int] (IO Array) where nodeMethod = Godot.Core.Mesh.surface_get_blend_shape_arrays {-# NOINLINE bindMesh_surface_get_material #-} -- | Returns a @Material@ in a given surface. Surface is rendered using this material. bindMesh_surface_get_material :: MethodBind bindMesh_surface_get_material = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "surface_get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @Material@ in a given surface. Surface is rendered using this material. surface_get_material :: (Mesh :< cls, Object :< cls) => cls -> Int -> IO Material surface_get_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_surface_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "surface_get_material" '[Int] (IO Material) where nodeMethod = Godot.Core.Mesh.surface_get_material {-# NOINLINE bindMesh_surface_set_material #-} -- | Sets a @Material@ for a given surface. Surface will be rendered using this material. bindMesh_surface_set_material :: MethodBind bindMesh_surface_set_material = unsafePerformIO $ withCString "Mesh" $ \ clsNamePtr -> withCString "surface_set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a @Material@ for a given surface. Surface will be rendered using this material. surface_set_material :: (Mesh :< cls, Object :< cls) => cls -> Int -> Material -> IO () surface_set_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMesh_surface_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mesh "surface_set_material" '[Int, Material] (IO ()) where nodeMethod = Godot.Core.Mesh.surface_set_material ================================================ FILE: src/Godot/Core/MeshDataTool.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MeshDataTool (Godot.Core.MeshDataTool.clear, Godot.Core.MeshDataTool.commit_to_surface, Godot.Core.MeshDataTool.create_from_surface, Godot.Core.MeshDataTool.get_edge_count, Godot.Core.MeshDataTool.get_edge_faces, Godot.Core.MeshDataTool.get_edge_meta, Godot.Core.MeshDataTool.get_edge_vertex, Godot.Core.MeshDataTool.get_face_count, Godot.Core.MeshDataTool.get_face_edge, Godot.Core.MeshDataTool.get_face_meta, Godot.Core.MeshDataTool.get_face_normal, Godot.Core.MeshDataTool.get_face_vertex, Godot.Core.MeshDataTool.get_format, Godot.Core.MeshDataTool.get_material, Godot.Core.MeshDataTool.get_vertex, Godot.Core.MeshDataTool.get_vertex_bones, Godot.Core.MeshDataTool.get_vertex_color, Godot.Core.MeshDataTool.get_vertex_count, Godot.Core.MeshDataTool.get_vertex_edges, Godot.Core.MeshDataTool.get_vertex_faces, Godot.Core.MeshDataTool.get_vertex_meta, Godot.Core.MeshDataTool.get_vertex_normal, Godot.Core.MeshDataTool.get_vertex_tangent, Godot.Core.MeshDataTool.get_vertex_uv, Godot.Core.MeshDataTool.get_vertex_uv2, Godot.Core.MeshDataTool.get_vertex_weights, Godot.Core.MeshDataTool.set_edge_meta, Godot.Core.MeshDataTool.set_face_meta, Godot.Core.MeshDataTool.set_material, Godot.Core.MeshDataTool.set_vertex, Godot.Core.MeshDataTool.set_vertex_bones, Godot.Core.MeshDataTool.set_vertex_color, Godot.Core.MeshDataTool.set_vertex_meta, Godot.Core.MeshDataTool.set_vertex_normal, Godot.Core.MeshDataTool.set_vertex_tangent, Godot.Core.MeshDataTool.set_vertex_uv, Godot.Core.MeshDataTool.set_vertex_uv2, Godot.Core.MeshDataTool.set_vertex_weights) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindMeshDataTool_clear #-} -- | Clears all data currently in MeshDataTool. bindMeshDataTool_clear :: MethodBind bindMeshDataTool_clear = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all data currently in MeshDataTool. clear :: (MeshDataTool :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "clear" '[] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.clear {-# NOINLINE bindMeshDataTool_commit_to_surface #-} -- | Adds a new surface to specified @Mesh@ with edited data. bindMeshDataTool_commit_to_surface :: MethodBind bindMeshDataTool_commit_to_surface = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "commit_to_surface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new surface to specified @Mesh@ with edited data. commit_to_surface :: (MeshDataTool :< cls, Object :< cls) => cls -> ArrayMesh -> IO Int commit_to_surface cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_commit_to_surface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "commit_to_surface" '[ArrayMesh] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.commit_to_surface {-# NOINLINE bindMeshDataTool_create_from_surface #-} -- | Uses specified surface of given @Mesh@ to populate data for MeshDataTool. -- Requires @Mesh@ with primitive type @Mesh.PRIMITIVE_TRIANGLES@. bindMeshDataTool_create_from_surface :: MethodBind bindMeshDataTool_create_from_surface = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "create_from_surface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Uses specified surface of given @Mesh@ to populate data for MeshDataTool. -- Requires @Mesh@ with primitive type @Mesh.PRIMITIVE_TRIANGLES@. create_from_surface :: (MeshDataTool :< cls, Object :< cls) => cls -> ArrayMesh -> Int -> IO Int create_from_surface cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_create_from_surface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "create_from_surface" '[ArrayMesh, Int] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.create_from_surface {-# NOINLINE bindMeshDataTool_get_edge_count #-} -- | Returns the number of edges in this @Mesh@. bindMeshDataTool_get_edge_count :: MethodBind bindMeshDataTool_get_edge_count = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_edge_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of edges in this @Mesh@. get_edge_count :: (MeshDataTool :< cls, Object :< cls) => cls -> IO Int get_edge_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_edge_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_edge_count" '[] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.get_edge_count {-# NOINLINE bindMeshDataTool_get_edge_faces #-} -- | Returns array of faces that touch given edge. bindMeshDataTool_get_edge_faces :: MethodBind bindMeshDataTool_get_edge_faces = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_edge_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns array of faces that touch given edge. get_edge_faces :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_edge_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_edge_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_edge_faces" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.MeshDataTool.get_edge_faces {-# NOINLINE bindMeshDataTool_get_edge_meta #-} -- | Returns meta information assigned to given edge. bindMeshDataTool_get_edge_meta :: MethodBind bindMeshDataTool_get_edge_meta = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_edge_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns meta information assigned to given edge. get_edge_meta :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_edge_meta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_edge_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_edge_meta" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.MeshDataTool.get_edge_meta {-# NOINLINE bindMeshDataTool_get_edge_vertex #-} -- | Returns index of specified vertex connected to given edge. -- Vertex argument can only be 0 or 1 because edges are comprised of two vertices. bindMeshDataTool_get_edge_vertex :: MethodBind bindMeshDataTool_get_edge_vertex = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_edge_vertex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns index of specified vertex connected to given edge. -- Vertex argument can only be 0 or 1 because edges are comprised of two vertices. get_edge_vertex :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Int -> IO Int get_edge_vertex cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_edge_vertex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_edge_vertex" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.get_edge_vertex {-# NOINLINE bindMeshDataTool_get_face_count #-} -- | Returns the number of faces in this @Mesh@. bindMeshDataTool_get_face_count :: MethodBind bindMeshDataTool_get_face_count = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_face_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of faces in this @Mesh@. get_face_count :: (MeshDataTool :< cls, Object :< cls) => cls -> IO Int get_face_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_face_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_face_count" '[] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.get_face_count {-# NOINLINE bindMeshDataTool_get_face_edge #-} -- | Returns specified edge associated with given face. -- Edge argument must 2 or less because a face only has three edges. bindMeshDataTool_get_face_edge :: MethodBind bindMeshDataTool_get_face_edge = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_face_edge" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns specified edge associated with given face. -- Edge argument must 2 or less because a face only has three edges. get_face_edge :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Int -> IO Int get_face_edge cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_face_edge (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_face_edge" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.get_face_edge {-# NOINLINE bindMeshDataTool_get_face_meta #-} -- | Returns the metadata associated with the given face. bindMeshDataTool_get_face_meta :: MethodBind bindMeshDataTool_get_face_meta = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_face_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the metadata associated with the given face. get_face_meta :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_face_meta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_face_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_face_meta" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.MeshDataTool.get_face_meta {-# NOINLINE bindMeshDataTool_get_face_normal #-} -- | Calculates and returns the face normal of the given face. bindMeshDataTool_get_face_normal :: MethodBind bindMeshDataTool_get_face_normal = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_face_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calculates and returns the face normal of the given face. get_face_normal :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_face_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_face_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_face_normal" '[Int] (IO Vector3) where nodeMethod = Godot.Core.MeshDataTool.get_face_normal {-# NOINLINE bindMeshDataTool_get_face_vertex #-} -- | Returns the specified vertex of the given face. -- Vertex argument must be 2 or less because faces contain three vertices. bindMeshDataTool_get_face_vertex :: MethodBind bindMeshDataTool_get_face_vertex = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_face_vertex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the specified vertex of the given face. -- Vertex argument must be 2 or less because faces contain three vertices. get_face_vertex :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Int -> IO Int get_face_vertex cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_face_vertex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_face_vertex" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.get_face_vertex {-# NOINLINE bindMeshDataTool_get_format #-} -- | Returns the @Mesh@'s format. Format is an integer made up of @Mesh@ format flags combined together. For example, a mesh containing both vertices and normals would return a format of @3@ because @ArrayMesh.ARRAY_FORMAT_VERTEX@ is @1@ and @ArrayMesh.ARRAY_FORMAT_NORMAL@ is @2@. -- See @enum ArrayMesh.ArrayFormat@ for a list of format flags. bindMeshDataTool_get_format :: MethodBind bindMeshDataTool_get_format = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Mesh@'s format. Format is an integer made up of @Mesh@ format flags combined together. For example, a mesh containing both vertices and normals would return a format of @3@ because @ArrayMesh.ARRAY_FORMAT_VERTEX@ is @1@ and @ArrayMesh.ARRAY_FORMAT_NORMAL@ is @2@. -- See @enum ArrayMesh.ArrayFormat@ for a list of format flags. get_format :: (MeshDataTool :< cls, Object :< cls) => cls -> IO Int get_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_format" '[] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.get_format {-# NOINLINE bindMeshDataTool_get_material #-} -- | Returns the material assigned to the @Mesh@. bindMeshDataTool_get_material :: MethodBind bindMeshDataTool_get_material = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the material assigned to the @Mesh@. get_material :: (MeshDataTool :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_material" '[] (IO Material) where nodeMethod = Godot.Core.MeshDataTool.get_material {-# NOINLINE bindMeshDataTool_get_vertex #-} -- | Returns the vertex at given index. bindMeshDataTool_get_vertex :: MethodBind bindMeshDataTool_get_vertex = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the vertex at given index. get_vertex :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_vertex cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex" '[Int] (IO Vector3) where nodeMethod = Godot.Core.MeshDataTool.get_vertex {-# NOINLINE bindMeshDataTool_get_vertex_bones #-} -- | Returns the bones of the given vertex. bindMeshDataTool_get_vertex_bones :: MethodBind bindMeshDataTool_get_vertex_bones = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_bones" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the bones of the given vertex. get_vertex_bones :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_vertex_bones cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_bones (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_bones" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_bones {-# NOINLINE bindMeshDataTool_get_vertex_color #-} -- | Returns the color of the given vertex. bindMeshDataTool_get_vertex_color :: MethodBind bindMeshDataTool_get_vertex_color = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color of the given vertex. get_vertex_color :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO Color get_vertex_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_color" '[Int] (IO Color) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_color {-# NOINLINE bindMeshDataTool_get_vertex_count #-} -- | Returns the total number of vertices in @Mesh@. bindMeshDataTool_get_vertex_count :: MethodBind bindMeshDataTool_get_vertex_count = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total number of vertices in @Mesh@. get_vertex_count :: (MeshDataTool :< cls, Object :< cls) => cls -> IO Int get_vertex_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_count" '[] (IO Int) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_count {-# NOINLINE bindMeshDataTool_get_vertex_edges #-} -- | Returns an array of edges that share the given vertex. bindMeshDataTool_get_vertex_edges :: MethodBind bindMeshDataTool_get_vertex_edges = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_edges" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of edges that share the given vertex. get_vertex_edges :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_vertex_edges cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_edges (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_edges" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_edges {-# NOINLINE bindMeshDataTool_get_vertex_faces #-} -- | Returns an array of faces that share the given vertex. bindMeshDataTool_get_vertex_faces :: MethodBind bindMeshDataTool_get_vertex_faces = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of faces that share the given vertex. get_vertex_faces :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_vertex_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_faces" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_faces {-# NOINLINE bindMeshDataTool_get_vertex_meta #-} -- | Returns the metadata associated with the given vertex. bindMeshDataTool_get_vertex_meta :: MethodBind bindMeshDataTool_get_vertex_meta = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the metadata associated with the given vertex. get_vertex_meta :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_vertex_meta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_meta" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_meta {-# NOINLINE bindMeshDataTool_get_vertex_normal #-} -- | Returns the normal of the given vertex. bindMeshDataTool_get_vertex_normal :: MethodBind bindMeshDataTool_get_vertex_normal = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the normal of the given vertex. get_vertex_normal :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_vertex_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_normal" '[Int] (IO Vector3) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_normal {-# NOINLINE bindMeshDataTool_get_vertex_tangent #-} -- | Returns the tangent of the given vertex. bindMeshDataTool_get_vertex_tangent :: MethodBind bindMeshDataTool_get_vertex_tangent = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tangent of the given vertex. get_vertex_tangent :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO Plane get_vertex_tangent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_tangent" '[Int] (IO Plane) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_tangent {-# NOINLINE bindMeshDataTool_get_vertex_uv #-} -- | Returns the UV of the given vertex. bindMeshDataTool_get_vertex_uv :: MethodBind bindMeshDataTool_get_vertex_uv = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the UV of the given vertex. get_vertex_uv :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_vertex_uv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_uv" '[Int] (IO Vector2) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_uv {-# NOINLINE bindMeshDataTool_get_vertex_uv2 #-} -- | Returns the UV2 of the given vertex. bindMeshDataTool_get_vertex_uv2 :: MethodBind bindMeshDataTool_get_vertex_uv2 = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_uv2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the UV2 of the given vertex. get_vertex_uv2 :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_vertex_uv2 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_uv2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_uv2" '[Int] (IO Vector2) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_uv2 {-# NOINLINE bindMeshDataTool_get_vertex_weights #-} -- | Returns bone weights of the given vertex. bindMeshDataTool_get_vertex_weights :: MethodBind bindMeshDataTool_get_vertex_weights = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "get_vertex_weights" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns bone weights of the given vertex. get_vertex_weights :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> IO PoolRealArray get_vertex_weights cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_get_vertex_weights (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "get_vertex_weights" '[Int] (IO PoolRealArray) where nodeMethod = Godot.Core.MeshDataTool.get_vertex_weights {-# NOINLINE bindMeshDataTool_set_edge_meta #-} -- | Sets the metadata of the given edge. bindMeshDataTool_set_edge_meta :: MethodBind bindMeshDataTool_set_edge_meta = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_edge_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the metadata of the given edge. set_edge_meta :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_edge_meta cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_edge_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_edge_meta" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_edge_meta {-# NOINLINE bindMeshDataTool_set_face_meta #-} -- | Sets the metadata of the given face. bindMeshDataTool_set_face_meta :: MethodBind bindMeshDataTool_set_face_meta = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_face_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the metadata of the given face. set_face_meta :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_face_meta cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_face_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_face_meta" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_face_meta {-# NOINLINE bindMeshDataTool_set_material #-} -- | Sets the material to be used by newly-constructed @Mesh@. bindMeshDataTool_set_material :: MethodBind bindMeshDataTool_set_material = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the material to be used by newly-constructed @Mesh@. set_material :: (MeshDataTool :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_material {-# NOINLINE bindMeshDataTool_set_vertex #-} -- | Sets the position of the given vertex. bindMeshDataTool_set_vertex :: MethodBind bindMeshDataTool_set_vertex = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position of the given vertex. set_vertex :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Vector3 -> IO () set_vertex cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex" '[Int, Vector3] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex {-# NOINLINE bindMeshDataTool_set_vertex_bones #-} -- | Sets the bones of the given vertex. bindMeshDataTool_set_vertex_bones :: MethodBind bindMeshDataTool_set_vertex_bones = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex_bones" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the bones of the given vertex. set_vertex_bones :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> PoolIntArray -> IO () set_vertex_bones cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex_bones (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex_bones" '[Int, PoolIntArray] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex_bones {-# NOINLINE bindMeshDataTool_set_vertex_color #-} -- | Sets the color of the given vertex. bindMeshDataTool_set_vertex_color :: MethodBind bindMeshDataTool_set_vertex_color = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color of the given vertex. set_vertex_color :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_vertex_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex_color" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex_color {-# NOINLINE bindMeshDataTool_set_vertex_meta #-} -- | Sets the metadata associated with the given vertex. bindMeshDataTool_set_vertex_meta :: MethodBind bindMeshDataTool_set_vertex_meta = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the metadata associated with the given vertex. set_vertex_meta :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_vertex_meta cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex_meta" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex_meta {-# NOINLINE bindMeshDataTool_set_vertex_normal #-} -- | Sets the normal of the given vertex. bindMeshDataTool_set_vertex_normal :: MethodBind bindMeshDataTool_set_vertex_normal = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the normal of the given vertex. set_vertex_normal :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Vector3 -> IO () set_vertex_normal cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex_normal" '[Int, Vector3] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex_normal {-# NOINLINE bindMeshDataTool_set_vertex_tangent #-} -- | Sets the tangent of the given vertex. bindMeshDataTool_set_vertex_tangent :: MethodBind bindMeshDataTool_set_vertex_tangent = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tangent of the given vertex. set_vertex_tangent :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Plane -> IO () set_vertex_tangent cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex_tangent" '[Int, Plane] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex_tangent {-# NOINLINE bindMeshDataTool_set_vertex_uv #-} -- | Sets the UV of the given vertex. bindMeshDataTool_set_vertex_uv :: MethodBind bindMeshDataTool_set_vertex_uv = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the UV of the given vertex. set_vertex_uv :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_vertex_uv cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex_uv" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex_uv {-# NOINLINE bindMeshDataTool_set_vertex_uv2 #-} -- | Sets the UV2 of the given vertex. bindMeshDataTool_set_vertex_uv2 :: MethodBind bindMeshDataTool_set_vertex_uv2 = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex_uv2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the UV2 of the given vertex. set_vertex_uv2 :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () set_vertex_uv2 cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex_uv2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex_uv2" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex_uv2 {-# NOINLINE bindMeshDataTool_set_vertex_weights #-} -- | Sets the bone weights of the given vertex. bindMeshDataTool_set_vertex_weights :: MethodBind bindMeshDataTool_set_vertex_weights = unsafePerformIO $ withCString "MeshDataTool" $ \ clsNamePtr -> withCString "set_vertex_weights" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the bone weights of the given vertex. set_vertex_weights :: (MeshDataTool :< cls, Object :< cls) => cls -> Int -> PoolRealArray -> IO () set_vertex_weights cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshDataTool_set_vertex_weights (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshDataTool "set_vertex_weights" '[Int, PoolRealArray] (IO ()) where nodeMethod = Godot.Core.MeshDataTool.set_vertex_weights ================================================ FILE: src/Godot/Core/MeshInstance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MeshInstance (Godot.Core.MeshInstance._mesh_changed, Godot.Core.MeshInstance.create_convex_collision, Godot.Core.MeshInstance.create_debug_tangents, Godot.Core.MeshInstance.create_trimesh_collision, Godot.Core.MeshInstance.get_mesh, Godot.Core.MeshInstance.get_skeleton_path, Godot.Core.MeshInstance.get_skin, Godot.Core.MeshInstance.get_surface_material, Godot.Core.MeshInstance.get_surface_material_count, Godot.Core.MeshInstance.set_mesh, Godot.Core.MeshInstance.set_skeleton_path, Godot.Core.MeshInstance.set_skin, Godot.Core.MeshInstance.set_surface_material) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.GeometryInstance() instance NodeProperty MeshInstance "mesh" Mesh 'False where nodeProperty = (get_mesh, wrapDroppingSetter set_mesh, Nothing) instance NodeProperty MeshInstance "skeleton" NodePath 'False where nodeProperty = (get_skeleton_path, wrapDroppingSetter set_skeleton_path, Nothing) instance NodeProperty MeshInstance "skin" Skin 'False where nodeProperty = (get_skin, wrapDroppingSetter set_skin, Nothing) {-# NOINLINE bindMeshInstance__mesh_changed #-} bindMeshInstance__mesh_changed :: MethodBind bindMeshInstance__mesh_changed = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "_mesh_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _mesh_changed :: (MeshInstance :< cls, Object :< cls) => cls -> IO () _mesh_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance__mesh_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "_mesh_changed" '[] (IO ()) where nodeMethod = Godot.Core.MeshInstance._mesh_changed {-# NOINLINE bindMeshInstance_create_convex_collision #-} -- | This helper creates a @StaticBody@ child node with a @ConvexPolygonShape@ collision shape calculated from the mesh geometry. It's mainly used for testing. bindMeshInstance_create_convex_collision :: MethodBind bindMeshInstance_create_convex_collision = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "create_convex_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This helper creates a @StaticBody@ child node with a @ConvexPolygonShape@ collision shape calculated from the mesh geometry. It's mainly used for testing. create_convex_collision :: (MeshInstance :< cls, Object :< cls) => cls -> IO () create_convex_collision cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_create_convex_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "create_convex_collision" '[] (IO ()) where nodeMethod = Godot.Core.MeshInstance.create_convex_collision {-# NOINLINE bindMeshInstance_create_debug_tangents #-} -- | This helper creates a @MeshInstance@ child node with gizmos at every vertex calculated from the mesh geometry. It's mainly used for testing. bindMeshInstance_create_debug_tangents :: MethodBind bindMeshInstance_create_debug_tangents = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "create_debug_tangents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This helper creates a @MeshInstance@ child node with gizmos at every vertex calculated from the mesh geometry. It's mainly used for testing. create_debug_tangents :: (MeshInstance :< cls, Object :< cls) => cls -> IO () create_debug_tangents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_create_debug_tangents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "create_debug_tangents" '[] (IO ()) where nodeMethod = Godot.Core.MeshInstance.create_debug_tangents {-# NOINLINE bindMeshInstance_create_trimesh_collision #-} -- | This helper creates a @StaticBody@ child node with a @ConcavePolygonShape@ collision shape calculated from the mesh geometry. It's mainly used for testing. bindMeshInstance_create_trimesh_collision :: MethodBind bindMeshInstance_create_trimesh_collision = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "create_trimesh_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This helper creates a @StaticBody@ child node with a @ConcavePolygonShape@ collision shape calculated from the mesh geometry. It's mainly used for testing. create_trimesh_collision :: (MeshInstance :< cls, Object :< cls) => cls -> IO () create_trimesh_collision cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_create_trimesh_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "create_trimesh_collision" '[] (IO ()) where nodeMethod = Godot.Core.MeshInstance.create_trimesh_collision {-# NOINLINE bindMeshInstance_get_mesh #-} -- | The @Mesh@ resource for the instance. bindMeshInstance_get_mesh :: MethodBind bindMeshInstance_get_mesh = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Mesh@ resource for the instance. get_mesh :: (MeshInstance :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.MeshInstance.get_mesh {-# NOINLINE bindMeshInstance_get_skeleton_path #-} -- | @NodePath@ to the @Skeleton@ associated with the instance. bindMeshInstance_get_skeleton_path :: MethodBind bindMeshInstance_get_skeleton_path = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "get_skeleton_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @NodePath@ to the @Skeleton@ associated with the instance. get_skeleton_path :: (MeshInstance :< cls, Object :< cls) => cls -> IO NodePath get_skeleton_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_get_skeleton_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "get_skeleton_path" '[] (IO NodePath) where nodeMethod = Godot.Core.MeshInstance.get_skeleton_path {-# NOINLINE bindMeshInstance_get_skin #-} -- | Sets the skin to be used by this instance. bindMeshInstance_get_skin :: MethodBind bindMeshInstance_get_skin = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "get_skin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the skin to be used by this instance. get_skin :: (MeshInstance :< cls, Object :< cls) => cls -> IO Skin get_skin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_get_skin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "get_skin" '[] (IO Skin) where nodeMethod = Godot.Core.MeshInstance.get_skin {-# NOINLINE bindMeshInstance_get_surface_material #-} -- | Returns the @Material@ for a surface of the @Mesh@ resource. bindMeshInstance_get_surface_material :: MethodBind bindMeshInstance_get_surface_material = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "get_surface_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Material@ for a surface of the @Mesh@ resource. get_surface_material :: (MeshInstance :< cls, Object :< cls) => cls -> Int -> IO Material get_surface_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_get_surface_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "get_surface_material" '[Int] (IO Material) where nodeMethod = Godot.Core.MeshInstance.get_surface_material {-# NOINLINE bindMeshInstance_get_surface_material_count #-} -- | Returns the number of surface materials. bindMeshInstance_get_surface_material_count :: MethodBind bindMeshInstance_get_surface_material_count = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "get_surface_material_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of surface materials. get_surface_material_count :: (MeshInstance :< cls, Object :< cls) => cls -> IO Int get_surface_material_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_get_surface_material_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "get_surface_material_count" '[] (IO Int) where nodeMethod = Godot.Core.MeshInstance.get_surface_material_count {-# NOINLINE bindMeshInstance_set_mesh #-} -- | The @Mesh@ resource for the instance. bindMeshInstance_set_mesh :: MethodBind bindMeshInstance_set_mesh = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "set_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Mesh@ resource for the instance. set_mesh :: (MeshInstance :< cls, Object :< cls) => cls -> Mesh -> IO () set_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_set_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "set_mesh" '[Mesh] (IO ()) where nodeMethod = Godot.Core.MeshInstance.set_mesh {-# NOINLINE bindMeshInstance_set_skeleton_path #-} -- | @NodePath@ to the @Skeleton@ associated with the instance. bindMeshInstance_set_skeleton_path :: MethodBind bindMeshInstance_set_skeleton_path = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "set_skeleton_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @NodePath@ to the @Skeleton@ associated with the instance. set_skeleton_path :: (MeshInstance :< cls, Object :< cls) => cls -> NodePath -> IO () set_skeleton_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_set_skeleton_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "set_skeleton_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.MeshInstance.set_skeleton_path {-# NOINLINE bindMeshInstance_set_skin #-} -- | Sets the skin to be used by this instance. bindMeshInstance_set_skin :: MethodBind bindMeshInstance_set_skin = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "set_skin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the skin to be used by this instance. set_skin :: (MeshInstance :< cls, Object :< cls) => cls -> Skin -> IO () set_skin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_set_skin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "set_skin" '[Skin] (IO ()) where nodeMethod = Godot.Core.MeshInstance.set_skin {-# NOINLINE bindMeshInstance_set_surface_material #-} -- | Sets the @Material@ for a surface of the @Mesh@ resource. bindMeshInstance_set_surface_material :: MethodBind bindMeshInstance_set_surface_material = unsafePerformIO $ withCString "MeshInstance" $ \ clsNamePtr -> withCString "set_surface_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Material@ for a surface of the @Mesh@ resource. set_surface_material :: (MeshInstance :< cls, Object :< cls) => cls -> Int -> Material -> IO () set_surface_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance_set_surface_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance "set_surface_material" '[Int, Material] (IO ()) where nodeMethod = Godot.Core.MeshInstance.set_surface_material ================================================ FILE: src/Godot/Core/MeshInstance2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MeshInstance2D (Godot.Core.MeshInstance2D.sig_texture_changed, Godot.Core.MeshInstance2D.get_mesh, Godot.Core.MeshInstance2D.get_normal_map, Godot.Core.MeshInstance2D.get_texture, Godot.Core.MeshInstance2D.set_mesh, Godot.Core.MeshInstance2D.set_normal_map, Godot.Core.MeshInstance2D.set_texture) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() -- | Emitted when the @texture@ is changed. sig_texture_changed :: Godot.Internal.Dispatch.Signal MeshInstance2D sig_texture_changed = Godot.Internal.Dispatch.Signal "texture_changed" instance NodeSignal MeshInstance2D "texture_changed" '[] instance NodeProperty MeshInstance2D "mesh" Mesh 'False where nodeProperty = (get_mesh, wrapDroppingSetter set_mesh, Nothing) instance NodeProperty MeshInstance2D "normal_map" Texture 'False where nodeProperty = (get_normal_map, wrapDroppingSetter set_normal_map, Nothing) instance NodeProperty MeshInstance2D "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) {-# NOINLINE bindMeshInstance2D_get_mesh #-} -- | The @Mesh@ that will be drawn by the @MeshInstance2D@. bindMeshInstance2D_get_mesh :: MethodBind bindMeshInstance2D_get_mesh = unsafePerformIO $ withCString "MeshInstance2D" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Mesh@ that will be drawn by the @MeshInstance2D@. get_mesh :: (MeshInstance2D :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance2D_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance2D "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.MeshInstance2D.get_mesh {-# NOINLINE bindMeshInstance2D_get_normal_map #-} -- | The normal map that will be used if using the default @CanvasItemMaterial@. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindMeshInstance2D_get_normal_map :: MethodBind bindMeshInstance2D_get_normal_map = unsafePerformIO $ withCString "MeshInstance2D" $ \ clsNamePtr -> withCString "get_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The normal map that will be used if using the default @CanvasItemMaterial@. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. get_normal_map :: (MeshInstance2D :< cls, Object :< cls) => cls -> IO Texture get_normal_map cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance2D_get_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance2D "get_normal_map" '[] (IO Texture) where nodeMethod = Godot.Core.MeshInstance2D.get_normal_map {-# NOINLINE bindMeshInstance2D_get_texture #-} -- | The @Texture@ that will be used if using the default @CanvasItemMaterial@. Can be accessed as @TEXTURE@ in CanvasItem shader. bindMeshInstance2D_get_texture :: MethodBind bindMeshInstance2D_get_texture = unsafePerformIO $ withCString "MeshInstance2D" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Texture@ that will be used if using the default @CanvasItemMaterial@. Can be accessed as @TEXTURE@ in CanvasItem shader. get_texture :: (MeshInstance2D :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance2D_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance2D "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.MeshInstance2D.get_texture {-# NOINLINE bindMeshInstance2D_set_mesh #-} -- | The @Mesh@ that will be drawn by the @MeshInstance2D@. bindMeshInstance2D_set_mesh :: MethodBind bindMeshInstance2D_set_mesh = unsafePerformIO $ withCString "MeshInstance2D" $ \ clsNamePtr -> withCString "set_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Mesh@ that will be drawn by the @MeshInstance2D@. set_mesh :: (MeshInstance2D :< cls, Object :< cls) => cls -> Mesh -> IO () set_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance2D_set_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance2D "set_mesh" '[Mesh] (IO ()) where nodeMethod = Godot.Core.MeshInstance2D.set_mesh {-# NOINLINE bindMeshInstance2D_set_normal_map #-} -- | The normal map that will be used if using the default @CanvasItemMaterial@. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindMeshInstance2D_set_normal_map :: MethodBind bindMeshInstance2D_set_normal_map = unsafePerformIO $ withCString "MeshInstance2D" $ \ clsNamePtr -> withCString "set_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The normal map that will be used if using the default @CanvasItemMaterial@. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. set_normal_map :: (MeshInstance2D :< cls, Object :< cls) => cls -> Texture -> IO () set_normal_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance2D_set_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance2D "set_normal_map" '[Texture] (IO ()) where nodeMethod = Godot.Core.MeshInstance2D.set_normal_map {-# NOINLINE bindMeshInstance2D_set_texture #-} -- | The @Texture@ that will be used if using the default @CanvasItemMaterial@. Can be accessed as @TEXTURE@ in CanvasItem shader. bindMeshInstance2D_set_texture :: MethodBind bindMeshInstance2D_set_texture = unsafePerformIO $ withCString "MeshInstance2D" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Texture@ that will be used if using the default @CanvasItemMaterial@. Can be accessed as @TEXTURE@ in CanvasItem shader. set_texture :: (MeshInstance2D :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshInstance2D_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshInstance2D "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.MeshInstance2D.set_texture ================================================ FILE: src/Godot/Core/MeshLibrary.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MeshLibrary (Godot.Core.MeshLibrary.clear, Godot.Core.MeshLibrary.create_item, Godot.Core.MeshLibrary.find_item_by_name, Godot.Core.MeshLibrary.get_item_list, Godot.Core.MeshLibrary.get_item_mesh, Godot.Core.MeshLibrary.get_item_name, Godot.Core.MeshLibrary.get_item_navmesh, Godot.Core.MeshLibrary.get_item_navmesh_transform, Godot.Core.MeshLibrary.get_item_preview, Godot.Core.MeshLibrary.get_item_shapes, Godot.Core.MeshLibrary.get_last_unused_item_id, Godot.Core.MeshLibrary.remove_item, Godot.Core.MeshLibrary.set_item_mesh, Godot.Core.MeshLibrary.set_item_name, Godot.Core.MeshLibrary.set_item_navmesh, Godot.Core.MeshLibrary.set_item_navmesh_transform, Godot.Core.MeshLibrary.set_item_preview, Godot.Core.MeshLibrary.set_item_shapes) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindMeshLibrary_clear #-} -- | Clears the library. bindMeshLibrary_clear :: MethodBind bindMeshLibrary_clear = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the library. clear :: (MeshLibrary :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "clear" '[] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.clear {-# NOINLINE bindMeshLibrary_create_item #-} -- | Creates a new item in the library with the given ID. -- You can get an unused ID from @method get_last_unused_item_id@. bindMeshLibrary_create_item :: MethodBind bindMeshLibrary_create_item = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "create_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new item in the library with the given ID. -- You can get an unused ID from @method get_last_unused_item_id@. create_item :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> IO () create_item cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_create_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "create_item" '[Int] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.create_item {-# NOINLINE bindMeshLibrary_find_item_by_name #-} -- | Returns the first item with the given name. bindMeshLibrary_find_item_by_name :: MethodBind bindMeshLibrary_find_item_by_name = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "find_item_by_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the first item with the given name. find_item_by_name :: (MeshLibrary :< cls, Object :< cls) => cls -> GodotString -> IO Int find_item_by_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_find_item_by_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "find_item_by_name" '[GodotString] (IO Int) where nodeMethod = Godot.Core.MeshLibrary.find_item_by_name {-# NOINLINE bindMeshLibrary_get_item_list #-} -- | Returns the list of item IDs in use. bindMeshLibrary_get_item_list :: MethodBind bindMeshLibrary_get_item_list = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "get_item_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of item IDs in use. get_item_list :: (MeshLibrary :< cls, Object :< cls) => cls -> IO PoolIntArray get_item_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_get_item_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "get_item_list" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.MeshLibrary.get_item_list {-# NOINLINE bindMeshLibrary_get_item_mesh #-} -- | Returns the item's mesh. bindMeshLibrary_get_item_mesh :: MethodBind bindMeshLibrary_get_item_mesh = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "get_item_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the item's mesh. get_item_mesh :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> IO Mesh get_item_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_get_item_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "get_item_mesh" '[Int] (IO Mesh) where nodeMethod = Godot.Core.MeshLibrary.get_item_mesh {-# NOINLINE bindMeshLibrary_get_item_name #-} -- | Returns the item's name. bindMeshLibrary_get_item_name :: MethodBind bindMeshLibrary_get_item_name = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "get_item_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the item's name. get_item_name :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> IO GodotString get_item_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_get_item_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "get_item_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.MeshLibrary.get_item_name {-# NOINLINE bindMeshLibrary_get_item_navmesh #-} -- | Returns the item's navigation mesh. bindMeshLibrary_get_item_navmesh :: MethodBind bindMeshLibrary_get_item_navmesh = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "get_item_navmesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the item's navigation mesh. get_item_navmesh :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> IO NavigationMesh get_item_navmesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_get_item_navmesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "get_item_navmesh" '[Int] (IO NavigationMesh) where nodeMethod = Godot.Core.MeshLibrary.get_item_navmesh {-# NOINLINE bindMeshLibrary_get_item_navmesh_transform #-} -- | Returns the transform applied to the item's navigation mesh. bindMeshLibrary_get_item_navmesh_transform :: MethodBind bindMeshLibrary_get_item_navmesh_transform = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "get_item_navmesh_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform applied to the item's navigation mesh. get_item_navmesh_transform :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> IO Transform get_item_navmesh_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_get_item_navmesh_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "get_item_navmesh_transform" '[Int] (IO Transform) where nodeMethod = Godot.Core.MeshLibrary.get_item_navmesh_transform {-# NOINLINE bindMeshLibrary_get_item_preview #-} -- | When running in the editor, returns a generated item preview (a 3D rendering in isometric perspective). When used in a running project, returns the manually-defined item preview which can be set using @method set_item_preview@. Returns an empty @Texture@ if no preview was manually set in a running project. bindMeshLibrary_get_item_preview :: MethodBind bindMeshLibrary_get_item_preview = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "get_item_preview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When running in the editor, returns a generated item preview (a 3D rendering in isometric perspective). When used in a running project, returns the manually-defined item preview which can be set using @method set_item_preview@. Returns an empty @Texture@ if no preview was manually set in a running project. get_item_preview :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> IO Texture get_item_preview cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_get_item_preview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "get_item_preview" '[Int] (IO Texture) where nodeMethod = Godot.Core.MeshLibrary.get_item_preview {-# NOINLINE bindMeshLibrary_get_item_shapes #-} -- | Returns an item's collision shapes. -- The array consists of each @Shape@ followed by its @Transform@. bindMeshLibrary_get_item_shapes :: MethodBind bindMeshLibrary_get_item_shapes = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "get_item_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an item's collision shapes. -- The array consists of each @Shape@ followed by its @Transform@. get_item_shapes :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> IO Array get_item_shapes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_get_item_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "get_item_shapes" '[Int] (IO Array) where nodeMethod = Godot.Core.MeshLibrary.get_item_shapes {-# NOINLINE bindMeshLibrary_get_last_unused_item_id #-} -- | Gets an unused ID for a new item. bindMeshLibrary_get_last_unused_item_id :: MethodBind bindMeshLibrary_get_last_unused_item_id = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "get_last_unused_item_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets an unused ID for a new item. get_last_unused_item_id :: (MeshLibrary :< cls, Object :< cls) => cls -> IO Int get_last_unused_item_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_get_last_unused_item_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "get_last_unused_item_id" '[] (IO Int) where nodeMethod = Godot.Core.MeshLibrary.get_last_unused_item_id {-# NOINLINE bindMeshLibrary_remove_item #-} -- | Removes the item. bindMeshLibrary_remove_item :: MethodBind bindMeshLibrary_remove_item = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "remove_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the item. remove_item :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> IO () remove_item cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_remove_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "remove_item" '[Int] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.remove_item {-# NOINLINE bindMeshLibrary_set_item_mesh #-} -- | Sets the item's mesh. bindMeshLibrary_set_item_mesh :: MethodBind bindMeshLibrary_set_item_mesh = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "set_item_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the item's mesh. set_item_mesh :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> Mesh -> IO () set_item_mesh cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_set_item_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "set_item_mesh" '[Int, Mesh] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.set_item_mesh {-# NOINLINE bindMeshLibrary_set_item_name #-} -- | Sets the item's name. -- This name is shown in the editor. It can also be used to look up the item later using @method find_item_by_name@. bindMeshLibrary_set_item_name :: MethodBind bindMeshLibrary_set_item_name = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "set_item_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the item's name. -- This name is shown in the editor. It can also be used to look up the item later using @method find_item_by_name@. set_item_name :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_item_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_set_item_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "set_item_name" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.set_item_name {-# NOINLINE bindMeshLibrary_set_item_navmesh #-} -- | Sets the item's navigation mesh. bindMeshLibrary_set_item_navmesh :: MethodBind bindMeshLibrary_set_item_navmesh = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "set_item_navmesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the item's navigation mesh. set_item_navmesh :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> NavigationMesh -> IO () set_item_navmesh cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_set_item_navmesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "set_item_navmesh" '[Int, NavigationMesh] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.set_item_navmesh {-# NOINLINE bindMeshLibrary_set_item_navmesh_transform #-} -- | Sets the transform to apply to the item's navigation mesh. bindMeshLibrary_set_item_navmesh_transform :: MethodBind bindMeshLibrary_set_item_navmesh_transform = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "set_item_navmesh_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform to apply to the item's navigation mesh. set_item_navmesh_transform :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> Transform -> IO () set_item_navmesh_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_set_item_navmesh_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "set_item_navmesh_transform" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.set_item_navmesh_transform {-# NOINLINE bindMeshLibrary_set_item_preview #-} -- | Sets a texture to use as the item's preview icon in the editor. bindMeshLibrary_set_item_preview :: MethodBind bindMeshLibrary_set_item_preview = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "set_item_preview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a texture to use as the item's preview icon in the editor. set_item_preview :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_item_preview cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_set_item_preview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "set_item_preview" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.set_item_preview {-# NOINLINE bindMeshLibrary_set_item_shapes #-} -- | Sets an item's collision shapes. -- The array should consist of @Shape@ objects, each followed by a @Transform@ that will be applied to it. For shapes that should not have a transform, use @Transform.IDENTITY@. bindMeshLibrary_set_item_shapes :: MethodBind bindMeshLibrary_set_item_shapes = unsafePerformIO $ withCString "MeshLibrary" $ \ clsNamePtr -> withCString "set_item_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an item's collision shapes. -- The array should consist of @Shape@ objects, each followed by a @Transform@ that will be applied to it. For shapes that should not have a transform, use @Transform.IDENTITY@. set_item_shapes :: (MeshLibrary :< cls, Object :< cls) => cls -> Int -> Array -> IO () set_item_shapes cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMeshLibrary_set_item_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshLibrary "set_item_shapes" '[Int, Array] (IO ()) where nodeMethod = Godot.Core.MeshLibrary.set_item_shapes ================================================ FILE: src/Godot/Core/MeshTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MeshTexture (Godot.Core.MeshTexture.get_base_texture, Godot.Core.MeshTexture.get_image_size, Godot.Core.MeshTexture.get_mesh, Godot.Core.MeshTexture.set_base_texture, Godot.Core.MeshTexture.set_image_size, Godot.Core.MeshTexture.set_mesh) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty MeshTexture "base_texture" Texture 'False where nodeProperty = (get_base_texture, wrapDroppingSetter set_base_texture, Nothing) instance NodeProperty MeshTexture "image_size" Vector2 'False where nodeProperty = (get_image_size, wrapDroppingSetter set_image_size, Nothing) instance NodeProperty MeshTexture "mesh" Mesh 'False where nodeProperty = (get_mesh, wrapDroppingSetter set_mesh, Nothing) {-# NOINLINE bindMeshTexture_get_base_texture #-} -- | Sets the base texture that the Mesh will use to draw. bindMeshTexture_get_base_texture :: MethodBind bindMeshTexture_get_base_texture = unsafePerformIO $ withCString "MeshTexture" $ \ clsNamePtr -> withCString "get_base_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the base texture that the Mesh will use to draw. get_base_texture :: (MeshTexture :< cls, Object :< cls) => cls -> IO Texture get_base_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshTexture_get_base_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshTexture "get_base_texture" '[] (IO Texture) where nodeMethod = Godot.Core.MeshTexture.get_base_texture {-# NOINLINE bindMeshTexture_get_image_size #-} -- | Sets the size of the image, needed for reference. bindMeshTexture_get_image_size :: MethodBind bindMeshTexture_get_image_size = unsafePerformIO $ withCString "MeshTexture" $ \ clsNamePtr -> withCString "get_image_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the image, needed for reference. get_image_size :: (MeshTexture :< cls, Object :< cls) => cls -> IO Vector2 get_image_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshTexture_get_image_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshTexture "get_image_size" '[] (IO Vector2) where nodeMethod = Godot.Core.MeshTexture.get_image_size {-# NOINLINE bindMeshTexture_get_mesh #-} -- | Sets the mesh used to draw. It must be a mesh using 2D vertices. bindMeshTexture_get_mesh :: MethodBind bindMeshTexture_get_mesh = unsafePerformIO $ withCString "MeshTexture" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the mesh used to draw. It must be a mesh using 2D vertices. get_mesh :: (MeshTexture :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMeshTexture_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshTexture "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.MeshTexture.get_mesh {-# NOINLINE bindMeshTexture_set_base_texture #-} -- | Sets the base texture that the Mesh will use to draw. bindMeshTexture_set_base_texture :: MethodBind bindMeshTexture_set_base_texture = unsafePerformIO $ withCString "MeshTexture" $ \ clsNamePtr -> withCString "set_base_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the base texture that the Mesh will use to draw. set_base_texture :: (MeshTexture :< cls, Object :< cls) => cls -> Texture -> IO () set_base_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshTexture_set_base_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshTexture "set_base_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.MeshTexture.set_base_texture {-# NOINLINE bindMeshTexture_set_image_size #-} -- | Sets the size of the image, needed for reference. bindMeshTexture_set_image_size :: MethodBind bindMeshTexture_set_image_size = unsafePerformIO $ withCString "MeshTexture" $ \ clsNamePtr -> withCString "set_image_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the image, needed for reference. set_image_size :: (MeshTexture :< cls, Object :< cls) => cls -> Vector2 -> IO () set_image_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshTexture_set_image_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshTexture "set_image_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.MeshTexture.set_image_size {-# NOINLINE bindMeshTexture_set_mesh #-} -- | Sets the mesh used to draw. It must be a mesh using 2D vertices. bindMeshTexture_set_mesh :: MethodBind bindMeshTexture_set_mesh = unsafePerformIO $ withCString "MeshTexture" $ \ clsNamePtr -> withCString "set_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the mesh used to draw. It must be a mesh using 2D vertices. set_mesh :: (MeshTexture :< cls, Object :< cls) => cls -> Mesh -> IO () set_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMeshTexture_set_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MeshTexture "set_mesh" '[Mesh] (IO ()) where nodeMethod = Godot.Core.MeshTexture.set_mesh ================================================ FILE: src/Godot/Core/MobileVRInterface.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MobileVRInterface (Godot.Core.MobileVRInterface.get_display_to_lens, Godot.Core.MobileVRInterface.get_display_width, Godot.Core.MobileVRInterface.get_eye_height, Godot.Core.MobileVRInterface.get_iod, Godot.Core.MobileVRInterface.get_k1, Godot.Core.MobileVRInterface.get_k2, Godot.Core.MobileVRInterface.get_oversample, Godot.Core.MobileVRInterface.set_display_to_lens, Godot.Core.MobileVRInterface.set_display_width, Godot.Core.MobileVRInterface.set_eye_height, Godot.Core.MobileVRInterface.set_iod, Godot.Core.MobileVRInterface.set_k1, Godot.Core.MobileVRInterface.set_k2, Godot.Core.MobileVRInterface.set_oversample) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ARVRInterface() instance NodeProperty MobileVRInterface "display_to_lens" Float 'False where nodeProperty = (get_display_to_lens, wrapDroppingSetter set_display_to_lens, Nothing) instance NodeProperty MobileVRInterface "display_width" Float 'False where nodeProperty = (get_display_width, wrapDroppingSetter set_display_width, Nothing) instance NodeProperty MobileVRInterface "eye_height" Float 'False where nodeProperty = (get_eye_height, wrapDroppingSetter set_eye_height, Nothing) instance NodeProperty MobileVRInterface "iod" Float 'False where nodeProperty = (get_iod, wrapDroppingSetter set_iod, Nothing) instance NodeProperty MobileVRInterface "k1" Float 'False where nodeProperty = (get_k1, wrapDroppingSetter set_k1, Nothing) instance NodeProperty MobileVRInterface "k2" Float 'False where nodeProperty = (get_k2, wrapDroppingSetter set_k2, Nothing) instance NodeProperty MobileVRInterface "oversample" Float 'False where nodeProperty = (get_oversample, wrapDroppingSetter set_oversample, Nothing) {-# NOINLINE bindMobileVRInterface_get_display_to_lens #-} bindMobileVRInterface_get_display_to_lens :: MethodBind bindMobileVRInterface_get_display_to_lens = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "get_display_to_lens" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_display_to_lens :: (MobileVRInterface :< cls, Object :< cls) => cls -> IO Float get_display_to_lens cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_get_display_to_lens (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "get_display_to_lens" '[] (IO Float) where nodeMethod = Godot.Core.MobileVRInterface.get_display_to_lens {-# NOINLINE bindMobileVRInterface_get_display_width #-} bindMobileVRInterface_get_display_width :: MethodBind bindMobileVRInterface_get_display_width = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "get_display_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_display_width :: (MobileVRInterface :< cls, Object :< cls) => cls -> IO Float get_display_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_get_display_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "get_display_width" '[] (IO Float) where nodeMethod = Godot.Core.MobileVRInterface.get_display_width {-# NOINLINE bindMobileVRInterface_get_eye_height #-} bindMobileVRInterface_get_eye_height :: MethodBind bindMobileVRInterface_get_eye_height = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "get_eye_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_eye_height :: (MobileVRInterface :< cls, Object :< cls) => cls -> IO Float get_eye_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_get_eye_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "get_eye_height" '[] (IO Float) where nodeMethod = Godot.Core.MobileVRInterface.get_eye_height {-# NOINLINE bindMobileVRInterface_get_iod #-} bindMobileVRInterface_get_iod :: MethodBind bindMobileVRInterface_get_iod = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "get_iod" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_iod :: (MobileVRInterface :< cls, Object :< cls) => cls -> IO Float get_iod cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_get_iod (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "get_iod" '[] (IO Float) where nodeMethod = Godot.Core.MobileVRInterface.get_iod {-# NOINLINE bindMobileVRInterface_get_k1 #-} bindMobileVRInterface_get_k1 :: MethodBind bindMobileVRInterface_get_k1 = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "get_k1" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_k1 :: (MobileVRInterface :< cls, Object :< cls) => cls -> IO Float get_k1 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_get_k1 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "get_k1" '[] (IO Float) where nodeMethod = Godot.Core.MobileVRInterface.get_k1 {-# NOINLINE bindMobileVRInterface_get_k2 #-} bindMobileVRInterface_get_k2 :: MethodBind bindMobileVRInterface_get_k2 = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "get_k2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_k2 :: (MobileVRInterface :< cls, Object :< cls) => cls -> IO Float get_k2 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_get_k2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "get_k2" '[] (IO Float) where nodeMethod = Godot.Core.MobileVRInterface.get_k2 {-# NOINLINE bindMobileVRInterface_get_oversample #-} bindMobileVRInterface_get_oversample :: MethodBind bindMobileVRInterface_get_oversample = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "get_oversample" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_oversample :: (MobileVRInterface :< cls, Object :< cls) => cls -> IO Float get_oversample cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_get_oversample (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "get_oversample" '[] (IO Float) where nodeMethod = Godot.Core.MobileVRInterface.get_oversample {-# NOINLINE bindMobileVRInterface_set_display_to_lens #-} bindMobileVRInterface_set_display_to_lens :: MethodBind bindMobileVRInterface_set_display_to_lens = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "set_display_to_lens" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_display_to_lens :: (MobileVRInterface :< cls, Object :< cls) => cls -> Float -> IO () set_display_to_lens cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_set_display_to_lens (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "set_display_to_lens" '[Float] (IO ()) where nodeMethod = Godot.Core.MobileVRInterface.set_display_to_lens {-# NOINLINE bindMobileVRInterface_set_display_width #-} bindMobileVRInterface_set_display_width :: MethodBind bindMobileVRInterface_set_display_width = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "set_display_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_display_width :: (MobileVRInterface :< cls, Object :< cls) => cls -> Float -> IO () set_display_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_set_display_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "set_display_width" '[Float] (IO ()) where nodeMethod = Godot.Core.MobileVRInterface.set_display_width {-# NOINLINE bindMobileVRInterface_set_eye_height #-} bindMobileVRInterface_set_eye_height :: MethodBind bindMobileVRInterface_set_eye_height = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "set_eye_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_eye_height :: (MobileVRInterface :< cls, Object :< cls) => cls -> Float -> IO () set_eye_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_set_eye_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "set_eye_height" '[Float] (IO ()) where nodeMethod = Godot.Core.MobileVRInterface.set_eye_height {-# NOINLINE bindMobileVRInterface_set_iod #-} bindMobileVRInterface_set_iod :: MethodBind bindMobileVRInterface_set_iod = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "set_iod" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_iod :: (MobileVRInterface :< cls, Object :< cls) => cls -> Float -> IO () set_iod cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_set_iod (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "set_iod" '[Float] (IO ()) where nodeMethod = Godot.Core.MobileVRInterface.set_iod {-# NOINLINE bindMobileVRInterface_set_k1 #-} bindMobileVRInterface_set_k1 :: MethodBind bindMobileVRInterface_set_k1 = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "set_k1" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_k1 :: (MobileVRInterface :< cls, Object :< cls) => cls -> Float -> IO () set_k1 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_set_k1 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "set_k1" '[Float] (IO ()) where nodeMethod = Godot.Core.MobileVRInterface.set_k1 {-# NOINLINE bindMobileVRInterface_set_k2 #-} bindMobileVRInterface_set_k2 :: MethodBind bindMobileVRInterface_set_k2 = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "set_k2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_k2 :: (MobileVRInterface :< cls, Object :< cls) => cls -> Float -> IO () set_k2 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_set_k2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "set_k2" '[Float] (IO ()) where nodeMethod = Godot.Core.MobileVRInterface.set_k2 {-# NOINLINE bindMobileVRInterface_set_oversample #-} bindMobileVRInterface_set_oversample :: MethodBind bindMobileVRInterface_set_oversample = unsafePerformIO $ withCString "MobileVRInterface" $ \ clsNamePtr -> withCString "set_oversample" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_oversample :: (MobileVRInterface :< cls, Object :< cls) => cls -> Float -> IO () set_oversample cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMobileVRInterface_set_oversample (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MobileVRInterface "set_oversample" '[Float] (IO ()) where nodeMethod = Godot.Core.MobileVRInterface.set_oversample ================================================ FILE: src/Godot/Core/MultiMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MultiMesh (Godot.Core.MultiMesh._CUSTOM_DATA_8BIT, Godot.Core.MultiMesh._TRANSFORM_3D, Godot.Core.MultiMesh._COLOR_NONE, Godot.Core.MultiMesh._COLOR_FLOAT, Godot.Core.MultiMesh._TRANSFORM_2D, Godot.Core.MultiMesh._COLOR_8BIT, Godot.Core.MultiMesh._CUSTOM_DATA_FLOAT, Godot.Core.MultiMesh._CUSTOM_DATA_NONE, Godot.Core.MultiMesh._get_color_array, Godot.Core.MultiMesh._get_custom_data_array, Godot.Core.MultiMesh._get_transform_2d_array, Godot.Core.MultiMesh._get_transform_array, Godot.Core.MultiMesh._set_color_array, Godot.Core.MultiMesh._set_custom_data_array, Godot.Core.MultiMesh._set_transform_2d_array, Godot.Core.MultiMesh._set_transform_array, Godot.Core.MultiMesh.get_aabb, Godot.Core.MultiMesh.get_color_format, Godot.Core.MultiMesh.get_custom_data_format, Godot.Core.MultiMesh.get_instance_color, Godot.Core.MultiMesh.get_instance_count, Godot.Core.MultiMesh.get_instance_custom_data, Godot.Core.MultiMesh.get_instance_transform, Godot.Core.MultiMesh.get_instance_transform_2d, Godot.Core.MultiMesh.get_mesh, Godot.Core.MultiMesh.get_transform_format, Godot.Core.MultiMesh.get_visible_instance_count, Godot.Core.MultiMesh.set_as_bulk_array, Godot.Core.MultiMesh.set_color_format, Godot.Core.MultiMesh.set_custom_data_format, Godot.Core.MultiMesh.set_instance_color, Godot.Core.MultiMesh.set_instance_count, Godot.Core.MultiMesh.set_instance_custom_data, Godot.Core.MultiMesh.set_instance_transform, Godot.Core.MultiMesh.set_instance_transform_2d, Godot.Core.MultiMesh.set_mesh, Godot.Core.MultiMesh.set_transform_format, Godot.Core.MultiMesh.set_visible_instance_count) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _CUSTOM_DATA_8BIT :: Int _CUSTOM_DATA_8BIT = 1 _TRANSFORM_3D :: Int _TRANSFORM_3D = 1 _COLOR_NONE :: Int _COLOR_NONE = 0 _COLOR_FLOAT :: Int _COLOR_FLOAT = 2 _TRANSFORM_2D :: Int _TRANSFORM_2D = 0 _COLOR_8BIT :: Int _COLOR_8BIT = 1 _CUSTOM_DATA_FLOAT :: Int _CUSTOM_DATA_FLOAT = 2 _CUSTOM_DATA_NONE :: Int _CUSTOM_DATA_NONE = 0 instance NodeProperty MultiMesh "color_array" PoolColorArray 'False where nodeProperty = (_get_color_array, wrapDroppingSetter _set_color_array, Nothing) instance NodeProperty MultiMesh "color_format" Int 'False where nodeProperty = (get_color_format, wrapDroppingSetter set_color_format, Nothing) instance NodeProperty MultiMesh "custom_data_array" PoolColorArray 'False where nodeProperty = (_get_custom_data_array, wrapDroppingSetter _set_custom_data_array, Nothing) instance NodeProperty MultiMesh "custom_data_format" Int 'False where nodeProperty = (get_custom_data_format, wrapDroppingSetter set_custom_data_format, Nothing) instance NodeProperty MultiMesh "instance_count" Int 'False where nodeProperty = (get_instance_count, wrapDroppingSetter set_instance_count, Nothing) instance NodeProperty MultiMesh "mesh" Mesh 'False where nodeProperty = (get_mesh, wrapDroppingSetter set_mesh, Nothing) instance NodeProperty MultiMesh "transform_2d_array" PoolVector2Array 'False where nodeProperty = (_get_transform_2d_array, wrapDroppingSetter _set_transform_2d_array, Nothing) instance NodeProperty MultiMesh "transform_array" PoolVector3Array 'False where nodeProperty = (_get_transform_array, wrapDroppingSetter _set_transform_array, Nothing) instance NodeProperty MultiMesh "transform_format" Int 'False where nodeProperty = (get_transform_format, wrapDroppingSetter set_transform_format, Nothing) instance NodeProperty MultiMesh "visible_instance_count" Int 'False where nodeProperty = (get_visible_instance_count, wrapDroppingSetter set_visible_instance_count, Nothing) {-# NOINLINE bindMultiMesh__get_color_array #-} bindMultiMesh__get_color_array :: MethodBind bindMultiMesh__get_color_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "_get_color_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_color_array :: (MultiMesh :< cls, Object :< cls) => cls -> IO PoolColorArray _get_color_array cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh__get_color_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "_get_color_array" '[] (IO PoolColorArray) where nodeMethod = Godot.Core.MultiMesh._get_color_array {-# NOINLINE bindMultiMesh__get_custom_data_array #-} bindMultiMesh__get_custom_data_array :: MethodBind bindMultiMesh__get_custom_data_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "_get_custom_data_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_custom_data_array :: (MultiMesh :< cls, Object :< cls) => cls -> IO PoolColorArray _get_custom_data_array cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh__get_custom_data_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "_get_custom_data_array" '[] (IO PoolColorArray) where nodeMethod = Godot.Core.MultiMesh._get_custom_data_array {-# NOINLINE bindMultiMesh__get_transform_2d_array #-} bindMultiMesh__get_transform_2d_array :: MethodBind bindMultiMesh__get_transform_2d_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "_get_transform_2d_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_transform_2d_array :: (MultiMesh :< cls, Object :< cls) => cls -> IO PoolVector2Array _get_transform_2d_array cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh__get_transform_2d_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "_get_transform_2d_array" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.MultiMesh._get_transform_2d_array {-# NOINLINE bindMultiMesh__get_transform_array #-} bindMultiMesh__get_transform_array :: MethodBind bindMultiMesh__get_transform_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "_get_transform_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_transform_array :: (MultiMesh :< cls, Object :< cls) => cls -> IO PoolVector3Array _get_transform_array cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh__get_transform_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "_get_transform_array" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.MultiMesh._get_transform_array {-# NOINLINE bindMultiMesh__set_color_array #-} bindMultiMesh__set_color_array :: MethodBind bindMultiMesh__set_color_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "_set_color_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_color_array :: (MultiMesh :< cls, Object :< cls) => cls -> PoolColorArray -> IO () _set_color_array cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh__set_color_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "_set_color_array" '[PoolColorArray] (IO ()) where nodeMethod = Godot.Core.MultiMesh._set_color_array {-# NOINLINE bindMultiMesh__set_custom_data_array #-} bindMultiMesh__set_custom_data_array :: MethodBind bindMultiMesh__set_custom_data_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "_set_custom_data_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_custom_data_array :: (MultiMesh :< cls, Object :< cls) => cls -> PoolColorArray -> IO () _set_custom_data_array cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh__set_custom_data_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "_set_custom_data_array" '[PoolColorArray] (IO ()) where nodeMethod = Godot.Core.MultiMesh._set_custom_data_array {-# NOINLINE bindMultiMesh__set_transform_2d_array #-} bindMultiMesh__set_transform_2d_array :: MethodBind bindMultiMesh__set_transform_2d_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "_set_transform_2d_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_transform_2d_array :: (MultiMesh :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () _set_transform_2d_array cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh__set_transform_2d_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "_set_transform_2d_array" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.MultiMesh._set_transform_2d_array {-# NOINLINE bindMultiMesh__set_transform_array #-} bindMultiMesh__set_transform_array :: MethodBind bindMultiMesh__set_transform_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "_set_transform_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_transform_array :: (MultiMesh :< cls, Object :< cls) => cls -> PoolVector3Array -> IO () _set_transform_array cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh__set_transform_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "_set_transform_array" '[PoolVector3Array] (IO ()) where nodeMethod = Godot.Core.MultiMesh._set_transform_array {-# NOINLINE bindMultiMesh_get_aabb #-} -- | Returns the visibility axis-aligned bounding box in local space. See also @method VisualInstance.get_transformed_aabb@. bindMultiMesh_get_aabb :: MethodBind bindMultiMesh_get_aabb = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the visibility axis-aligned bounding box in local space. See also @method VisualInstance.get_transformed_aabb@. get_aabb :: (MultiMesh :< cls, Object :< cls) => cls -> IO Aabb get_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.MultiMesh.get_aabb {-# NOINLINE bindMultiMesh_get_color_format #-} -- | Format of colors in color array that gets passed to shader. bindMultiMesh_get_color_format :: MethodBind bindMultiMesh_get_color_format = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_color_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Format of colors in color array that gets passed to shader. get_color_format :: (MultiMesh :< cls, Object :< cls) => cls -> IO Int get_color_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_color_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_color_format" '[] (IO Int) where nodeMethod = Godot.Core.MultiMesh.get_color_format {-# NOINLINE bindMultiMesh_get_custom_data_format #-} -- | Format of custom data in custom data array that gets passed to shader. bindMultiMesh_get_custom_data_format :: MethodBind bindMultiMesh_get_custom_data_format = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_custom_data_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Format of custom data in custom data array that gets passed to shader. get_custom_data_format :: (MultiMesh :< cls, Object :< cls) => cls -> IO Int get_custom_data_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_custom_data_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_custom_data_format" '[] (IO Int) where nodeMethod = Godot.Core.MultiMesh.get_custom_data_format {-# NOINLINE bindMultiMesh_get_instance_color #-} -- | Gets a specific instance's color. bindMultiMesh_get_instance_color :: MethodBind bindMultiMesh_get_instance_color = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_instance_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a specific instance's color. get_instance_color :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO Color get_instance_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_instance_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_instance_color" '[Int] (IO Color) where nodeMethod = Godot.Core.MultiMesh.get_instance_color {-# NOINLINE bindMultiMesh_get_instance_count #-} -- | Number of instances that will get drawn. This clears and (re)sizes the buffers. By default, all instances are drawn but you can limit this with @visible_instance_count@. bindMultiMesh_get_instance_count :: MethodBind bindMultiMesh_get_instance_count = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_instance_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of instances that will get drawn. This clears and (re)sizes the buffers. By default, all instances are drawn but you can limit this with @visible_instance_count@. get_instance_count :: (MultiMesh :< cls, Object :< cls) => cls -> IO Int get_instance_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_instance_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_instance_count" '[] (IO Int) where nodeMethod = Godot.Core.MultiMesh.get_instance_count {-# NOINLINE bindMultiMesh_get_instance_custom_data #-} -- | Returns the custom data that has been set for a specific instance. bindMultiMesh_get_instance_custom_data :: MethodBind bindMultiMesh_get_instance_custom_data = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_instance_custom_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the custom data that has been set for a specific instance. get_instance_custom_data :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO Color get_instance_custom_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_instance_custom_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_instance_custom_data" '[Int] (IO Color) where nodeMethod = Godot.Core.MultiMesh.get_instance_custom_data {-# NOINLINE bindMultiMesh_get_instance_transform #-} -- | Returns the @Transform@ of a specific instance. bindMultiMesh_get_instance_transform :: MethodBind bindMultiMesh_get_instance_transform = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_instance_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Transform@ of a specific instance. get_instance_transform :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO Transform get_instance_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_instance_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_instance_transform" '[Int] (IO Transform) where nodeMethod = Godot.Core.MultiMesh.get_instance_transform {-# NOINLINE bindMultiMesh_get_instance_transform_2d #-} -- | Returns the @Transform2D@ of a specific instance. bindMultiMesh_get_instance_transform_2d :: MethodBind bindMultiMesh_get_instance_transform_2d = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_instance_transform_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Transform2D@ of a specific instance. get_instance_transform_2d :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO Transform2d get_instance_transform_2d cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_instance_transform_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_instance_transform_2d" '[Int] (IO Transform2d) where nodeMethod = Godot.Core.MultiMesh.get_instance_transform_2d {-# NOINLINE bindMultiMesh_get_mesh #-} -- | Mesh to be drawn. bindMultiMesh_get_mesh :: MethodBind bindMultiMesh_get_mesh = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Mesh to be drawn. get_mesh :: (MultiMesh :< cls, Object :< cls) => cls -> IO Mesh get_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_mesh" '[] (IO Mesh) where nodeMethod = Godot.Core.MultiMesh.get_mesh {-# NOINLINE bindMultiMesh_get_transform_format #-} -- | Format of transform used to transform mesh, either 2D or 3D. bindMultiMesh_get_transform_format :: MethodBind bindMultiMesh_get_transform_format = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_transform_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Format of transform used to transform mesh, either 2D or 3D. get_transform_format :: (MultiMesh :< cls, Object :< cls) => cls -> IO Int get_transform_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_transform_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_transform_format" '[] (IO Int) where nodeMethod = Godot.Core.MultiMesh.get_transform_format {-# NOINLINE bindMultiMesh_get_visible_instance_count #-} -- | Limits the number of instances drawn, -1 draws all instances. Changing this does not change the sizes of the buffers. bindMultiMesh_get_visible_instance_count :: MethodBind bindMultiMesh_get_visible_instance_count = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "get_visible_instance_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Limits the number of instances drawn, -1 draws all instances. Changing this does not change the sizes of the buffers. get_visible_instance_count :: (MultiMesh :< cls, Object :< cls) => cls -> IO Int get_visible_instance_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_get_visible_instance_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "get_visible_instance_count" '[] (IO Int) where nodeMethod = Godot.Core.MultiMesh.get_visible_instance_count {-# NOINLINE bindMultiMesh_set_as_bulk_array #-} -- | Sets all data related to the instances in one go. This is especially useful when loading the data from disk or preparing the data from GDNative. -- All data is packed in one large float array. An array may look like this: Transform for instance 1, color data for instance 1, custom data for instance 1, transform for instance 2, color data for instance 2, etc... -- @Transform@ is stored as 12 floats, @Transform2D@ is stored as 8 floats, @COLOR_8BIT@ / @CUSTOM_DATA_8BIT@ is stored as 1 float (4 bytes as is) and @COLOR_FLOAT@ / @CUSTOM_DATA_FLOAT@ is stored as 4 floats. bindMultiMesh_set_as_bulk_array :: MethodBind bindMultiMesh_set_as_bulk_array = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_as_bulk_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets all data related to the instances in one go. This is especially useful when loading the data from disk or preparing the data from GDNative. -- All data is packed in one large float array. An array may look like this: Transform for instance 1, color data for instance 1, custom data for instance 1, transform for instance 2, color data for instance 2, etc... -- @Transform@ is stored as 12 floats, @Transform2D@ is stored as 8 floats, @COLOR_8BIT@ / @CUSTOM_DATA_8BIT@ is stored as 1 float (4 bytes as is) and @COLOR_FLOAT@ / @CUSTOM_DATA_FLOAT@ is stored as 4 floats. set_as_bulk_array :: (MultiMesh :< cls, Object :< cls) => cls -> PoolRealArray -> IO () set_as_bulk_array cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_as_bulk_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_as_bulk_array" '[PoolRealArray] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_as_bulk_array {-# NOINLINE bindMultiMesh_set_color_format #-} -- | Format of colors in color array that gets passed to shader. bindMultiMesh_set_color_format :: MethodBind bindMultiMesh_set_color_format = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_color_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Format of colors in color array that gets passed to shader. set_color_format :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO () set_color_format cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_color_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_color_format" '[Int] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_color_format {-# NOINLINE bindMultiMesh_set_custom_data_format #-} -- | Format of custom data in custom data array that gets passed to shader. bindMultiMesh_set_custom_data_format :: MethodBind bindMultiMesh_set_custom_data_format = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_custom_data_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Format of custom data in custom data array that gets passed to shader. set_custom_data_format :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO () set_custom_data_format cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_custom_data_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_custom_data_format" '[Int] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_custom_data_format {-# NOINLINE bindMultiMesh_set_instance_color #-} -- | Sets the color of a specific instance. -- For the color to take effect, ensure that @color_format@ is non-@null@ on the @MultiMesh@ and @SpatialMaterial.vertex_color_use_as_albedo@ is @true@ on the material. bindMultiMesh_set_instance_color :: MethodBind bindMultiMesh_set_instance_color = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_instance_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color of a specific instance. -- For the color to take effect, ensure that @color_format@ is non-@null@ on the @MultiMesh@ and @SpatialMaterial.vertex_color_use_as_albedo@ is @true@ on the material. set_instance_color :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_instance_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_instance_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_instance_color" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_instance_color {-# NOINLINE bindMultiMesh_set_instance_count #-} -- | Number of instances that will get drawn. This clears and (re)sizes the buffers. By default, all instances are drawn but you can limit this with @visible_instance_count@. bindMultiMesh_set_instance_count :: MethodBind bindMultiMesh_set_instance_count = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_instance_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of instances that will get drawn. This clears and (re)sizes the buffers. By default, all instances are drawn but you can limit this with @visible_instance_count@. set_instance_count :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO () set_instance_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_instance_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_instance_count" '[Int] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_instance_count {-# NOINLINE bindMultiMesh_set_instance_custom_data #-} -- | Sets custom data for a specific instance. Although @Color@ is used, it is just a container for 4 floating point numbers. The format of the number can change depending on the @enum CustomDataFormat@ used. bindMultiMesh_set_instance_custom_data :: MethodBind bindMultiMesh_set_instance_custom_data = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_instance_custom_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets custom data for a specific instance. Although @Color@ is used, it is just a container for 4 floating point numbers. The format of the number can change depending on the @enum CustomDataFormat@ used. set_instance_custom_data :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_instance_custom_data cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_instance_custom_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_instance_custom_data" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_instance_custom_data {-# NOINLINE bindMultiMesh_set_instance_transform #-} -- | Sets the @Transform@ for a specific instance. bindMultiMesh_set_instance_transform :: MethodBind bindMultiMesh_set_instance_transform = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_instance_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform@ for a specific instance. set_instance_transform :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> Transform -> IO () set_instance_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_instance_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_instance_transform" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_instance_transform {-# NOINLINE bindMultiMesh_set_instance_transform_2d #-} -- | Sets the @Transform2D@ for a specific instance. bindMultiMesh_set_instance_transform_2d :: MethodBind bindMultiMesh_set_instance_transform_2d = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_instance_transform_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform2D@ for a specific instance. set_instance_transform_2d :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> Transform2d -> IO () set_instance_transform_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_instance_transform_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_instance_transform_2d" '[Int, Transform2d] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_instance_transform_2d {-# NOINLINE bindMultiMesh_set_mesh #-} -- | Mesh to be drawn. bindMultiMesh_set_mesh :: MethodBind bindMultiMesh_set_mesh = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Mesh to be drawn. set_mesh :: (MultiMesh :< cls, Object :< cls) => cls -> Mesh -> IO () set_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_mesh" '[Mesh] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_mesh {-# NOINLINE bindMultiMesh_set_transform_format #-} -- | Format of transform used to transform mesh, either 2D or 3D. bindMultiMesh_set_transform_format :: MethodBind bindMultiMesh_set_transform_format = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_transform_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Format of transform used to transform mesh, either 2D or 3D. set_transform_format :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO () set_transform_format cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_transform_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_transform_format" '[Int] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_transform_format {-# NOINLINE bindMultiMesh_set_visible_instance_count #-} -- | Limits the number of instances drawn, -1 draws all instances. Changing this does not change the sizes of the buffers. bindMultiMesh_set_visible_instance_count :: MethodBind bindMultiMesh_set_visible_instance_count = unsafePerformIO $ withCString "MultiMesh" $ \ clsNamePtr -> withCString "set_visible_instance_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Limits the number of instances drawn, -1 draws all instances. Changing this does not change the sizes of the buffers. set_visible_instance_count :: (MultiMesh :< cls, Object :< cls) => cls -> Int -> IO () set_visible_instance_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMesh_set_visible_instance_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMesh "set_visible_instance_count" '[Int] (IO ()) where nodeMethod = Godot.Core.MultiMesh.set_visible_instance_count ================================================ FILE: src/Godot/Core/MultiMeshInstance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MultiMeshInstance (Godot.Core.MultiMeshInstance.get_multimesh, Godot.Core.MultiMeshInstance.set_multimesh) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.GeometryInstance() instance NodeProperty MultiMeshInstance "multimesh" MultiMesh 'False where nodeProperty = (get_multimesh, wrapDroppingSetter set_multimesh, Nothing) {-# NOINLINE bindMultiMeshInstance_get_multimesh #-} -- | The @MultiMesh@ resource that will be used and shared among all instances of the @MultiMeshInstance@. bindMultiMeshInstance_get_multimesh :: MethodBind bindMultiMeshInstance_get_multimesh = unsafePerformIO $ withCString "MultiMeshInstance" $ \ clsNamePtr -> withCString "get_multimesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @MultiMesh@ resource that will be used and shared among all instances of the @MultiMeshInstance@. get_multimesh :: (MultiMeshInstance :< cls, Object :< cls) => cls -> IO MultiMesh get_multimesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMeshInstance_get_multimesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMeshInstance "get_multimesh" '[] (IO MultiMesh) where nodeMethod = Godot.Core.MultiMeshInstance.get_multimesh {-# NOINLINE bindMultiMeshInstance_set_multimesh #-} -- | The @MultiMesh@ resource that will be used and shared among all instances of the @MultiMeshInstance@. bindMultiMeshInstance_set_multimesh :: MethodBind bindMultiMeshInstance_set_multimesh = unsafePerformIO $ withCString "MultiMeshInstance" $ \ clsNamePtr -> withCString "set_multimesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @MultiMesh@ resource that will be used and shared among all instances of the @MultiMeshInstance@. set_multimesh :: (MultiMeshInstance :< cls, Object :< cls) => cls -> MultiMesh -> IO () set_multimesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMeshInstance_set_multimesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMeshInstance "set_multimesh" '[MultiMesh] (IO ()) where nodeMethod = Godot.Core.MultiMeshInstance.set_multimesh ================================================ FILE: src/Godot/Core/MultiMeshInstance2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MultiMeshInstance2D (Godot.Core.MultiMeshInstance2D.sig_texture_changed, Godot.Core.MultiMeshInstance2D.get_multimesh, Godot.Core.MultiMeshInstance2D.get_normal_map, Godot.Core.MultiMeshInstance2D.get_texture, Godot.Core.MultiMeshInstance2D.set_multimesh, Godot.Core.MultiMeshInstance2D.set_normal_map, Godot.Core.MultiMeshInstance2D.set_texture) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() -- | Emitted when the @texture@ is changed. sig_texture_changed :: Godot.Internal.Dispatch.Signal MultiMeshInstance2D sig_texture_changed = Godot.Internal.Dispatch.Signal "texture_changed" instance NodeSignal MultiMeshInstance2D "texture_changed" '[] instance NodeProperty MultiMeshInstance2D "multimesh" MultiMesh 'False where nodeProperty = (get_multimesh, wrapDroppingSetter set_multimesh, Nothing) instance NodeProperty MultiMeshInstance2D "normal_map" Texture 'False where nodeProperty = (get_normal_map, wrapDroppingSetter set_normal_map, Nothing) instance NodeProperty MultiMeshInstance2D "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) {-# NOINLINE bindMultiMeshInstance2D_get_multimesh #-} -- | The @MultiMesh@ that will be drawn by the @MultiMeshInstance2D@. bindMultiMeshInstance2D_get_multimesh :: MethodBind bindMultiMeshInstance2D_get_multimesh = unsafePerformIO $ withCString "MultiMeshInstance2D" $ \ clsNamePtr -> withCString "get_multimesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @MultiMesh@ that will be drawn by the @MultiMeshInstance2D@. get_multimesh :: (MultiMeshInstance2D :< cls, Object :< cls) => cls -> IO MultiMesh get_multimesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMeshInstance2D_get_multimesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMeshInstance2D "get_multimesh" '[] (IO MultiMesh) where nodeMethod = Godot.Core.MultiMeshInstance2D.get_multimesh {-# NOINLINE bindMultiMeshInstance2D_get_normal_map #-} -- | The normal map that will be used if using the default @CanvasItemMaterial@. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindMultiMeshInstance2D_get_normal_map :: MethodBind bindMultiMeshInstance2D_get_normal_map = unsafePerformIO $ withCString "MultiMeshInstance2D" $ \ clsNamePtr -> withCString "get_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The normal map that will be used if using the default @CanvasItemMaterial@. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. get_normal_map :: (MultiMeshInstance2D :< cls, Object :< cls) => cls -> IO Texture get_normal_map cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMeshInstance2D_get_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMeshInstance2D "get_normal_map" '[] (IO Texture) where nodeMethod = Godot.Core.MultiMeshInstance2D.get_normal_map {-# NOINLINE bindMultiMeshInstance2D_get_texture #-} -- | The @Texture@ that will be used if using the default @CanvasItemMaterial@. Can be accessed as @TEXTURE@ in CanvasItem shader. bindMultiMeshInstance2D_get_texture :: MethodBind bindMultiMeshInstance2D_get_texture = unsafePerformIO $ withCString "MultiMeshInstance2D" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Texture@ that will be used if using the default @CanvasItemMaterial@. Can be accessed as @TEXTURE@ in CanvasItem shader. get_texture :: (MultiMeshInstance2D :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMeshInstance2D_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMeshInstance2D "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.MultiMeshInstance2D.get_texture {-# NOINLINE bindMultiMeshInstance2D_set_multimesh #-} -- | The @MultiMesh@ that will be drawn by the @MultiMeshInstance2D@. bindMultiMeshInstance2D_set_multimesh :: MethodBind bindMultiMeshInstance2D_set_multimesh = unsafePerformIO $ withCString "MultiMeshInstance2D" $ \ clsNamePtr -> withCString "set_multimesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @MultiMesh@ that will be drawn by the @MultiMeshInstance2D@. set_multimesh :: (MultiMeshInstance2D :< cls, Object :< cls) => cls -> MultiMesh -> IO () set_multimesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMeshInstance2D_set_multimesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMeshInstance2D "set_multimesh" '[MultiMesh] (IO ()) where nodeMethod = Godot.Core.MultiMeshInstance2D.set_multimesh {-# NOINLINE bindMultiMeshInstance2D_set_normal_map #-} -- | The normal map that will be used if using the default @CanvasItemMaterial@. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindMultiMeshInstance2D_set_normal_map :: MethodBind bindMultiMeshInstance2D_set_normal_map = unsafePerformIO $ withCString "MultiMeshInstance2D" $ \ clsNamePtr -> withCString "set_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The normal map that will be used if using the default @CanvasItemMaterial@. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. set_normal_map :: (MultiMeshInstance2D :< cls, Object :< cls) => cls -> Texture -> IO () set_normal_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMeshInstance2D_set_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMeshInstance2D "set_normal_map" '[Texture] (IO ()) where nodeMethod = Godot.Core.MultiMeshInstance2D.set_normal_map {-# NOINLINE bindMultiMeshInstance2D_set_texture #-} -- | The @Texture@ that will be used if using the default @CanvasItemMaterial@. Can be accessed as @TEXTURE@ in CanvasItem shader. bindMultiMeshInstance2D_set_texture :: MethodBind bindMultiMeshInstance2D_set_texture = unsafePerformIO $ withCString "MultiMeshInstance2D" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Texture@ that will be used if using the default @CanvasItemMaterial@. Can be accessed as @TEXTURE@ in CanvasItem shader. set_texture :: (MultiMeshInstance2D :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiMeshInstance2D_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiMeshInstance2D "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.MultiMeshInstance2D.set_texture ================================================ FILE: src/Godot/Core/MultiplayerAPI.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MultiplayerAPI (Godot.Core.MultiplayerAPI._RPC_MODE_SLAVE, Godot.Core.MultiplayerAPI._RPC_MODE_DISABLED, Godot.Core.MultiplayerAPI._RPC_MODE_MASTER, Godot.Core.MultiplayerAPI._RPC_MODE_MASTERSYNC, Godot.Core.MultiplayerAPI._RPC_MODE_SYNC, Godot.Core.MultiplayerAPI._RPC_MODE_REMOTE, Godot.Core.MultiplayerAPI._RPC_MODE_PUPPET, Godot.Core.MultiplayerAPI._RPC_MODE_PUPPETSYNC, Godot.Core.MultiplayerAPI._RPC_MODE_REMOTESYNC, Godot.Core.MultiplayerAPI.sig_connected_to_server, Godot.Core.MultiplayerAPI.sig_connection_failed, Godot.Core.MultiplayerAPI.sig_network_peer_connected, Godot.Core.MultiplayerAPI.sig_network_peer_disconnected, Godot.Core.MultiplayerAPI.sig_network_peer_packet, Godot.Core.MultiplayerAPI.sig_server_disconnected, Godot.Core.MultiplayerAPI._add_peer, Godot.Core.MultiplayerAPI._connected_to_server, Godot.Core.MultiplayerAPI._connection_failed, Godot.Core.MultiplayerAPI._del_peer, Godot.Core.MultiplayerAPI._server_disconnected, Godot.Core.MultiplayerAPI.clear, Godot.Core.MultiplayerAPI.get_network_connected_peers, Godot.Core.MultiplayerAPI.get_network_peer, Godot.Core.MultiplayerAPI.get_network_unique_id, Godot.Core.MultiplayerAPI.get_rpc_sender_id, Godot.Core.MultiplayerAPI.has_network_peer, Godot.Core.MultiplayerAPI.is_network_server, Godot.Core.MultiplayerAPI.is_object_decoding_allowed, Godot.Core.MultiplayerAPI.is_refusing_new_network_connections, Godot.Core.MultiplayerAPI.poll, Godot.Core.MultiplayerAPI.send_bytes, Godot.Core.MultiplayerAPI.set_allow_object_decoding, Godot.Core.MultiplayerAPI.set_network_peer, Godot.Core.MultiplayerAPI.set_refuse_new_network_connections, Godot.Core.MultiplayerAPI.set_root_node) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _RPC_MODE_SLAVE :: Int _RPC_MODE_SLAVE = 3 _RPC_MODE_DISABLED :: Int _RPC_MODE_DISABLED = 0 _RPC_MODE_MASTER :: Int _RPC_MODE_MASTER = 2 _RPC_MODE_MASTERSYNC :: Int _RPC_MODE_MASTERSYNC = 5 _RPC_MODE_SYNC :: Int _RPC_MODE_SYNC = 4 _RPC_MODE_REMOTE :: Int _RPC_MODE_REMOTE = 1 _RPC_MODE_PUPPET :: Int _RPC_MODE_PUPPET = 3 _RPC_MODE_PUPPETSYNC :: Int _RPC_MODE_PUPPETSYNC = 6 _RPC_MODE_REMOTESYNC :: Int _RPC_MODE_REMOTESYNC = 4 -- | Emitted when this MultiplayerAPI's @network_peer@ successfully connected to a server. Only emitted on clients. sig_connected_to_server :: Godot.Internal.Dispatch.Signal MultiplayerAPI sig_connected_to_server = Godot.Internal.Dispatch.Signal "connected_to_server" instance NodeSignal MultiplayerAPI "connected_to_server" '[] -- | Emitted when this MultiplayerAPI's @network_peer@ fails to establish a connection to a server. Only emitted on clients. sig_connection_failed :: Godot.Internal.Dispatch.Signal MultiplayerAPI sig_connection_failed = Godot.Internal.Dispatch.Signal "connection_failed" instance NodeSignal MultiplayerAPI "connection_failed" '[] -- | Emitted when this MultiplayerAPI's @network_peer@ connects with a new peer. ID is the peer ID of the new peer. Clients get notified when other clients connect to the same server. Upon connecting to a server, a client also receives this signal for the server (with ID being 1). sig_network_peer_connected :: Godot.Internal.Dispatch.Signal MultiplayerAPI sig_network_peer_connected = Godot.Internal.Dispatch.Signal "network_peer_connected" instance NodeSignal MultiplayerAPI "network_peer_connected" '[Int] -- | Emitted when this MultiplayerAPI's @network_peer@ disconnects from a peer. Clients get notified when other clients disconnect from the same server. sig_network_peer_disconnected :: Godot.Internal.Dispatch.Signal MultiplayerAPI sig_network_peer_disconnected = Godot.Internal.Dispatch.Signal "network_peer_disconnected" instance NodeSignal MultiplayerAPI "network_peer_disconnected" '[Int] -- | Emitted when this MultiplayerAPI's @network_peer@ receive a @packet@ with custom data (see @method send_bytes@). ID is the peer ID of the peer that sent the packet. sig_network_peer_packet :: Godot.Internal.Dispatch.Signal MultiplayerAPI sig_network_peer_packet = Godot.Internal.Dispatch.Signal "network_peer_packet" instance NodeSignal MultiplayerAPI "network_peer_packet" '[Int, PoolByteArray] -- | Emitted when this MultiplayerAPI's @network_peer@ disconnects from server. Only emitted on clients. sig_server_disconnected :: Godot.Internal.Dispatch.Signal MultiplayerAPI sig_server_disconnected = Godot.Internal.Dispatch.Signal "server_disconnected" instance NodeSignal MultiplayerAPI "server_disconnected" '[] instance NodeProperty MultiplayerAPI "allow_object_decoding" Bool 'False where nodeProperty = (is_object_decoding_allowed, wrapDroppingSetter set_allow_object_decoding, Nothing) instance NodeProperty MultiplayerAPI "network_peer" NetworkedMultiplayerPeer 'False where nodeProperty = (get_network_peer, wrapDroppingSetter set_network_peer, Nothing) instance NodeProperty MultiplayerAPI "refuse_new_network_connections" Bool 'False where nodeProperty = (is_refusing_new_network_connections, wrapDroppingSetter set_refuse_new_network_connections, Nothing) {-# NOINLINE bindMultiplayerAPI__add_peer #-} bindMultiplayerAPI__add_peer :: MethodBind bindMultiplayerAPI__add_peer = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "_add_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _add_peer :: (MultiplayerAPI :< cls, Object :< cls) => cls -> Int -> IO () _add_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI__add_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "_add_peer" '[Int] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI._add_peer {-# NOINLINE bindMultiplayerAPI__connected_to_server #-} bindMultiplayerAPI__connected_to_server :: MethodBind bindMultiplayerAPI__connected_to_server = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "_connected_to_server" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _connected_to_server :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO () _connected_to_server cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI__connected_to_server (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "_connected_to_server" '[] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI._connected_to_server {-# NOINLINE bindMultiplayerAPI__connection_failed #-} bindMultiplayerAPI__connection_failed :: MethodBind bindMultiplayerAPI__connection_failed = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "_connection_failed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _connection_failed :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO () _connection_failed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI__connection_failed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "_connection_failed" '[] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI._connection_failed {-# NOINLINE bindMultiplayerAPI__del_peer #-} bindMultiplayerAPI__del_peer :: MethodBind bindMultiplayerAPI__del_peer = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "_del_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _del_peer :: (MultiplayerAPI :< cls, Object :< cls) => cls -> Int -> IO () _del_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI__del_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "_del_peer" '[Int] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI._del_peer {-# NOINLINE bindMultiplayerAPI__server_disconnected #-} bindMultiplayerAPI__server_disconnected :: MethodBind bindMultiplayerAPI__server_disconnected = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "_server_disconnected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _server_disconnected :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO () _server_disconnected cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI__server_disconnected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "_server_disconnected" '[] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI._server_disconnected {-# NOINLINE bindMultiplayerAPI_clear #-} -- | Clears the current MultiplayerAPI network state (you shouldn't call this unless you know what you are doing). bindMultiplayerAPI_clear :: MethodBind bindMultiplayerAPI_clear = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the current MultiplayerAPI network state (you shouldn't call this unless you know what you are doing). clear :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "clear" '[] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI.clear {-# NOINLINE bindMultiplayerAPI_get_network_connected_peers #-} -- | Returns the peer IDs of all connected peers of this MultiplayerAPI's @network_peer@. bindMultiplayerAPI_get_network_connected_peers :: MethodBind bindMultiplayerAPI_get_network_connected_peers = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "get_network_connected_peers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the peer IDs of all connected peers of this MultiplayerAPI's @network_peer@. get_network_connected_peers :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO PoolIntArray get_network_connected_peers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_get_network_connected_peers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "get_network_connected_peers" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.MultiplayerAPI.get_network_connected_peers {-# NOINLINE bindMultiplayerAPI_get_network_peer #-} -- | The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the MultiplayerAPI will become a network server (check with @method is_network_server@) and will set root node's network mode to master, or it will become a regular peer with root node set to puppet. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to MultiplayerAPI's signals. bindMultiplayerAPI_get_network_peer :: MethodBind bindMultiplayerAPI_get_network_peer = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "get_network_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the MultiplayerAPI will become a network server (check with @method is_network_server@) and will set root node's network mode to master, or it will become a regular peer with root node set to puppet. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to MultiplayerAPI's signals. get_network_peer :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO NetworkedMultiplayerPeer get_network_peer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_get_network_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "get_network_peer" '[] (IO NetworkedMultiplayerPeer) where nodeMethod = Godot.Core.MultiplayerAPI.get_network_peer {-# NOINLINE bindMultiplayerAPI_get_network_unique_id #-} -- | Returns the unique peer ID of this MultiplayerAPI's @network_peer@. bindMultiplayerAPI_get_network_unique_id :: MethodBind bindMultiplayerAPI_get_network_unique_id = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "get_network_unique_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the unique peer ID of this MultiplayerAPI's @network_peer@. get_network_unique_id :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO Int get_network_unique_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_get_network_unique_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "get_network_unique_id" '[] (IO Int) where nodeMethod = Godot.Core.MultiplayerAPI.get_network_unique_id {-# NOINLINE bindMultiplayerAPI_get_rpc_sender_id #-} -- | Returns the sender's peer ID for the RPC currently being executed. -- __Note:__ If not inside an RPC this method will return 0. bindMultiplayerAPI_get_rpc_sender_id :: MethodBind bindMultiplayerAPI_get_rpc_sender_id = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "get_rpc_sender_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the sender's peer ID for the RPC currently being executed. -- __Note:__ If not inside an RPC this method will return 0. get_rpc_sender_id :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO Int get_rpc_sender_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_get_rpc_sender_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "get_rpc_sender_id" '[] (IO Int) where nodeMethod = Godot.Core.MultiplayerAPI.get_rpc_sender_id {-# NOINLINE bindMultiplayerAPI_has_network_peer #-} -- | Returns @true@ if there is a @network_peer@ set. bindMultiplayerAPI_has_network_peer :: MethodBind bindMultiplayerAPI_has_network_peer = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "has_network_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if there is a @network_peer@ set. has_network_peer :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO Bool has_network_peer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_has_network_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "has_network_peer" '[] (IO Bool) where nodeMethod = Godot.Core.MultiplayerAPI.has_network_peer {-# NOINLINE bindMultiplayerAPI_is_network_server #-} -- | Returns @true@ if this MultiplayerAPI's @network_peer@ is in server mode (listening for connections). bindMultiplayerAPI_is_network_server :: MethodBind bindMultiplayerAPI_is_network_server = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "is_network_server" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this MultiplayerAPI's @network_peer@ is in server mode (listening for connections). is_network_server :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO Bool is_network_server cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_is_network_server (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "is_network_server" '[] (IO Bool) where nodeMethod = Godot.Core.MultiplayerAPI.is_network_server {-# NOINLINE bindMultiplayerAPI_is_object_decoding_allowed #-} -- | If @true@ (or if the @network_peer@ has @PacketPeer.allow_object_decoding@ set to @true@), the MultiplayerAPI will allow encoding and decoding of object during RPCs/RSETs. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. bindMultiplayerAPI_is_object_decoding_allowed :: MethodBind bindMultiplayerAPI_is_object_decoding_allowed = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "is_object_decoding_allowed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@ (or if the @network_peer@ has @PacketPeer.allow_object_decoding@ set to @true@), the MultiplayerAPI will allow encoding and decoding of object during RPCs/RSETs. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. is_object_decoding_allowed :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO Bool is_object_decoding_allowed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_is_object_decoding_allowed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "is_object_decoding_allowed" '[] (IO Bool) where nodeMethod = Godot.Core.MultiplayerAPI.is_object_decoding_allowed {-# NOINLINE bindMultiplayerAPI_is_refusing_new_network_connections #-} -- | If @true@, the MultiplayerAPI's @network_peer@ refuses new incoming connections. bindMultiplayerAPI_is_refusing_new_network_connections :: MethodBind bindMultiplayerAPI_is_refusing_new_network_connections = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "is_refusing_new_network_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the MultiplayerAPI's @network_peer@ refuses new incoming connections. is_refusing_new_network_connections :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO Bool is_refusing_new_network_connections cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_is_refusing_new_network_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "is_refusing_new_network_connections" '[] (IO Bool) where nodeMethod = Godot.Core.MultiplayerAPI.is_refusing_new_network_connections {-# NOINLINE bindMultiplayerAPI_poll #-} -- | Method used for polling the MultiplayerAPI. You only need to worry about this if you are using @Node.custom_multiplayer@ override or you set @SceneTree.multiplayer_poll@ to @false@. By default, @SceneTree@ will poll its MultiplayerAPI for you. -- __Note:__ This method results in RPCs and RSETs being called, so they will be executed in the same context of this function (e.g. @_process@, @physics@, @Thread@). bindMultiplayerAPI_poll :: MethodBind bindMultiplayerAPI_poll = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "poll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Method used for polling the MultiplayerAPI. You only need to worry about this if you are using @Node.custom_multiplayer@ override or you set @SceneTree.multiplayer_poll@ to @false@. By default, @SceneTree@ will poll its MultiplayerAPI for you. -- __Note:__ This method results in RPCs and RSETs being called, so they will be executed in the same context of this function (e.g. @_process@, @physics@, @Thread@). poll :: (MultiplayerAPI :< cls, Object :< cls) => cls -> IO () poll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_poll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "poll" '[] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI.poll {-# NOINLINE bindMultiplayerAPI_send_bytes #-} -- | Sends the given raw @bytes@ to a specific peer identified by @id@ (see @method NetworkedMultiplayerPeer.set_target_peer@). Default ID is @0@, i.e. broadcast to all peers. bindMultiplayerAPI_send_bytes :: MethodBind bindMultiplayerAPI_send_bytes = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "send_bytes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends the given raw @bytes@ to a specific peer identified by @id@ (see @method NetworkedMultiplayerPeer.set_target_peer@). Default ID is @0@, i.e. broadcast to all peers. send_bytes :: (MultiplayerAPI :< cls, Object :< cls) => cls -> PoolByteArray -> Maybe Int -> Maybe Int -> IO Int send_bytes cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, maybe (VariantInt (2)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_send_bytes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "send_bytes" '[PoolByteArray, Maybe Int, Maybe Int] (IO Int) where nodeMethod = Godot.Core.MultiplayerAPI.send_bytes {-# NOINLINE bindMultiplayerAPI_set_allow_object_decoding #-} -- | If @true@ (or if the @network_peer@ has @PacketPeer.allow_object_decoding@ set to @true@), the MultiplayerAPI will allow encoding and decoding of object during RPCs/RSETs. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. bindMultiplayerAPI_set_allow_object_decoding :: MethodBind bindMultiplayerAPI_set_allow_object_decoding = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "set_allow_object_decoding" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@ (or if the @network_peer@ has @PacketPeer.allow_object_decoding@ set to @true@), the MultiplayerAPI will allow encoding and decoding of object during RPCs/RSETs. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. set_allow_object_decoding :: (MultiplayerAPI :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_object_decoding cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_set_allow_object_decoding (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "set_allow_object_decoding" '[Bool] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI.set_allow_object_decoding {-# NOINLINE bindMultiplayerAPI_set_network_peer #-} -- | The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the MultiplayerAPI will become a network server (check with @method is_network_server@) and will set root node's network mode to master, or it will become a regular peer with root node set to puppet. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to MultiplayerAPI's signals. bindMultiplayerAPI_set_network_peer :: MethodBind bindMultiplayerAPI_set_network_peer = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "set_network_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the MultiplayerAPI will become a network server (check with @method is_network_server@) and will set root node's network mode to master, or it will become a regular peer with root node set to puppet. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to MultiplayerAPI's signals. set_network_peer :: (MultiplayerAPI :< cls, Object :< cls) => cls -> NetworkedMultiplayerPeer -> IO () set_network_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_set_network_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "set_network_peer" '[NetworkedMultiplayerPeer] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI.set_network_peer {-# NOINLINE bindMultiplayerAPI_set_refuse_new_network_connections #-} -- | If @true@, the MultiplayerAPI's @network_peer@ refuses new incoming connections. bindMultiplayerAPI_set_refuse_new_network_connections :: MethodBind bindMultiplayerAPI_set_refuse_new_network_connections = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "set_refuse_new_network_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the MultiplayerAPI's @network_peer@ refuses new incoming connections. set_refuse_new_network_connections :: (MultiplayerAPI :< cls, Object :< cls) => cls -> Bool -> IO () set_refuse_new_network_connections cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_set_refuse_new_network_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "set_refuse_new_network_connections" '[Bool] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI.set_refuse_new_network_connections {-# NOINLINE bindMultiplayerAPI_set_root_node #-} -- | Sets the base root node to use for RPCs. Instead of an absolute path, a relative path will be used to find the node upon which the RPC should be executed. -- This effectively allows to have different branches of the scene tree to be managed by different MultiplayerAPI, allowing for example to run both client and server in the same scene. bindMultiplayerAPI_set_root_node :: MethodBind bindMultiplayerAPI_set_root_node = unsafePerformIO $ withCString "MultiplayerAPI" $ \ clsNamePtr -> withCString "set_root_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the base root node to use for RPCs. Instead of an absolute path, a relative path will be used to find the node upon which the RPC should be executed. -- This effectively allows to have different branches of the scene tree to be managed by different MultiplayerAPI, allowing for example to run both client and server in the same scene. set_root_node :: (MultiplayerAPI :< cls, Object :< cls) => cls -> Node -> IO () set_root_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindMultiplayerAPI_set_root_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod MultiplayerAPI "set_root_node" '[Node] (IO ()) where nodeMethod = Godot.Core.MultiplayerAPI.set_root_node ================================================ FILE: src/Godot/Core/MultiplayerPeerGDNative.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.MultiplayerPeerGDNative () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.NetworkedMultiplayerPeer() ================================================ FILE: src/Godot/Core/Mutex.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Mutex (Godot.Core.Mutex.lock, Godot.Core.Mutex.try_lock, Godot.Core.Mutex.unlock) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindMutex_lock #-} -- | Locks this @Mutex@, blocks until it is unlocked by the current owner. bindMutex_lock :: MethodBind bindMutex_lock = unsafePerformIO $ withCString "_Mutex" $ \ clsNamePtr -> withCString "lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Locks this @Mutex@, blocks until it is unlocked by the current owner. lock :: (Mutex :< cls, Object :< cls) => cls -> IO () lock cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMutex_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mutex "lock" '[] (IO ()) where nodeMethod = Godot.Core.Mutex.lock {-# NOINLINE bindMutex_try_lock #-} -- | Tries locking this @Mutex@, but does not block. Returns @OK@ on success, @ERR_BUSY@ otherwise. bindMutex_try_lock :: MethodBind bindMutex_try_lock = unsafePerformIO $ withCString "_Mutex" $ \ clsNamePtr -> withCString "try_lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tries locking this @Mutex@, but does not block. Returns @OK@ on success, @ERR_BUSY@ otherwise. try_lock :: (Mutex :< cls, Object :< cls) => cls -> IO Int try_lock cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMutex_try_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mutex "try_lock" '[] (IO Int) where nodeMethod = Godot.Core.Mutex.try_lock {-# NOINLINE bindMutex_unlock #-} -- | Unlocks this @Mutex@, leaving it to other threads. bindMutex_unlock :: MethodBind bindMutex_unlock = unsafePerformIO $ withCString "_Mutex" $ \ clsNamePtr -> withCString "unlock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unlocks this @Mutex@, leaving it to other threads. unlock :: (Mutex :< cls, Object :< cls) => cls -> IO () unlock cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindMutex_unlock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Mutex "unlock" '[] (IO ()) where nodeMethod = Godot.Core.Mutex.unlock ================================================ FILE: src/Godot/Core/NativeScript.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NativeScript (Godot.Core.NativeScript.get_class_documentation, Godot.Core.NativeScript.get_class_name, Godot.Core.NativeScript.get_library, Godot.Core.NativeScript.get_method_documentation, Godot.Core.NativeScript.get_property_documentation, Godot.Core.NativeScript.get_script_class_icon_path, Godot.Core.NativeScript.get_script_class_name, Godot.Core.NativeScript.get_signal_documentation, Godot.Core.NativeScript.new, Godot.Core.NativeScript.set_class_name, Godot.Core.NativeScript.set_library, Godot.Core.NativeScript.set_script_class_icon_path, Godot.Core.NativeScript.set_script_class_name) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Script() instance NodeProperty NativeScript "class_name" GodotString 'False where nodeProperty = (get_class_name, wrapDroppingSetter set_class_name, Nothing) instance NodeProperty NativeScript "library" GDNativeLibrary 'False where nodeProperty = (get_library, wrapDroppingSetter set_library, Nothing) instance NodeProperty NativeScript "script_class_icon_path" GodotString 'False where nodeProperty = (get_script_class_icon_path, wrapDroppingSetter set_script_class_icon_path, Nothing) instance NodeProperty NativeScript "script_class_name" GodotString 'False where nodeProperty = (get_script_class_name, wrapDroppingSetter set_script_class_name, Nothing) {-# NOINLINE bindNativeScript_get_class_documentation #-} bindNativeScript_get_class_documentation :: MethodBind bindNativeScript_get_class_documentation = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "get_class_documentation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_class_documentation :: (NativeScript :< cls, Object :< cls) => cls -> IO GodotString get_class_documentation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_get_class_documentation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "get_class_documentation" '[] (IO GodotString) where nodeMethod = Godot.Core.NativeScript.get_class_documentation {-# NOINLINE bindNativeScript_get_class_name #-} bindNativeScript_get_class_name :: MethodBind bindNativeScript_get_class_name = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "get_class_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_class_name :: (NativeScript :< cls, Object :< cls) => cls -> IO GodotString get_class_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_get_class_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "get_class_name" '[] (IO GodotString) where nodeMethod = Godot.Core.NativeScript.get_class_name {-# NOINLINE bindNativeScript_get_library #-} bindNativeScript_get_library :: MethodBind bindNativeScript_get_library = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "get_library" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_library :: (NativeScript :< cls, Object :< cls) => cls -> IO GDNativeLibrary get_library cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_get_library (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "get_library" '[] (IO GDNativeLibrary) where nodeMethod = Godot.Core.NativeScript.get_library {-# NOINLINE bindNativeScript_get_method_documentation #-} bindNativeScript_get_method_documentation :: MethodBind bindNativeScript_get_method_documentation = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "get_method_documentation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_method_documentation :: (NativeScript :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_method_documentation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_get_method_documentation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "get_method_documentation" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.NativeScript.get_method_documentation {-# NOINLINE bindNativeScript_get_property_documentation #-} bindNativeScript_get_property_documentation :: MethodBind bindNativeScript_get_property_documentation = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "get_property_documentation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_property_documentation :: (NativeScript :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_property_documentation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_get_property_documentation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "get_property_documentation" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.NativeScript.get_property_documentation {-# NOINLINE bindNativeScript_get_script_class_icon_path #-} bindNativeScript_get_script_class_icon_path :: MethodBind bindNativeScript_get_script_class_icon_path = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "get_script_class_icon_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_script_class_icon_path :: (NativeScript :< cls, Object :< cls) => cls -> IO GodotString get_script_class_icon_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_get_script_class_icon_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "get_script_class_icon_path" '[] (IO GodotString) where nodeMethod = Godot.Core.NativeScript.get_script_class_icon_path {-# NOINLINE bindNativeScript_get_script_class_name #-} bindNativeScript_get_script_class_name :: MethodBind bindNativeScript_get_script_class_name = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "get_script_class_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_script_class_name :: (NativeScript :< cls, Object :< cls) => cls -> IO GodotString get_script_class_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_get_script_class_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "get_script_class_name" '[] (IO GodotString) where nodeMethod = Godot.Core.NativeScript.get_script_class_name {-# NOINLINE bindNativeScript_get_signal_documentation #-} bindNativeScript_get_signal_documentation :: MethodBind bindNativeScript_get_signal_documentation = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "get_signal_documentation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_signal_documentation :: (NativeScript :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_signal_documentation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_get_signal_documentation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "get_signal_documentation" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.NativeScript.get_signal_documentation {-# NOINLINE bindNativeScript_new #-} bindNativeScript_new :: MethodBind bindNativeScript_new = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "new" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr new :: (NativeScript :< cls, Object :< cls) => cls -> [Variant 'GodotTy] -> IO GodotVariant new cls varargs = withVariantArray ([] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_new (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "new" '[[Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.NativeScript.new {-# NOINLINE bindNativeScript_set_class_name #-} bindNativeScript_set_class_name :: MethodBind bindNativeScript_set_class_name = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "set_class_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_class_name :: (NativeScript :< cls, Object :< cls) => cls -> GodotString -> IO () set_class_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_set_class_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "set_class_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.NativeScript.set_class_name {-# NOINLINE bindNativeScript_set_library #-} bindNativeScript_set_library :: MethodBind bindNativeScript_set_library = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "set_library" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_library :: (NativeScript :< cls, Object :< cls) => cls -> GDNativeLibrary -> IO () set_library cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_set_library (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "set_library" '[GDNativeLibrary] (IO ()) where nodeMethod = Godot.Core.NativeScript.set_library {-# NOINLINE bindNativeScript_set_script_class_icon_path #-} bindNativeScript_set_script_class_icon_path :: MethodBind bindNativeScript_set_script_class_icon_path = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "set_script_class_icon_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_script_class_icon_path :: (NativeScript :< cls, Object :< cls) => cls -> GodotString -> IO () set_script_class_icon_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_set_script_class_icon_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "set_script_class_icon_path" '[GodotString] (IO ()) where nodeMethod = Godot.Core.NativeScript.set_script_class_icon_path {-# NOINLINE bindNativeScript_set_script_class_name #-} bindNativeScript_set_script_class_name :: MethodBind bindNativeScript_set_script_class_name = unsafePerformIO $ withCString "NativeScript" $ \ clsNamePtr -> withCString "set_script_class_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_script_class_name :: (NativeScript :< cls, Object :< cls) => cls -> GodotString -> IO () set_script_class_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNativeScript_set_script_class_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NativeScript "set_script_class_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.NativeScript.set_script_class_name ================================================ FILE: src/Godot/Core/Navigation.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Navigation (Godot.Core.Navigation.get_closest_point, Godot.Core.Navigation.get_closest_point_normal, Godot.Core.Navigation.get_closest_point_owner, Godot.Core.Navigation.get_closest_point_to_segment, Godot.Core.Navigation.get_simple_path, Godot.Core.Navigation.get_up_vector, Godot.Core.Navigation.navmesh_add, Godot.Core.Navigation.navmesh_remove, Godot.Core.Navigation.navmesh_set_transform, Godot.Core.Navigation.set_up_vector) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty Navigation "up_vector" Vector3 'False where nodeProperty = (get_up_vector, wrapDroppingSetter set_up_vector, Nothing) {-# NOINLINE bindNavigation_get_closest_point #-} -- | Returns the navigation point closest to the point given. Points are in local coordinate space. bindNavigation_get_closest_point :: MethodBind bindNavigation_get_closest_point = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "get_closest_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the navigation point closest to the point given. Points are in local coordinate space. get_closest_point :: (Navigation :< cls, Object :< cls) => cls -> Vector3 -> IO Vector3 get_closest_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_get_closest_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "get_closest_point" '[Vector3] (IO Vector3) where nodeMethod = Godot.Core.Navigation.get_closest_point {-# NOINLINE bindNavigation_get_closest_point_normal #-} -- | Returns the surface normal at the navigation point closest to the point given. Useful for rotating a navigation agent according to the navigation mesh it moves on. bindNavigation_get_closest_point_normal :: MethodBind bindNavigation_get_closest_point_normal = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "get_closest_point_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the surface normal at the navigation point closest to the point given. Useful for rotating a navigation agent according to the navigation mesh it moves on. get_closest_point_normal :: (Navigation :< cls, Object :< cls) => cls -> Vector3 -> IO Vector3 get_closest_point_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_get_closest_point_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "get_closest_point_normal" '[Vector3] (IO Vector3) where nodeMethod = Godot.Core.Navigation.get_closest_point_normal {-# NOINLINE bindNavigation_get_closest_point_owner #-} -- | Returns the owner of the @NavigationMesh@ which contains the navigation point closest to the point given. This is usually a @NavigationMeshInstance@. For meshes added via @method navmesh_add@, returns the owner that was given (or @null@ if the @owner@ parameter was omitted). bindNavigation_get_closest_point_owner :: MethodBind bindNavigation_get_closest_point_owner = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "get_closest_point_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the owner of the @NavigationMesh@ which contains the navigation point closest to the point given. This is usually a @NavigationMeshInstance@. For meshes added via @method navmesh_add@, returns the owner that was given (or @null@ if the @owner@ parameter was omitted). get_closest_point_owner :: (Navigation :< cls, Object :< cls) => cls -> Vector3 -> IO Object get_closest_point_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_get_closest_point_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "get_closest_point_owner" '[Vector3] (IO Object) where nodeMethod = Godot.Core.Navigation.get_closest_point_owner {-# NOINLINE bindNavigation_get_closest_point_to_segment #-} -- | Returns the navigation point closest to the given line segment. When enabling @use_collision@, only considers intersection points between segment and navigation meshes. If multiple intersection points are found, the one closest to the segment start point is returned. bindNavigation_get_closest_point_to_segment :: MethodBind bindNavigation_get_closest_point_to_segment = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "get_closest_point_to_segment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the navigation point closest to the given line segment. When enabling @use_collision@, only considers intersection points between segment and navigation meshes. If multiple intersection points are found, the one closest to the segment start point is returned. get_closest_point_to_segment :: (Navigation :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Maybe Bool -> IO Vector3 get_closest_point_to_segment cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_get_closest_point_to_segment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "get_closest_point_to_segment" '[Vector3, Vector3, Maybe Bool] (IO Vector3) where nodeMethod = Godot.Core.Navigation.get_closest_point_to_segment {-# NOINLINE bindNavigation_get_simple_path #-} -- | Returns the path between two given points. Points are in local coordinate space. If @optimize@ is @true@ (the default), the agent properties associated with each @NavigationMesh@ (radius, height, etc.) are considered in the path calculation, otherwise they are ignored. bindNavigation_get_simple_path :: MethodBind bindNavigation_get_simple_path = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "get_simple_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path between two given points. Points are in local coordinate space. If @optimize@ is @true@ (the default), the agent properties associated with each @NavigationMesh@ (radius, height, etc.) are considered in the path calculation, otherwise they are ignored. get_simple_path :: (Navigation :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Maybe Bool -> IO PoolVector3Array get_simple_path cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_get_simple_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "get_simple_path" '[Vector3, Vector3, Maybe Bool] (IO PoolVector3Array) where nodeMethod = Godot.Core.Navigation.get_simple_path {-# NOINLINE bindNavigation_get_up_vector #-} -- | Defines which direction is up. By default, this is @(0, 1, 0)@, which is the world's "up" direction. bindNavigation_get_up_vector :: MethodBind bindNavigation_get_up_vector = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "get_up_vector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines which direction is up. By default, this is @(0, 1, 0)@, which is the world's "up" direction. get_up_vector :: (Navigation :< cls, Object :< cls) => cls -> IO Vector3 get_up_vector cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_get_up_vector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "get_up_vector" '[] (IO Vector3) where nodeMethod = Godot.Core.Navigation.get_up_vector {-# NOINLINE bindNavigation_navmesh_add #-} -- | Adds a @NavigationMesh@. Returns an ID for use with @method navmesh_remove@ or @method navmesh_set_transform@. If given, a @Transform2D@ is applied to the polygon. The optional @owner@ is used as return value for @method get_closest_point_owner@. bindNavigation_navmesh_add :: MethodBind bindNavigation_navmesh_add = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "navmesh_add" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @NavigationMesh@. Returns an ID for use with @method navmesh_remove@ or @method navmesh_set_transform@. If given, a @Transform2D@ is applied to the polygon. The optional @owner@ is used as return value for @method get_closest_point_owner@. navmesh_add :: (Navigation :< cls, Object :< cls) => cls -> NavigationMesh -> Transform -> Maybe Object -> IO Int navmesh_add cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_navmesh_add (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "navmesh_add" '[NavigationMesh, Transform, Maybe Object] (IO Int) where nodeMethod = Godot.Core.Navigation.navmesh_add {-# NOINLINE bindNavigation_navmesh_remove #-} -- | Removes the @NavigationMesh@ with the given ID. bindNavigation_navmesh_remove :: MethodBind bindNavigation_navmesh_remove = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "navmesh_remove" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the @NavigationMesh@ with the given ID. navmesh_remove :: (Navigation :< cls, Object :< cls) => cls -> Int -> IO () navmesh_remove cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_navmesh_remove (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "navmesh_remove" '[Int] (IO ()) where nodeMethod = Godot.Core.Navigation.navmesh_remove {-# NOINLINE bindNavigation_navmesh_set_transform #-} -- | Sets the transform applied to the @NavigationMesh@ with the given ID. bindNavigation_navmesh_set_transform :: MethodBind bindNavigation_navmesh_set_transform = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "navmesh_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform applied to the @NavigationMesh@ with the given ID. navmesh_set_transform :: (Navigation :< cls, Object :< cls) => cls -> Int -> Transform -> IO () navmesh_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_navmesh_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "navmesh_set_transform" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.Navigation.navmesh_set_transform {-# NOINLINE bindNavigation_set_up_vector #-} -- | Defines which direction is up. By default, this is @(0, 1, 0)@, which is the world's "up" direction. bindNavigation_set_up_vector :: MethodBind bindNavigation_set_up_vector = unsafePerformIO $ withCString "Navigation" $ \ clsNamePtr -> withCString "set_up_vector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines which direction is up. By default, this is @(0, 1, 0)@, which is the world's "up" direction. set_up_vector :: (Navigation :< cls, Object :< cls) => cls -> Vector3 -> IO () set_up_vector cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation_set_up_vector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation "set_up_vector" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Navigation.set_up_vector ================================================ FILE: src/Godot/Core/Navigation2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Navigation2D (Godot.Core.Navigation2D.get_closest_point, Godot.Core.Navigation2D.get_closest_point_owner, Godot.Core.Navigation2D.get_simple_path, Godot.Core.Navigation2D.navpoly_add, Godot.Core.Navigation2D.navpoly_remove, Godot.Core.Navigation2D.navpoly_set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() {-# NOINLINE bindNavigation2D_get_closest_point #-} -- | Returns the navigation point closest to the point given. Points are in local coordinate space. bindNavigation2D_get_closest_point :: MethodBind bindNavigation2D_get_closest_point = unsafePerformIO $ withCString "Navigation2D" $ \ clsNamePtr -> withCString "get_closest_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the navigation point closest to the point given. Points are in local coordinate space. get_closest_point :: (Navigation2D :< cls, Object :< cls) => cls -> Vector2 -> IO Vector2 get_closest_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation2D_get_closest_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation2D "get_closest_point" '[Vector2] (IO Vector2) where nodeMethod = Godot.Core.Navigation2D.get_closest_point {-# NOINLINE bindNavigation2D_get_closest_point_owner #-} -- | Returns the owner of the @NavigationPolygon@ which contains the navigation point closest to the point given. This is usually a @NavigationPolygonInstance@. For polygons added via @method navpoly_add@, returns the owner that was given (or @null@ if the @owner@ parameter was omitted). bindNavigation2D_get_closest_point_owner :: MethodBind bindNavigation2D_get_closest_point_owner = unsafePerformIO $ withCString "Navigation2D" $ \ clsNamePtr -> withCString "get_closest_point_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the owner of the @NavigationPolygon@ which contains the navigation point closest to the point given. This is usually a @NavigationPolygonInstance@. For polygons added via @method navpoly_add@, returns the owner that was given (or @null@ if the @owner@ parameter was omitted). get_closest_point_owner :: (Navigation2D :< cls, Object :< cls) => cls -> Vector2 -> IO Object get_closest_point_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation2D_get_closest_point_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation2D "get_closest_point_owner" '[Vector2] (IO Object) where nodeMethod = Godot.Core.Navigation2D.get_closest_point_owner {-# NOINLINE bindNavigation2D_get_simple_path #-} -- | Returns the path between two given points. Points are in local coordinate space. If @optimize@ is @true@ (the default), the path is smoothed by merging path segments where possible. bindNavigation2D_get_simple_path :: MethodBind bindNavigation2D_get_simple_path = unsafePerformIO $ withCString "Navigation2D" $ \ clsNamePtr -> withCString "get_simple_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path between two given points. Points are in local coordinate space. If @optimize@ is @true@ (the default), the path is smoothed by merging path segments where possible. get_simple_path :: (Navigation2D :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Maybe Bool -> IO PoolVector2Array get_simple_path cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation2D_get_simple_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation2D "get_simple_path" '[Vector2, Vector2, Maybe Bool] (IO PoolVector2Array) where nodeMethod = Godot.Core.Navigation2D.get_simple_path {-# NOINLINE bindNavigation2D_navpoly_add #-} -- | Adds a @NavigationPolygon@. Returns an ID for use with @method navpoly_remove@ or @method navpoly_set_transform@. If given, a @Transform2D@ is applied to the polygon. The optional @owner@ is used as return value for @method get_closest_point_owner@. bindNavigation2D_navpoly_add :: MethodBind bindNavigation2D_navpoly_add = unsafePerformIO $ withCString "Navigation2D" $ \ clsNamePtr -> withCString "navpoly_add" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @NavigationPolygon@. Returns an ID for use with @method navpoly_remove@ or @method navpoly_set_transform@. If given, a @Transform2D@ is applied to the polygon. The optional @owner@ is used as return value for @method get_closest_point_owner@. navpoly_add :: (Navigation2D :< cls, Object :< cls) => cls -> NavigationPolygon -> Transform2d -> Maybe Object -> IO Int navpoly_add cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation2D_navpoly_add (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation2D "navpoly_add" '[NavigationPolygon, Transform2d, Maybe Object] (IO Int) where nodeMethod = Godot.Core.Navigation2D.navpoly_add {-# NOINLINE bindNavigation2D_navpoly_remove #-} -- | Removes the @NavigationPolygon@ with the given ID. bindNavigation2D_navpoly_remove :: MethodBind bindNavigation2D_navpoly_remove = unsafePerformIO $ withCString "Navigation2D" $ \ clsNamePtr -> withCString "navpoly_remove" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the @NavigationPolygon@ with the given ID. navpoly_remove :: (Navigation2D :< cls, Object :< cls) => cls -> Int -> IO () navpoly_remove cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation2D_navpoly_remove (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation2D "navpoly_remove" '[Int] (IO ()) where nodeMethod = Godot.Core.Navigation2D.navpoly_remove {-# NOINLINE bindNavigation2D_navpoly_set_transform #-} -- | Sets the transform applied to the @NavigationPolygon@ with the given ID. bindNavigation2D_navpoly_set_transform :: MethodBind bindNavigation2D_navpoly_set_transform = unsafePerformIO $ withCString "Navigation2D" $ \ clsNamePtr -> withCString "navpoly_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform applied to the @NavigationPolygon@ with the given ID. navpoly_set_transform :: (Navigation2D :< cls, Object :< cls) => cls -> Int -> Transform2d -> IO () navpoly_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNavigation2D_navpoly_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Navigation2D "navpoly_set_transform" '[Int, Transform2d] (IO ()) where nodeMethod = Godot.Core.Navigation2D.navpoly_set_transform ================================================ FILE: src/Godot/Core/NavigationMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NavigationMesh (Godot.Core.NavigationMesh._SAMPLE_PARTITION_LAYERS, Godot.Core.NavigationMesh._SAMPLE_PARTITION_WATERSHED, Godot.Core.NavigationMesh._SAMPLE_PARTITION_MONOTONE, Godot.Core.NavigationMesh._PARSED_GEOMETRY_BOTH, Godot.Core.NavigationMesh._PARSED_GEOMETRY_MESH_INSTANCES, Godot.Core.NavigationMesh._PARSED_GEOMETRY_STATIC_COLLIDERS, Godot.Core.NavigationMesh._get_polygons, Godot.Core.NavigationMesh._set_polygons, Godot.Core.NavigationMesh.add_polygon, Godot.Core.NavigationMesh.clear_polygons, Godot.Core.NavigationMesh.create_from_mesh, Godot.Core.NavigationMesh.get_agent_height, Godot.Core.NavigationMesh.get_agent_max_climb, Godot.Core.NavigationMesh.get_agent_max_slope, Godot.Core.NavigationMesh.get_agent_radius, Godot.Core.NavigationMesh.get_cell_height, Godot.Core.NavigationMesh.get_cell_size, Godot.Core.NavigationMesh.get_collision_mask, Godot.Core.NavigationMesh.get_collision_mask_bit, Godot.Core.NavigationMesh.get_detail_sample_distance, Godot.Core.NavigationMesh.get_detail_sample_max_error, Godot.Core.NavigationMesh.get_edge_max_error, Godot.Core.NavigationMesh.get_edge_max_length, Godot.Core.NavigationMesh.get_filter_ledge_spans, Godot.Core.NavigationMesh.get_filter_low_hanging_obstacles, Godot.Core.NavigationMesh.get_filter_walkable_low_height_spans, Godot.Core.NavigationMesh.get_parsed_geometry_type, Godot.Core.NavigationMesh.get_polygon, Godot.Core.NavigationMesh.get_polygon_count, Godot.Core.NavigationMesh.get_region_merge_size, Godot.Core.NavigationMesh.get_region_min_size, Godot.Core.NavigationMesh.get_sample_partition_type, Godot.Core.NavigationMesh.get_source_geometry_mode, Godot.Core.NavigationMesh.get_source_group_name, Godot.Core.NavigationMesh.get_vertices, Godot.Core.NavigationMesh.get_verts_per_poly, Godot.Core.NavigationMesh.set_agent_height, Godot.Core.NavigationMesh.set_agent_max_climb, Godot.Core.NavigationMesh.set_agent_max_slope, Godot.Core.NavigationMesh.set_agent_radius, Godot.Core.NavigationMesh.set_cell_height, Godot.Core.NavigationMesh.set_cell_size, Godot.Core.NavigationMesh.set_collision_mask, Godot.Core.NavigationMesh.set_collision_mask_bit, Godot.Core.NavigationMesh.set_detail_sample_distance, Godot.Core.NavigationMesh.set_detail_sample_max_error, Godot.Core.NavigationMesh.set_edge_max_error, Godot.Core.NavigationMesh.set_edge_max_length, Godot.Core.NavigationMesh.set_filter_ledge_spans, Godot.Core.NavigationMesh.set_filter_low_hanging_obstacles, Godot.Core.NavigationMesh.set_filter_walkable_low_height_spans, Godot.Core.NavigationMesh.set_parsed_geometry_type, Godot.Core.NavigationMesh.set_region_merge_size, Godot.Core.NavigationMesh.set_region_min_size, Godot.Core.NavigationMesh.set_sample_partition_type, Godot.Core.NavigationMesh.set_source_geometry_mode, Godot.Core.NavigationMesh.set_source_group_name, Godot.Core.NavigationMesh.set_vertices, Godot.Core.NavigationMesh.set_verts_per_poly) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _SAMPLE_PARTITION_LAYERS :: Int _SAMPLE_PARTITION_LAYERS = 2 _SAMPLE_PARTITION_WATERSHED :: Int _SAMPLE_PARTITION_WATERSHED = 0 _SAMPLE_PARTITION_MONOTONE :: Int _SAMPLE_PARTITION_MONOTONE = 1 _PARSED_GEOMETRY_BOTH :: Int _PARSED_GEOMETRY_BOTH = 2 _PARSED_GEOMETRY_MESH_INSTANCES :: Int _PARSED_GEOMETRY_MESH_INSTANCES = 0 _PARSED_GEOMETRY_STATIC_COLLIDERS :: Int _PARSED_GEOMETRY_STATIC_COLLIDERS = 1 instance NodeProperty NavigationMesh "agent/height" Float 'False where nodeProperty = (get_agent_height, wrapDroppingSetter set_agent_height, Nothing) instance NodeProperty NavigationMesh "agent/max_climb" Float 'False where nodeProperty = (get_agent_max_climb, wrapDroppingSetter set_agent_max_climb, Nothing) instance NodeProperty NavigationMesh "agent/max_slope" Float 'False where nodeProperty = (get_agent_max_slope, wrapDroppingSetter set_agent_max_slope, Nothing) instance NodeProperty NavigationMesh "agent/radius" Float 'False where nodeProperty = (get_agent_radius, wrapDroppingSetter set_agent_radius, Nothing) instance NodeProperty NavigationMesh "cell/height" Float 'False where nodeProperty = (get_cell_height, wrapDroppingSetter set_cell_height, Nothing) instance NodeProperty NavigationMesh "cell/size" Float 'False where nodeProperty = (get_cell_size, wrapDroppingSetter set_cell_size, Nothing) instance NodeProperty NavigationMesh "detail/sample_distance" Float 'False where nodeProperty = (get_detail_sample_distance, wrapDroppingSetter set_detail_sample_distance, Nothing) instance NodeProperty NavigationMesh "detail/sample_max_error" Float 'False where nodeProperty = (get_detail_sample_max_error, wrapDroppingSetter set_detail_sample_max_error, Nothing) instance NodeProperty NavigationMesh "edge/max_error" Float 'False where nodeProperty = (get_edge_max_error, wrapDroppingSetter set_edge_max_error, Nothing) instance NodeProperty NavigationMesh "edge/max_length" Float 'False where nodeProperty = (get_edge_max_length, wrapDroppingSetter set_edge_max_length, Nothing) instance NodeProperty NavigationMesh "filter/filter_walkable_low_height_spans" Bool 'False where nodeProperty = (get_filter_walkable_low_height_spans, wrapDroppingSetter set_filter_walkable_low_height_spans, Nothing) instance NodeProperty NavigationMesh "filter/ledge_spans" Bool 'False where nodeProperty = (get_filter_ledge_spans, wrapDroppingSetter set_filter_ledge_spans, Nothing) instance NodeProperty NavigationMesh "filter/low_hanging_obstacles" Bool 'False where nodeProperty = (get_filter_low_hanging_obstacles, wrapDroppingSetter set_filter_low_hanging_obstacles, Nothing) instance NodeProperty NavigationMesh "geometry/collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty NavigationMesh "geometry/parsed_geometry_type" Int 'False where nodeProperty = (get_parsed_geometry_type, wrapDroppingSetter set_parsed_geometry_type, Nothing) instance NodeProperty NavigationMesh "geometry/source_geometry_mode" Int 'False where nodeProperty = (get_source_geometry_mode, wrapDroppingSetter set_source_geometry_mode, Nothing) instance NodeProperty NavigationMesh "geometry/source_group_name" GodotString 'False where nodeProperty = (get_source_group_name, wrapDroppingSetter set_source_group_name, Nothing) instance NodeProperty NavigationMesh "polygon/verts_per_poly" Float 'False where nodeProperty = (get_verts_per_poly, wrapDroppingSetter set_verts_per_poly, Nothing) instance NodeProperty NavigationMesh "polygons" Array 'False where nodeProperty = (_get_polygons, wrapDroppingSetter _set_polygons, Nothing) instance NodeProperty NavigationMesh "region/merge_size" Float 'False where nodeProperty = (get_region_merge_size, wrapDroppingSetter set_region_merge_size, Nothing) instance NodeProperty NavigationMesh "region/min_size" Float 'False where nodeProperty = (get_region_min_size, wrapDroppingSetter set_region_min_size, Nothing) instance NodeProperty NavigationMesh "sample_partition_type/sample_partition_type" Int 'False where nodeProperty = (get_sample_partition_type, wrapDroppingSetter set_sample_partition_type, Nothing) instance NodeProperty NavigationMesh "vertices" PoolVector3Array 'False where nodeProperty = (get_vertices, wrapDroppingSetter set_vertices, Nothing) {-# NOINLINE bindNavigationMesh__get_polygons #-} bindNavigationMesh__get_polygons :: MethodBind bindNavigationMesh__get_polygons = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "_get_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_polygons :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Array _get_polygons cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh__get_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "_get_polygons" '[] (IO Array) where nodeMethod = Godot.Core.NavigationMesh._get_polygons {-# NOINLINE bindNavigationMesh__set_polygons #-} bindNavigationMesh__set_polygons :: MethodBind bindNavigationMesh__set_polygons = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "_set_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_polygons :: (NavigationMesh :< cls, Object :< cls) => cls -> Array -> IO () _set_polygons cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh__set_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "_set_polygons" '[Array] (IO ()) where nodeMethod = Godot.Core.NavigationMesh._set_polygons {-# NOINLINE bindNavigationMesh_add_polygon #-} bindNavigationMesh_add_polygon :: MethodBind bindNavigationMesh_add_polygon = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "add_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_polygon :: (NavigationMesh :< cls, Object :< cls) => cls -> PoolIntArray -> IO () add_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_add_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "add_polygon" '[PoolIntArray] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.add_polygon {-# NOINLINE bindNavigationMesh_clear_polygons #-} bindNavigationMesh_clear_polygons :: MethodBind bindNavigationMesh_clear_polygons = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "clear_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear_polygons :: (NavigationMesh :< cls, Object :< cls) => cls -> IO () clear_polygons cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_clear_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "clear_polygons" '[] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.clear_polygons {-# NOINLINE bindNavigationMesh_create_from_mesh #-} bindNavigationMesh_create_from_mesh :: MethodBind bindNavigationMesh_create_from_mesh = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "create_from_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr create_from_mesh :: (NavigationMesh :< cls, Object :< cls) => cls -> Mesh -> IO () create_from_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_create_from_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "create_from_mesh" '[Mesh] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.create_from_mesh {-# NOINLINE bindNavigationMesh_get_agent_height #-} bindNavigationMesh_get_agent_height :: MethodBind bindNavigationMesh_get_agent_height = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_agent_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_agent_height :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_agent_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_agent_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_agent_height" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_agent_height {-# NOINLINE bindNavigationMesh_get_agent_max_climb #-} bindNavigationMesh_get_agent_max_climb :: MethodBind bindNavigationMesh_get_agent_max_climb = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_agent_max_climb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_agent_max_climb :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_agent_max_climb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_agent_max_climb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_agent_max_climb" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_agent_max_climb {-# NOINLINE bindNavigationMesh_get_agent_max_slope #-} bindNavigationMesh_get_agent_max_slope :: MethodBind bindNavigationMesh_get_agent_max_slope = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_agent_max_slope" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_agent_max_slope :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_agent_max_slope cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_agent_max_slope (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_agent_max_slope" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_agent_max_slope {-# NOINLINE bindNavigationMesh_get_agent_radius #-} bindNavigationMesh_get_agent_radius :: MethodBind bindNavigationMesh_get_agent_radius = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_agent_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_agent_radius :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_agent_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_agent_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_agent_radius" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_agent_radius {-# NOINLINE bindNavigationMesh_get_cell_height #-} bindNavigationMesh_get_cell_height :: MethodBind bindNavigationMesh_get_cell_height = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_cell_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_height :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_cell_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_cell_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_cell_height" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_cell_height {-# NOINLINE bindNavigationMesh_get_cell_size #-} bindNavigationMesh_get_cell_size :: MethodBind bindNavigationMesh_get_cell_size = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_size :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_cell_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_cell_size" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_cell_size {-# NOINLINE bindNavigationMesh_get_collision_mask #-} bindNavigationMesh_get_collision_mask :: MethodBind bindNavigationMesh_get_collision_mask = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_mask :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.NavigationMesh.get_collision_mask {-# NOINLINE bindNavigationMesh_get_collision_mask_bit #-} bindNavigationMesh_get_collision_mask_bit :: MethodBind bindNavigationMesh_get_collision_mask_bit = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_mask_bit :: (NavigationMesh :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.NavigationMesh.get_collision_mask_bit {-# NOINLINE bindNavigationMesh_get_detail_sample_distance #-} bindNavigationMesh_get_detail_sample_distance :: MethodBind bindNavigationMesh_get_detail_sample_distance = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_detail_sample_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_detail_sample_distance :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_detail_sample_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_detail_sample_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_detail_sample_distance" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_detail_sample_distance {-# NOINLINE bindNavigationMesh_get_detail_sample_max_error #-} bindNavigationMesh_get_detail_sample_max_error :: MethodBind bindNavigationMesh_get_detail_sample_max_error = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_detail_sample_max_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_detail_sample_max_error :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_detail_sample_max_error cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_detail_sample_max_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_detail_sample_max_error" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_detail_sample_max_error {-# NOINLINE bindNavigationMesh_get_edge_max_error #-} bindNavigationMesh_get_edge_max_error :: MethodBind bindNavigationMesh_get_edge_max_error = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_edge_max_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_edge_max_error :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_edge_max_error cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_edge_max_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_edge_max_error" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_edge_max_error {-# NOINLINE bindNavigationMesh_get_edge_max_length #-} bindNavigationMesh_get_edge_max_length :: MethodBind bindNavigationMesh_get_edge_max_length = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_edge_max_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_edge_max_length :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_edge_max_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_edge_max_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_edge_max_length" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_edge_max_length {-# NOINLINE bindNavigationMesh_get_filter_ledge_spans #-} bindNavigationMesh_get_filter_ledge_spans :: MethodBind bindNavigationMesh_get_filter_ledge_spans = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_filter_ledge_spans" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_filter_ledge_spans :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Bool get_filter_ledge_spans cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_filter_ledge_spans (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_filter_ledge_spans" '[] (IO Bool) where nodeMethod = Godot.Core.NavigationMesh.get_filter_ledge_spans {-# NOINLINE bindNavigationMesh_get_filter_low_hanging_obstacles #-} bindNavigationMesh_get_filter_low_hanging_obstacles :: MethodBind bindNavigationMesh_get_filter_low_hanging_obstacles = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_filter_low_hanging_obstacles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_filter_low_hanging_obstacles :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Bool get_filter_low_hanging_obstacles cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_filter_low_hanging_obstacles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_filter_low_hanging_obstacles" '[] (IO Bool) where nodeMethod = Godot.Core.NavigationMesh.get_filter_low_hanging_obstacles {-# NOINLINE bindNavigationMesh_get_filter_walkable_low_height_spans #-} bindNavigationMesh_get_filter_walkable_low_height_spans :: MethodBind bindNavigationMesh_get_filter_walkable_low_height_spans = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_filter_walkable_low_height_spans" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_filter_walkable_low_height_spans :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Bool get_filter_walkable_low_height_spans cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_filter_walkable_low_height_spans (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_filter_walkable_low_height_spans" '[] (IO Bool) where nodeMethod = Godot.Core.NavigationMesh.get_filter_walkable_low_height_spans {-# NOINLINE bindNavigationMesh_get_parsed_geometry_type #-} bindNavigationMesh_get_parsed_geometry_type :: MethodBind bindNavigationMesh_get_parsed_geometry_type = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_parsed_geometry_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_parsed_geometry_type :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Int get_parsed_geometry_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_parsed_geometry_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_parsed_geometry_type" '[] (IO Int) where nodeMethod = Godot.Core.NavigationMesh.get_parsed_geometry_type {-# NOINLINE bindNavigationMesh_get_polygon #-} bindNavigationMesh_get_polygon :: MethodBind bindNavigationMesh_get_polygon = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_polygon :: (NavigationMesh :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_polygon" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.NavigationMesh.get_polygon {-# NOINLINE bindNavigationMesh_get_polygon_count #-} bindNavigationMesh_get_polygon_count :: MethodBind bindNavigationMesh_get_polygon_count = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_polygon_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_polygon_count :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Int get_polygon_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_polygon_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_polygon_count" '[] (IO Int) where nodeMethod = Godot.Core.NavigationMesh.get_polygon_count {-# NOINLINE bindNavigationMesh_get_region_merge_size #-} bindNavigationMesh_get_region_merge_size :: MethodBind bindNavigationMesh_get_region_merge_size = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_region_merge_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_region_merge_size :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_region_merge_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_region_merge_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_region_merge_size" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_region_merge_size {-# NOINLINE bindNavigationMesh_get_region_min_size #-} bindNavigationMesh_get_region_min_size :: MethodBind bindNavigationMesh_get_region_min_size = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_region_min_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_region_min_size :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_region_min_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_region_min_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_region_min_size" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_region_min_size {-# NOINLINE bindNavigationMesh_get_sample_partition_type #-} bindNavigationMesh_get_sample_partition_type :: MethodBind bindNavigationMesh_get_sample_partition_type = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_sample_partition_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_sample_partition_type :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Int get_sample_partition_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_sample_partition_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_sample_partition_type" '[] (IO Int) where nodeMethod = Godot.Core.NavigationMesh.get_sample_partition_type {-# NOINLINE bindNavigationMesh_get_source_geometry_mode #-} bindNavigationMesh_get_source_geometry_mode :: MethodBind bindNavigationMesh_get_source_geometry_mode = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_source_geometry_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_source_geometry_mode :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Int get_source_geometry_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_source_geometry_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_source_geometry_mode" '[] (IO Int) where nodeMethod = Godot.Core.NavigationMesh.get_source_geometry_mode {-# NOINLINE bindNavigationMesh_get_source_group_name #-} bindNavigationMesh_get_source_group_name :: MethodBind bindNavigationMesh_get_source_group_name = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_source_group_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_source_group_name :: (NavigationMesh :< cls, Object :< cls) => cls -> IO GodotString get_source_group_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_source_group_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_source_group_name" '[] (IO GodotString) where nodeMethod = Godot.Core.NavigationMesh.get_source_group_name {-# NOINLINE bindNavigationMesh_get_vertices #-} bindNavigationMesh_get_vertices :: MethodBind bindNavigationMesh_get_vertices = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_vertices" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_vertices :: (NavigationMesh :< cls, Object :< cls) => cls -> IO PoolVector3Array get_vertices cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_vertices (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_vertices" '[] (IO PoolVector3Array) where nodeMethod = Godot.Core.NavigationMesh.get_vertices {-# NOINLINE bindNavigationMesh_get_verts_per_poly #-} bindNavigationMesh_get_verts_per_poly :: MethodBind bindNavigationMesh_get_verts_per_poly = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "get_verts_per_poly" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_verts_per_poly :: (NavigationMesh :< cls, Object :< cls) => cls -> IO Float get_verts_per_poly cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_get_verts_per_poly (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "get_verts_per_poly" '[] (IO Float) where nodeMethod = Godot.Core.NavigationMesh.get_verts_per_poly {-# NOINLINE bindNavigationMesh_set_agent_height #-} bindNavigationMesh_set_agent_height :: MethodBind bindNavigationMesh_set_agent_height = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_agent_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_agent_height :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_agent_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_agent_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_agent_height" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_agent_height {-# NOINLINE bindNavigationMesh_set_agent_max_climb #-} bindNavigationMesh_set_agent_max_climb :: MethodBind bindNavigationMesh_set_agent_max_climb = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_agent_max_climb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_agent_max_climb :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_agent_max_climb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_agent_max_climb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_agent_max_climb" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_agent_max_climb {-# NOINLINE bindNavigationMesh_set_agent_max_slope #-} bindNavigationMesh_set_agent_max_slope :: MethodBind bindNavigationMesh_set_agent_max_slope = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_agent_max_slope" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_agent_max_slope :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_agent_max_slope cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_agent_max_slope (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_agent_max_slope" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_agent_max_slope {-# NOINLINE bindNavigationMesh_set_agent_radius #-} bindNavigationMesh_set_agent_radius :: MethodBind bindNavigationMesh_set_agent_radius = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_agent_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_agent_radius :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_agent_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_agent_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_agent_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_agent_radius {-# NOINLINE bindNavigationMesh_set_cell_height #-} bindNavigationMesh_set_cell_height :: MethodBind bindNavigationMesh_set_cell_height = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_cell_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_height :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_cell_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_cell_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_cell_height" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_cell_height {-# NOINLINE bindNavigationMesh_set_cell_size #-} bindNavigationMesh_set_cell_size :: MethodBind bindNavigationMesh_set_cell_size = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_size :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_cell_size" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_cell_size {-# NOINLINE bindNavigationMesh_set_collision_mask #-} bindNavigationMesh_set_collision_mask :: MethodBind bindNavigationMesh_set_collision_mask = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_mask :: (NavigationMesh :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_collision_mask {-# NOINLINE bindNavigationMesh_set_collision_mask_bit #-} bindNavigationMesh_set_collision_mask_bit :: MethodBind bindNavigationMesh_set_collision_mask_bit = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_collision_mask_bit :: (NavigationMesh :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_collision_mask_bit {-# NOINLINE bindNavigationMesh_set_detail_sample_distance #-} bindNavigationMesh_set_detail_sample_distance :: MethodBind bindNavigationMesh_set_detail_sample_distance = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_detail_sample_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_detail_sample_distance :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_detail_sample_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_detail_sample_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_detail_sample_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_detail_sample_distance {-# NOINLINE bindNavigationMesh_set_detail_sample_max_error #-} bindNavigationMesh_set_detail_sample_max_error :: MethodBind bindNavigationMesh_set_detail_sample_max_error = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_detail_sample_max_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_detail_sample_max_error :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_detail_sample_max_error cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_detail_sample_max_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_detail_sample_max_error" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_detail_sample_max_error {-# NOINLINE bindNavigationMesh_set_edge_max_error #-} bindNavigationMesh_set_edge_max_error :: MethodBind bindNavigationMesh_set_edge_max_error = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_edge_max_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_edge_max_error :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_edge_max_error cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_edge_max_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_edge_max_error" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_edge_max_error {-# NOINLINE bindNavigationMesh_set_edge_max_length #-} bindNavigationMesh_set_edge_max_length :: MethodBind bindNavigationMesh_set_edge_max_length = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_edge_max_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_edge_max_length :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_edge_max_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_edge_max_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_edge_max_length" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_edge_max_length {-# NOINLINE bindNavigationMesh_set_filter_ledge_spans #-} bindNavigationMesh_set_filter_ledge_spans :: MethodBind bindNavigationMesh_set_filter_ledge_spans = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_filter_ledge_spans" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_filter_ledge_spans :: (NavigationMesh :< cls, Object :< cls) => cls -> Bool -> IO () set_filter_ledge_spans cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_filter_ledge_spans (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_filter_ledge_spans" '[Bool] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_filter_ledge_spans {-# NOINLINE bindNavigationMesh_set_filter_low_hanging_obstacles #-} bindNavigationMesh_set_filter_low_hanging_obstacles :: MethodBind bindNavigationMesh_set_filter_low_hanging_obstacles = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_filter_low_hanging_obstacles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_filter_low_hanging_obstacles :: (NavigationMesh :< cls, Object :< cls) => cls -> Bool -> IO () set_filter_low_hanging_obstacles cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_filter_low_hanging_obstacles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_filter_low_hanging_obstacles" '[Bool] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_filter_low_hanging_obstacles {-# NOINLINE bindNavigationMesh_set_filter_walkable_low_height_spans #-} bindNavigationMesh_set_filter_walkable_low_height_spans :: MethodBind bindNavigationMesh_set_filter_walkable_low_height_spans = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_filter_walkable_low_height_spans" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_filter_walkable_low_height_spans :: (NavigationMesh :< cls, Object :< cls) => cls -> Bool -> IO () set_filter_walkable_low_height_spans cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_filter_walkable_low_height_spans (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_filter_walkable_low_height_spans" '[Bool] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_filter_walkable_low_height_spans {-# NOINLINE bindNavigationMesh_set_parsed_geometry_type #-} bindNavigationMesh_set_parsed_geometry_type :: MethodBind bindNavigationMesh_set_parsed_geometry_type = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_parsed_geometry_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_parsed_geometry_type :: (NavigationMesh :< cls, Object :< cls) => cls -> Int -> IO () set_parsed_geometry_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_parsed_geometry_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_parsed_geometry_type" '[Int] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_parsed_geometry_type {-# NOINLINE bindNavigationMesh_set_region_merge_size #-} bindNavigationMesh_set_region_merge_size :: MethodBind bindNavigationMesh_set_region_merge_size = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_region_merge_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_region_merge_size :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_region_merge_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_region_merge_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_region_merge_size" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_region_merge_size {-# NOINLINE bindNavigationMesh_set_region_min_size #-} bindNavigationMesh_set_region_min_size :: MethodBind bindNavigationMesh_set_region_min_size = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_region_min_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_region_min_size :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_region_min_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_region_min_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_region_min_size" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_region_min_size {-# NOINLINE bindNavigationMesh_set_sample_partition_type #-} bindNavigationMesh_set_sample_partition_type :: MethodBind bindNavigationMesh_set_sample_partition_type = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_sample_partition_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_sample_partition_type :: (NavigationMesh :< cls, Object :< cls) => cls -> Int -> IO () set_sample_partition_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_sample_partition_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_sample_partition_type" '[Int] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_sample_partition_type {-# NOINLINE bindNavigationMesh_set_source_geometry_mode #-} bindNavigationMesh_set_source_geometry_mode :: MethodBind bindNavigationMesh_set_source_geometry_mode = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_source_geometry_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_source_geometry_mode :: (NavigationMesh :< cls, Object :< cls) => cls -> Int -> IO () set_source_geometry_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_source_geometry_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_source_geometry_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_source_geometry_mode {-# NOINLINE bindNavigationMesh_set_source_group_name #-} bindNavigationMesh_set_source_group_name :: MethodBind bindNavigationMesh_set_source_group_name = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_source_group_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_source_group_name :: (NavigationMesh :< cls, Object :< cls) => cls -> GodotString -> IO () set_source_group_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_source_group_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_source_group_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_source_group_name {-# NOINLINE bindNavigationMesh_set_vertices #-} bindNavigationMesh_set_vertices :: MethodBind bindNavigationMesh_set_vertices = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_vertices" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_vertices :: (NavigationMesh :< cls, Object :< cls) => cls -> PoolVector3Array -> IO () set_vertices cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_vertices (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_vertices" '[PoolVector3Array] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_vertices {-# NOINLINE bindNavigationMesh_set_verts_per_poly #-} bindNavigationMesh_set_verts_per_poly :: MethodBind bindNavigationMesh_set_verts_per_poly = unsafePerformIO $ withCString "NavigationMesh" $ \ clsNamePtr -> withCString "set_verts_per_poly" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_verts_per_poly :: (NavigationMesh :< cls, Object :< cls) => cls -> Float -> IO () set_verts_per_poly cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMesh_set_verts_per_poly (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMesh "set_verts_per_poly" '[Float] (IO ()) where nodeMethod = Godot.Core.NavigationMesh.set_verts_per_poly ================================================ FILE: src/Godot/Core/NavigationMeshInstance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NavigationMeshInstance (Godot.Core.NavigationMeshInstance.get_navigation_mesh, Godot.Core.NavigationMeshInstance.is_enabled, Godot.Core.NavigationMeshInstance.set_enabled, Godot.Core.NavigationMeshInstance.set_navigation_mesh) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty NavigationMeshInstance "enabled" Bool 'False where nodeProperty = (is_enabled, wrapDroppingSetter set_enabled, Nothing) instance NodeProperty NavigationMeshInstance "navmesh" NavigationMesh 'False where nodeProperty = (get_navigation_mesh, wrapDroppingSetter set_navigation_mesh, Nothing) {-# NOINLINE bindNavigationMeshInstance_get_navigation_mesh #-} bindNavigationMeshInstance_get_navigation_mesh :: MethodBind bindNavigationMeshInstance_get_navigation_mesh = unsafePerformIO $ withCString "NavigationMeshInstance" $ \ clsNamePtr -> withCString "get_navigation_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_navigation_mesh :: (NavigationMeshInstance :< cls, Object :< cls) => cls -> IO NavigationMesh get_navigation_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMeshInstance_get_navigation_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMeshInstance "get_navigation_mesh" '[] (IO NavigationMesh) where nodeMethod = Godot.Core.NavigationMeshInstance.get_navigation_mesh {-# NOINLINE bindNavigationMeshInstance_is_enabled #-} bindNavigationMeshInstance_is_enabled :: MethodBind bindNavigationMeshInstance_is_enabled = unsafePerformIO $ withCString "NavigationMeshInstance" $ \ clsNamePtr -> withCString "is_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_enabled :: (NavigationMeshInstance :< cls, Object :< cls) => cls -> IO Bool is_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMeshInstance_is_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMeshInstance "is_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.NavigationMeshInstance.is_enabled {-# NOINLINE bindNavigationMeshInstance_set_enabled #-} bindNavigationMeshInstance_set_enabled :: MethodBind bindNavigationMeshInstance_set_enabled = unsafePerformIO $ withCString "NavigationMeshInstance" $ \ clsNamePtr -> withCString "set_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_enabled :: (NavigationMeshInstance :< cls, Object :< cls) => cls -> Bool -> IO () set_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMeshInstance_set_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMeshInstance "set_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.NavigationMeshInstance.set_enabled {-# NOINLINE bindNavigationMeshInstance_set_navigation_mesh #-} bindNavigationMeshInstance_set_navigation_mesh :: MethodBind bindNavigationMeshInstance_set_navigation_mesh = unsafePerformIO $ withCString "NavigationMeshInstance" $ \ clsNamePtr -> withCString "set_navigation_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_navigation_mesh :: (NavigationMeshInstance :< cls, Object :< cls) => cls -> NavigationMesh -> IO () set_navigation_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationMeshInstance_set_navigation_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationMeshInstance "set_navigation_mesh" '[NavigationMesh] (IO ()) where nodeMethod = Godot.Core.NavigationMeshInstance.set_navigation_mesh ================================================ FILE: src/Godot/Core/NavigationPolygon.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NavigationPolygon (Godot.Core.NavigationPolygon._get_outlines, Godot.Core.NavigationPolygon._get_polygons, Godot.Core.NavigationPolygon._set_outlines, Godot.Core.NavigationPolygon._set_polygons, Godot.Core.NavigationPolygon.add_outline, Godot.Core.NavigationPolygon.add_outline_at_index, Godot.Core.NavigationPolygon.add_polygon, Godot.Core.NavigationPolygon.clear_outlines, Godot.Core.NavigationPolygon.clear_polygons, Godot.Core.NavigationPolygon.get_outline, Godot.Core.NavigationPolygon.get_outline_count, Godot.Core.NavigationPolygon.get_polygon, Godot.Core.NavigationPolygon.get_polygon_count, Godot.Core.NavigationPolygon.get_vertices, Godot.Core.NavigationPolygon.make_polygons_from_outlines, Godot.Core.NavigationPolygon.remove_outline, Godot.Core.NavigationPolygon.set_outline, Godot.Core.NavigationPolygon.set_vertices) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty NavigationPolygon "outlines" Array 'False where nodeProperty = (_get_outlines, wrapDroppingSetter _set_outlines, Nothing) instance NodeProperty NavigationPolygon "polygons" Array 'False where nodeProperty = (_get_polygons, wrapDroppingSetter _set_polygons, Nothing) instance NodeProperty NavigationPolygon "vertices" PoolVector2Array 'False where nodeProperty = (get_vertices, wrapDroppingSetter set_vertices, Nothing) {-# NOINLINE bindNavigationPolygon__get_outlines #-} bindNavigationPolygon__get_outlines :: MethodBind bindNavigationPolygon__get_outlines = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "_get_outlines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_outlines :: (NavigationPolygon :< cls, Object :< cls) => cls -> IO Array _get_outlines cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon__get_outlines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "_get_outlines" '[] (IO Array) where nodeMethod = Godot.Core.NavigationPolygon._get_outlines {-# NOINLINE bindNavigationPolygon__get_polygons #-} bindNavigationPolygon__get_polygons :: MethodBind bindNavigationPolygon__get_polygons = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "_get_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_polygons :: (NavigationPolygon :< cls, Object :< cls) => cls -> IO Array _get_polygons cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon__get_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "_get_polygons" '[] (IO Array) where nodeMethod = Godot.Core.NavigationPolygon._get_polygons {-# NOINLINE bindNavigationPolygon__set_outlines #-} bindNavigationPolygon__set_outlines :: MethodBind bindNavigationPolygon__set_outlines = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "_set_outlines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_outlines :: (NavigationPolygon :< cls, Object :< cls) => cls -> Array -> IO () _set_outlines cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon__set_outlines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "_set_outlines" '[Array] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon._set_outlines {-# NOINLINE bindNavigationPolygon__set_polygons #-} bindNavigationPolygon__set_polygons :: MethodBind bindNavigationPolygon__set_polygons = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "_set_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_polygons :: (NavigationPolygon :< cls, Object :< cls) => cls -> Array -> IO () _set_polygons cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon__set_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "_set_polygons" '[Array] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon._set_polygons {-# NOINLINE bindNavigationPolygon_add_outline #-} -- | Appends a @PoolVector2Array@ that contains the vertices of an outline to the internal array that contains all the outlines. You have to call @method make_polygons_from_outlines@ in order for this array to be converted to polygons that the engine will use. bindNavigationPolygon_add_outline :: MethodBind bindNavigationPolygon_add_outline = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "add_outline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Appends a @PoolVector2Array@ that contains the vertices of an outline to the internal array that contains all the outlines. You have to call @method make_polygons_from_outlines@ in order for this array to be converted to polygons that the engine will use. add_outline :: (NavigationPolygon :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () add_outline cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_add_outline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "add_outline" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.add_outline {-# NOINLINE bindNavigationPolygon_add_outline_at_index #-} -- | Adds a @PoolVector2Array@ that contains the vertices of an outline to the internal array that contains all the outlines at a fixed position. You have to call @method make_polygons_from_outlines@ in order for this array to be converted to polygons that the engine will use. bindNavigationPolygon_add_outline_at_index :: MethodBind bindNavigationPolygon_add_outline_at_index = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "add_outline_at_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @PoolVector2Array@ that contains the vertices of an outline to the internal array that contains all the outlines at a fixed position. You have to call @method make_polygons_from_outlines@ in order for this array to be converted to polygons that the engine will use. add_outline_at_index :: (NavigationPolygon :< cls, Object :< cls) => cls -> PoolVector2Array -> Int -> IO () add_outline_at_index cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_add_outline_at_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "add_outline_at_index" '[PoolVector2Array, Int] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.add_outline_at_index {-# NOINLINE bindNavigationPolygon_add_polygon #-} -- | Adds a polygon using the indices of the vertices you get when calling @method get_vertices@. bindNavigationPolygon_add_polygon :: MethodBind bindNavigationPolygon_add_polygon = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "add_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a polygon using the indices of the vertices you get when calling @method get_vertices@. add_polygon :: (NavigationPolygon :< cls, Object :< cls) => cls -> PoolIntArray -> IO () add_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_add_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "add_polygon" '[PoolIntArray] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.add_polygon {-# NOINLINE bindNavigationPolygon_clear_outlines #-} -- | Clears the array of the outlines, but it doesn't clear the vertices and the polygons that were created by them. bindNavigationPolygon_clear_outlines :: MethodBind bindNavigationPolygon_clear_outlines = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "clear_outlines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the array of the outlines, but it doesn't clear the vertices and the polygons that were created by them. clear_outlines :: (NavigationPolygon :< cls, Object :< cls) => cls -> IO () clear_outlines cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_clear_outlines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "clear_outlines" '[] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.clear_outlines {-# NOINLINE bindNavigationPolygon_clear_polygons #-} -- | Clears the array of polygons, but it doesn't clear the array of outlines and vertices. bindNavigationPolygon_clear_polygons :: MethodBind bindNavigationPolygon_clear_polygons = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "clear_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the array of polygons, but it doesn't clear the array of outlines and vertices. clear_polygons :: (NavigationPolygon :< cls, Object :< cls) => cls -> IO () clear_polygons cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_clear_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "clear_polygons" '[] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.clear_polygons {-# NOINLINE bindNavigationPolygon_get_outline #-} -- | Returns a @PoolVector2Array@ containing the vertices of an outline that was created in the editor or by script. bindNavigationPolygon_get_outline :: MethodBind bindNavigationPolygon_get_outline = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "get_outline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @PoolVector2Array@ containing the vertices of an outline that was created in the editor or by script. get_outline :: (NavigationPolygon :< cls, Object :< cls) => cls -> Int -> IO PoolVector2Array get_outline cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_get_outline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "get_outline" '[Int] (IO PoolVector2Array) where nodeMethod = Godot.Core.NavigationPolygon.get_outline {-# NOINLINE bindNavigationPolygon_get_outline_count #-} -- | Returns the number of outlines that were created in the editor or by script. bindNavigationPolygon_get_outline_count :: MethodBind bindNavigationPolygon_get_outline_count = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "get_outline_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of outlines that were created in the editor or by script. get_outline_count :: (NavigationPolygon :< cls, Object :< cls) => cls -> IO Int get_outline_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_get_outline_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "get_outline_count" '[] (IO Int) where nodeMethod = Godot.Core.NavigationPolygon.get_outline_count {-# NOINLINE bindNavigationPolygon_get_polygon #-} -- | Returns a @PoolIntArray@ containing the indices of the vertices of a created polygon. bindNavigationPolygon_get_polygon :: MethodBind bindNavigationPolygon_get_polygon = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "get_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @PoolIntArray@ containing the indices of the vertices of a created polygon. get_polygon :: (NavigationPolygon :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_get_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "get_polygon" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.NavigationPolygon.get_polygon {-# NOINLINE bindNavigationPolygon_get_polygon_count #-} -- | Returns the count of all polygons. bindNavigationPolygon_get_polygon_count :: MethodBind bindNavigationPolygon_get_polygon_count = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "get_polygon_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the count of all polygons. get_polygon_count :: (NavigationPolygon :< cls, Object :< cls) => cls -> IO Int get_polygon_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_get_polygon_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "get_polygon_count" '[] (IO Int) where nodeMethod = Godot.Core.NavigationPolygon.get_polygon_count {-# NOINLINE bindNavigationPolygon_get_vertices #-} -- | Returns a @PoolVector2Array@ containing all the vertices being used to create the polygons. bindNavigationPolygon_get_vertices :: MethodBind bindNavigationPolygon_get_vertices = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "get_vertices" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @PoolVector2Array@ containing all the vertices being used to create the polygons. get_vertices :: (NavigationPolygon :< cls, Object :< cls) => cls -> IO PoolVector2Array get_vertices cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_get_vertices (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "get_vertices" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.NavigationPolygon.get_vertices {-# NOINLINE bindNavigationPolygon_make_polygons_from_outlines #-} -- | Creates polygons from the outlines added in the editor or by script. bindNavigationPolygon_make_polygons_from_outlines :: MethodBind bindNavigationPolygon_make_polygons_from_outlines = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "make_polygons_from_outlines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates polygons from the outlines added in the editor or by script. make_polygons_from_outlines :: (NavigationPolygon :< cls, Object :< cls) => cls -> IO () make_polygons_from_outlines cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_make_polygons_from_outlines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "make_polygons_from_outlines" '[] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.make_polygons_from_outlines {-# NOINLINE bindNavigationPolygon_remove_outline #-} -- | Removes an outline created in the editor or by script. You have to call @method make_polygons_from_outlines@ for the polygons to update. bindNavigationPolygon_remove_outline :: MethodBind bindNavigationPolygon_remove_outline = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "remove_outline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes an outline created in the editor or by script. You have to call @method make_polygons_from_outlines@ for the polygons to update. remove_outline :: (NavigationPolygon :< cls, Object :< cls) => cls -> Int -> IO () remove_outline cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_remove_outline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "remove_outline" '[Int] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.remove_outline {-# NOINLINE bindNavigationPolygon_set_outline #-} -- | Changes an outline created in the editor or by script. You have to call @method make_polygons_from_outlines@ for the polygons to update. bindNavigationPolygon_set_outline :: MethodBind bindNavigationPolygon_set_outline = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "set_outline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes an outline created in the editor or by script. You have to call @method make_polygons_from_outlines@ for the polygons to update. set_outline :: (NavigationPolygon :< cls, Object :< cls) => cls -> Int -> PoolVector2Array -> IO () set_outline cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_set_outline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "set_outline" '[Int, PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.set_outline {-# NOINLINE bindNavigationPolygon_set_vertices #-} -- | Sets the vertices that can be then indexed to create polygons with the @method add_polygon@ method. bindNavigationPolygon_set_vertices :: MethodBind bindNavigationPolygon_set_vertices = unsafePerformIO $ withCString "NavigationPolygon" $ \ clsNamePtr -> withCString "set_vertices" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the vertices that can be then indexed to create polygons with the @method add_polygon@ method. set_vertices :: (NavigationPolygon :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_vertices cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygon_set_vertices (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygon "set_vertices" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.NavigationPolygon.set_vertices ================================================ FILE: src/Godot/Core/NavigationPolygonInstance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NavigationPolygonInstance (Godot.Core.NavigationPolygonInstance._navpoly_changed, Godot.Core.NavigationPolygonInstance.get_navigation_polygon, Godot.Core.NavigationPolygonInstance.is_enabled, Godot.Core.NavigationPolygonInstance.set_enabled, Godot.Core.NavigationPolygonInstance.set_navigation_polygon) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty NavigationPolygonInstance "enabled" Bool 'False where nodeProperty = (is_enabled, wrapDroppingSetter set_enabled, Nothing) instance NodeProperty NavigationPolygonInstance "navpoly" NavigationPolygon 'False where nodeProperty = (get_navigation_polygon, wrapDroppingSetter set_navigation_polygon, Nothing) {-# NOINLINE bindNavigationPolygonInstance__navpoly_changed #-} bindNavigationPolygonInstance__navpoly_changed :: MethodBind bindNavigationPolygonInstance__navpoly_changed = unsafePerformIO $ withCString "NavigationPolygonInstance" $ \ clsNamePtr -> withCString "_navpoly_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _navpoly_changed :: (NavigationPolygonInstance :< cls, Object :< cls) => cls -> IO () _navpoly_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygonInstance__navpoly_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygonInstance "_navpoly_changed" '[] (IO ()) where nodeMethod = Godot.Core.NavigationPolygonInstance._navpoly_changed {-# NOINLINE bindNavigationPolygonInstance_get_navigation_polygon #-} bindNavigationPolygonInstance_get_navigation_polygon :: MethodBind bindNavigationPolygonInstance_get_navigation_polygon = unsafePerformIO $ withCString "NavigationPolygonInstance" $ \ clsNamePtr -> withCString "get_navigation_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_navigation_polygon :: (NavigationPolygonInstance :< cls, Object :< cls) => cls -> IO NavigationPolygon get_navigation_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygonInstance_get_navigation_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygonInstance "get_navigation_polygon" '[] (IO NavigationPolygon) where nodeMethod = Godot.Core.NavigationPolygonInstance.get_navigation_polygon {-# NOINLINE bindNavigationPolygonInstance_is_enabled #-} bindNavigationPolygonInstance_is_enabled :: MethodBind bindNavigationPolygonInstance_is_enabled = unsafePerformIO $ withCString "NavigationPolygonInstance" $ \ clsNamePtr -> withCString "is_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_enabled :: (NavigationPolygonInstance :< cls, Object :< cls) => cls -> IO Bool is_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygonInstance_is_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygonInstance "is_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.NavigationPolygonInstance.is_enabled {-# NOINLINE bindNavigationPolygonInstance_set_enabled #-} bindNavigationPolygonInstance_set_enabled :: MethodBind bindNavigationPolygonInstance_set_enabled = unsafePerformIO $ withCString "NavigationPolygonInstance" $ \ clsNamePtr -> withCString "set_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_enabled :: (NavigationPolygonInstance :< cls, Object :< cls) => cls -> Bool -> IO () set_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygonInstance_set_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygonInstance "set_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.NavigationPolygonInstance.set_enabled {-# NOINLINE bindNavigationPolygonInstance_set_navigation_polygon #-} bindNavigationPolygonInstance_set_navigation_polygon :: MethodBind bindNavigationPolygonInstance_set_navigation_polygon = unsafePerformIO $ withCString "NavigationPolygonInstance" $ \ clsNamePtr -> withCString "set_navigation_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_navigation_polygon :: (NavigationPolygonInstance :< cls, Object :< cls) => cls -> NavigationPolygon -> IO () set_navigation_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNavigationPolygonInstance_set_navigation_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NavigationPolygonInstance "set_navigation_polygon" '[NavigationPolygon] (IO ()) where nodeMethod = Godot.Core.NavigationPolygonInstance.set_navigation_polygon ================================================ FILE: src/Godot/Core/NetworkedMultiplayerENet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NetworkedMultiplayerENet (Godot.Core.NetworkedMultiplayerENet._COMPRESS_NONE, Godot.Core.NetworkedMultiplayerENet._COMPRESS_RANGE_CODER, Godot.Core.NetworkedMultiplayerENet._COMPRESS_ZLIB, Godot.Core.NetworkedMultiplayerENet._COMPRESS_FASTLZ, Godot.Core.NetworkedMultiplayerENet._COMPRESS_ZSTD, Godot.Core.NetworkedMultiplayerENet.close_connection, Godot.Core.NetworkedMultiplayerENet.create_client, Godot.Core.NetworkedMultiplayerENet.create_server, Godot.Core.NetworkedMultiplayerENet.disconnect_peer, Godot.Core.NetworkedMultiplayerENet.get_channel_count, Godot.Core.NetworkedMultiplayerENet.get_compression_mode, Godot.Core.NetworkedMultiplayerENet.get_last_packet_channel, Godot.Core.NetworkedMultiplayerENet.get_packet_channel, Godot.Core.NetworkedMultiplayerENet.get_peer_address, Godot.Core.NetworkedMultiplayerENet.get_peer_port, Godot.Core.NetworkedMultiplayerENet.get_transfer_channel, Godot.Core.NetworkedMultiplayerENet.is_always_ordered, Godot.Core.NetworkedMultiplayerENet.is_server_relay_enabled, Godot.Core.NetworkedMultiplayerENet.set_always_ordered, Godot.Core.NetworkedMultiplayerENet.set_bind_ip, Godot.Core.NetworkedMultiplayerENet.set_channel_count, Godot.Core.NetworkedMultiplayerENet.set_compression_mode, Godot.Core.NetworkedMultiplayerENet.set_server_relay_enabled, Godot.Core.NetworkedMultiplayerENet.set_transfer_channel) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.NetworkedMultiplayerPeer() _COMPRESS_NONE :: Int _COMPRESS_NONE = 0 _COMPRESS_RANGE_CODER :: Int _COMPRESS_RANGE_CODER = 1 _COMPRESS_ZLIB :: Int _COMPRESS_ZLIB = 3 _COMPRESS_FASTLZ :: Int _COMPRESS_FASTLZ = 2 _COMPRESS_ZSTD :: Int _COMPRESS_ZSTD = 4 instance NodeProperty NetworkedMultiplayerENet "always_ordered" Bool 'False where nodeProperty = (is_always_ordered, wrapDroppingSetter set_always_ordered, Nothing) instance NodeProperty NetworkedMultiplayerENet "channel_count" Int 'False where nodeProperty = (get_channel_count, wrapDroppingSetter set_channel_count, Nothing) instance NodeProperty NetworkedMultiplayerENet "compression_mode" Int 'False where nodeProperty = (get_compression_mode, wrapDroppingSetter set_compression_mode, Nothing) instance NodeProperty NetworkedMultiplayerENet "server_relay" Bool 'False where nodeProperty = (is_server_relay_enabled, wrapDroppingSetter set_server_relay_enabled, Nothing) instance NodeProperty NetworkedMultiplayerENet "transfer_channel" Int 'False where nodeProperty = (get_transfer_channel, wrapDroppingSetter set_transfer_channel, Nothing) {-# NOINLINE bindNetworkedMultiplayerENet_close_connection #-} bindNetworkedMultiplayerENet_close_connection :: MethodBind bindNetworkedMultiplayerENet_close_connection = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "close_connection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr close_connection :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Maybe Int -> IO () close_connection cls arg1 = withVariantArray [maybe (VariantInt (100)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_close_connection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "close_connection" '[Maybe Int] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.close_connection {-# NOINLINE bindNetworkedMultiplayerENet_create_client #-} bindNetworkedMultiplayerENet_create_client :: MethodBind bindNetworkedMultiplayerENet_create_client = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "create_client" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr create_client :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> GodotString -> Int -> Maybe Int -> Maybe Int -> Maybe Int -> IO Int create_client cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (0)) toVariant arg3, maybe (VariantInt (0)) toVariant arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_create_client (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "create_client" '[GodotString, Int, Maybe Int, Maybe Int, Maybe Int] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.create_client {-# NOINLINE bindNetworkedMultiplayerENet_create_server #-} bindNetworkedMultiplayerENet_create_server :: MethodBind bindNetworkedMultiplayerENet_create_server = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "create_server" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr create_server :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Int -> Maybe Int -> Maybe Int -> Maybe Int -> IO Int create_server cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantInt (32)) toVariant arg2, maybe (VariantInt (0)) toVariant arg3, maybe (VariantInt (0)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_create_server (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "create_server" '[Int, Maybe Int, Maybe Int, Maybe Int] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.create_server {-# NOINLINE bindNetworkedMultiplayerENet_disconnect_peer #-} bindNetworkedMultiplayerENet_disconnect_peer :: MethodBind bindNetworkedMultiplayerENet_disconnect_peer = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "disconnect_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr disconnect_peer :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO () disconnect_peer cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_disconnect_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "disconnect_peer" '[Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.disconnect_peer {-# NOINLINE bindNetworkedMultiplayerENet_get_channel_count #-} bindNetworkedMultiplayerENet_get_channel_count :: MethodBind bindNetworkedMultiplayerENet_get_channel_count = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "get_channel_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_channel_count :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> IO Int get_channel_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_get_channel_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "get_channel_count" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.get_channel_count {-# NOINLINE bindNetworkedMultiplayerENet_get_compression_mode #-} bindNetworkedMultiplayerENet_get_compression_mode :: MethodBind bindNetworkedMultiplayerENet_get_compression_mode = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "get_compression_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_compression_mode :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> IO Int get_compression_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_get_compression_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "get_compression_mode" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.get_compression_mode {-# NOINLINE bindNetworkedMultiplayerENet_get_last_packet_channel #-} bindNetworkedMultiplayerENet_get_last_packet_channel :: MethodBind bindNetworkedMultiplayerENet_get_last_packet_channel = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "get_last_packet_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_last_packet_channel :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> IO Int get_last_packet_channel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_get_last_packet_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "get_last_packet_channel" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.get_last_packet_channel {-# NOINLINE bindNetworkedMultiplayerENet_get_packet_channel #-} bindNetworkedMultiplayerENet_get_packet_channel :: MethodBind bindNetworkedMultiplayerENet_get_packet_channel = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "get_packet_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_packet_channel :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> IO Int get_packet_channel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_get_packet_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "get_packet_channel" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.get_packet_channel {-# NOINLINE bindNetworkedMultiplayerENet_get_peer_address #-} bindNetworkedMultiplayerENet_get_peer_address :: MethodBind bindNetworkedMultiplayerENet_get_peer_address = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "get_peer_address" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_peer_address :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Int -> IO GodotString get_peer_address cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_get_peer_address (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "get_peer_address" '[Int] (IO GodotString) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.get_peer_address {-# NOINLINE bindNetworkedMultiplayerENet_get_peer_port #-} bindNetworkedMultiplayerENet_get_peer_port :: MethodBind bindNetworkedMultiplayerENet_get_peer_port = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "get_peer_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_peer_port :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Int -> IO Int get_peer_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_get_peer_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "get_peer_port" '[Int] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.get_peer_port {-# NOINLINE bindNetworkedMultiplayerENet_get_transfer_channel #-} bindNetworkedMultiplayerENet_get_transfer_channel :: MethodBind bindNetworkedMultiplayerENet_get_transfer_channel = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "get_transfer_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_transfer_channel :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> IO Int get_transfer_channel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_get_transfer_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "get_transfer_channel" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.get_transfer_channel {-# NOINLINE bindNetworkedMultiplayerENet_is_always_ordered #-} bindNetworkedMultiplayerENet_is_always_ordered :: MethodBind bindNetworkedMultiplayerENet_is_always_ordered = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "is_always_ordered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_always_ordered :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> IO Bool is_always_ordered cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_is_always_ordered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "is_always_ordered" '[] (IO Bool) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.is_always_ordered {-# NOINLINE bindNetworkedMultiplayerENet_is_server_relay_enabled #-} bindNetworkedMultiplayerENet_is_server_relay_enabled :: MethodBind bindNetworkedMultiplayerENet_is_server_relay_enabled = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "is_server_relay_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_server_relay_enabled :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> IO Bool is_server_relay_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_is_server_relay_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "is_server_relay_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.is_server_relay_enabled {-# NOINLINE bindNetworkedMultiplayerENet_set_always_ordered #-} bindNetworkedMultiplayerENet_set_always_ordered :: MethodBind bindNetworkedMultiplayerENet_set_always_ordered = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "set_always_ordered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_always_ordered :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Bool -> IO () set_always_ordered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_set_always_ordered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "set_always_ordered" '[Bool] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.set_always_ordered {-# NOINLINE bindNetworkedMultiplayerENet_set_bind_ip #-} bindNetworkedMultiplayerENet_set_bind_ip :: MethodBind bindNetworkedMultiplayerENet_set_bind_ip = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "set_bind_ip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bind_ip :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> GodotString -> IO () set_bind_ip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_set_bind_ip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "set_bind_ip" '[GodotString] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.set_bind_ip {-# NOINLINE bindNetworkedMultiplayerENet_set_channel_count #-} bindNetworkedMultiplayerENet_set_channel_count :: MethodBind bindNetworkedMultiplayerENet_set_channel_count = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "set_channel_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_channel_count :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Int -> IO () set_channel_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_set_channel_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "set_channel_count" '[Int] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.set_channel_count {-# NOINLINE bindNetworkedMultiplayerENet_set_compression_mode #-} bindNetworkedMultiplayerENet_set_compression_mode :: MethodBind bindNetworkedMultiplayerENet_set_compression_mode = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "set_compression_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_compression_mode :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Int -> IO () set_compression_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_set_compression_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "set_compression_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.set_compression_mode {-# NOINLINE bindNetworkedMultiplayerENet_set_server_relay_enabled #-} bindNetworkedMultiplayerENet_set_server_relay_enabled :: MethodBind bindNetworkedMultiplayerENet_set_server_relay_enabled = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "set_server_relay_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_server_relay_enabled :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Bool -> IO () set_server_relay_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_set_server_relay_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "set_server_relay_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.set_server_relay_enabled {-# NOINLINE bindNetworkedMultiplayerENet_set_transfer_channel #-} bindNetworkedMultiplayerENet_set_transfer_channel :: MethodBind bindNetworkedMultiplayerENet_set_transfer_channel = unsafePerformIO $ withCString "NetworkedMultiplayerENet" $ \ clsNamePtr -> withCString "set_transfer_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_transfer_channel :: (NetworkedMultiplayerENet :< cls, Object :< cls) => cls -> Int -> IO () set_transfer_channel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerENet_set_transfer_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerENet "set_transfer_channel" '[Int] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerENet.set_transfer_channel ================================================ FILE: src/Godot/Core/NetworkedMultiplayerPeer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NetworkedMultiplayerPeer (Godot.Core.NetworkedMultiplayerPeer._CONNECTION_DISCONNECTED, Godot.Core.NetworkedMultiplayerPeer._TRANSFER_MODE_UNRELIABLE, Godot.Core.NetworkedMultiplayerPeer._CONNECTION_CONNECTED, Godot.Core.NetworkedMultiplayerPeer._TARGET_PEER_SERVER, Godot.Core.NetworkedMultiplayerPeer._TARGET_PEER_BROADCAST, Godot.Core.NetworkedMultiplayerPeer._CONNECTION_CONNECTING, Godot.Core.NetworkedMultiplayerPeer._TRANSFER_MODE_RELIABLE, Godot.Core.NetworkedMultiplayerPeer._TRANSFER_MODE_UNRELIABLE_ORDERED, Godot.Core.NetworkedMultiplayerPeer.sig_connection_failed, Godot.Core.NetworkedMultiplayerPeer.sig_connection_succeeded, Godot.Core.NetworkedMultiplayerPeer.sig_peer_connected, Godot.Core.NetworkedMultiplayerPeer.sig_peer_disconnected, Godot.Core.NetworkedMultiplayerPeer.sig_server_disconnected, Godot.Core.NetworkedMultiplayerPeer.get_connection_status, Godot.Core.NetworkedMultiplayerPeer.get_packet_peer, Godot.Core.NetworkedMultiplayerPeer.get_transfer_mode, Godot.Core.NetworkedMultiplayerPeer.get_unique_id, Godot.Core.NetworkedMultiplayerPeer.is_refusing_new_connections, Godot.Core.NetworkedMultiplayerPeer.poll, Godot.Core.NetworkedMultiplayerPeer.set_refuse_new_connections, Godot.Core.NetworkedMultiplayerPeer.set_target_peer, Godot.Core.NetworkedMultiplayerPeer.set_transfer_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PacketPeer() _CONNECTION_DISCONNECTED :: Int _CONNECTION_DISCONNECTED = 0 _TRANSFER_MODE_UNRELIABLE :: Int _TRANSFER_MODE_UNRELIABLE = 0 _CONNECTION_CONNECTED :: Int _CONNECTION_CONNECTED = 2 _TARGET_PEER_SERVER :: Int _TARGET_PEER_SERVER = 1 _TARGET_PEER_BROADCAST :: Int _TARGET_PEER_BROADCAST = 0 _CONNECTION_CONNECTING :: Int _CONNECTION_CONNECTING = 1 _TRANSFER_MODE_RELIABLE :: Int _TRANSFER_MODE_RELIABLE = 2 _TRANSFER_MODE_UNRELIABLE_ORDERED :: Int _TRANSFER_MODE_UNRELIABLE_ORDERED = 1 -- | Emitted when a connection attempt fails. sig_connection_failed :: Godot.Internal.Dispatch.Signal NetworkedMultiplayerPeer sig_connection_failed = Godot.Internal.Dispatch.Signal "connection_failed" instance NodeSignal NetworkedMultiplayerPeer "connection_failed" '[] -- | Emitted when a connection attempt succeeds. sig_connection_succeeded :: Godot.Internal.Dispatch.Signal NetworkedMultiplayerPeer sig_connection_succeeded = Godot.Internal.Dispatch.Signal "connection_succeeded" instance NodeSignal NetworkedMultiplayerPeer "connection_succeeded" '[] -- | Emitted by the server when a client connects. sig_peer_connected :: Godot.Internal.Dispatch.Signal NetworkedMultiplayerPeer sig_peer_connected = Godot.Internal.Dispatch.Signal "peer_connected" instance NodeSignal NetworkedMultiplayerPeer "peer_connected" '[Int] -- | Emitted by the server when a client disconnects. sig_peer_disconnected :: Godot.Internal.Dispatch.Signal NetworkedMultiplayerPeer sig_peer_disconnected = Godot.Internal.Dispatch.Signal "peer_disconnected" instance NodeSignal NetworkedMultiplayerPeer "peer_disconnected" '[Int] -- | Emitted by clients when the server disconnects. sig_server_disconnected :: Godot.Internal.Dispatch.Signal NetworkedMultiplayerPeer sig_server_disconnected = Godot.Internal.Dispatch.Signal "server_disconnected" instance NodeSignal NetworkedMultiplayerPeer "server_disconnected" '[] instance NodeProperty NetworkedMultiplayerPeer "refuse_new_connections" Bool 'False where nodeProperty = (is_refusing_new_connections, wrapDroppingSetter set_refuse_new_connections, Nothing) instance NodeProperty NetworkedMultiplayerPeer "transfer_mode" Int 'False where nodeProperty = (get_transfer_mode, wrapDroppingSetter set_transfer_mode, Nothing) {-# NOINLINE bindNetworkedMultiplayerPeer_get_connection_status #-} -- | Returns the current state of the connection. See @enum ConnectionStatus@. bindNetworkedMultiplayerPeer_get_connection_status :: MethodBind bindNetworkedMultiplayerPeer_get_connection_status = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "get_connection_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current state of the connection. See @enum ConnectionStatus@. get_connection_status :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> IO Int get_connection_status cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_get_connection_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "get_connection_status" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.get_connection_status {-# NOINLINE bindNetworkedMultiplayerPeer_get_packet_peer #-} -- | Returns the ID of the @NetworkedMultiplayerPeer@ who sent the most recent packet. bindNetworkedMultiplayerPeer_get_packet_peer :: MethodBind bindNetworkedMultiplayerPeer_get_packet_peer = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "get_packet_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the ID of the @NetworkedMultiplayerPeer@ who sent the most recent packet. get_packet_peer :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> IO Int get_packet_peer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_get_packet_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "get_packet_peer" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.get_packet_peer {-# NOINLINE bindNetworkedMultiplayerPeer_get_transfer_mode #-} -- | The manner in which to send packets to the @target_peer@. See @enum TransferMode@. bindNetworkedMultiplayerPeer_get_transfer_mode :: MethodBind bindNetworkedMultiplayerPeer_get_transfer_mode = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "get_transfer_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The manner in which to send packets to the @target_peer@. See @enum TransferMode@. get_transfer_mode :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> IO Int get_transfer_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_get_transfer_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "get_transfer_mode" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.get_transfer_mode {-# NOINLINE bindNetworkedMultiplayerPeer_get_unique_id #-} -- | Returns the ID of this @NetworkedMultiplayerPeer@. bindNetworkedMultiplayerPeer_get_unique_id :: MethodBind bindNetworkedMultiplayerPeer_get_unique_id = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "get_unique_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the ID of this @NetworkedMultiplayerPeer@. get_unique_id :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> IO Int get_unique_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_get_unique_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "get_unique_id" '[] (IO Int) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.get_unique_id {-# NOINLINE bindNetworkedMultiplayerPeer_is_refusing_new_connections #-} -- | If @true@, this @NetworkedMultiplayerPeer@ refuses new connections. bindNetworkedMultiplayerPeer_is_refusing_new_connections :: MethodBind bindNetworkedMultiplayerPeer_is_refusing_new_connections = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "is_refusing_new_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this @NetworkedMultiplayerPeer@ refuses new connections. is_refusing_new_connections :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> IO Bool is_refusing_new_connections cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_is_refusing_new_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "is_refusing_new_connections" '[] (IO Bool) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.is_refusing_new_connections {-# NOINLINE bindNetworkedMultiplayerPeer_poll #-} -- | Waits up to 1 second to receive a new network event. bindNetworkedMultiplayerPeer_poll :: MethodBind bindNetworkedMultiplayerPeer_poll = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "poll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Waits up to 1 second to receive a new network event. poll :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> IO () poll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_poll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "poll" '[] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.poll {-# NOINLINE bindNetworkedMultiplayerPeer_set_refuse_new_connections #-} -- | If @true@, this @NetworkedMultiplayerPeer@ refuses new connections. bindNetworkedMultiplayerPeer_set_refuse_new_connections :: MethodBind bindNetworkedMultiplayerPeer_set_refuse_new_connections = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "set_refuse_new_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this @NetworkedMultiplayerPeer@ refuses new connections. set_refuse_new_connections :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> Bool -> IO () set_refuse_new_connections cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_set_refuse_new_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "set_refuse_new_connections" '[Bool] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.set_refuse_new_connections {-# NOINLINE bindNetworkedMultiplayerPeer_set_target_peer #-} -- | Sets the peer to which packets will be sent. -- The @id@ can be one of: @TARGET_PEER_BROADCAST@ to send to all connected peers, @TARGET_PEER_SERVER@ to send to the peer acting as server, a valid peer ID to send to that specific peer, a negative peer ID to send to all peers except that one. By default, the target peer is @TARGET_PEER_BROADCAST@. bindNetworkedMultiplayerPeer_set_target_peer :: MethodBind bindNetworkedMultiplayerPeer_set_target_peer = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "set_target_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the peer to which packets will be sent. -- The @id@ can be one of: @TARGET_PEER_BROADCAST@ to send to all connected peers, @TARGET_PEER_SERVER@ to send to the peer acting as server, a valid peer ID to send to that specific peer, a negative peer ID to send to all peers except that one. By default, the target peer is @TARGET_PEER_BROADCAST@. set_target_peer :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> Int -> IO () set_target_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_set_target_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "set_target_peer" '[Int] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.set_target_peer {-# NOINLINE bindNetworkedMultiplayerPeer_set_transfer_mode #-} -- | The manner in which to send packets to the @target_peer@. See @enum TransferMode@. bindNetworkedMultiplayerPeer_set_transfer_mode :: MethodBind bindNetworkedMultiplayerPeer_set_transfer_mode = unsafePerformIO $ withCString "NetworkedMultiplayerPeer" $ \ clsNamePtr -> withCString "set_transfer_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The manner in which to send packets to the @target_peer@. See @enum TransferMode@. set_transfer_mode :: (NetworkedMultiplayerPeer :< cls, Object :< cls) => cls -> Int -> IO () set_transfer_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNetworkedMultiplayerPeer_set_transfer_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NetworkedMultiplayerPeer "set_transfer_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.NetworkedMultiplayerPeer.set_transfer_mode ================================================ FILE: src/Godot/Core/NinePatchRect.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NinePatchRect (Godot.Core.NinePatchRect._AXIS_STRETCH_MODE_TILE_FIT, Godot.Core.NinePatchRect._AXIS_STRETCH_MODE_TILE, Godot.Core.NinePatchRect._AXIS_STRETCH_MODE_STRETCH, Godot.Core.NinePatchRect.sig_texture_changed, Godot.Core.NinePatchRect.get_h_axis_stretch_mode, Godot.Core.NinePatchRect.get_patch_margin, Godot.Core.NinePatchRect.get_region_rect, Godot.Core.NinePatchRect.get_texture, Godot.Core.NinePatchRect.get_v_axis_stretch_mode, Godot.Core.NinePatchRect.is_draw_center_enabled, Godot.Core.NinePatchRect.set_draw_center, Godot.Core.NinePatchRect.set_h_axis_stretch_mode, Godot.Core.NinePatchRect.set_patch_margin, Godot.Core.NinePatchRect.set_region_rect, Godot.Core.NinePatchRect.set_texture, Godot.Core.NinePatchRect.set_v_axis_stretch_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _AXIS_STRETCH_MODE_TILE_FIT :: Int _AXIS_STRETCH_MODE_TILE_FIT = 2 _AXIS_STRETCH_MODE_TILE :: Int _AXIS_STRETCH_MODE_TILE = 1 _AXIS_STRETCH_MODE_STRETCH :: Int _AXIS_STRETCH_MODE_STRETCH = 0 -- | Emitted when the node's texture changes. sig_texture_changed :: Godot.Internal.Dispatch.Signal NinePatchRect sig_texture_changed = Godot.Internal.Dispatch.Signal "texture_changed" instance NodeSignal NinePatchRect "texture_changed" '[] instance NodeProperty NinePatchRect "axis_stretch_horizontal" Int 'False where nodeProperty = (get_h_axis_stretch_mode, wrapDroppingSetter set_h_axis_stretch_mode, Nothing) instance NodeProperty NinePatchRect "axis_stretch_vertical" Int 'False where nodeProperty = (get_v_axis_stretch_mode, wrapDroppingSetter set_v_axis_stretch_mode, Nothing) instance NodeProperty NinePatchRect "draw_center" Bool 'False where nodeProperty = (is_draw_center_enabled, wrapDroppingSetter set_draw_center, Nothing) instance NodeProperty NinePatchRect "patch_margin_bottom" Int 'False where nodeProperty = (wrapIndexedGetter 3 get_patch_margin, wrapIndexedSetter 3 set_patch_margin, Nothing) instance NodeProperty NinePatchRect "patch_margin_left" Int 'False where nodeProperty = (wrapIndexedGetter 0 get_patch_margin, wrapIndexedSetter 0 set_patch_margin, Nothing) instance NodeProperty NinePatchRect "patch_margin_right" Int 'False where nodeProperty = (wrapIndexedGetter 2 get_patch_margin, wrapIndexedSetter 2 set_patch_margin, Nothing) instance NodeProperty NinePatchRect "patch_margin_top" Int 'False where nodeProperty = (wrapIndexedGetter 1 get_patch_margin, wrapIndexedSetter 1 set_patch_margin, Nothing) instance NodeProperty NinePatchRect "region_rect" Rect2 'False where nodeProperty = (get_region_rect, wrapDroppingSetter set_region_rect, Nothing) instance NodeProperty NinePatchRect "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) {-# NOINLINE bindNinePatchRect_get_h_axis_stretch_mode #-} -- | Doesn't do anything at the time of writing. bindNinePatchRect_get_h_axis_stretch_mode :: MethodBind bindNinePatchRect_get_h_axis_stretch_mode = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "get_h_axis_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Doesn't do anything at the time of writing. get_h_axis_stretch_mode :: (NinePatchRect :< cls, Object :< cls) => cls -> IO Int get_h_axis_stretch_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_get_h_axis_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "get_h_axis_stretch_mode" '[] (IO Int) where nodeMethod = Godot.Core.NinePatchRect.get_h_axis_stretch_mode {-# NOINLINE bindNinePatchRect_get_patch_margin #-} -- | Returns the size of the margin identified by the given @enum Margin@ constant. bindNinePatchRect_get_patch_margin :: MethodBind bindNinePatchRect_get_patch_margin = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "get_patch_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of the margin identified by the given @enum Margin@ constant. get_patch_margin :: (NinePatchRect :< cls, Object :< cls) => cls -> Int -> IO Int get_patch_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_get_patch_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "get_patch_margin" '[Int] (IO Int) where nodeMethod = Godot.Core.NinePatchRect.get_patch_margin {-# NOINLINE bindNinePatchRect_get_region_rect #-} -- | Rectangular region of the texture to sample from. If you're working with an atlas, use this property to define the area the 9-slice should use. All other properties are relative to this one. If the rect is empty, NinePatchRect will use the whole texture. bindNinePatchRect_get_region_rect :: MethodBind bindNinePatchRect_get_region_rect = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "get_region_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rectangular region of the texture to sample from. If you're working with an atlas, use this property to define the area the 9-slice should use. All other properties are relative to this one. If the rect is empty, NinePatchRect will use the whole texture. get_region_rect :: (NinePatchRect :< cls, Object :< cls) => cls -> IO Rect2 get_region_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_get_region_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "get_region_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.NinePatchRect.get_region_rect {-# NOINLINE bindNinePatchRect_get_texture #-} -- | The node's texture resource. bindNinePatchRect_get_texture :: MethodBind bindNinePatchRect_get_texture = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's texture resource. get_texture :: (NinePatchRect :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.NinePatchRect.get_texture {-# NOINLINE bindNinePatchRect_get_v_axis_stretch_mode #-} -- | Doesn't do anything at the time of writing. bindNinePatchRect_get_v_axis_stretch_mode :: MethodBind bindNinePatchRect_get_v_axis_stretch_mode = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "get_v_axis_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Doesn't do anything at the time of writing. get_v_axis_stretch_mode :: (NinePatchRect :< cls, Object :< cls) => cls -> IO Int get_v_axis_stretch_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_get_v_axis_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "get_v_axis_stretch_mode" '[] (IO Int) where nodeMethod = Godot.Core.NinePatchRect.get_v_axis_stretch_mode {-# NOINLINE bindNinePatchRect_is_draw_center_enabled #-} -- | If @true@, draw the panel's center. Else, only draw the 9-slice's borders. bindNinePatchRect_is_draw_center_enabled :: MethodBind bindNinePatchRect_is_draw_center_enabled = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "is_draw_center_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, draw the panel's center. Else, only draw the 9-slice's borders. is_draw_center_enabled :: (NinePatchRect :< cls, Object :< cls) => cls -> IO Bool is_draw_center_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_is_draw_center_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "is_draw_center_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.NinePatchRect.is_draw_center_enabled {-# NOINLINE bindNinePatchRect_set_draw_center #-} -- | If @true@, draw the panel's center. Else, only draw the 9-slice's borders. bindNinePatchRect_set_draw_center :: MethodBind bindNinePatchRect_set_draw_center = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "set_draw_center" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, draw the panel's center. Else, only draw the 9-slice's borders. set_draw_center :: (NinePatchRect :< cls, Object :< cls) => cls -> Bool -> IO () set_draw_center cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_set_draw_center (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "set_draw_center" '[Bool] (IO ()) where nodeMethod = Godot.Core.NinePatchRect.set_draw_center {-# NOINLINE bindNinePatchRect_set_h_axis_stretch_mode #-} -- | Doesn't do anything at the time of writing. bindNinePatchRect_set_h_axis_stretch_mode :: MethodBind bindNinePatchRect_set_h_axis_stretch_mode = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "set_h_axis_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Doesn't do anything at the time of writing. set_h_axis_stretch_mode :: (NinePatchRect :< cls, Object :< cls) => cls -> Int -> IO () set_h_axis_stretch_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_set_h_axis_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "set_h_axis_stretch_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.NinePatchRect.set_h_axis_stretch_mode {-# NOINLINE bindNinePatchRect_set_patch_margin #-} -- | Sets the size of the margin identified by the given @enum Margin@ constant to @value@ in pixels. bindNinePatchRect_set_patch_margin :: MethodBind bindNinePatchRect_set_patch_margin = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "set_patch_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the margin identified by the given @enum Margin@ constant to @value@ in pixels. set_patch_margin :: (NinePatchRect :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_patch_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_set_patch_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "set_patch_margin" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.NinePatchRect.set_patch_margin {-# NOINLINE bindNinePatchRect_set_region_rect #-} -- | Rectangular region of the texture to sample from. If you're working with an atlas, use this property to define the area the 9-slice should use. All other properties are relative to this one. If the rect is empty, NinePatchRect will use the whole texture. bindNinePatchRect_set_region_rect :: MethodBind bindNinePatchRect_set_region_rect = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "set_region_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rectangular region of the texture to sample from. If you're working with an atlas, use this property to define the area the 9-slice should use. All other properties are relative to this one. If the rect is empty, NinePatchRect will use the whole texture. set_region_rect :: (NinePatchRect :< cls, Object :< cls) => cls -> Rect2 -> IO () set_region_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_set_region_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "set_region_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.NinePatchRect.set_region_rect {-# NOINLINE bindNinePatchRect_set_texture #-} -- | The node's texture resource. bindNinePatchRect_set_texture :: MethodBind bindNinePatchRect_set_texture = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's texture resource. set_texture :: (NinePatchRect :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.NinePatchRect.set_texture {-# NOINLINE bindNinePatchRect_set_v_axis_stretch_mode #-} -- | Doesn't do anything at the time of writing. bindNinePatchRect_set_v_axis_stretch_mode :: MethodBind bindNinePatchRect_set_v_axis_stretch_mode = unsafePerformIO $ withCString "NinePatchRect" $ \ clsNamePtr -> withCString "set_v_axis_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Doesn't do anything at the time of writing. set_v_axis_stretch_mode :: (NinePatchRect :< cls, Object :< cls) => cls -> Int -> IO () set_v_axis_stretch_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNinePatchRect_set_v_axis_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NinePatchRect "set_v_axis_stretch_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.NinePatchRect.set_v_axis_stretch_mode ================================================ FILE: src/Godot/Core/Node.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Node (Godot.Core.Node._DUPLICATE_GROUPS, Godot.Core.Node._DUPLICATE_SCRIPTS, Godot.Core.Node._NOTIFICATION_PAUSED, Godot.Core.Node._NOTIFICATION_MOVED_IN_PARENT, Godot.Core.Node._NOTIFICATION_UNPARENTED, Godot.Core.Node._PAUSE_MODE_PROCESS, Godot.Core.Node._NOTIFICATION_WM_ABOUT, Godot.Core.Node._NOTIFICATION_DRAG_END, Godot.Core.Node._NOTIFICATION_PATH_CHANGED, Godot.Core.Node._NOTIFICATION_APP_PAUSED, Godot.Core.Node._NOTIFICATION_PHYSICS_PROCESS, Godot.Core.Node._NOTIFICATION_INTERNAL_PHYSICS_PROCESS, Godot.Core.Node._NOTIFICATION_WM_GO_BACK_REQUEST, Godot.Core.Node._NOTIFICATION_WM_QUIT_REQUEST, Godot.Core.Node._DUPLICATE_USE_INSTANCING, Godot.Core.Node._NOTIFICATION_ENTER_TREE, Godot.Core.Node._NOTIFICATION_EXIT_TREE, Godot.Core.Node._NOTIFICATION_WM_FOCUS_IN, Godot.Core.Node._NOTIFICATION_WM_MOUSE_EXIT, Godot.Core.Node._NOTIFICATION_PROCESS, Godot.Core.Node._NOTIFICATION_INTERNAL_PROCESS, Godot.Core.Node._PAUSE_MODE_STOP, Godot.Core.Node._PAUSE_MODE_INHERIT, Godot.Core.Node._NOTIFICATION_TRANSLATION_CHANGED, Godot.Core.Node._NOTIFICATION_INSTANCED, Godot.Core.Node._NOTIFICATION_UNPAUSED, Godot.Core.Node._NOTIFICATION_PARENTED, Godot.Core.Node._NOTIFICATION_WM_FOCUS_OUT, Godot.Core.Node._NOTIFICATION_DRAG_BEGIN, Godot.Core.Node._DUPLICATE_SIGNALS, Godot.Core.Node._NOTIFICATION_OS_MEMORY_WARNING, Godot.Core.Node._NOTIFICATION_WM_UNFOCUS_REQUEST, Godot.Core.Node._NOTIFICATION_OS_IME_UPDATE, Godot.Core.Node._NOTIFICATION_APP_RESUMED, Godot.Core.Node._NOTIFICATION_READY, Godot.Core.Node._NOTIFICATION_WM_MOUSE_ENTER, Godot.Core.Node._NOTIFICATION_CRASH, Godot.Core.Node.sig_ready, Godot.Core.Node.sig_renamed, Godot.Core.Node.sig_tree_entered, Godot.Core.Node.sig_tree_exited, Godot.Core.Node.sig_tree_exiting, Godot.Core.Node._enter_tree, Godot.Core.Node._exit_tree, Godot.Core.Node._get_configuration_warning, Godot.Core.Node._get_editor_description, Godot.Core.Node._get_import_path, Godot.Core.Node._input, Godot.Core.Node._physics_process, Godot.Core.Node._process, Godot.Core.Node._ready, Godot.Core.Node._set_editor_description, Godot.Core.Node._set_import_path, Godot.Core.Node._unhandled_input, Godot.Core.Node._unhandled_key_input, Godot.Core.Node.add_child, Godot.Core.Node.add_child_below_node, Godot.Core.Node.add_to_group, Godot.Core.Node.can_process, Godot.Core.Node.duplicate, Godot.Core.Node.find_node, Godot.Core.Node.find_parent, Godot.Core.Node.get_child, Godot.Core.Node.get_child_count, Godot.Core.Node.get_children, Godot.Core.Node.get_custom_multiplayer, Godot.Core.Node.get_filename, Godot.Core.Node.get_groups, Godot.Core.Node.get_index, Godot.Core.Node.get_multiplayer, Godot.Core.Node.get_name, Godot.Core.Node.get_network_master, Godot.Core.Node.get_node, Godot.Core.Node.get_node_and_resource, Godot.Core.Node.get_node_or_null, Godot.Core.Node.get_owner, Godot.Core.Node.get_parent, Godot.Core.Node.get_path, Godot.Core.Node.get_path_to, Godot.Core.Node.get_pause_mode, Godot.Core.Node.get_physics_process_delta_time, Godot.Core.Node.get_position_in_parent, Godot.Core.Node.get_process_delta_time, Godot.Core.Node.get_process_priority, Godot.Core.Node.get_scene_instance_load_placeholder, Godot.Core.Node.get_tree, Godot.Core.Node.get_viewport, Godot.Core.Node.has_node, Godot.Core.Node.has_node_and_resource, Godot.Core.Node.is_a_parent_of, Godot.Core.Node.is_displayed_folded, Godot.Core.Node.is_greater_than, Godot.Core.Node.is_in_group, Godot.Core.Node.is_inside_tree, Godot.Core.Node.is_network_master, Godot.Core.Node.is_physics_processing, Godot.Core.Node.is_physics_processing_internal, Godot.Core.Node.is_processing, Godot.Core.Node.is_processing_input, Godot.Core.Node.is_processing_internal, Godot.Core.Node.is_processing_unhandled_input, Godot.Core.Node.is_processing_unhandled_key_input, Godot.Core.Node.move_child, Godot.Core.Node.print_stray_nodes, Godot.Core.Node.print_tree, Godot.Core.Node.print_tree_pretty, Godot.Core.Node.propagate_call, Godot.Core.Node.propagate_notification, Godot.Core.Node.queue_free, Godot.Core.Node.raise, Godot.Core.Node.remove_and_skip, Godot.Core.Node.remove_child, Godot.Core.Node.remove_from_group, Godot.Core.Node.replace_by, Godot.Core.Node.request_ready, Godot.Core.Node.rpc, Godot.Core.Node.rpc_config, Godot.Core.Node.rpc_id, Godot.Core.Node.rpc_unreliable, Godot.Core.Node.rpc_unreliable_id, Godot.Core.Node.rset, Godot.Core.Node.rset_config, Godot.Core.Node.rset_id, Godot.Core.Node.rset_unreliable, Godot.Core.Node.rset_unreliable_id, Godot.Core.Node.set_custom_multiplayer, Godot.Core.Node.set_display_folded, Godot.Core.Node.set_filename, Godot.Core.Node.set_name, Godot.Core.Node.set_network_master, Godot.Core.Node.set_owner, Godot.Core.Node.set_pause_mode, Godot.Core.Node.set_physics_process, Godot.Core.Node.set_physics_process_internal, Godot.Core.Node.set_process, Godot.Core.Node.set_process_input, Godot.Core.Node.set_process_internal, Godot.Core.Node.set_process_priority, Godot.Core.Node.set_process_unhandled_input, Godot.Core.Node.set_process_unhandled_key_input, Godot.Core.Node.set_scene_instance_load_placeholder, Godot.Core.Node.update_configuration_warning) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _DUPLICATE_GROUPS :: Int _DUPLICATE_GROUPS = 2 _DUPLICATE_SCRIPTS :: Int _DUPLICATE_SCRIPTS = 4 _NOTIFICATION_PAUSED :: Int _NOTIFICATION_PAUSED = 14 _NOTIFICATION_MOVED_IN_PARENT :: Int _NOTIFICATION_MOVED_IN_PARENT = 12 _NOTIFICATION_UNPARENTED :: Int _NOTIFICATION_UNPARENTED = 19 _PAUSE_MODE_PROCESS :: Int _PAUSE_MODE_PROCESS = 2 _NOTIFICATION_WM_ABOUT :: Int _NOTIFICATION_WM_ABOUT = 1011 _NOTIFICATION_DRAG_END :: Int _NOTIFICATION_DRAG_END = 22 _NOTIFICATION_PATH_CHANGED :: Int _NOTIFICATION_PATH_CHANGED = 23 _NOTIFICATION_APP_PAUSED :: Int _NOTIFICATION_APP_PAUSED = 1015 _NOTIFICATION_PHYSICS_PROCESS :: Int _NOTIFICATION_PHYSICS_PROCESS = 16 _NOTIFICATION_INTERNAL_PHYSICS_PROCESS :: Int _NOTIFICATION_INTERNAL_PHYSICS_PROCESS = 26 _NOTIFICATION_WM_GO_BACK_REQUEST :: Int _NOTIFICATION_WM_GO_BACK_REQUEST = 1007 _NOTIFICATION_WM_QUIT_REQUEST :: Int _NOTIFICATION_WM_QUIT_REQUEST = 1006 _DUPLICATE_USE_INSTANCING :: Int _DUPLICATE_USE_INSTANCING = 8 _NOTIFICATION_ENTER_TREE :: Int _NOTIFICATION_ENTER_TREE = 10 _NOTIFICATION_EXIT_TREE :: Int _NOTIFICATION_EXIT_TREE = 11 _NOTIFICATION_WM_FOCUS_IN :: Int _NOTIFICATION_WM_FOCUS_IN = 1004 _NOTIFICATION_WM_MOUSE_EXIT :: Int _NOTIFICATION_WM_MOUSE_EXIT = 1003 _NOTIFICATION_PROCESS :: Int _NOTIFICATION_PROCESS = 17 _NOTIFICATION_INTERNAL_PROCESS :: Int _NOTIFICATION_INTERNAL_PROCESS = 25 _PAUSE_MODE_STOP :: Int _PAUSE_MODE_STOP = 1 _PAUSE_MODE_INHERIT :: Int _PAUSE_MODE_INHERIT = 0 _NOTIFICATION_TRANSLATION_CHANGED :: Int _NOTIFICATION_TRANSLATION_CHANGED = 1010 _NOTIFICATION_INSTANCED :: Int _NOTIFICATION_INSTANCED = 20 _NOTIFICATION_UNPAUSED :: Int _NOTIFICATION_UNPAUSED = 15 _NOTIFICATION_PARENTED :: Int _NOTIFICATION_PARENTED = 18 _NOTIFICATION_WM_FOCUS_OUT :: Int _NOTIFICATION_WM_FOCUS_OUT = 1005 _NOTIFICATION_DRAG_BEGIN :: Int _NOTIFICATION_DRAG_BEGIN = 21 _DUPLICATE_SIGNALS :: Int _DUPLICATE_SIGNALS = 1 _NOTIFICATION_OS_MEMORY_WARNING :: Int _NOTIFICATION_OS_MEMORY_WARNING = 1009 _NOTIFICATION_WM_UNFOCUS_REQUEST :: Int _NOTIFICATION_WM_UNFOCUS_REQUEST = 1008 _NOTIFICATION_OS_IME_UPDATE :: Int _NOTIFICATION_OS_IME_UPDATE = 1013 _NOTIFICATION_APP_RESUMED :: Int _NOTIFICATION_APP_RESUMED = 1014 _NOTIFICATION_READY :: Int _NOTIFICATION_READY = 13 _NOTIFICATION_WM_MOUSE_ENTER :: Int _NOTIFICATION_WM_MOUSE_ENTER = 1002 _NOTIFICATION_CRASH :: Int _NOTIFICATION_CRASH = 1012 -- | Emitted when the node is ready. sig_ready :: Godot.Internal.Dispatch.Signal Node sig_ready = Godot.Internal.Dispatch.Signal "ready" instance NodeSignal Node "ready" '[] -- | Emitted when the node is renamed. sig_renamed :: Godot.Internal.Dispatch.Signal Node sig_renamed = Godot.Internal.Dispatch.Signal "renamed" instance NodeSignal Node "renamed" '[] -- | Emitted when the node enters the tree. sig_tree_entered :: Godot.Internal.Dispatch.Signal Node sig_tree_entered = Godot.Internal.Dispatch.Signal "tree_entered" instance NodeSignal Node "tree_entered" '[] -- | Emitted after the node exits the tree and is no longer active. sig_tree_exited :: Godot.Internal.Dispatch.Signal Node sig_tree_exited = Godot.Internal.Dispatch.Signal "tree_exited" instance NodeSignal Node "tree_exited" '[] -- | Emitted when the node is still active but about to exit the tree. This is the right place for de-initialization (or a "destructor", if you will). sig_tree_exiting :: Godot.Internal.Dispatch.Signal Node sig_tree_exiting = Godot.Internal.Dispatch.Signal "tree_exiting" instance NodeSignal Node "tree_exiting" '[] instance NodeProperty Node "_import_path" NodePath 'False where nodeProperty = (_get_import_path, wrapDroppingSetter _set_import_path, Nothing) instance NodeProperty Node "custom_multiplayer" MultiplayerAPI 'False where nodeProperty = (get_custom_multiplayer, wrapDroppingSetter set_custom_multiplayer, Nothing) instance NodeProperty Node "editor_description" GodotString 'False where nodeProperty = (_get_editor_description, wrapDroppingSetter _set_editor_description, Nothing) instance NodeProperty Node "filename" GodotString 'False where nodeProperty = (get_filename, wrapDroppingSetter set_filename, Nothing) instance NodeProperty Node "multiplayer" MultiplayerAPI 'True where nodeProperty = (get_multiplayer, (), Nothing) instance NodeProperty Node "name" GodotString 'False where nodeProperty = (get_name, wrapDroppingSetter set_name, Nothing) instance NodeProperty Node "owner" Node 'False where nodeProperty = (get_owner, wrapDroppingSetter set_owner, Nothing) instance NodeProperty Node "pause_mode" Int 'False where nodeProperty = (get_pause_mode, wrapDroppingSetter set_pause_mode, Nothing) instance NodeProperty Node "process_priority" Int 'False where nodeProperty = (get_process_priority, wrapDroppingSetter set_process_priority, Nothing) {-# NOINLINE bindNode__enter_tree #-} -- | Called when the node enters the @SceneTree@ (e.g. upon instancing, scene changing, or after calling @method add_child@ in a script). If the node has children, its @method _enter_tree@ callback will be called first, and then that of the children. -- Corresponds to the @NOTIFICATION_ENTER_TREE@ notification in @method Object._notification@. bindNode__enter_tree :: MethodBind bindNode__enter_tree = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_enter_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when the node enters the @SceneTree@ (e.g. upon instancing, scene changing, or after calling @method add_child@ in a script). If the node has children, its @method _enter_tree@ callback will be called first, and then that of the children. -- Corresponds to the @NOTIFICATION_ENTER_TREE@ notification in @method Object._notification@. _enter_tree :: (Node :< cls, Object :< cls) => cls -> IO () _enter_tree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode__enter_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_enter_tree" '[] (IO ()) where nodeMethod = Godot.Core.Node._enter_tree {-# NOINLINE bindNode__exit_tree #-} -- | Called when the node is about to leave the @SceneTree@ (e.g. upon freeing, scene changing, or after calling @method remove_child@ in a script). If the node has children, its @method _exit_tree@ callback will be called last, after all its children have left the tree. -- Corresponds to the @NOTIFICATION_EXIT_TREE@ notification in @method Object._notification@ and signal @signal tree_exiting@. To get notified when the node has already left the active tree, connect to the @signal tree_exited@. bindNode__exit_tree :: MethodBind bindNode__exit_tree = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_exit_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when the node is about to leave the @SceneTree@ (e.g. upon freeing, scene changing, or after calling @method remove_child@ in a script). If the node has children, its @method _exit_tree@ callback will be called last, after all its children have left the tree. -- Corresponds to the @NOTIFICATION_EXIT_TREE@ notification in @method Object._notification@ and signal @signal tree_exiting@. To get notified when the node has already left the active tree, connect to the @signal tree_exited@. _exit_tree :: (Node :< cls, Object :< cls) => cls -> IO () _exit_tree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode__exit_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_exit_tree" '[] (IO ()) where nodeMethod = Godot.Core.Node._exit_tree {-# NOINLINE bindNode__get_configuration_warning #-} -- | The string returned from this method is displayed as a warning in the Scene Dock if the script that overrides it is a @tool@ script. -- Returning an empty string produces no warning. -- Call @method update_configuration_warning@ when the warning needs to be updated for this node. bindNode__get_configuration_warning :: MethodBind bindNode__get_configuration_warning = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_get_configuration_warning" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The string returned from this method is displayed as a warning in the Scene Dock if the script that overrides it is a @tool@ script. -- Returning an empty string produces no warning. -- Call @method update_configuration_warning@ when the warning needs to be updated for this node. _get_configuration_warning :: (Node :< cls, Object :< cls) => cls -> IO GodotString _get_configuration_warning cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode__get_configuration_warning (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_get_configuration_warning" '[] (IO GodotString) where nodeMethod = Godot.Core.Node._get_configuration_warning {-# NOINLINE bindNode__get_editor_description #-} bindNode__get_editor_description :: MethodBind bindNode__get_editor_description = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_get_editor_description" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_editor_description :: (Node :< cls, Object :< cls) => cls -> IO GodotString _get_editor_description cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode__get_editor_description (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_get_editor_description" '[] (IO GodotString) where nodeMethod = Godot.Core.Node._get_editor_description {-# NOINLINE bindNode__get_import_path #-} bindNode__get_import_path :: MethodBind bindNode__get_import_path = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_get_import_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_import_path :: (Node :< cls, Object :< cls) => cls -> IO NodePath _get_import_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode__get_import_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_get_import_path" '[] (IO NodePath) where nodeMethod = Godot.Core.Node._get_import_path {-# NOINLINE bindNode__input #-} -- | Called when there is an input event. The input event propagates up through the node tree until a node consumes it. -- It is only called if input processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_process_input@. -- To consume the input event and stop it propagating further to other nodes, @method SceneTree.set_input_as_handled@ can be called. -- For gameplay input, @method _unhandled_input@ and @method _unhandled_key_input@ are usually a better fit as they allow the GUI to intercept the events first. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). bindNode__input :: MethodBind bindNode__input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when there is an input event. The input event propagates up through the node tree until a node consumes it. -- It is only called if input processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_process_input@. -- To consume the input event and stop it propagating further to other nodes, @method SceneTree.set_input_as_handled@ can be called. -- For gameplay input, @method _unhandled_input@ and @method _unhandled_key_input@ are usually a better fit as they allow the GUI to intercept the events first. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). _input :: (Node :< cls, Object :< cls) => cls -> InputEvent -> IO () _input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode__input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Node._input {-# NOINLINE bindNode__physics_process #-} -- | Called during the physics processing step of the main loop. Physics processing means that the frame rate is synced to the physics, i.e. the @delta@ variable should be constant. -- It is only called if physics processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_physics_process@. -- Corresponds to the @NOTIFICATION_PHYSICS_PROCESS@ notification in @method Object._notification@. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). bindNode__physics_process :: MethodBind bindNode__physics_process = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_physics_process" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called during the physics processing step of the main loop. Physics processing means that the frame rate is synced to the physics, i.e. the @delta@ variable should be constant. -- It is only called if physics processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_physics_process@. -- Corresponds to the @NOTIFICATION_PHYSICS_PROCESS@ notification in @method Object._notification@. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). _physics_process :: (Node :< cls, Object :< cls) => cls -> Float -> IO () _physics_process cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode__physics_process (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_physics_process" '[Float] (IO ()) where nodeMethod = Godot.Core.Node._physics_process {-# NOINLINE bindNode__process #-} -- | Called during the processing step of the main loop. Processing happens at every frame and as fast as possible, so the @delta@ time since the previous frame is not constant. -- It is only called if processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_process@. -- Corresponds to the @NOTIFICATION_PROCESS@ notification in @method Object._notification@. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). bindNode__process :: MethodBind bindNode__process = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_process" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called during the processing step of the main loop. Processing happens at every frame and as fast as possible, so the @delta@ time since the previous frame is not constant. -- It is only called if processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_process@. -- Corresponds to the @NOTIFICATION_PROCESS@ notification in @method Object._notification@. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). _process :: (Node :< cls, Object :< cls) => cls -> Float -> IO () _process cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode__process (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_process" '[Float] (IO ()) where nodeMethod = Godot.Core.Node._process {-# NOINLINE bindNode__ready #-} -- | Called when the node is "ready", i.e. when both the node and its children have entered the scene tree. If the node has children, their @method _ready@ callbacks get triggered first, and the parent node will receive the ready notification afterwards. -- Corresponds to the @NOTIFICATION_READY@ notification in @method Object._notification@. See also the @onready@ keyword for variables. -- Usually used for initialization. For even earlier initialization, @method Object._init@ may be used. See also @method _enter_tree@. -- __Note:__ @method _ready@ may be called only once for each node. After removing a node from the scene tree and adding again, @_ready@ will not be called for the second time. This can be bypassed with requesting another call with @method request_ready@, which may be called anywhere before adding the node again. bindNode__ready :: MethodBind bindNode__ready = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_ready" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when the node is "ready", i.e. when both the node and its children have entered the scene tree. If the node has children, their @method _ready@ callbacks get triggered first, and the parent node will receive the ready notification afterwards. -- Corresponds to the @NOTIFICATION_READY@ notification in @method Object._notification@. See also the @onready@ keyword for variables. -- Usually used for initialization. For even earlier initialization, @method Object._init@ may be used. See also @method _enter_tree@. -- __Note:__ @method _ready@ may be called only once for each node. After removing a node from the scene tree and adding again, @_ready@ will not be called for the second time. This can be bypassed with requesting another call with @method request_ready@, which may be called anywhere before adding the node again. _ready :: (Node :< cls, Object :< cls) => cls -> IO () _ready cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode__ready (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_ready" '[] (IO ()) where nodeMethod = Godot.Core.Node._ready {-# NOINLINE bindNode__set_editor_description #-} bindNode__set_editor_description :: MethodBind bindNode__set_editor_description = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_set_editor_description" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_editor_description :: (Node :< cls, Object :< cls) => cls -> GodotString -> IO () _set_editor_description cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode__set_editor_description (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_set_editor_description" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Node._set_editor_description {-# NOINLINE bindNode__set_import_path #-} bindNode__set_import_path :: MethodBind bindNode__set_import_path = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_set_import_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_import_path :: (Node :< cls, Object :< cls) => cls -> NodePath -> IO () _set_import_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode__set_import_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_set_import_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.Node._set_import_path {-# NOINLINE bindNode__unhandled_input #-} -- | Called when an @InputEvent@ hasn't been consumed by @method _input@ or any GUI. The input event propagates up through the node tree until a node consumes it. -- It is only called if unhandled input processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_process_unhandled_input@. -- To consume the input event and stop it propagating further to other nodes, @method SceneTree.set_input_as_handled@ can be called. -- For gameplay input, this and @method _unhandled_key_input@ are usually a better fit than @method _input@ as they allow the GUI to intercept the events first. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). bindNode__unhandled_input :: MethodBind bindNode__unhandled_input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when an @InputEvent@ hasn't been consumed by @method _input@ or any GUI. The input event propagates up through the node tree until a node consumes it. -- It is only called if unhandled input processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_process_unhandled_input@. -- To consume the input event and stop it propagating further to other nodes, @method SceneTree.set_input_as_handled@ can be called. -- For gameplay input, this and @method _unhandled_key_input@ are usually a better fit than @method _input@ as they allow the GUI to intercept the events first. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). _unhandled_input :: (Node :< cls, Object :< cls) => cls -> InputEvent -> IO () _unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode__unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_unhandled_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Node._unhandled_input {-# NOINLINE bindNode__unhandled_key_input #-} -- | Called when an @InputEventKey@ hasn't been consumed by @method _input@ or any GUI. The input event propagates up through the node tree until a node consumes it. -- It is only called if unhandled key input processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_process_unhandled_key_input@. -- To consume the input event and stop it propagating further to other nodes, @method SceneTree.set_input_as_handled@ can be called. -- For gameplay input, this and @method _unhandled_input@ are usually a better fit than @method _input@ as they allow the GUI to intercept the events first. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). bindNode__unhandled_key_input :: MethodBind bindNode__unhandled_key_input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "_unhandled_key_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when an @InputEventKey@ hasn't been consumed by @method _input@ or any GUI. The input event propagates up through the node tree until a node consumes it. -- It is only called if unhandled key input processing is enabled, which is done automatically if this method is overridden, and can be toggled with @method set_process_unhandled_key_input@. -- To consume the input event and stop it propagating further to other nodes, @method SceneTree.set_input_as_handled@ can be called. -- For gameplay input, this and @method _unhandled_input@ are usually a better fit than @method _input@ as they allow the GUI to intercept the events first. -- __Note:__ This method is only called if the node is present in the scene tree (i.e. if it's not orphan). _unhandled_key_input :: (Node :< cls, Object :< cls) => cls -> InputEventKey -> IO () _unhandled_key_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode__unhandled_key_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "_unhandled_key_input" '[InputEventKey] (IO ()) where nodeMethod = Godot.Core.Node._unhandled_key_input {-# NOINLINE bindNode_add_child #-} -- | Adds a child node. Nodes can have any number of children, but every child must have a unique name. Child nodes are automatically deleted when the parent node is deleted, so an entire scene can be removed by deleting its topmost node. -- If @legible_unique_name@ is @true@, the child node will have an human-readable name based on the name of the node being instanced instead of its type. -- __Note:__ If the child node already has a parent, the function will fail. Use @method remove_child@ first to remove the node from its current parent. For example: -- -- @ -- -- if child_node.get_parent(): -- child_node.get_parent().remove_child(child_node) -- add_child(child_node) -- -- @ -- -- __Note:__ If you want a child to be persisted to a @PackedScene@, you must set @owner@ in addition to calling @method add_child@. This is typically relevant for @url=https://godot.readthedocs.io/en/latest/tutorials/misc/running_code_in_the_editor.html@tool scripts@/url@ and @url=https://godot.readthedocs.io/en/latest/tutorials/plugins/editor/index.html@editor plugins@/url@. If @method add_child@ is called without setting @owner@, the newly added @Node@ will not be visible in the scene tree, though it will be visible in the 2D/3D view. bindNode_add_child :: MethodBind bindNode_add_child = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "add_child" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a child node. Nodes can have any number of children, but every child must have a unique name. Child nodes are automatically deleted when the parent node is deleted, so an entire scene can be removed by deleting its topmost node. -- If @legible_unique_name@ is @true@, the child node will have an human-readable name based on the name of the node being instanced instead of its type. -- __Note:__ If the child node already has a parent, the function will fail. Use @method remove_child@ first to remove the node from its current parent. For example: -- -- @ -- -- if child_node.get_parent(): -- child_node.get_parent().remove_child(child_node) -- add_child(child_node) -- -- @ -- -- __Note:__ If you want a child to be persisted to a @PackedScene@, you must set @owner@ in addition to calling @method add_child@. This is typically relevant for @url=https://godot.readthedocs.io/en/latest/tutorials/misc/running_code_in_the_editor.html@tool scripts@/url@ and @url=https://godot.readthedocs.io/en/latest/tutorials/plugins/editor/index.html@editor plugins@/url@. If @method add_child@ is called without setting @owner@, the newly added @Node@ will not be visible in the scene tree, though it will be visible in the 2D/3D view. add_child :: (Node :< cls, Object :< cls) => cls -> Node -> Maybe Bool -> IO () add_child cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_add_child (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "add_child" '[Node, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Node.add_child {-# NOINLINE bindNode_add_child_below_node #-} -- | Adds @child_node@ as a child. The child is placed below the given @node@ in the list of children. -- If @legible_unique_name@ is @true@, the child node will have an human-readable name based on the name of the node being instanced instead of its type. bindNode_add_child_below_node :: MethodBind bindNode_add_child_below_node = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "add_child_below_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds @child_node@ as a child. The child is placed below the given @node@ in the list of children. -- If @legible_unique_name@ is @true@, the child node will have an human-readable name based on the name of the node being instanced instead of its type. add_child_below_node :: (Node :< cls, Object :< cls) => cls -> Node -> Node -> Maybe Bool -> IO () add_child_below_node cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNode_add_child_below_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "add_child_below_node" '[Node, Node, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Node.add_child_below_node {-# NOINLINE bindNode_add_to_group #-} -- | Adds the node to a group. Groups are helpers to name and organize a subset of nodes, for example "enemies" or "collectables". A node can be in any number of groups. Nodes can be assigned a group at any time, but will not be added until they are inside the scene tree (see @method is_inside_tree@). See notes in the description, and the group methods in @SceneTree@. -- The @persistent@ option is used when packing node to @PackedScene@ and saving to file. Non-persistent groups aren't stored. bindNode_add_to_group :: MethodBind bindNode_add_to_group = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "add_to_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the node to a group. Groups are helpers to name and organize a subset of nodes, for example "enemies" or "collectables". A node can be in any number of groups. Nodes can be assigned a group at any time, but will not be added until they are inside the scene tree (see @method is_inside_tree@). See notes in the description, and the group methods in @SceneTree@. -- The @persistent@ option is used when packing node to @PackedScene@ and saving to file. Non-persistent groups aren't stored. add_to_group :: (Node :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO () add_to_group cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_add_to_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "add_to_group" '[GodotString, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Node.add_to_group {-# NOINLINE bindNode_can_process #-} -- | Returns @true@ if the node can process while the scene tree is paused (see @pause_mode@). Always returns @true@ if the scene tree is not paused, and @false@ if the node is not in the tree. bindNode_can_process :: MethodBind bindNode_can_process = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "can_process" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node can process while the scene tree is paused (see @pause_mode@). Always returns @true@ if the scene tree is not paused, and @false@ if the node is not in the tree. can_process :: (Node :< cls, Object :< cls) => cls -> IO Bool can_process cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_can_process (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "can_process" '[] (IO Bool) where nodeMethod = Godot.Core.Node.can_process {-# NOINLINE bindNode_duplicate #-} -- | Duplicates the node, returning a new node. -- You can fine-tune the behavior using the @flags@ (see @enum DuplicateFlags@). -- __Note:__ It will not work properly if the node contains a script with constructor arguments (i.e. needs to supply arguments to @method Object._init@ method). In that case, the node will be duplicated without a script. bindNode_duplicate :: MethodBind bindNode_duplicate = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "duplicate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Duplicates the node, returning a new node. -- You can fine-tune the behavior using the @flags@ (see @enum DuplicateFlags@). -- __Note:__ It will not work properly if the node contains a script with constructor arguments (i.e. needs to supply arguments to @method Object._init@ method). In that case, the node will be duplicated without a script. duplicate :: (Node :< cls, Object :< cls) => cls -> Maybe Int -> IO Node duplicate cls arg1 = withVariantArray [maybe (VariantInt (15)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_duplicate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "duplicate" '[Maybe Int] (IO Node) where nodeMethod = Godot.Core.Node.duplicate {-# NOINLINE bindNode_find_node #-} -- | Finds a descendant of this node whose name matches @mask@ as in @method String.match@ (i.e. case-sensitive, but @"*"@ matches zero or more characters and @"?"@ matches any single character except @"."@). -- __Note:__ It does not match against the full path, just against individual node names. -- If @owned@ is @true@, this method only finds nodes whose owner is this node. This is especially important for scenes instantiated through a script, because those scenes don't have an owner. -- __Note:__ As this method walks through all the descendants of the node, it is the slowest way to get a reference to another node. Whenever possible, consider using @method get_node@ instead. To avoid using @method find_node@ too often, consider caching the node reference into a variable. bindNode_find_node :: MethodBind bindNode_find_node = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "find_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Finds a descendant of this node whose name matches @mask@ as in @method String.match@ (i.e. case-sensitive, but @"*"@ matches zero or more characters and @"?"@ matches any single character except @"."@). -- __Note:__ It does not match against the full path, just against individual node names. -- If @owned@ is @true@, this method only finds nodes whose owner is this node. This is especially important for scenes instantiated through a script, because those scenes don't have an owner. -- __Note:__ As this method walks through all the descendants of the node, it is the slowest way to get a reference to another node. Whenever possible, consider using @method get_node@ instead. To avoid using @method find_node@ too often, consider caching the node reference into a variable. find_node :: (Node :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> Maybe Bool -> IO Node find_node cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2, maybe (VariantBool True) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNode_find_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "find_node" '[GodotString, Maybe Bool, Maybe Bool] (IO Node) where nodeMethod = Godot.Core.Node.find_node {-# NOINLINE bindNode_find_parent #-} -- | Finds the first parent of the current node whose name matches @mask@ as in @method String.match@ (i.e. case-sensitive, but @"*"@ matches zero or more characters and @"?"@ matches any single character except @"."@). -- __Note:__ It does not match against the full path, just against individual node names. -- __Note:__ As this method walks upwards in the scene tree, it can be slow in large, deeply nested scene trees. Whenever possible, consider using @method get_node@ instead. To avoid using @method find_parent@ too often, consider caching the node reference into a variable. bindNode_find_parent :: MethodBind bindNode_find_parent = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "find_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Finds the first parent of the current node whose name matches @mask@ as in @method String.match@ (i.e. case-sensitive, but @"*"@ matches zero or more characters and @"?"@ matches any single character except @"."@). -- __Note:__ It does not match against the full path, just against individual node names. -- __Note:__ As this method walks upwards in the scene tree, it can be slow in large, deeply nested scene trees. Whenever possible, consider using @method get_node@ instead. To avoid using @method find_parent@ too often, consider caching the node reference into a variable. find_parent :: (Node :< cls, Object :< cls) => cls -> GodotString -> IO Node find_parent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_find_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "find_parent" '[GodotString] (IO Node) where nodeMethod = Godot.Core.Node.find_parent {-# NOINLINE bindNode_get_child #-} -- | Returns a child node by its index (see @method get_child_count@). This method is often used for iterating all children of a node. -- To access a child node via its name, use @method get_node@. bindNode_get_child :: MethodBind bindNode_get_child = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_child" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a child node by its index (see @method get_child_count@). This method is often used for iterating all children of a node. -- To access a child node via its name, use @method get_node@. get_child :: (Node :< cls, Object :< cls) => cls -> Int -> IO Node get_child cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_child (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_child" '[Int] (IO Node) where nodeMethod = Godot.Core.Node.get_child {-# NOINLINE bindNode_get_child_count #-} -- | Returns the number of child nodes. bindNode_get_child_count :: MethodBind bindNode_get_child_count = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_child_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of child nodes. get_child_count :: (Node :< cls, Object :< cls) => cls -> IO Int get_child_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_child_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_child_count" '[] (IO Int) where nodeMethod = Godot.Core.Node.get_child_count {-# NOINLINE bindNode_get_children #-} -- | Returns an array of references to node's children. bindNode_get_children :: MethodBind bindNode_get_children = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_children" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of references to node's children. get_children :: (Node :< cls, Object :< cls) => cls -> IO Array get_children cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_children (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_children" '[] (IO Array) where nodeMethod = Godot.Core.Node.get_children {-# NOINLINE bindNode_get_custom_multiplayer #-} -- | The override to the default @MultiplayerAPI@. Set to @null@ to use the default @SceneTree@ one. bindNode_get_custom_multiplayer :: MethodBind bindNode_get_custom_multiplayer = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_custom_multiplayer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The override to the default @MultiplayerAPI@. Set to @null@ to use the default @SceneTree@ one. get_custom_multiplayer :: (Node :< cls, Object :< cls) => cls -> IO MultiplayerAPI get_custom_multiplayer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_custom_multiplayer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_custom_multiplayer" '[] (IO MultiplayerAPI) where nodeMethod = Godot.Core.Node.get_custom_multiplayer {-# NOINLINE bindNode_get_filename #-} -- | When a scene is instanced from a file, its topmost node contains the filename from which it was loaded. bindNode_get_filename :: MethodBind bindNode_get_filename = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_filename" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When a scene is instanced from a file, its topmost node contains the filename from which it was loaded. get_filename :: (Node :< cls, Object :< cls) => cls -> IO GodotString get_filename cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_filename (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_filename" '[] (IO GodotString) where nodeMethod = Godot.Core.Node.get_filename {-# NOINLINE bindNode_get_groups #-} -- | Returns an array listing the groups that the node is a member of. bindNode_get_groups :: MethodBind bindNode_get_groups = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_groups" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array listing the groups that the node is a member of. get_groups :: (Node :< cls, Object :< cls) => cls -> IO Array get_groups cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_groups (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_groups" '[] (IO Array) where nodeMethod = Godot.Core.Node.get_groups {-# NOINLINE bindNode_get_index #-} -- | Returns the node's index, i.e. its position among the siblings of its parent. bindNode_get_index :: MethodBind bindNode_get_index = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the node's index, i.e. its position among the siblings of its parent. get_index :: (Node :< cls, Object :< cls) => cls -> IO Int get_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_index" '[] (IO Int) where nodeMethod = Godot.Core.Node.get_index {-# NOINLINE bindNode_get_multiplayer #-} -- | The @MultiplayerAPI@ instance associated with this node. Either the @custom_multiplayer@, or the default SceneTree one (if inside tree). bindNode_get_multiplayer :: MethodBind bindNode_get_multiplayer = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_multiplayer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @MultiplayerAPI@ instance associated with this node. Either the @custom_multiplayer@, or the default SceneTree one (if inside tree). get_multiplayer :: (Node :< cls, Object :< cls) => cls -> IO MultiplayerAPI get_multiplayer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_multiplayer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_multiplayer" '[] (IO MultiplayerAPI) where nodeMethod = Godot.Core.Node.get_multiplayer {-# NOINLINE bindNode_get_name #-} -- | The name of the node. This name is unique among the siblings (other child nodes from the same parent). When set to an existing name, the node will be automatically renamed. bindNode_get_name :: MethodBind bindNode_get_name = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the node. This name is unique among the siblings (other child nodes from the same parent). When set to an existing name, the node will be automatically renamed. get_name :: (Node :< cls, Object :< cls) => cls -> IO GodotString get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_name" '[] (IO GodotString) where nodeMethod = Godot.Core.Node.get_name {-# NOINLINE bindNode_get_network_master #-} -- | Returns the peer ID of the network master for this node. See @method set_network_master@. bindNode_get_network_master :: MethodBind bindNode_get_network_master = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_network_master" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the peer ID of the network master for this node. See @method set_network_master@. get_network_master :: (Node :< cls, Object :< cls) => cls -> IO Int get_network_master cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_network_master (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_network_master" '[] (IO Int) where nodeMethod = Godot.Core.Node.get_network_master {-# NOINLINE bindNode_get_node #-} -- | Fetches a node. The @NodePath@ can be either a relative path (from the current node) or an absolute path (in the scene tree) to a node. If the path does not exist, a @null instance@ is returned and an error is logged. Attempts to access methods on the return value will result in an "Attempt to call on a null instance." error. -- __Note:__ Fetching absolute paths only works when the node is inside the scene tree (see @method is_inside_tree@). -- __Example:__ Assume your current node is Character and the following tree: -- -- @ -- -- /root -- /root/Character -- /root/Character/Sword -- /root/Character/Backpack/Dagger -- /root/MyGame -- /root/Swamp/Alligator -- /root/Swamp/Mosquito -- /root/Swamp/Goblin -- -- @ -- -- Possible paths are: -- -- @ -- -- get_node("Sword") -- get_node("Backpack/Dagger") -- get_node("../Swamp/Alligator") -- get_node("/root/MyGame") -- -- @ bindNode_get_node :: MethodBind bindNode_get_node = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Fetches a node. The @NodePath@ can be either a relative path (from the current node) or an absolute path (in the scene tree) to a node. If the path does not exist, a @null instance@ is returned and an error is logged. Attempts to access methods on the return value will result in an "Attempt to call on a null instance." error. -- __Note:__ Fetching absolute paths only works when the node is inside the scene tree (see @method is_inside_tree@). -- __Example:__ Assume your current node is Character and the following tree: -- -- @ -- -- /root -- /root/Character -- /root/Character/Sword -- /root/Character/Backpack/Dagger -- /root/MyGame -- /root/Swamp/Alligator -- /root/Swamp/Mosquito -- /root/Swamp/Goblin -- -- @ -- -- Possible paths are: -- -- @ -- -- get_node("Sword") -- get_node("Backpack/Dagger") -- get_node("../Swamp/Alligator") -- get_node("/root/MyGame") -- -- @ get_node :: (Node :< cls, Object :< cls) => cls -> NodePath -> IO Node get_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_node" '[NodePath] (IO Node) where nodeMethod = Godot.Core.Node.get_node {-# NOINLINE bindNode_get_node_and_resource #-} -- | Fetches a node and one of its resources as specified by the @NodePath@'s subname (e.g. @Area2D/CollisionShape2D:shape@). If several nested resources are specified in the @NodePath@, the last one will be fetched. -- The return value is an array of size 3: the first index points to the @Node@ (or @null@ if not found), the second index points to the @Resource@ (or @null@ if not found), and the third index is the remaining @NodePath@, if any. -- For example, assuming that @Area2D/CollisionShape2D@ is a valid node and that its @shape@ property has been assigned a @RectangleShape2D@ resource, one could have this kind of output: -- -- @ -- -- print(get_node_and_resource("Area2D/CollisionShape2D")) # @@CollisionShape2D:1161@, Null, @ -- print(get_node_and_resource("Area2D/CollisionShape2D:shape")) # @@CollisionShape2D:1161@, @RectangleShape2D:1156@, @ -- print(get_node_and_resource("Area2D/CollisionShape2D:shape:extents")) # @@CollisionShape2D:1161@, @RectangleShape2D:1156@, :extents@ -- -- @ bindNode_get_node_and_resource :: MethodBind bindNode_get_node_and_resource = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_node_and_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Fetches a node and one of its resources as specified by the @NodePath@'s subname (e.g. @Area2D/CollisionShape2D:shape@). If several nested resources are specified in the @NodePath@, the last one will be fetched. -- The return value is an array of size 3: the first index points to the @Node@ (or @null@ if not found), the second index points to the @Resource@ (or @null@ if not found), and the third index is the remaining @NodePath@, if any. -- For example, assuming that @Area2D/CollisionShape2D@ is a valid node and that its @shape@ property has been assigned a @RectangleShape2D@ resource, one could have this kind of output: -- -- @ -- -- print(get_node_and_resource("Area2D/CollisionShape2D")) # @@CollisionShape2D:1161@, Null, @ -- print(get_node_and_resource("Area2D/CollisionShape2D:shape")) # @@CollisionShape2D:1161@, @RectangleShape2D:1156@, @ -- print(get_node_and_resource("Area2D/CollisionShape2D:shape:extents")) # @@CollisionShape2D:1161@, @RectangleShape2D:1156@, :extents@ -- -- @ get_node_and_resource :: (Node :< cls, Object :< cls) => cls -> NodePath -> IO Array get_node_and_resource cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_node_and_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_node_and_resource" '[NodePath] (IO Array) where nodeMethod = Godot.Core.Node.get_node_and_resource {-# NOINLINE bindNode_get_node_or_null #-} -- | Similar to @method get_node@, but does not log an error if @path@ does not point to a valid @Node@. bindNode_get_node_or_null :: MethodBind bindNode_get_node_or_null = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_node_or_null" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Similar to @method get_node@, but does not log an error if @path@ does not point to a valid @Node@. get_node_or_null :: (Node :< cls, Object :< cls) => cls -> NodePath -> IO Node get_node_or_null cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_node_or_null (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_node_or_null" '[NodePath] (IO Node) where nodeMethod = Godot.Core.Node.get_node_or_null {-# NOINLINE bindNode_get_owner #-} -- | The node owner. A node can have any other node as owner (as long as it is a valid parent, grandparent, etc. ascending in the tree). When saving a node (using @PackedScene@), all the nodes it owns will be saved with it. This allows for the creation of complex @SceneTree@s, with instancing and subinstancing. bindNode_get_owner :: MethodBind bindNode_get_owner = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node owner. A node can have any other node as owner (as long as it is a valid parent, grandparent, etc. ascending in the tree). When saving a node (using @PackedScene@), all the nodes it owns will be saved with it. This allows for the creation of complex @SceneTree@s, with instancing and subinstancing. get_owner :: (Node :< cls, Object :< cls) => cls -> IO Node get_owner cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_owner" '[] (IO Node) where nodeMethod = Godot.Core.Node.get_owner {-# NOINLINE bindNode_get_parent #-} -- | Returns the parent node of the current node, or a @null instance@ if the node lacks a parent. bindNode_get_parent :: MethodBind bindNode_get_parent = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parent node of the current node, or a @null instance@ if the node lacks a parent. get_parent :: (Node :< cls, Object :< cls) => cls -> IO Node get_parent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_parent" '[] (IO Node) where nodeMethod = Godot.Core.Node.get_parent {-# NOINLINE bindNode_get_path #-} -- | Returns the absolute path of the current node. This only works if the current node is inside the scene tree (see @method is_inside_tree@). bindNode_get_path :: MethodBind bindNode_get_path = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the absolute path of the current node. This only works if the current node is inside the scene tree (see @method is_inside_tree@). get_path :: (Node :< cls, Object :< cls) => cls -> IO NodePath get_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_path" '[] (IO NodePath) where nodeMethod = Godot.Core.Node.get_path {-# NOINLINE bindNode_get_path_to #-} -- | Returns the relative @NodePath@ from this node to the specified @node@. Both nodes must be in the same scene or the function will fail. bindNode_get_path_to :: MethodBind bindNode_get_path_to = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_path_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the relative @NodePath@ from this node to the specified @node@. Both nodes must be in the same scene or the function will fail. get_path_to :: (Node :< cls, Object :< cls) => cls -> Node -> IO NodePath get_path_to cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_path_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_path_to" '[Node] (IO NodePath) where nodeMethod = Godot.Core.Node.get_path_to {-# NOINLINE bindNode_get_pause_mode #-} -- | Pause mode. How the node will behave if the @SceneTree@ is paused. bindNode_get_pause_mode :: MethodBind bindNode_get_pause_mode = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_pause_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pause mode. How the node will behave if the @SceneTree@ is paused. get_pause_mode :: (Node :< cls, Object :< cls) => cls -> IO Int get_pause_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_pause_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_pause_mode" '[] (IO Int) where nodeMethod = Godot.Core.Node.get_pause_mode {-# NOINLINE bindNode_get_physics_process_delta_time #-} -- | Returns the time elapsed since the last physics-bound frame (see @method _physics_process@). This is always a constant value in physics processing unless the frames per second is changed via @Engine.iterations_per_second@. bindNode_get_physics_process_delta_time :: MethodBind bindNode_get_physics_process_delta_time = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_physics_process_delta_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the time elapsed since the last physics-bound frame (see @method _physics_process@). This is always a constant value in physics processing unless the frames per second is changed via @Engine.iterations_per_second@. get_physics_process_delta_time :: (Node :< cls, Object :< cls) => cls -> IO Float get_physics_process_delta_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_physics_process_delta_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_physics_process_delta_time" '[] (IO Float) where nodeMethod = Godot.Core.Node.get_physics_process_delta_time {-# NOINLINE bindNode_get_position_in_parent #-} -- | Returns the node's order in the scene tree branch. For example, if called on the first child node the position is @0@. bindNode_get_position_in_parent :: MethodBind bindNode_get_position_in_parent = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_position_in_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the node's order in the scene tree branch. For example, if called on the first child node the position is @0@. get_position_in_parent :: (Node :< cls, Object :< cls) => cls -> IO Int get_position_in_parent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_position_in_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_position_in_parent" '[] (IO Int) where nodeMethod = Godot.Core.Node.get_position_in_parent {-# NOINLINE bindNode_get_process_delta_time #-} -- | Returns the time elapsed (in seconds) since the last process callback. This value may vary from frame to frame. bindNode_get_process_delta_time :: MethodBind bindNode_get_process_delta_time = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_process_delta_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the time elapsed (in seconds) since the last process callback. This value may vary from frame to frame. get_process_delta_time :: (Node :< cls, Object :< cls) => cls -> IO Float get_process_delta_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_process_delta_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_process_delta_time" '[] (IO Float) where nodeMethod = Godot.Core.Node.get_process_delta_time {-# NOINLINE bindNode_get_process_priority #-} -- | The node's priority in the execution order of the enabled processing callbacks (i.e. @NOTIFICATION_PROCESS@, @NOTIFICATION_PHYSICS_PROCESS@ and their internal counterparts). Nodes whose process priority value is @i@lower@/i@ will have their processing callbacks executed first. bindNode_get_process_priority :: MethodBind bindNode_get_process_priority = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_process_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's priority in the execution order of the enabled processing callbacks (i.e. @NOTIFICATION_PROCESS@, @NOTIFICATION_PHYSICS_PROCESS@ and their internal counterparts). Nodes whose process priority value is @i@lower@/i@ will have their processing callbacks executed first. get_process_priority :: (Node :< cls, Object :< cls) => cls -> IO Int get_process_priority cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_process_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_process_priority" '[] (IO Int) where nodeMethod = Godot.Core.Node.get_process_priority {-# NOINLINE bindNode_get_scene_instance_load_placeholder #-} -- | Returns @true@ if this is an instance load placeholder. See @InstancePlaceholder@. bindNode_get_scene_instance_load_placeholder :: MethodBind bindNode_get_scene_instance_load_placeholder = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_scene_instance_load_placeholder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this is an instance load placeholder. See @InstancePlaceholder@. get_scene_instance_load_placeholder :: (Node :< cls, Object :< cls) => cls -> IO Bool get_scene_instance_load_placeholder cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_scene_instance_load_placeholder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_scene_instance_load_placeholder" '[] (IO Bool) where nodeMethod = Godot.Core.Node.get_scene_instance_load_placeholder {-# NOINLINE bindNode_get_tree #-} -- | Returns the @SceneTree@ that contains this node. bindNode_get_tree :: MethodBind bindNode_get_tree = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @SceneTree@ that contains this node. get_tree :: (Node :< cls, Object :< cls) => cls -> IO SceneTree get_tree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_tree" '[] (IO SceneTree) where nodeMethod = Godot.Core.Node.get_tree {-# NOINLINE bindNode_get_viewport #-} -- | Returns the node's @Viewport@. bindNode_get_viewport :: MethodBind bindNode_get_viewport = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "get_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the node's @Viewport@. get_viewport :: (Node :< cls, Object :< cls) => cls -> IO Viewport get_viewport cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_get_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "get_viewport" '[] (IO Viewport) where nodeMethod = Godot.Core.Node.get_viewport {-# NOINLINE bindNode_has_node #-} -- | Returns @true@ if the node that the @NodePath@ points to exists. bindNode_has_node :: MethodBind bindNode_has_node = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "has_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node that the @NodePath@ points to exists. has_node :: (Node :< cls, Object :< cls) => cls -> NodePath -> IO Bool has_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_has_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "has_node" '[NodePath] (IO Bool) where nodeMethod = Godot.Core.Node.has_node {-# NOINLINE bindNode_has_node_and_resource #-} -- | Returns @true@ if the @NodePath@ points to a valid node and its subname points to a valid resource, e.g. @Area2D/CollisionShape2D:shape@. Properties with a non-@Resource@ type (e.g. nodes or primitive math types) are not considered resources. bindNode_has_node_and_resource :: MethodBind bindNode_has_node_and_resource = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "has_node_and_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the @NodePath@ points to a valid node and its subname points to a valid resource, e.g. @Area2D/CollisionShape2D:shape@. Properties with a non-@Resource@ type (e.g. nodes or primitive math types) are not considered resources. has_node_and_resource :: (Node :< cls, Object :< cls) => cls -> NodePath -> IO Bool has_node_and_resource cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_has_node_and_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "has_node_and_resource" '[NodePath] (IO Bool) where nodeMethod = Godot.Core.Node.has_node_and_resource {-# NOINLINE bindNode_is_a_parent_of #-} -- | Returns @true@ if the given node is a direct or indirect child of the current node. bindNode_is_a_parent_of :: MethodBind bindNode_is_a_parent_of = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_a_parent_of" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given node is a direct or indirect child of the current node. is_a_parent_of :: (Node :< cls, Object :< cls) => cls -> Node -> IO Bool is_a_parent_of cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_a_parent_of (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_a_parent_of" '[Node] (IO Bool) where nodeMethod = Godot.Core.Node.is_a_parent_of {-# NOINLINE bindNode_is_displayed_folded #-} -- | Returns @true@ if the node is folded (collapsed) in the Scene dock. bindNode_is_displayed_folded :: MethodBind bindNode_is_displayed_folded = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_displayed_folded" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node is folded (collapsed) in the Scene dock. is_displayed_folded :: (Node :< cls, Object :< cls) => cls -> IO Bool is_displayed_folded cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_displayed_folded (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_displayed_folded" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_displayed_folded {-# NOINLINE bindNode_is_greater_than #-} -- | Returns @true@ if the given node occurs later in the scene hierarchy than the current node. bindNode_is_greater_than :: MethodBind bindNode_is_greater_than = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_greater_than" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given node occurs later in the scene hierarchy than the current node. is_greater_than :: (Node :< cls, Object :< cls) => cls -> Node -> IO Bool is_greater_than cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_greater_than (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_greater_than" '[Node] (IO Bool) where nodeMethod = Godot.Core.Node.is_greater_than {-# NOINLINE bindNode_is_in_group #-} -- | Returns @true@ if this node is in the specified group. See notes in the description, and the group methods in @SceneTree@. bindNode_is_in_group :: MethodBind bindNode_is_in_group = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_in_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this node is in the specified group. See notes in the description, and the group methods in @SceneTree@. is_in_group :: (Node :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_in_group cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_in_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_in_group" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Node.is_in_group {-# NOINLINE bindNode_is_inside_tree #-} -- | Returns @true@ if this node is currently inside a @SceneTree@. bindNode_is_inside_tree :: MethodBind bindNode_is_inside_tree = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_inside_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this node is currently inside a @SceneTree@. is_inside_tree :: (Node :< cls, Object :< cls) => cls -> IO Bool is_inside_tree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_inside_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_inside_tree" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_inside_tree {-# NOINLINE bindNode_is_network_master #-} -- | Returns @true@ if the local system is the master of this node. bindNode_is_network_master :: MethodBind bindNode_is_network_master = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_network_master" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the local system is the master of this node. is_network_master :: (Node :< cls, Object :< cls) => cls -> IO Bool is_network_master cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_network_master (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_network_master" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_network_master {-# NOINLINE bindNode_is_physics_processing #-} -- | Returns @true@ if physics processing is enabled (see @method set_physics_process@). bindNode_is_physics_processing :: MethodBind bindNode_is_physics_processing = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_physics_processing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if physics processing is enabled (see @method set_physics_process@). is_physics_processing :: (Node :< cls, Object :< cls) => cls -> IO Bool is_physics_processing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_physics_processing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_physics_processing" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_physics_processing {-# NOINLINE bindNode_is_physics_processing_internal #-} -- | Returns @true@ if internal physics processing is enabled (see @method set_physics_process_internal@). bindNode_is_physics_processing_internal :: MethodBind bindNode_is_physics_processing_internal = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_physics_processing_internal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if internal physics processing is enabled (see @method set_physics_process_internal@). is_physics_processing_internal :: (Node :< cls, Object :< cls) => cls -> IO Bool is_physics_processing_internal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_physics_processing_internal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_physics_processing_internal" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_physics_processing_internal {-# NOINLINE bindNode_is_processing #-} -- | Returns @true@ if processing is enabled (see @method set_process@). bindNode_is_processing :: MethodBind bindNode_is_processing = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_processing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if processing is enabled (see @method set_process@). is_processing :: (Node :< cls, Object :< cls) => cls -> IO Bool is_processing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_processing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_processing" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_processing {-# NOINLINE bindNode_is_processing_input #-} -- | Returns @true@ if the node is processing input (see @method set_process_input@). bindNode_is_processing_input :: MethodBind bindNode_is_processing_input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_processing_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node is processing input (see @method set_process_input@). is_processing_input :: (Node :< cls, Object :< cls) => cls -> IO Bool is_processing_input cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_processing_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_processing_input" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_processing_input {-# NOINLINE bindNode_is_processing_internal #-} -- | Returns @true@ if internal processing is enabled (see @method set_process_internal@). bindNode_is_processing_internal :: MethodBind bindNode_is_processing_internal = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_processing_internal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if internal processing is enabled (see @method set_process_internal@). is_processing_internal :: (Node :< cls, Object :< cls) => cls -> IO Bool is_processing_internal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_processing_internal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_processing_internal" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_processing_internal {-# NOINLINE bindNode_is_processing_unhandled_input #-} -- | Returns @true@ if the node is processing unhandled input (see @method set_process_unhandled_input@). bindNode_is_processing_unhandled_input :: MethodBind bindNode_is_processing_unhandled_input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_processing_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node is processing unhandled input (see @method set_process_unhandled_input@). is_processing_unhandled_input :: (Node :< cls, Object :< cls) => cls -> IO Bool is_processing_unhandled_input cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_processing_unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_processing_unhandled_input" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_processing_unhandled_input {-# NOINLINE bindNode_is_processing_unhandled_key_input #-} -- | Returns @true@ if the node is processing unhandled key input (see @method set_process_unhandled_key_input@). bindNode_is_processing_unhandled_key_input :: MethodBind bindNode_is_processing_unhandled_key_input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "is_processing_unhandled_key_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node is processing unhandled key input (see @method set_process_unhandled_key_input@). is_processing_unhandled_key_input :: (Node :< cls, Object :< cls) => cls -> IO Bool is_processing_unhandled_key_input cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_is_processing_unhandled_key_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "is_processing_unhandled_key_input" '[] (IO Bool) where nodeMethod = Godot.Core.Node.is_processing_unhandled_key_input {-# NOINLINE bindNode_move_child #-} -- | Moves a child node to a different position (order) among the other children. Since calls, signals, etc are performed by tree order, changing the order of children nodes may be useful. bindNode_move_child :: MethodBind bindNode_move_child = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "move_child" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves a child node to a different position (order) among the other children. Since calls, signals, etc are performed by tree order, changing the order of children nodes may be useful. move_child :: (Node :< cls, Object :< cls) => cls -> Node -> Int -> IO () move_child cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_move_child (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "move_child" '[Node, Int] (IO ()) where nodeMethod = Godot.Core.Node.move_child {-# NOINLINE bindNode_print_stray_nodes #-} -- | Prints all stray nodes (nodes outside the @SceneTree@). Used for debugging. Works only in debug builds. bindNode_print_stray_nodes :: MethodBind bindNode_print_stray_nodes = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "print_stray_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Prints all stray nodes (nodes outside the @SceneTree@). Used for debugging. Works only in debug builds. print_stray_nodes :: (Node :< cls, Object :< cls) => cls -> IO () print_stray_nodes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_print_stray_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "print_stray_nodes" '[] (IO ()) where nodeMethod = Godot.Core.Node.print_stray_nodes {-# NOINLINE bindNode_print_tree #-} -- | Prints the tree to stdout. Used mainly for debugging purposes. This version displays the path relative to the current node, and is good for copy/pasting into the @method get_node@ function. -- __Example output:__ -- -- @ -- -- TheGame -- TheGame/Menu -- TheGame/Menu/Label -- TheGame/Menu/Camera2D -- TheGame/SplashScreen -- TheGame/SplashScreen/Camera2D -- -- @ bindNode_print_tree :: MethodBind bindNode_print_tree = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "print_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Prints the tree to stdout. Used mainly for debugging purposes. This version displays the path relative to the current node, and is good for copy/pasting into the @method get_node@ function. -- __Example output:__ -- -- @ -- -- TheGame -- TheGame/Menu -- TheGame/Menu/Label -- TheGame/Menu/Camera2D -- TheGame/SplashScreen -- TheGame/SplashScreen/Camera2D -- -- @ print_tree :: (Node :< cls, Object :< cls) => cls -> IO () print_tree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_print_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "print_tree" '[] (IO ()) where nodeMethod = Godot.Core.Node.print_tree {-# NOINLINE bindNode_print_tree_pretty #-} -- | Similar to @method print_tree@, this prints the tree to stdout. This version displays a more graphical representation similar to what is displayed in the scene inspector. It is useful for inspecting larger trees. -- __Example output:__ -- -- @ -- -- ┖╴TheGame -- ┠╴Menu -- ┃ ┠╴Label -- ┃ ┖╴Camera2D -- ┖╴SplashScreen -- ┖╴Camera2D -- -- @ bindNode_print_tree_pretty :: MethodBind bindNode_print_tree_pretty = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "print_tree_pretty" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Similar to @method print_tree@, this prints the tree to stdout. This version displays a more graphical representation similar to what is displayed in the scene inspector. It is useful for inspecting larger trees. -- __Example output:__ -- -- @ -- -- ┖╴TheGame -- ┠╴Menu -- ┃ ┠╴Label -- ┃ ┖╴Camera2D -- ┖╴SplashScreen -- ┖╴Camera2D -- -- @ print_tree_pretty :: (Node :< cls, Object :< cls) => cls -> IO () print_tree_pretty cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_print_tree_pretty (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "print_tree_pretty" '[] (IO ()) where nodeMethod = Godot.Core.Node.print_tree_pretty {-# NOINLINE bindNode_propagate_call #-} -- | Calls the given method (if present) with the arguments given in @args@ on this node and recursively on all its children. If the @parent_first@ argument is @true@, the method will be called on the current node first, then on all its children. If @parent_first@ is @false@, the children will be called first. bindNode_propagate_call :: MethodBind bindNode_propagate_call = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "propagate_call" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the given method (if present) with the arguments given in @args@ on this node and recursively on all its children. If the @parent_first@ argument is @true@, the method will be called on the current node first, then on all its children. If @parent_first@ is @false@, the children will be called first. propagate_call :: (Node :< cls, Object :< cls) => cls -> GodotString -> Maybe Array -> Maybe Bool -> IO () propagate_call cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, defaultedVariant VariantArray V.empty arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNode_propagate_call (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "propagate_call" '[GodotString, Maybe Array, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Node.propagate_call {-# NOINLINE bindNode_propagate_notification #-} -- | Notifies the current node and all its children recursively by calling @method Object.notification@ on all of them. bindNode_propagate_notification :: MethodBind bindNode_propagate_notification = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "propagate_notification" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Notifies the current node and all its children recursively by calling @method Object.notification@ on all of them. propagate_notification :: (Node :< cls, Object :< cls) => cls -> Int -> IO () propagate_notification cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_propagate_notification (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "propagate_notification" '[Int] (IO ()) where nodeMethod = Godot.Core.Node.propagate_notification {-# NOINLINE bindNode_queue_free #-} -- | Queues a node for deletion at the end of the current frame. When deleted, all of its child nodes will be deleted as well. This method ensures it's safe to delete the node, contrary to @method Object.free@. Use @method Object.is_queued_for_deletion@ to check whether a node will be deleted at the end of the frame. bindNode_queue_free :: MethodBind bindNode_queue_free = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "queue_free" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Queues a node for deletion at the end of the current frame. When deleted, all of its child nodes will be deleted as well. This method ensures it's safe to delete the node, contrary to @method Object.free@. Use @method Object.is_queued_for_deletion@ to check whether a node will be deleted at the end of the frame. queue_free :: (Node :< cls, Object :< cls) => cls -> IO () queue_free cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_queue_free (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "queue_free" '[] (IO ()) where nodeMethod = Godot.Core.Node.queue_free {-# NOINLINE bindNode_raise #-} -- | Moves this node to the bottom of parent node's children hierarchy. This is often useful in GUIs (@Control@ nodes), because their order of drawing depends on their order in the tree, i.e. the further they are on the node list, the higher they are drawn. After using @raise@, a Control will be drawn on top of their siblings. bindNode_raise :: MethodBind bindNode_raise = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "raise" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves this node to the bottom of parent node's children hierarchy. This is often useful in GUIs (@Control@ nodes), because their order of drawing depends on their order in the tree, i.e. the further they are on the node list, the higher they are drawn. After using @raise@, a Control will be drawn on top of their siblings. raise :: (Node :< cls, Object :< cls) => cls -> IO () raise cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_raise (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "raise" '[] (IO ()) where nodeMethod = Godot.Core.Node.raise {-# NOINLINE bindNode_remove_and_skip #-} -- | Removes a node and sets all its children as children of the parent node (if it exists). All event subscriptions that pass by the removed node will be unsubscribed. bindNode_remove_and_skip :: MethodBind bindNode_remove_and_skip = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "remove_and_skip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a node and sets all its children as children of the parent node (if it exists). All event subscriptions that pass by the removed node will be unsubscribed. remove_and_skip :: (Node :< cls, Object :< cls) => cls -> IO () remove_and_skip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_remove_and_skip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "remove_and_skip" '[] (IO ()) where nodeMethod = Godot.Core.Node.remove_and_skip {-# NOINLINE bindNode_remove_child #-} -- | Removes a child node. The node is NOT deleted and must be deleted manually. bindNode_remove_child :: MethodBind bindNode_remove_child = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "remove_child" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a child node. The node is NOT deleted and must be deleted manually. remove_child :: (Node :< cls, Object :< cls) => cls -> Node -> IO () remove_child cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_remove_child (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "remove_child" '[Node] (IO ()) where nodeMethod = Godot.Core.Node.remove_child {-# NOINLINE bindNode_remove_from_group #-} -- | Removes a node from a group. See notes in the description, and the group methods in @SceneTree@. bindNode_remove_from_group :: MethodBind bindNode_remove_from_group = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "remove_from_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a node from a group. See notes in the description, and the group methods in @SceneTree@. remove_from_group :: (Node :< cls, Object :< cls) => cls -> GodotString -> IO () remove_from_group cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_remove_from_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "remove_from_group" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Node.remove_from_group {-# NOINLINE bindNode_replace_by #-} -- | Replaces a node in a scene by the given one. Subscriptions that pass through this node will be lost. bindNode_replace_by :: MethodBind bindNode_replace_by = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "replace_by" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Replaces a node in a scene by the given one. Subscriptions that pass through this node will be lost. replace_by :: (Node :< cls, Object :< cls) => cls -> Node -> Maybe Bool -> IO () replace_by cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_replace_by (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "replace_by" '[Node, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Node.replace_by {-# NOINLINE bindNode_request_ready #-} -- | Requests that @_ready@ be called again. Note that the method won't be called immediately, but is scheduled for when the node is added to the scene tree again (see @method _ready@). @_ready@ is called only for the node which requested it, which means that you need to request ready for each child if you want them to call @_ready@ too (in which case, @_ready@ will be called in the same order as it would normally). bindNode_request_ready :: MethodBind bindNode_request_ready = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "request_ready" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Requests that @_ready@ be called again. Note that the method won't be called immediately, but is scheduled for when the node is added to the scene tree again (see @method _ready@). @_ready@ is called only for the node which requested it, which means that you need to request ready for each child if you want them to call @_ready@ too (in which case, @_ready@ will be called in the same order as it would normally). request_ready :: (Node :< cls, Object :< cls) => cls -> IO () request_ready cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_request_ready (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "request_ready" '[] (IO ()) where nodeMethod = Godot.Core.Node.request_ready {-# NOINLINE bindNode_rpc #-} -- | Sends a remote procedure call request for the given @method@ to peers on the network (and locally), optionally sending all additional arguments as arguments to the method called by the RPC. The call request will only be received by nodes with the same @NodePath@, including the exact same node name. Behaviour depends on the RPC configuration for the given method, see @method rpc_config@. Methods are not exposed to RPCs by default. See also @method rset@ and @method rset_config@ for properties. Returns an empty @Variant@. -- __Note:__ You can only safely use RPCs on clients after you received the @connected_to_server@ signal from the @SceneTree@. You also need to keep track of the connection state, either by the @SceneTree@ signals like @server_disconnected@ or by checking @SceneTree.network_peer.get_connection_status() == CONNECTION_CONNECTED@. bindNode_rpc :: MethodBind bindNode_rpc = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rpc" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a remote procedure call request for the given @method@ to peers on the network (and locally), optionally sending all additional arguments as arguments to the method called by the RPC. The call request will only be received by nodes with the same @NodePath@, including the exact same node name. Behaviour depends on the RPC configuration for the given method, see @method rpc_config@. Methods are not exposed to RPCs by default. See also @method rset@ and @method rset_config@ for properties. Returns an empty @Variant@. -- __Note:__ You can only safely use RPCs on clients after you received the @connected_to_server@ signal from the @SceneTree@. You also need to keep track of the connection state, either by the @SceneTree@ signals like @server_disconnected@ or by checking @SceneTree.network_peer.get_connection_status() == CONNECTION_CONNECTED@. rpc :: (Node :< cls, Object :< cls) => cls -> GodotString -> [Variant 'GodotTy] -> IO GodotVariant rpc cls arg1 varargs = withVariantArray ([toVariant arg1] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindNode_rpc (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rpc" '[GodotString, [Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.Node.rpc {-# NOINLINE bindNode_rpc_config #-} -- | Changes the RPC mode for the given @method@ to the given @mode@. See @enum MultiplayerAPI.RPCMode@. An alternative is annotating methods and properties with the corresponding keywords (@remote@, @master@, @puppet@, @remotesync@, @mastersync@, @puppetsync@). By default, methods are not exposed to networking (and RPCs). See also @method rset@ and @method rset_config@ for properties. bindNode_rpc_config :: MethodBind bindNode_rpc_config = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rpc_config" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the RPC mode for the given @method@ to the given @mode@. See @enum MultiplayerAPI.RPCMode@. An alternative is annotating methods and properties with the corresponding keywords (@remote@, @master@, @puppet@, @remotesync@, @mastersync@, @puppetsync@). By default, methods are not exposed to networking (and RPCs). See also @method rset@ and @method rset_config@ for properties. rpc_config :: (Node :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () rpc_config cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_rpc_config (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rpc_config" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.Node.rpc_config {-# NOINLINE bindNode_rpc_id #-} -- | Sends a @method rpc@ to a specific peer identified by @peer_id@ (see @method NetworkedMultiplayerPeer.set_target_peer@). Returns an empty @Variant@. bindNode_rpc_id :: MethodBind bindNode_rpc_id = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rpc_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a @method rpc@ to a specific peer identified by @peer_id@ (see @method NetworkedMultiplayerPeer.set_target_peer@). Returns an empty @Variant@. rpc_id :: (Node :< cls, Object :< cls) => cls -> Int -> GodotString -> [Variant 'GodotTy] -> IO GodotVariant rpc_id cls arg1 arg2 varargs = withVariantArray ([toVariant arg1, toVariant arg2] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindNode_rpc_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rpc_id" '[Int, GodotString, [Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.Node.rpc_id {-# NOINLINE bindNode_rpc_unreliable #-} -- | Sends a @method rpc@ using an unreliable protocol. Returns an empty @Variant@. bindNode_rpc_unreliable :: MethodBind bindNode_rpc_unreliable = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rpc_unreliable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a @method rpc@ using an unreliable protocol. Returns an empty @Variant@. rpc_unreliable :: (Node :< cls, Object :< cls) => cls -> GodotString -> [Variant 'GodotTy] -> IO GodotVariant rpc_unreliable cls arg1 varargs = withVariantArray ([toVariant arg1] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindNode_rpc_unreliable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rpc_unreliable" '[GodotString, [Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.Node.rpc_unreliable {-# NOINLINE bindNode_rpc_unreliable_id #-} -- | Sends a @method rpc@ to a specific peer identified by @peer_id@ using an unreliable protocol (see @method NetworkedMultiplayerPeer.set_target_peer@). Returns an empty @Variant@. bindNode_rpc_unreliable_id :: MethodBind bindNode_rpc_unreliable_id = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rpc_unreliable_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a @method rpc@ to a specific peer identified by @peer_id@ using an unreliable protocol (see @method NetworkedMultiplayerPeer.set_target_peer@). Returns an empty @Variant@. rpc_unreliable_id :: (Node :< cls, Object :< cls) => cls -> Int -> GodotString -> [Variant 'GodotTy] -> IO GodotVariant rpc_unreliable_id cls arg1 arg2 varargs = withVariantArray ([toVariant arg1, toVariant arg2] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindNode_rpc_unreliable_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rpc_unreliable_id" '[Int, GodotString, [Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.Node.rpc_unreliable_id {-# NOINLINE bindNode_rset #-} -- | Remotely changes a property's value on other peers (and locally). Behaviour depends on the RPC configuration for the given property, see @method rset_config@. See also @method rpc@ for RPCs for methods, most information applies to this method as well. bindNode_rset :: MethodBind bindNode_rset = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Remotely changes a property's value on other peers (and locally). Behaviour depends on the RPC configuration for the given property, see @method rset_config@. See also @method rpc@ for RPCs for methods, most information applies to this method as well. rset :: (Node :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () rset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_rset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rset" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Node.rset {-# NOINLINE bindNode_rset_config #-} -- | Changes the RPC mode for the given @property@ to the given @mode@. See @enum MultiplayerAPI.RPCMode@. An alternative is annotating methods and properties with the corresponding keywords (@remote@, @master@, @puppet@, @remotesync@, @mastersync@, @puppetsync@). By default, properties are not exposed to networking (and RPCs). See also @method rpc@ and @method rpc_config@ for methods. bindNode_rset_config :: MethodBind bindNode_rset_config = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rset_config" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the RPC mode for the given @property@ to the given @mode@. See @enum MultiplayerAPI.RPCMode@. An alternative is annotating methods and properties with the corresponding keywords (@remote@, @master@, @puppet@, @remotesync@, @mastersync@, @puppetsync@). By default, properties are not exposed to networking (and RPCs). See also @method rpc@ and @method rpc_config@ for methods. rset_config :: (Node :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () rset_config cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_rset_config (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rset_config" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.Node.rset_config {-# NOINLINE bindNode_rset_id #-} -- | Remotely changes the property's value on a specific peer identified by @peer_id@ (see @method NetworkedMultiplayerPeer.set_target_peer@). bindNode_rset_id :: MethodBind bindNode_rset_id = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rset_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Remotely changes the property's value on a specific peer identified by @peer_id@ (see @method NetworkedMultiplayerPeer.set_target_peer@). rset_id :: (Node :< cls, Object :< cls) => cls -> Int -> GodotString -> GodotVariant -> IO () rset_id cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNode_rset_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rset_id" '[Int, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Node.rset_id {-# NOINLINE bindNode_rset_unreliable #-} -- | Remotely changes the property's value on other peers (and locally) using an unreliable protocol. bindNode_rset_unreliable :: MethodBind bindNode_rset_unreliable = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rset_unreliable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Remotely changes the property's value on other peers (and locally) using an unreliable protocol. rset_unreliable :: (Node :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () rset_unreliable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_rset_unreliable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rset_unreliable" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Node.rset_unreliable {-# NOINLINE bindNode_rset_unreliable_id #-} -- | Remotely changes property's value on a specific peer identified by @peer_id@ using an unreliable protocol (see @method NetworkedMultiplayerPeer.set_target_peer@). bindNode_rset_unreliable_id :: MethodBind bindNode_rset_unreliable_id = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "rset_unreliable_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Remotely changes property's value on a specific peer identified by @peer_id@ using an unreliable protocol (see @method NetworkedMultiplayerPeer.set_target_peer@). rset_unreliable_id :: (Node :< cls, Object :< cls) => cls -> Int -> GodotString -> GodotVariant -> IO () rset_unreliable_id cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindNode_rset_unreliable_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "rset_unreliable_id" '[Int, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Node.rset_unreliable_id {-# NOINLINE bindNode_set_custom_multiplayer #-} -- | The override to the default @MultiplayerAPI@. Set to @null@ to use the default @SceneTree@ one. bindNode_set_custom_multiplayer :: MethodBind bindNode_set_custom_multiplayer = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_custom_multiplayer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The override to the default @MultiplayerAPI@. Set to @null@ to use the default @SceneTree@ one. set_custom_multiplayer :: (Node :< cls, Object :< cls) => cls -> MultiplayerAPI -> IO () set_custom_multiplayer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_custom_multiplayer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_custom_multiplayer" '[MultiplayerAPI] (IO ()) where nodeMethod = Godot.Core.Node.set_custom_multiplayer {-# NOINLINE bindNode_set_display_folded #-} -- | Sets the folded state of the node in the Scene dock. bindNode_set_display_folded :: MethodBind bindNode_set_display_folded = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_display_folded" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the folded state of the node in the Scene dock. set_display_folded :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_display_folded cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_display_folded (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_display_folded" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_display_folded {-# NOINLINE bindNode_set_filename #-} -- | When a scene is instanced from a file, its topmost node contains the filename from which it was loaded. bindNode_set_filename :: MethodBind bindNode_set_filename = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_filename" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When a scene is instanced from a file, its topmost node contains the filename from which it was loaded. set_filename :: (Node :< cls, Object :< cls) => cls -> GodotString -> IO () set_filename cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_filename (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_filename" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Node.set_filename {-# NOINLINE bindNode_set_name #-} -- | The name of the node. This name is unique among the siblings (other child nodes from the same parent). When set to an existing name, the node will be automatically renamed. bindNode_set_name :: MethodBind bindNode_set_name = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the node. This name is unique among the siblings (other child nodes from the same parent). When set to an existing name, the node will be automatically renamed. set_name :: (Node :< cls, Object :< cls) => cls -> GodotString -> IO () set_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Node.set_name {-# NOINLINE bindNode_set_network_master #-} -- | Sets the node's network master to the peer with the given peer ID. The network master is the peer that has authority over the node on the network. Useful in conjunction with the @master@ and @puppet@ keywords. Inherited from the parent node by default, which ultimately defaults to peer ID 1 (the server). If @recursive@, the given peer is recursively set as the master for all children of this node. bindNode_set_network_master :: MethodBind bindNode_set_network_master = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_network_master" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the node's network master to the peer with the given peer ID. The network master is the peer that has authority over the node on the network. Useful in conjunction with the @master@ and @puppet@ keywords. Inherited from the parent node by default, which ultimately defaults to peer ID 1 (the server). If @recursive@, the given peer is recursively set as the master for all children of this node. set_network_master :: (Node :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO () set_network_master cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_network_master (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_network_master" '[Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_network_master {-# NOINLINE bindNode_set_owner #-} -- | The node owner. A node can have any other node as owner (as long as it is a valid parent, grandparent, etc. ascending in the tree). When saving a node (using @PackedScene@), all the nodes it owns will be saved with it. This allows for the creation of complex @SceneTree@s, with instancing and subinstancing. bindNode_set_owner :: MethodBind bindNode_set_owner = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_owner" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node owner. A node can have any other node as owner (as long as it is a valid parent, grandparent, etc. ascending in the tree). When saving a node (using @PackedScene@), all the nodes it owns will be saved with it. This allows for the creation of complex @SceneTree@s, with instancing and subinstancing. set_owner :: (Node :< cls, Object :< cls) => cls -> Node -> IO () set_owner cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_owner (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_owner" '[Node] (IO ()) where nodeMethod = Godot.Core.Node.set_owner {-# NOINLINE bindNode_set_pause_mode #-} -- | Pause mode. How the node will behave if the @SceneTree@ is paused. bindNode_set_pause_mode :: MethodBind bindNode_set_pause_mode = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_pause_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pause mode. How the node will behave if the @SceneTree@ is paused. set_pause_mode :: (Node :< cls, Object :< cls) => cls -> Int -> IO () set_pause_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_pause_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_pause_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Node.set_pause_mode {-# NOINLINE bindNode_set_physics_process #-} -- | Enables or disables physics (i.e. fixed framerate) processing. When a node is being processed, it will receive a @NOTIFICATION_PHYSICS_PROCESS@ at a fixed (usually 60 FPS, see @Engine.iterations_per_second@ to change) interval (and the @method _physics_process@ callback will be called if exists). Enabled automatically if @method _physics_process@ is overridden. Any calls to this before @method _ready@ will be ignored. bindNode_set_physics_process :: MethodBind bindNode_set_physics_process = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_physics_process" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables physics (i.e. fixed framerate) processing. When a node is being processed, it will receive a @NOTIFICATION_PHYSICS_PROCESS@ at a fixed (usually 60 FPS, see @Engine.iterations_per_second@ to change) interval (and the @method _physics_process@ callback will be called if exists). Enabled automatically if @method _physics_process@ is overridden. Any calls to this before @method _ready@ will be ignored. set_physics_process :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_physics_process cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_physics_process (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_physics_process" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_physics_process {-# NOINLINE bindNode_set_physics_process_internal #-} -- | Enables or disables internal physics for this node. Internal physics processing happens in isolation from the normal @method _physics_process@ calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or physics processing is disabled for scripting (@method set_physics_process@). Only useful for advanced uses to manipulate built-in nodes' behaviour. bindNode_set_physics_process_internal :: MethodBind bindNode_set_physics_process_internal = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_physics_process_internal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables internal physics for this node. Internal physics processing happens in isolation from the normal @method _physics_process@ calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or physics processing is disabled for scripting (@method set_physics_process@). Only useful for advanced uses to manipulate built-in nodes' behaviour. set_physics_process_internal :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_physics_process_internal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_physics_process_internal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_physics_process_internal" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_physics_process_internal {-# NOINLINE bindNode_set_process #-} -- | Enables or disables processing. When a node is being processed, it will receive a @NOTIFICATION_PROCESS@ on every drawn frame (and the @method _process@ callback will be called if exists). Enabled automatically if @method _process@ is overridden. Any calls to this before @method _ready@ will be ignored. bindNode_set_process :: MethodBind bindNode_set_process = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_process" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables processing. When a node is being processed, it will receive a @NOTIFICATION_PROCESS@ on every drawn frame (and the @method _process@ callback will be called if exists). Enabled automatically if @method _process@ is overridden. Any calls to this before @method _ready@ will be ignored. set_process :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_process cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_process (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_process" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_process {-# NOINLINE bindNode_set_process_input #-} -- | Enables or disables input processing. This is not required for GUI controls! Enabled automatically if @method _input@ is overridden. Any calls to this before @method _ready@ will be ignored. bindNode_set_process_input :: MethodBind bindNode_set_process_input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_process_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables input processing. This is not required for GUI controls! Enabled automatically if @method _input@ is overridden. Any calls to this before @method _ready@ will be ignored. set_process_input :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_process_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_process_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_process_input" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_process_input {-# NOINLINE bindNode_set_process_internal #-} -- | Enables or disabled internal processing for this node. Internal processing happens in isolation from the normal @method _process@ calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or processing is disabled for scripting (@method set_process@). Only useful for advanced uses to manipulate built-in nodes' behaviour. bindNode_set_process_internal :: MethodBind bindNode_set_process_internal = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_process_internal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disabled internal processing for this node. Internal processing happens in isolation from the normal @method _process@ calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or processing is disabled for scripting (@method set_process@). Only useful for advanced uses to manipulate built-in nodes' behaviour. set_process_internal :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_process_internal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_process_internal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_process_internal" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_process_internal {-# NOINLINE bindNode_set_process_priority #-} -- | The node's priority in the execution order of the enabled processing callbacks (i.e. @NOTIFICATION_PROCESS@, @NOTIFICATION_PHYSICS_PROCESS@ and their internal counterparts). Nodes whose process priority value is @i@lower@/i@ will have their processing callbacks executed first. bindNode_set_process_priority :: MethodBind bindNode_set_process_priority = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_process_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's priority in the execution order of the enabled processing callbacks (i.e. @NOTIFICATION_PROCESS@, @NOTIFICATION_PHYSICS_PROCESS@ and their internal counterparts). Nodes whose process priority value is @i@lower@/i@ will have their processing callbacks executed first. set_process_priority :: (Node :< cls, Object :< cls) => cls -> Int -> IO () set_process_priority cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_process_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_process_priority" '[Int] (IO ()) where nodeMethod = Godot.Core.Node.set_process_priority {-# NOINLINE bindNode_set_process_unhandled_input #-} -- | Enables unhandled input processing. This is not required for GUI controls! It enables the node to receive all input that was not previously handled (usually by a @Control@). Enabled automatically if @method _unhandled_input@ is overridden. Any calls to this before @method _ready@ will be ignored. bindNode_set_process_unhandled_input :: MethodBind bindNode_set_process_unhandled_input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_process_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables unhandled input processing. This is not required for GUI controls! It enables the node to receive all input that was not previously handled (usually by a @Control@). Enabled automatically if @method _unhandled_input@ is overridden. Any calls to this before @method _ready@ will be ignored. set_process_unhandled_input :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_process_unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_process_unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_process_unhandled_input" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_process_unhandled_input {-# NOINLINE bindNode_set_process_unhandled_key_input #-} -- | Enables unhandled key input processing. Enabled automatically if @method _unhandled_key_input@ is overridden. Any calls to this before @method _ready@ will be ignored. bindNode_set_process_unhandled_key_input :: MethodBind bindNode_set_process_unhandled_key_input = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_process_unhandled_key_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables unhandled key input processing. Enabled automatically if @method _unhandled_key_input@ is overridden. Any calls to this before @method _ready@ will be ignored. set_process_unhandled_key_input :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_process_unhandled_key_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_process_unhandled_key_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_process_unhandled_key_input" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_process_unhandled_key_input {-# NOINLINE bindNode_set_scene_instance_load_placeholder #-} -- | Sets whether this is an instance load placeholder. See @InstancePlaceholder@. bindNode_set_scene_instance_load_placeholder :: MethodBind bindNode_set_scene_instance_load_placeholder = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "set_scene_instance_load_placeholder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether this is an instance load placeholder. See @InstancePlaceholder@. set_scene_instance_load_placeholder :: (Node :< cls, Object :< cls) => cls -> Bool -> IO () set_scene_instance_load_placeholder cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode_set_scene_instance_load_placeholder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "set_scene_instance_load_placeholder" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node.set_scene_instance_load_placeholder {-# NOINLINE bindNode_update_configuration_warning #-} -- | Updates the warning displayed for this node in the Scene Dock. -- Use @method _get_configuration_warning@ to setup the warning message to display. bindNode_update_configuration_warning :: MethodBind bindNode_update_configuration_warning = unsafePerformIO $ withCString "Node" $ \ clsNamePtr -> withCString "update_configuration_warning" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the warning displayed for this node in the Scene Dock. -- Use @method _get_configuration_warning@ to setup the warning message to display. update_configuration_warning :: (Node :< cls, Object :< cls) => cls -> IO () update_configuration_warning cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode_update_configuration_warning (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node "update_configuration_warning" '[] (IO ()) where nodeMethod = Godot.Core.Node.update_configuration_warning ================================================ FILE: src/Godot/Core/Node2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Node2D (Godot.Core.Node2D.get_global_transform, Godot.Core.Node2D.get_transform, Godot.Core.Node2D.apply_scale, Godot.Core.Node2D.get_angle_to, Godot.Core.Node2D.get_global_position, Godot.Core.Node2D.get_global_rotation, Godot.Core.Node2D.get_global_rotation_degrees, Godot.Core.Node2D.get_global_scale, Godot.Core.Node2D.get_position, Godot.Core.Node2D.get_relative_transform_to_parent, Godot.Core.Node2D.get_rotation, Godot.Core.Node2D.get_rotation_degrees, Godot.Core.Node2D.get_scale, Godot.Core.Node2D.get_z_index, Godot.Core.Node2D.global_translate, Godot.Core.Node2D.is_z_relative, Godot.Core.Node2D.look_at, Godot.Core.Node2D.move_local_x, Godot.Core.Node2D.move_local_y, Godot.Core.Node2D.rotate, Godot.Core.Node2D.set_global_position, Godot.Core.Node2D.set_global_rotation, Godot.Core.Node2D.set_global_rotation_degrees, Godot.Core.Node2D.set_global_scale, Godot.Core.Node2D.set_global_transform, Godot.Core.Node2D.set_position, Godot.Core.Node2D.set_rotation, Godot.Core.Node2D.set_rotation_degrees, Godot.Core.Node2D.set_scale, Godot.Core.Node2D.set_transform, Godot.Core.Node2D.set_z_as_relative, Godot.Core.Node2D.set_z_index, Godot.Core.Node2D.to_global, Godot.Core.Node2D.to_local, Godot.Core.Node2D.translate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CanvasItem() instance NodeProperty Node2D "global_position" Vector2 'False where nodeProperty = (get_global_position, wrapDroppingSetter set_global_position, Nothing) instance NodeProperty Node2D "global_rotation" Float 'False where nodeProperty = (get_global_rotation, wrapDroppingSetter set_global_rotation, Nothing) instance NodeProperty Node2D "global_rotation_degrees" Float 'False where nodeProperty = (get_global_rotation_degrees, wrapDroppingSetter set_global_rotation_degrees, Nothing) instance NodeProperty Node2D "global_scale" Vector2 'False where nodeProperty = (get_global_scale, wrapDroppingSetter set_global_scale, Nothing) {-# NOINLINE bindNode2D_get_global_transform #-} -- | Global @Transform2D@. bindNode2D_get_global_transform :: MethodBind bindNode2D_get_global_transform = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_global_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global @Transform2D@. get_global_transform :: (Node2D :< cls, Object :< cls) => cls -> IO Transform2d get_global_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_global_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_global_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.Node2D.get_global_transform instance NodeProperty Node2D "global_transform" Transform2d 'False where nodeProperty = (get_global_transform, wrapDroppingSetter set_global_transform, Nothing) instance NodeProperty Node2D "position" Vector2 'False where nodeProperty = (get_position, wrapDroppingSetter set_position, Nothing) instance NodeProperty Node2D "rotation" Float 'False where nodeProperty = (get_rotation, wrapDroppingSetter set_rotation, Nothing) instance NodeProperty Node2D "rotation_degrees" Float 'False where nodeProperty = (get_rotation_degrees, wrapDroppingSetter set_rotation_degrees, Nothing) instance NodeProperty Node2D "scale" Vector2 'False where nodeProperty = (get_scale, wrapDroppingSetter set_scale, Nothing) {-# NOINLINE bindNode2D_get_transform #-} -- | Local @Transform2D@. bindNode2D_get_transform :: MethodBind bindNode2D_get_transform = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Local @Transform2D@. get_transform :: (Node2D :< cls, Object :< cls) => cls -> IO Transform2d get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.Node2D.get_transform instance NodeProperty Node2D "transform" Transform2d 'False where nodeProperty = (get_transform, wrapDroppingSetter set_transform, Nothing) instance NodeProperty Node2D "z_as_relative" Bool 'False where nodeProperty = (is_z_relative, wrapDroppingSetter set_z_as_relative, Nothing) instance NodeProperty Node2D "z_index" Int 'False where nodeProperty = (get_z_index, wrapDroppingSetter set_z_index, Nothing) {-# NOINLINE bindNode2D_apply_scale #-} -- | Multiplies the current scale by the @ratio@ vector. bindNode2D_apply_scale :: MethodBind bindNode2D_apply_scale = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "apply_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the current scale by the @ratio@ vector. apply_scale :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO () apply_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_apply_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "apply_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Node2D.apply_scale {-# NOINLINE bindNode2D_get_angle_to #-} -- | Returns the angle between the node and the @point@ in radians. bindNode2D_get_angle_to :: MethodBind bindNode2D_get_angle_to = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_angle_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the angle between the node and the @point@ in radians. get_angle_to :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO Float get_angle_to cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_angle_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_angle_to" '[Vector2] (IO Float) where nodeMethod = Godot.Core.Node2D.get_angle_to {-# NOINLINE bindNode2D_get_global_position #-} -- | Global position. bindNode2D_get_global_position :: MethodBind bindNode2D_get_global_position = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_global_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global position. get_global_position :: (Node2D :< cls, Object :< cls) => cls -> IO Vector2 get_global_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_global_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_global_position" '[] (IO Vector2) where nodeMethod = Godot.Core.Node2D.get_global_position {-# NOINLINE bindNode2D_get_global_rotation #-} -- | Global rotation in radians. bindNode2D_get_global_rotation :: MethodBind bindNode2D_get_global_rotation = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_global_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global rotation in radians. get_global_rotation :: (Node2D :< cls, Object :< cls) => cls -> IO Float get_global_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_global_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_global_rotation" '[] (IO Float) where nodeMethod = Godot.Core.Node2D.get_global_rotation {-# NOINLINE bindNode2D_get_global_rotation_degrees #-} -- | Global rotation in degrees. bindNode2D_get_global_rotation_degrees :: MethodBind bindNode2D_get_global_rotation_degrees = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_global_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global rotation in degrees. get_global_rotation_degrees :: (Node2D :< cls, Object :< cls) => cls -> IO Float get_global_rotation_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_global_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_global_rotation_degrees" '[] (IO Float) where nodeMethod = Godot.Core.Node2D.get_global_rotation_degrees {-# NOINLINE bindNode2D_get_global_scale #-} -- | Global scale. bindNode2D_get_global_scale :: MethodBind bindNode2D_get_global_scale = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_global_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global scale. get_global_scale :: (Node2D :< cls, Object :< cls) => cls -> IO Vector2 get_global_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_global_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_global_scale" '[] (IO Vector2) where nodeMethod = Godot.Core.Node2D.get_global_scale {-# NOINLINE bindNode2D_get_position #-} -- | Position, relative to the node's parent. bindNode2D_get_position :: MethodBind bindNode2D_get_position = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Position, relative to the node's parent. get_position :: (Node2D :< cls, Object :< cls) => cls -> IO Vector2 get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_position" '[] (IO Vector2) where nodeMethod = Godot.Core.Node2D.get_position {-# NOINLINE bindNode2D_get_relative_transform_to_parent #-} -- | Returns the @Transform2D@ relative to this node's parent. bindNode2D_get_relative_transform_to_parent :: MethodBind bindNode2D_get_relative_transform_to_parent = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_relative_transform_to_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Transform2D@ relative to this node's parent. get_relative_transform_to_parent :: (Node2D :< cls, Object :< cls) => cls -> Node -> IO Transform2d get_relative_transform_to_parent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_relative_transform_to_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_relative_transform_to_parent" '[Node] (IO Transform2d) where nodeMethod = Godot.Core.Node2D.get_relative_transform_to_parent {-# NOINLINE bindNode2D_get_rotation #-} -- | Rotation in radians, relative to the node's parent. bindNode2D_get_rotation :: MethodBind bindNode2D_get_rotation = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotation in radians, relative to the node's parent. get_rotation :: (Node2D :< cls, Object :< cls) => cls -> IO Float get_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_rotation" '[] (IO Float) where nodeMethod = Godot.Core.Node2D.get_rotation {-# NOINLINE bindNode2D_get_rotation_degrees #-} -- | Rotation in degrees, relative to the node's parent. bindNode2D_get_rotation_degrees :: MethodBind bindNode2D_get_rotation_degrees = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotation in degrees, relative to the node's parent. get_rotation_degrees :: (Node2D :< cls, Object :< cls) => cls -> IO Float get_rotation_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_rotation_degrees" '[] (IO Float) where nodeMethod = Godot.Core.Node2D.get_rotation_degrees {-# NOINLINE bindNode2D_get_scale #-} -- | The node's scale. Unscaled value: @(1, 1)@. bindNode2D_get_scale :: MethodBind bindNode2D_get_scale = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's scale. Unscaled value: @(1, 1)@. get_scale :: (Node2D :< cls, Object :< cls) => cls -> IO Vector2 get_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_scale" '[] (IO Vector2) where nodeMethod = Godot.Core.Node2D.get_scale {-# NOINLINE bindNode2D_get_z_index #-} -- | Z index. Controls the order in which the nodes render. A node with a higher Z index will display in front of others. bindNode2D_get_z_index :: MethodBind bindNode2D_get_z_index = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "get_z_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Z index. Controls the order in which the nodes render. A node with a higher Z index will display in front of others. get_z_index :: (Node2D :< cls, Object :< cls) => cls -> IO Int get_z_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_get_z_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "get_z_index" '[] (IO Int) where nodeMethod = Godot.Core.Node2D.get_z_index {-# NOINLINE bindNode2D_global_translate #-} -- | Adds the @offset@ vector to the node's global position. bindNode2D_global_translate :: MethodBind bindNode2D_global_translate = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "global_translate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the @offset@ vector to the node's global position. global_translate :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO () global_translate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_global_translate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "global_translate" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Node2D.global_translate {-# NOINLINE bindNode2D_is_z_relative #-} -- | If @true@, the node's Z index is relative to its parent's Z index. If this node's Z index is 2 and its parent's effective Z index is 3, then this node's effective Z index will be 2 + 3 = 5. bindNode2D_is_z_relative :: MethodBind bindNode2D_is_z_relative = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "is_z_relative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the node's Z index is relative to its parent's Z index. If this node's Z index is 2 and its parent's effective Z index is 3, then this node's effective Z index will be 2 + 3 = 5. is_z_relative :: (Node2D :< cls, Object :< cls) => cls -> IO Bool is_z_relative cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_is_z_relative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "is_z_relative" '[] (IO Bool) where nodeMethod = Godot.Core.Node2D.is_z_relative {-# NOINLINE bindNode2D_look_at #-} -- | Rotates the node so it points towards the @point@, which is expected to use global coordinates. bindNode2D_look_at :: MethodBind bindNode2D_look_at = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "look_at" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotates the node so it points towards the @point@, which is expected to use global coordinates. look_at :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO () look_at cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_look_at (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "look_at" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Node2D.look_at {-# NOINLINE bindNode2D_move_local_x #-} -- | Applies a local translation on the node's X axis based on the @method Node._process@'s @delta@. If @scaled@ is @false@, normalizes the movement. bindNode2D_move_local_x :: MethodBind bindNode2D_move_local_x = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "move_local_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a local translation on the node's X axis based on the @method Node._process@'s @delta@. If @scaled@ is @false@, normalizes the movement. move_local_x :: (Node2D :< cls, Object :< cls) => cls -> Float -> Maybe Bool -> IO () move_local_x cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_move_local_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "move_local_x" '[Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Node2D.move_local_x {-# NOINLINE bindNode2D_move_local_y #-} -- | Applies a local translation on the node's Y axis based on the @method Node._process@'s @delta@. If @scaled@ is @false@, normalizes the movement. bindNode2D_move_local_y :: MethodBind bindNode2D_move_local_y = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "move_local_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a local translation on the node's Y axis based on the @method Node._process@'s @delta@. If @scaled@ is @false@, normalizes the movement. move_local_y :: (Node2D :< cls, Object :< cls) => cls -> Float -> Maybe Bool -> IO () move_local_y cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_move_local_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "move_local_y" '[Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Node2D.move_local_y {-# NOINLINE bindNode2D_rotate #-} -- | Applies a rotation to the node, in radians, starting from its current rotation. bindNode2D_rotate :: MethodBind bindNode2D_rotate = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "rotate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a rotation to the node, in radians, starting from its current rotation. rotate :: (Node2D :< cls, Object :< cls) => cls -> Float -> IO () rotate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_rotate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "rotate" '[Float] (IO ()) where nodeMethod = Godot.Core.Node2D.rotate {-# NOINLINE bindNode2D_set_global_position #-} -- | Global position. bindNode2D_set_global_position :: MethodBind bindNode2D_set_global_position = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_global_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global position. set_global_position :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_global_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_global_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_global_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Node2D.set_global_position {-# NOINLINE bindNode2D_set_global_rotation #-} -- | Global rotation in radians. bindNode2D_set_global_rotation :: MethodBind bindNode2D_set_global_rotation = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_global_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global rotation in radians. set_global_rotation :: (Node2D :< cls, Object :< cls) => cls -> Float -> IO () set_global_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_global_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_global_rotation" '[Float] (IO ()) where nodeMethod = Godot.Core.Node2D.set_global_rotation {-# NOINLINE bindNode2D_set_global_rotation_degrees #-} -- | Global rotation in degrees. bindNode2D_set_global_rotation_degrees :: MethodBind bindNode2D_set_global_rotation_degrees = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_global_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global rotation in degrees. set_global_rotation_degrees :: (Node2D :< cls, Object :< cls) => cls -> Float -> IO () set_global_rotation_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_global_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_global_rotation_degrees" '[Float] (IO ()) where nodeMethod = Godot.Core.Node2D.set_global_rotation_degrees {-# NOINLINE bindNode2D_set_global_scale #-} -- | Global scale. bindNode2D_set_global_scale :: MethodBind bindNode2D_set_global_scale = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_global_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global scale. set_global_scale :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_global_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_global_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_global_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Node2D.set_global_scale {-# NOINLINE bindNode2D_set_global_transform #-} -- | Global @Transform2D@. bindNode2D_set_global_transform :: MethodBind bindNode2D_set_global_transform = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_global_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Global @Transform2D@. set_global_transform :: (Node2D :< cls, Object :< cls) => cls -> Transform2d -> IO () set_global_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_global_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_global_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.Node2D.set_global_transform {-# NOINLINE bindNode2D_set_position #-} -- | Position, relative to the node's parent. bindNode2D_set_position :: MethodBind bindNode2D_set_position = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Position, relative to the node's parent. set_position :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Node2D.set_position {-# NOINLINE bindNode2D_set_rotation #-} -- | Rotation in radians, relative to the node's parent. bindNode2D_set_rotation :: MethodBind bindNode2D_set_rotation = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotation in radians, relative to the node's parent. set_rotation :: (Node2D :< cls, Object :< cls) => cls -> Float -> IO () set_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_rotation" '[Float] (IO ()) where nodeMethod = Godot.Core.Node2D.set_rotation {-# NOINLINE bindNode2D_set_rotation_degrees #-} -- | Rotation in degrees, relative to the node's parent. bindNode2D_set_rotation_degrees :: MethodBind bindNode2D_set_rotation_degrees = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotation in degrees, relative to the node's parent. set_rotation_degrees :: (Node2D :< cls, Object :< cls) => cls -> Float -> IO () set_rotation_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_rotation_degrees" '[Float] (IO ()) where nodeMethod = Godot.Core.Node2D.set_rotation_degrees {-# NOINLINE bindNode2D_set_scale #-} -- | The node's scale. Unscaled value: @(1, 1)@. bindNode2D_set_scale :: MethodBind bindNode2D_set_scale = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's scale. Unscaled value: @(1, 1)@. set_scale :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Node2D.set_scale {-# NOINLINE bindNode2D_set_transform #-} -- | Local @Transform2D@. bindNode2D_set_transform :: MethodBind bindNode2D_set_transform = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Local @Transform2D@. set_transform :: (Node2D :< cls, Object :< cls) => cls -> Transform2d -> IO () set_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.Node2D.set_transform {-# NOINLINE bindNode2D_set_z_as_relative #-} -- | If @true@, the node's Z index is relative to its parent's Z index. If this node's Z index is 2 and its parent's effective Z index is 3, then this node's effective Z index will be 2 + 3 = 5. bindNode2D_set_z_as_relative :: MethodBind bindNode2D_set_z_as_relative = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_z_as_relative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the node's Z index is relative to its parent's Z index. If this node's Z index is 2 and its parent's effective Z index is 3, then this node's effective Z index will be 2 + 3 = 5. set_z_as_relative :: (Node2D :< cls, Object :< cls) => cls -> Bool -> IO () set_z_as_relative cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_z_as_relative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_z_as_relative" '[Bool] (IO ()) where nodeMethod = Godot.Core.Node2D.set_z_as_relative {-# NOINLINE bindNode2D_set_z_index #-} -- | Z index. Controls the order in which the nodes render. A node with a higher Z index will display in front of others. bindNode2D_set_z_index :: MethodBind bindNode2D_set_z_index = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "set_z_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Z index. Controls the order in which the nodes render. A node with a higher Z index will display in front of others. set_z_index :: (Node2D :< cls, Object :< cls) => cls -> Int -> IO () set_z_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_set_z_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "set_z_index" '[Int] (IO ()) where nodeMethod = Godot.Core.Node2D.set_z_index {-# NOINLINE bindNode2D_to_global #-} -- | Transforms the provided local position into a position in global coordinate space. The input is expected to be local relative to the @Node2D@ it is called on. e.g. Applying this method to the positions of child nodes will correctly transform their positions into the global coordinate space, but applying it to a node's own position will give an incorrect result, as it will incorporate the node's own transformation into its global position. bindNode2D_to_global :: MethodBind bindNode2D_to_global = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "to_global" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Transforms the provided local position into a position in global coordinate space. The input is expected to be local relative to the @Node2D@ it is called on. e.g. Applying this method to the positions of child nodes will correctly transform their positions into the global coordinate space, but applying it to a node's own position will give an incorrect result, as it will incorporate the node's own transformation into its global position. to_global :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO Vector2 to_global cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_to_global (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "to_global" '[Vector2] (IO Vector2) where nodeMethod = Godot.Core.Node2D.to_global {-# NOINLINE bindNode2D_to_local #-} -- | Transforms the provided global position into a position in local coordinate space. The output will be local relative to the @Node2D@ it is called on. e.g. It is appropriate for determining the positions of child nodes, but it is not appropriate for determining its own position relative to its parent. bindNode2D_to_local :: MethodBind bindNode2D_to_local = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "to_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Transforms the provided global position into a position in local coordinate space. The output will be local relative to the @Node2D@ it is called on. e.g. It is appropriate for determining the positions of child nodes, but it is not appropriate for determining its own position relative to its parent. to_local :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO Vector2 to_local cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_to_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "to_local" '[Vector2] (IO Vector2) where nodeMethod = Godot.Core.Node2D.to_local {-# NOINLINE bindNode2D_translate #-} -- | Translates the node by the given @offset@ in local coordinates. bindNode2D_translate :: MethodBind bindNode2D_translate = unsafePerformIO $ withCString "Node2D" $ \ clsNamePtr -> withCString "translate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Translates the node by the given @offset@ in local coordinates. translate :: (Node2D :< cls, Object :< cls) => cls -> Vector2 -> IO () translate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNode2D_translate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Node2D "translate" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Node2D.translate ================================================ FILE: src/Godot/Core/NoiseTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.NoiseTexture (Godot.Core.NoiseTexture.get_height, Godot.Core.NoiseTexture.get_width, Godot.Core.NoiseTexture._generate_texture, Godot.Core.NoiseTexture._queue_update, Godot.Core.NoiseTexture._thread_done, Godot.Core.NoiseTexture._update_texture, Godot.Core.NoiseTexture.get_bump_strength, Godot.Core.NoiseTexture.get_noise, Godot.Core.NoiseTexture.get_seamless, Godot.Core.NoiseTexture.is_normalmap, Godot.Core.NoiseTexture.set_as_normalmap, Godot.Core.NoiseTexture.set_bump_strength, Godot.Core.NoiseTexture.set_height, Godot.Core.NoiseTexture.set_noise, Godot.Core.NoiseTexture.set_seamless, Godot.Core.NoiseTexture.set_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty NoiseTexture "as_normalmap" Bool 'False where nodeProperty = (is_normalmap, wrapDroppingSetter set_as_normalmap, Nothing) instance NodeProperty NoiseTexture "bump_strength" Float 'False where nodeProperty = (get_bump_strength, wrapDroppingSetter set_bump_strength, Nothing) {-# NOINLINE bindNoiseTexture_get_height #-} bindNoiseTexture_get_height :: MethodBind bindNoiseTexture_get_height = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_height :: (NoiseTexture :< cls, Object :< cls) => cls -> IO Int get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "get_height" '[] (IO Int) where nodeMethod = Godot.Core.NoiseTexture.get_height instance NodeProperty NoiseTexture "height" Int 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty NoiseTexture "noise" OpenSimplexNoise 'False where nodeProperty = (get_noise, wrapDroppingSetter set_noise, Nothing) instance NodeProperty NoiseTexture "seamless" Bool 'False where nodeProperty = (get_seamless, wrapDroppingSetter set_seamless, Nothing) {-# NOINLINE bindNoiseTexture_get_width #-} bindNoiseTexture_get_width :: MethodBind bindNoiseTexture_get_width = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_width :: (NoiseTexture :< cls, Object :< cls) => cls -> IO Int get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "get_width" '[] (IO Int) where nodeMethod = Godot.Core.NoiseTexture.get_width instance NodeProperty NoiseTexture "width" Int 'False where nodeProperty = (get_width, wrapDroppingSetter set_width, Nothing) {-# NOINLINE bindNoiseTexture__generate_texture #-} bindNoiseTexture__generate_texture :: MethodBind bindNoiseTexture__generate_texture = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "_generate_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _generate_texture :: (NoiseTexture :< cls, Object :< cls) => cls -> IO Image _generate_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture__generate_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "_generate_texture" '[] (IO Image) where nodeMethod = Godot.Core.NoiseTexture._generate_texture {-# NOINLINE bindNoiseTexture__queue_update #-} bindNoiseTexture__queue_update :: MethodBind bindNoiseTexture__queue_update = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "_queue_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _queue_update :: (NoiseTexture :< cls, Object :< cls) => cls -> IO () _queue_update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture__queue_update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "_queue_update" '[] (IO ()) where nodeMethod = Godot.Core.NoiseTexture._queue_update {-# NOINLINE bindNoiseTexture__thread_done #-} bindNoiseTexture__thread_done :: MethodBind bindNoiseTexture__thread_done = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "_thread_done" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _thread_done :: (NoiseTexture :< cls, Object :< cls) => cls -> Image -> IO () _thread_done cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture__thread_done (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "_thread_done" '[Image] (IO ()) where nodeMethod = Godot.Core.NoiseTexture._thread_done {-# NOINLINE bindNoiseTexture__update_texture #-} bindNoiseTexture__update_texture :: MethodBind bindNoiseTexture__update_texture = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "_update_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_texture :: (NoiseTexture :< cls, Object :< cls) => cls -> IO () _update_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture__update_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "_update_texture" '[] (IO ()) where nodeMethod = Godot.Core.NoiseTexture._update_texture {-# NOINLINE bindNoiseTexture_get_bump_strength #-} bindNoiseTexture_get_bump_strength :: MethodBind bindNoiseTexture_get_bump_strength = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "get_bump_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bump_strength :: (NoiseTexture :< cls, Object :< cls) => cls -> IO Float get_bump_strength cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_get_bump_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "get_bump_strength" '[] (IO Float) where nodeMethod = Godot.Core.NoiseTexture.get_bump_strength {-# NOINLINE bindNoiseTexture_get_noise #-} bindNoiseTexture_get_noise :: MethodBind bindNoiseTexture_get_noise = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "get_noise" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_noise :: (NoiseTexture :< cls, Object :< cls) => cls -> IO OpenSimplexNoise get_noise cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_get_noise (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "get_noise" '[] (IO OpenSimplexNoise) where nodeMethod = Godot.Core.NoiseTexture.get_noise {-# NOINLINE bindNoiseTexture_get_seamless #-} bindNoiseTexture_get_seamless :: MethodBind bindNoiseTexture_get_seamless = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "get_seamless" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_seamless :: (NoiseTexture :< cls, Object :< cls) => cls -> IO Bool get_seamless cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_get_seamless (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "get_seamless" '[] (IO Bool) where nodeMethod = Godot.Core.NoiseTexture.get_seamless {-# NOINLINE bindNoiseTexture_is_normalmap #-} bindNoiseTexture_is_normalmap :: MethodBind bindNoiseTexture_is_normalmap = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "is_normalmap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_normalmap :: (NoiseTexture :< cls, Object :< cls) => cls -> IO Bool is_normalmap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_is_normalmap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "is_normalmap" '[] (IO Bool) where nodeMethod = Godot.Core.NoiseTexture.is_normalmap {-# NOINLINE bindNoiseTexture_set_as_normalmap #-} bindNoiseTexture_set_as_normalmap :: MethodBind bindNoiseTexture_set_as_normalmap = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "set_as_normalmap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_as_normalmap :: (NoiseTexture :< cls, Object :< cls) => cls -> Bool -> IO () set_as_normalmap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_set_as_normalmap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "set_as_normalmap" '[Bool] (IO ()) where nodeMethod = Godot.Core.NoiseTexture.set_as_normalmap {-# NOINLINE bindNoiseTexture_set_bump_strength #-} bindNoiseTexture_set_bump_strength :: MethodBind bindNoiseTexture_set_bump_strength = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "set_bump_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bump_strength :: (NoiseTexture :< cls, Object :< cls) => cls -> Float -> IO () set_bump_strength cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_set_bump_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "set_bump_strength" '[Float] (IO ()) where nodeMethod = Godot.Core.NoiseTexture.set_bump_strength {-# NOINLINE bindNoiseTexture_set_height #-} bindNoiseTexture_set_height :: MethodBind bindNoiseTexture_set_height = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_height :: (NoiseTexture :< cls, Object :< cls) => cls -> Int -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "set_height" '[Int] (IO ()) where nodeMethod = Godot.Core.NoiseTexture.set_height {-# NOINLINE bindNoiseTexture_set_noise #-} bindNoiseTexture_set_noise :: MethodBind bindNoiseTexture_set_noise = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "set_noise" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_noise :: (NoiseTexture :< cls, Object :< cls) => cls -> OpenSimplexNoise -> IO () set_noise cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_set_noise (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "set_noise" '[OpenSimplexNoise] (IO ()) where nodeMethod = Godot.Core.NoiseTexture.set_noise {-# NOINLINE bindNoiseTexture_set_seamless #-} bindNoiseTexture_set_seamless :: MethodBind bindNoiseTexture_set_seamless = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "set_seamless" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_seamless :: (NoiseTexture :< cls, Object :< cls) => cls -> Bool -> IO () set_seamless cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_set_seamless (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "set_seamless" '[Bool] (IO ()) where nodeMethod = Godot.Core.NoiseTexture.set_seamless {-# NOINLINE bindNoiseTexture_set_width #-} bindNoiseTexture_set_width :: MethodBind bindNoiseTexture_set_width = unsafePerformIO $ withCString "NoiseTexture" $ \ clsNamePtr -> withCString "set_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_width :: (NoiseTexture :< cls, Object :< cls) => cls -> Int -> IO () set_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindNoiseTexture_set_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod NoiseTexture "set_width" '[Int] (IO ()) where nodeMethod = Godot.Core.NoiseTexture.set_width ================================================ FILE: src/Godot/Core/OS.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.OS (Godot.Core.OS._POWERSTATE_NO_BATTERY, Godot.Core.OS._SCREEN_ORIENTATION_SENSOR_PORTRAIT, Godot.Core.OS._SCREEN_ORIENTATION_SENSOR, Godot.Core.OS._DAY_THURSDAY, Godot.Core.OS._POWERSTATE_UNKNOWN, Godot.Core.OS._MONTH_MARCH, Godot.Core.OS._DAY_FRIDAY, Godot.Core.OS._SYSTEM_DIR_DOWNLOADS, Godot.Core.OS._MONTH_NOVEMBER, Godot.Core.OS._MONTH_JULY, Godot.Core.OS._SYSTEM_DIR_PICTURES, Godot.Core.OS._MONTH_DECEMBER, Godot.Core.OS._DAY_TUESDAY, Godot.Core.OS._SYSTEM_DIR_DESKTOP, Godot.Core.OS._DAY_MONDAY, Godot.Core.OS._SYSTEM_DIR_MUSIC, Godot.Core.OS._SYSTEM_DIR_RINGTONES, Godot.Core.OS._MONTH_AUGUST, Godot.Core.OS._SYSTEM_DIR_DOCUMENTS, Godot.Core.OS._SYSTEM_DIR_MOVIES, Godot.Core.OS._SYSTEM_DIR_DCIM, Godot.Core.OS._POWERSTATE_CHARGED, Godot.Core.OS._MONTH_APRIL, Godot.Core.OS._POWERSTATE_ON_BATTERY, Godot.Core.OS._DAY_SUNDAY, Godot.Core.OS._MONTH_MAY, Godot.Core.OS._SCREEN_ORIENTATION_REVERSE_PORTRAIT, Godot.Core.OS._MONTH_JANUARY, Godot.Core.OS._MONTH_OCTOBER, Godot.Core.OS._SCREEN_ORIENTATION_PORTRAIT, Godot.Core.OS._SCREEN_ORIENTATION_SENSOR_LANDSCAPE, Godot.Core.OS._MONTH_SEPTEMBER, Godot.Core.OS._VIDEO_DRIVER_GLES2, Godot.Core.OS._POWERSTATE_CHARGING, Godot.Core.OS._MONTH_FEBRUARY, Godot.Core.OS._MONTH_JUNE, Godot.Core.OS._SCREEN_ORIENTATION_REVERSE_LANDSCAPE, Godot.Core.OS._DAY_SATURDAY, Godot.Core.OS._SCREEN_ORIENTATION_LANDSCAPE, Godot.Core.OS._DAY_WEDNESDAY, Godot.Core.OS._VIDEO_DRIVER_GLES3, Godot.Core.OS.get_clipboard, Godot.Core.OS.set_clipboard, Godot.Core.OS.get_current_screen, Godot.Core.OS.set_current_screen, Godot.Core.OS.get_exit_code, Godot.Core.OS.set_exit_code, Godot.Core.OS.is_keep_screen_on, Godot.Core.OS.set_keep_screen_on, Godot.Core.OS.is_in_low_processor_usage_mode, Godot.Core.OS.set_low_processor_usage_mode, Godot.Core.OS.get_low_processor_usage_mode_sleep_usec, Godot.Core.OS.set_low_processor_usage_mode_sleep_usec, Godot.Core.OS.get_max_window_size, Godot.Core.OS.set_max_window_size, Godot.Core.OS.get_min_window_size, Godot.Core.OS.set_min_window_size, Godot.Core.OS.get_screen_orientation, Godot.Core.OS.set_screen_orientation, Godot.Core.OS.is_vsync_enabled, Godot.Core.OS.set_use_vsync, Godot.Core.OS.is_vsync_via_compositor_enabled, Godot.Core.OS.set_vsync_via_compositor, Godot.Core.OS.get_borderless_window, Godot.Core.OS.set_borderless_window, Godot.Core.OS.is_window_fullscreen, Godot.Core.OS.set_window_fullscreen, Godot.Core.OS.is_window_maximized, Godot.Core.OS.set_window_maximized, Godot.Core.OS.is_window_minimized, Godot.Core.OS.set_window_minimized, Godot.Core.OS.get_window_per_pixel_transparency_enabled, Godot.Core.OS.set_window_per_pixel_transparency_enabled, Godot.Core.OS.get_window_position, Godot.Core.OS.set_window_position, Godot.Core.OS.is_window_resizable, Godot.Core.OS.set_window_resizable, Godot.Core.OS.get_window_size, Godot.Core.OS.set_window_size, Godot.Core.OS.alert, Godot.Core.OS.can_draw, Godot.Core.OS.can_use_threads, Godot.Core.OS.center_window, Godot.Core.OS.close_midi_inputs, Godot.Core.OS.delay_msec, Godot.Core.OS.delay_usec, Godot.Core.OS.dump_memory_to_file, Godot.Core.OS.dump_resources_to_file, Godot.Core.OS.execute, Godot.Core.OS.find_scancode_from_string, Godot.Core.OS.get_audio_driver_count, Godot.Core.OS.get_audio_driver_name, Godot.Core.OS.get_cmdline_args, Godot.Core.OS.get_connected_midi_inputs, Godot.Core.OS.get_current_video_driver, Godot.Core.OS.get_date, Godot.Core.OS.get_datetime, Godot.Core.OS.get_datetime_from_unix_time, Godot.Core.OS.get_dynamic_memory_usage, Godot.Core.OS.get_environment, Godot.Core.OS.get_executable_path, Godot.Core.OS.get_granted_permissions, Godot.Core.OS.get_ime_selection, Godot.Core.OS.get_ime_text, Godot.Core.OS.get_latin_keyboard_variant, Godot.Core.OS.get_locale, Godot.Core.OS.get_model_name, Godot.Core.OS.get_name, Godot.Core.OS.get_power_percent_left, Godot.Core.OS.get_power_seconds_left, Godot.Core.OS.get_power_state, Godot.Core.OS.get_process_id, Godot.Core.OS.get_processor_count, Godot.Core.OS.get_real_window_size, Godot.Core.OS.get_scancode_string, Godot.Core.OS.get_screen_count, Godot.Core.OS.get_screen_dpi, Godot.Core.OS.get_screen_position, Godot.Core.OS.get_screen_size, Godot.Core.OS.get_splash_tick_msec, Godot.Core.OS.get_static_memory_peak_usage, Godot.Core.OS.get_static_memory_usage, Godot.Core.OS.get_system_dir, Godot.Core.OS.get_system_time_msecs, Godot.Core.OS.get_system_time_secs, Godot.Core.OS.get_ticks_msec, Godot.Core.OS.get_ticks_usec, Godot.Core.OS.get_time, Godot.Core.OS.get_time_zone_info, Godot.Core.OS.get_unique_id, Godot.Core.OS.get_unix_time, Godot.Core.OS.get_unix_time_from_datetime, Godot.Core.OS.get_user_data_dir, Godot.Core.OS.get_video_driver_count, Godot.Core.OS.get_video_driver_name, Godot.Core.OS.get_virtual_keyboard_height, Godot.Core.OS.get_window_safe_area, Godot.Core.OS.global_menu_add_item, Godot.Core.OS.global_menu_add_separator, Godot.Core.OS.global_menu_clear, Godot.Core.OS.global_menu_remove_item, Godot.Core.OS.has_environment, Godot.Core.OS.has_feature, Godot.Core.OS.has_touchscreen_ui_hint, Godot.Core.OS.has_virtual_keyboard, Godot.Core.OS.hide_virtual_keyboard, Godot.Core.OS.is_debug_build, Godot.Core.OS.is_ok_left_and_cancel_right, Godot.Core.OS.is_scancode_unicode, Godot.Core.OS.is_stdout_verbose, Godot.Core.OS.is_userfs_persistent, Godot.Core.OS.is_window_always_on_top, Godot.Core.OS.is_window_focused, Godot.Core.OS.kill, Godot.Core.OS.move_window_to_foreground, Godot.Core.OS.native_video_is_playing, Godot.Core.OS.native_video_pause, Godot.Core.OS.native_video_play, Godot.Core.OS.native_video_stop, Godot.Core.OS.native_video_unpause, Godot.Core.OS.open_midi_inputs, Godot.Core.OS.print_all_resources, Godot.Core.OS.print_all_textures_by_size, Godot.Core.OS.print_resources_by_type, Godot.Core.OS.print_resources_in_use, Godot.Core.OS.request_attention, Godot.Core.OS.request_permission, Godot.Core.OS.request_permissions, Godot.Core.OS.set_icon, Godot.Core.OS.set_ime_active, Godot.Core.OS.set_ime_position, Godot.Core.OS.set_native_icon, Godot.Core.OS.set_thread_name, Godot.Core.OS.set_use_file_access_save_and_swap, Godot.Core.OS.set_window_always_on_top, Godot.Core.OS.set_window_title, Godot.Core.OS.shell_open, Godot.Core.OS.show_virtual_keyboard) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _POWERSTATE_NO_BATTERY :: Int _POWERSTATE_NO_BATTERY = 2 _SCREEN_ORIENTATION_SENSOR_PORTRAIT :: Int _SCREEN_ORIENTATION_SENSOR_PORTRAIT = 5 _SCREEN_ORIENTATION_SENSOR :: Int _SCREEN_ORIENTATION_SENSOR = 6 _DAY_THURSDAY :: Int _DAY_THURSDAY = 4 _POWERSTATE_UNKNOWN :: Int _POWERSTATE_UNKNOWN = 0 _MONTH_MARCH :: Int _MONTH_MARCH = 3 _DAY_FRIDAY :: Int _DAY_FRIDAY = 5 _SYSTEM_DIR_DOWNLOADS :: Int _SYSTEM_DIR_DOWNLOADS = 3 _MONTH_NOVEMBER :: Int _MONTH_NOVEMBER = 11 _MONTH_JULY :: Int _MONTH_JULY = 7 _SYSTEM_DIR_PICTURES :: Int _SYSTEM_DIR_PICTURES = 6 _MONTH_DECEMBER :: Int _MONTH_DECEMBER = 12 _DAY_TUESDAY :: Int _DAY_TUESDAY = 2 _SYSTEM_DIR_DESKTOP :: Int _SYSTEM_DIR_DESKTOP = 0 _DAY_MONDAY :: Int _DAY_MONDAY = 1 _SYSTEM_DIR_MUSIC :: Int _SYSTEM_DIR_MUSIC = 5 _SYSTEM_DIR_RINGTONES :: Int _SYSTEM_DIR_RINGTONES = 7 _MONTH_AUGUST :: Int _MONTH_AUGUST = 8 _SYSTEM_DIR_DOCUMENTS :: Int _SYSTEM_DIR_DOCUMENTS = 2 _SYSTEM_DIR_MOVIES :: Int _SYSTEM_DIR_MOVIES = 4 _SYSTEM_DIR_DCIM :: Int _SYSTEM_DIR_DCIM = 1 _POWERSTATE_CHARGED :: Int _POWERSTATE_CHARGED = 4 _MONTH_APRIL :: Int _MONTH_APRIL = 4 _POWERSTATE_ON_BATTERY :: Int _POWERSTATE_ON_BATTERY = 1 _DAY_SUNDAY :: Int _DAY_SUNDAY = 0 _MONTH_MAY :: Int _MONTH_MAY = 5 _SCREEN_ORIENTATION_REVERSE_PORTRAIT :: Int _SCREEN_ORIENTATION_REVERSE_PORTRAIT = 3 _MONTH_JANUARY :: Int _MONTH_JANUARY = 1 _MONTH_OCTOBER :: Int _MONTH_OCTOBER = 10 _SCREEN_ORIENTATION_PORTRAIT :: Int _SCREEN_ORIENTATION_PORTRAIT = 1 _SCREEN_ORIENTATION_SENSOR_LANDSCAPE :: Int _SCREEN_ORIENTATION_SENSOR_LANDSCAPE = 4 _MONTH_SEPTEMBER :: Int _MONTH_SEPTEMBER = 9 _VIDEO_DRIVER_GLES2 :: Int _VIDEO_DRIVER_GLES2 = 1 _POWERSTATE_CHARGING :: Int _POWERSTATE_CHARGING = 3 _MONTH_FEBRUARY :: Int _MONTH_FEBRUARY = 2 _MONTH_JUNE :: Int _MONTH_JUNE = 6 _SCREEN_ORIENTATION_REVERSE_LANDSCAPE :: Int _SCREEN_ORIENTATION_REVERSE_LANDSCAPE = 2 _DAY_SATURDAY :: Int _DAY_SATURDAY = 6 _SCREEN_ORIENTATION_LANDSCAPE :: Int _SCREEN_ORIENTATION_LANDSCAPE = 0 _DAY_WEDNESDAY :: Int _DAY_WEDNESDAY = 3 _VIDEO_DRIVER_GLES3 :: Int _VIDEO_DRIVER_GLES3 = 0 {-# NOINLINE bindOS_get_clipboard #-} -- | The clipboard from the host OS. Might be unavailable on some platforms. bindOS_get_clipboard :: MethodBind bindOS_get_clipboard = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_clipboard" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The clipboard from the host OS. Might be unavailable on some platforms. get_clipboard :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_clipboard cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_clipboard (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_clipboard" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_clipboard {-# NOINLINE bindOS_set_clipboard #-} -- | The clipboard from the host OS. Might be unavailable on some platforms. bindOS_set_clipboard :: MethodBind bindOS_set_clipboard = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_clipboard" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The clipboard from the host OS. Might be unavailable on some platforms. set_clipboard :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO () set_clipboard cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_clipboard (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_clipboard" '[GodotString] (IO ()) where nodeMethod = Godot.Core.OS.set_clipboard instance NodeProperty OS "clipboard" GodotString 'False where nodeProperty = (get_clipboard, wrapDroppingSetter set_clipboard, Nothing) {-# NOINLINE bindOS_get_current_screen #-} -- | The current screen index (starting from 0). bindOS_get_current_screen :: MethodBind bindOS_get_current_screen = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_current_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current screen index (starting from 0). get_current_screen :: (OS :< cls, Object :< cls) => cls -> IO Int get_current_screen cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_current_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_current_screen" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_current_screen {-# NOINLINE bindOS_set_current_screen #-} -- | The current screen index (starting from 0). bindOS_set_current_screen :: MethodBind bindOS_set_current_screen = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_current_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current screen index (starting from 0). set_current_screen :: (OS :< cls, Object :< cls) => cls -> Int -> IO () set_current_screen cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_current_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_current_screen" '[Int] (IO ()) where nodeMethod = Godot.Core.OS.set_current_screen instance NodeProperty OS "current_screen" Int 'False where nodeProperty = (get_current_screen, wrapDroppingSetter set_current_screen, Nothing) {-# NOINLINE bindOS_get_exit_code #-} -- | The exit code passed to the OS when the main loop exits. By convention, an exit code of @0@ indicates success whereas a non-zero exit code indicates an error. For portability reasons, the exit code should be set between 0 and 125 (inclusive). -- __Note:__ This value will be ignored if using @method SceneTree.quit@ with an @exit_code@ argument passed. bindOS_get_exit_code :: MethodBind bindOS_get_exit_code = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_exit_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The exit code passed to the OS when the main loop exits. By convention, an exit code of @0@ indicates success whereas a non-zero exit code indicates an error. For portability reasons, the exit code should be set between 0 and 125 (inclusive). -- __Note:__ This value will be ignored if using @method SceneTree.quit@ with an @exit_code@ argument passed. get_exit_code :: (OS :< cls, Object :< cls) => cls -> IO Int get_exit_code cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_exit_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_exit_code" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_exit_code {-# NOINLINE bindOS_set_exit_code #-} -- | The exit code passed to the OS when the main loop exits. By convention, an exit code of @0@ indicates success whereas a non-zero exit code indicates an error. For portability reasons, the exit code should be set between 0 and 125 (inclusive). -- __Note:__ This value will be ignored if using @method SceneTree.quit@ with an @exit_code@ argument passed. bindOS_set_exit_code :: MethodBind bindOS_set_exit_code = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_exit_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The exit code passed to the OS when the main loop exits. By convention, an exit code of @0@ indicates success whereas a non-zero exit code indicates an error. For portability reasons, the exit code should be set between 0 and 125 (inclusive). -- __Note:__ This value will be ignored if using @method SceneTree.quit@ with an @exit_code@ argument passed. set_exit_code :: (OS :< cls, Object :< cls) => cls -> Int -> IO () set_exit_code cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_exit_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_exit_code" '[Int] (IO ()) where nodeMethod = Godot.Core.OS.set_exit_code instance NodeProperty OS "exit_code" Int 'False where nodeProperty = (get_exit_code, wrapDroppingSetter set_exit_code, Nothing) {-# NOINLINE bindOS_is_keep_screen_on #-} -- | If @true@, the engine tries to keep the screen on while the game is running. Useful on mobile. bindOS_is_keep_screen_on :: MethodBind bindOS_is_keep_screen_on = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_keep_screen_on" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the engine tries to keep the screen on while the game is running. Useful on mobile. is_keep_screen_on :: (OS :< cls, Object :< cls) => cls -> IO Bool is_keep_screen_on cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_keep_screen_on (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_keep_screen_on" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_keep_screen_on {-# NOINLINE bindOS_set_keep_screen_on #-} -- | If @true@, the engine tries to keep the screen on while the game is running. Useful on mobile. bindOS_set_keep_screen_on :: MethodBind bindOS_set_keep_screen_on = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_keep_screen_on" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the engine tries to keep the screen on while the game is running. Useful on mobile. set_keep_screen_on :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_keep_screen_on cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_keep_screen_on (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_keep_screen_on" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_keep_screen_on instance NodeProperty OS "keep_screen_on" Bool 'False where nodeProperty = (is_keep_screen_on, wrapDroppingSetter set_keep_screen_on, Nothing) {-# NOINLINE bindOS_is_in_low_processor_usage_mode #-} -- | If @true@, the engine optimizes for low processor usage by only refreshing the screen if needed. Can improve battery consumption on mobile. bindOS_is_in_low_processor_usage_mode :: MethodBind bindOS_is_in_low_processor_usage_mode = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_in_low_processor_usage_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the engine optimizes for low processor usage by only refreshing the screen if needed. Can improve battery consumption on mobile. is_in_low_processor_usage_mode :: (OS :< cls, Object :< cls) => cls -> IO Bool is_in_low_processor_usage_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_in_low_processor_usage_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_in_low_processor_usage_mode" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_in_low_processor_usage_mode {-# NOINLINE bindOS_set_low_processor_usage_mode #-} -- | If @true@, the engine optimizes for low processor usage by only refreshing the screen if needed. Can improve battery consumption on mobile. bindOS_set_low_processor_usage_mode :: MethodBind bindOS_set_low_processor_usage_mode = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_low_processor_usage_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the engine optimizes for low processor usage by only refreshing the screen if needed. Can improve battery consumption on mobile. set_low_processor_usage_mode :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_low_processor_usage_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_low_processor_usage_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_low_processor_usage_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_low_processor_usage_mode instance NodeProperty OS "low_processor_usage_mode" Bool 'False where nodeProperty = (is_in_low_processor_usage_mode, wrapDroppingSetter set_low_processor_usage_mode, Nothing) {-# NOINLINE bindOS_get_low_processor_usage_mode_sleep_usec #-} -- | The amount of sleeping between frames when the low-processor usage mode is enabled (in microseconds). Higher values will result in lower CPU usage. bindOS_get_low_processor_usage_mode_sleep_usec :: MethodBind bindOS_get_low_processor_usage_mode_sleep_usec = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_low_processor_usage_mode_sleep_usec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of sleeping between frames when the low-processor usage mode is enabled (in microseconds). Higher values will result in lower CPU usage. get_low_processor_usage_mode_sleep_usec :: (OS :< cls, Object :< cls) => cls -> IO Int get_low_processor_usage_mode_sleep_usec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_low_processor_usage_mode_sleep_usec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_low_processor_usage_mode_sleep_usec" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_low_processor_usage_mode_sleep_usec {-# NOINLINE bindOS_set_low_processor_usage_mode_sleep_usec #-} -- | The amount of sleeping between frames when the low-processor usage mode is enabled (in microseconds). Higher values will result in lower CPU usage. bindOS_set_low_processor_usage_mode_sleep_usec :: MethodBind bindOS_set_low_processor_usage_mode_sleep_usec = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_low_processor_usage_mode_sleep_usec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of sleeping between frames when the low-processor usage mode is enabled (in microseconds). Higher values will result in lower CPU usage. set_low_processor_usage_mode_sleep_usec :: (OS :< cls, Object :< cls) => cls -> Int -> IO () set_low_processor_usage_mode_sleep_usec cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_low_processor_usage_mode_sleep_usec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_low_processor_usage_mode_sleep_usec" '[Int] (IO ()) where nodeMethod = Godot.Core.OS.set_low_processor_usage_mode_sleep_usec instance NodeProperty OS "low_processor_usage_mode_sleep_usec" Int 'False where nodeProperty = (get_low_processor_usage_mode_sleep_usec, wrapDroppingSetter set_low_processor_usage_mode_sleep_usec, Nothing) {-# NOINLINE bindOS_get_max_window_size #-} -- | The maximum size of the window (without counting window manager decorations). Does not affect fullscreen mode. Set to @(0, 0)@ to reset to the system default value. bindOS_get_max_window_size :: MethodBind bindOS_get_max_window_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_max_window_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum size of the window (without counting window manager decorations). Does not affect fullscreen mode. Set to @(0, 0)@ to reset to the system default value. get_max_window_size :: (OS :< cls, Object :< cls) => cls -> IO Vector2 get_max_window_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_max_window_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_max_window_size" '[] (IO Vector2) where nodeMethod = Godot.Core.OS.get_max_window_size {-# NOINLINE bindOS_set_max_window_size #-} -- | The maximum size of the window (without counting window manager decorations). Does not affect fullscreen mode. Set to @(0, 0)@ to reset to the system default value. bindOS_set_max_window_size :: MethodBind bindOS_set_max_window_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_max_window_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum size of the window (without counting window manager decorations). Does not affect fullscreen mode. Set to @(0, 0)@ to reset to the system default value. set_max_window_size :: (OS :< cls, Object :< cls) => cls -> Vector2 -> IO () set_max_window_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_max_window_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_max_window_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.OS.set_max_window_size instance NodeProperty OS "max_window_size" Vector2 'False where nodeProperty = (get_max_window_size, wrapDroppingSetter set_max_window_size, Nothing) {-# NOINLINE bindOS_get_min_window_size #-} -- | The minimum size of the window (without counting window manager decorations). Does not affect fullscreen mode. Set to @(0, 0)@ to reset to the system default value. bindOS_get_min_window_size :: MethodBind bindOS_get_min_window_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_min_window_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum size of the window (without counting window manager decorations). Does not affect fullscreen mode. Set to @(0, 0)@ to reset to the system default value. get_min_window_size :: (OS :< cls, Object :< cls) => cls -> IO Vector2 get_min_window_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_min_window_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_min_window_size" '[] (IO Vector2) where nodeMethod = Godot.Core.OS.get_min_window_size {-# NOINLINE bindOS_set_min_window_size #-} -- | The minimum size of the window (without counting window manager decorations). Does not affect fullscreen mode. Set to @(0, 0)@ to reset to the system default value. bindOS_set_min_window_size :: MethodBind bindOS_set_min_window_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_min_window_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The minimum size of the window (without counting window manager decorations). Does not affect fullscreen mode. Set to @(0, 0)@ to reset to the system default value. set_min_window_size :: (OS :< cls, Object :< cls) => cls -> Vector2 -> IO () set_min_window_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_min_window_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_min_window_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.OS.set_min_window_size instance NodeProperty OS "min_window_size" Vector2 'False where nodeProperty = (get_min_window_size, wrapDroppingSetter set_min_window_size, Nothing) {-# NOINLINE bindOS_get_screen_orientation #-} -- | The current screen orientation. bindOS_get_screen_orientation :: MethodBind bindOS_get_screen_orientation = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_screen_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current screen orientation. get_screen_orientation :: (OS :< cls, Object :< cls) => cls -> IO Int get_screen_orientation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_screen_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_screen_orientation" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_screen_orientation {-# NOINLINE bindOS_set_screen_orientation #-} -- | The current screen orientation. bindOS_set_screen_orientation :: MethodBind bindOS_set_screen_orientation = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_screen_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current screen orientation. set_screen_orientation :: (OS :< cls, Object :< cls) => cls -> Int -> IO () set_screen_orientation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_screen_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_screen_orientation" '[Int] (IO ()) where nodeMethod = Godot.Core.OS.set_screen_orientation instance NodeProperty OS "screen_orientation" Int 'False where nodeProperty = (get_screen_orientation, wrapDroppingSetter set_screen_orientation, Nothing) {-# NOINLINE bindOS_is_vsync_enabled #-} -- | If @true@, vertical synchronization (Vsync) is enabled. bindOS_is_vsync_enabled :: MethodBind bindOS_is_vsync_enabled = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_vsync_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, vertical synchronization (Vsync) is enabled. is_vsync_enabled :: (OS :< cls, Object :< cls) => cls -> IO Bool is_vsync_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_vsync_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_vsync_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_vsync_enabled {-# NOINLINE bindOS_set_use_vsync #-} -- | If @true@, vertical synchronization (Vsync) is enabled. bindOS_set_use_vsync :: MethodBind bindOS_set_use_vsync = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_use_vsync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, vertical synchronization (Vsync) is enabled. set_use_vsync :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_use_vsync cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_use_vsync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_use_vsync" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_use_vsync instance NodeProperty OS "vsync_enabled" Bool 'False where nodeProperty = (is_vsync_enabled, wrapDroppingSetter set_use_vsync, Nothing) {-# NOINLINE bindOS_is_vsync_via_compositor_enabled #-} -- | If @true@ and @vsync_enabled@ is true, the operating system's window compositor will be used for vsync when the compositor is enabled and the game is in windowed mode. -- __Note:__ This option is experimental and meant to alleviate stutter experienced by some users. However, some users have experienced a Vsync framerate halving (e.g. from 60 FPS to 30 FPS) when using it. -- __Note:__ This property is only implemented on Windows. bindOS_is_vsync_via_compositor_enabled :: MethodBind bindOS_is_vsync_via_compositor_enabled = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_vsync_via_compositor_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@ and @vsync_enabled@ is true, the operating system's window compositor will be used for vsync when the compositor is enabled and the game is in windowed mode. -- __Note:__ This option is experimental and meant to alleviate stutter experienced by some users. However, some users have experienced a Vsync framerate halving (e.g. from 60 FPS to 30 FPS) when using it. -- __Note:__ This property is only implemented on Windows. is_vsync_via_compositor_enabled :: (OS :< cls, Object :< cls) => cls -> IO Bool is_vsync_via_compositor_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_vsync_via_compositor_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_vsync_via_compositor_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_vsync_via_compositor_enabled {-# NOINLINE bindOS_set_vsync_via_compositor #-} -- | If @true@ and @vsync_enabled@ is true, the operating system's window compositor will be used for vsync when the compositor is enabled and the game is in windowed mode. -- __Note:__ This option is experimental and meant to alleviate stutter experienced by some users. However, some users have experienced a Vsync framerate halving (e.g. from 60 FPS to 30 FPS) when using it. -- __Note:__ This property is only implemented on Windows. bindOS_set_vsync_via_compositor :: MethodBind bindOS_set_vsync_via_compositor = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_vsync_via_compositor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@ and @vsync_enabled@ is true, the operating system's window compositor will be used for vsync when the compositor is enabled and the game is in windowed mode. -- __Note:__ This option is experimental and meant to alleviate stutter experienced by some users. However, some users have experienced a Vsync framerate halving (e.g. from 60 FPS to 30 FPS) when using it. -- __Note:__ This property is only implemented on Windows. set_vsync_via_compositor :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_vsync_via_compositor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_vsync_via_compositor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_vsync_via_compositor" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_vsync_via_compositor instance NodeProperty OS "vsync_via_compositor" Bool 'False where nodeProperty = (is_vsync_via_compositor_enabled, wrapDroppingSetter set_vsync_via_compositor, Nothing) {-# NOINLINE bindOS_get_borderless_window #-} -- | If @true@, removes the window frame. -- __Note:__ Setting @window_borderless@ to @false@ disables per-pixel transparency. bindOS_get_borderless_window :: MethodBind bindOS_get_borderless_window = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_borderless_window" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, removes the window frame. -- __Note:__ Setting @window_borderless@ to @false@ disables per-pixel transparency. get_borderless_window :: (OS :< cls, Object :< cls) => cls -> IO Bool get_borderless_window cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_borderless_window (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_borderless_window" '[] (IO Bool) where nodeMethod = Godot.Core.OS.get_borderless_window {-# NOINLINE bindOS_set_borderless_window #-} -- | If @true@, removes the window frame. -- __Note:__ Setting @window_borderless@ to @false@ disables per-pixel transparency. bindOS_set_borderless_window :: MethodBind bindOS_set_borderless_window = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_borderless_window" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, removes the window frame. -- __Note:__ Setting @window_borderless@ to @false@ disables per-pixel transparency. set_borderless_window :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_borderless_window cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_borderless_window (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_borderless_window" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_borderless_window instance NodeProperty OS "window_borderless" Bool 'False where nodeProperty = (get_borderless_window, wrapDroppingSetter set_borderless_window, Nothing) {-# NOINLINE bindOS_is_window_fullscreen #-} -- | If @true@, the window is fullscreen. bindOS_is_window_fullscreen :: MethodBind bindOS_is_window_fullscreen = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_window_fullscreen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window is fullscreen. is_window_fullscreen :: (OS :< cls, Object :< cls) => cls -> IO Bool is_window_fullscreen cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_window_fullscreen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_window_fullscreen" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_window_fullscreen {-# NOINLINE bindOS_set_window_fullscreen #-} -- | If @true@, the window is fullscreen. bindOS_set_window_fullscreen :: MethodBind bindOS_set_window_fullscreen = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_fullscreen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window is fullscreen. set_window_fullscreen :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_window_fullscreen cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_fullscreen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_fullscreen" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_window_fullscreen instance NodeProperty OS "window_fullscreen" Bool 'False where nodeProperty = (is_window_fullscreen, wrapDroppingSetter set_window_fullscreen, Nothing) {-# NOINLINE bindOS_is_window_maximized #-} -- | If @true@, the window is maximized. bindOS_is_window_maximized :: MethodBind bindOS_is_window_maximized = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_window_maximized" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window is maximized. is_window_maximized :: (OS :< cls, Object :< cls) => cls -> IO Bool is_window_maximized cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_window_maximized (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_window_maximized" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_window_maximized {-# NOINLINE bindOS_set_window_maximized #-} -- | If @true@, the window is maximized. bindOS_set_window_maximized :: MethodBind bindOS_set_window_maximized = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_maximized" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window is maximized. set_window_maximized :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_window_maximized cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_maximized (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_maximized" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_window_maximized instance NodeProperty OS "window_maximized" Bool 'False where nodeProperty = (is_window_maximized, wrapDroppingSetter set_window_maximized, Nothing) {-# NOINLINE bindOS_is_window_minimized #-} -- | If @true@, the window is minimized. bindOS_is_window_minimized :: MethodBind bindOS_is_window_minimized = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_window_minimized" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window is minimized. is_window_minimized :: (OS :< cls, Object :< cls) => cls -> IO Bool is_window_minimized cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_window_minimized (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_window_minimized" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_window_minimized {-# NOINLINE bindOS_set_window_minimized #-} -- | If @true@, the window is minimized. bindOS_set_window_minimized :: MethodBind bindOS_set_window_minimized = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_minimized" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window is minimized. set_window_minimized :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_window_minimized cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_minimized (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_minimized" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_window_minimized instance NodeProperty OS "window_minimized" Bool 'False where nodeProperty = (is_window_minimized, wrapDroppingSetter set_window_minimized, Nothing) {-# NOINLINE bindOS_get_window_per_pixel_transparency_enabled #-} -- | If @true@, the window background is transparent and window frame is removed. -- Use @get_tree().get_root().set_transparent_background(true)@ to disable main viewport background rendering. -- __Note:__ This property has no effect if __Project > Project Settings > Display > Window > Per-pixel transparency > Allowed__ setting is disabled. -- __Note:__ This property is implemented on HTML5, Linux, macOS and Windows. bindOS_get_window_per_pixel_transparency_enabled :: MethodBind bindOS_get_window_per_pixel_transparency_enabled = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_window_per_pixel_transparency_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window background is transparent and window frame is removed. -- Use @get_tree().get_root().set_transparent_background(true)@ to disable main viewport background rendering. -- __Note:__ This property has no effect if __Project > Project Settings > Display > Window > Per-pixel transparency > Allowed__ setting is disabled. -- __Note:__ This property is implemented on HTML5, Linux, macOS and Windows. get_window_per_pixel_transparency_enabled :: (OS :< cls, Object :< cls) => cls -> IO Bool get_window_per_pixel_transparency_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_window_per_pixel_transparency_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_window_per_pixel_transparency_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.OS.get_window_per_pixel_transparency_enabled {-# NOINLINE bindOS_set_window_per_pixel_transparency_enabled #-} -- | If @true@, the window background is transparent and window frame is removed. -- Use @get_tree().get_root().set_transparent_background(true)@ to disable main viewport background rendering. -- __Note:__ This property has no effect if __Project > Project Settings > Display > Window > Per-pixel transparency > Allowed__ setting is disabled. -- __Note:__ This property is implemented on HTML5, Linux, macOS and Windows. bindOS_set_window_per_pixel_transparency_enabled :: MethodBind bindOS_set_window_per_pixel_transparency_enabled = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_per_pixel_transparency_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window background is transparent and window frame is removed. -- Use @get_tree().get_root().set_transparent_background(true)@ to disable main viewport background rendering. -- __Note:__ This property has no effect if __Project > Project Settings > Display > Window > Per-pixel transparency > Allowed__ setting is disabled. -- __Note:__ This property is implemented on HTML5, Linux, macOS and Windows. set_window_per_pixel_transparency_enabled :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_window_per_pixel_transparency_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_per_pixel_transparency_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_per_pixel_transparency_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_window_per_pixel_transparency_enabled instance NodeProperty OS "window_per_pixel_transparency_enabled" Bool 'False where nodeProperty = (get_window_per_pixel_transparency_enabled, wrapDroppingSetter set_window_per_pixel_transparency_enabled, Nothing) {-# NOINLINE bindOS_get_window_position #-} -- | The window position relative to the screen, the origin is the top left corner, +Y axis goes to the bottom and +X axis goes to the right. bindOS_get_window_position :: MethodBind bindOS_get_window_position = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_window_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The window position relative to the screen, the origin is the top left corner, +Y axis goes to the bottom and +X axis goes to the right. get_window_position :: (OS :< cls, Object :< cls) => cls -> IO Vector2 get_window_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_window_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_window_position" '[] (IO Vector2) where nodeMethod = Godot.Core.OS.get_window_position {-# NOINLINE bindOS_set_window_position #-} -- | The window position relative to the screen, the origin is the top left corner, +Y axis goes to the bottom and +X axis goes to the right. bindOS_set_window_position :: MethodBind bindOS_set_window_position = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The window position relative to the screen, the origin is the top left corner, +Y axis goes to the bottom and +X axis goes to the right. set_window_position :: (OS :< cls, Object :< cls) => cls -> Vector2 -> IO () set_window_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.OS.set_window_position instance NodeProperty OS "window_position" Vector2 'False where nodeProperty = (get_window_position, wrapDroppingSetter set_window_position, Nothing) {-# NOINLINE bindOS_is_window_resizable #-} -- | If @true@, the window is resizable by the user. bindOS_is_window_resizable :: MethodBind bindOS_is_window_resizable = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_window_resizable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window is resizable by the user. is_window_resizable :: (OS :< cls, Object :< cls) => cls -> IO Bool is_window_resizable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_window_resizable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_window_resizable" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_window_resizable {-# NOINLINE bindOS_set_window_resizable #-} -- | If @true@, the window is resizable by the user. bindOS_set_window_resizable :: MethodBind bindOS_set_window_resizable = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_resizable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window is resizable by the user. set_window_resizable :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_window_resizable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_resizable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_resizable" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_window_resizable instance NodeProperty OS "window_resizable" Bool 'False where nodeProperty = (is_window_resizable, wrapDroppingSetter set_window_resizable, Nothing) {-# NOINLINE bindOS_get_window_size #-} -- | The size of the window (without counting window manager decorations). bindOS_get_window_size :: MethodBind bindOS_get_window_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_window_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the window (without counting window manager decorations). get_window_size :: (OS :< cls, Object :< cls) => cls -> IO Vector2 get_window_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_window_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_window_size" '[] (IO Vector2) where nodeMethod = Godot.Core.OS.get_window_size {-# NOINLINE bindOS_set_window_size #-} -- | The size of the window (without counting window manager decorations). bindOS_set_window_size :: MethodBind bindOS_set_window_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the window (without counting window manager decorations). set_window_size :: (OS :< cls, Object :< cls) => cls -> Vector2 -> IO () set_window_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.OS.set_window_size instance NodeProperty OS "window_size" Vector2 'False where nodeProperty = (get_window_size, wrapDroppingSetter set_window_size, Nothing) {-# NOINLINE bindOS_alert #-} -- | Displays a modal dialog box using the host OS' facilities. Execution is blocked until the dialog is closed. bindOS_alert :: MethodBind bindOS_alert = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "alert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Displays a modal dialog box using the host OS' facilities. Execution is blocked until the dialog is closed. alert :: (OS :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO () alert cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "Alert!" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOS_alert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "alert" '[GodotString, Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.OS.alert {-# NOINLINE bindOS_can_draw #-} -- | Returns @true@ if the host OS allows drawing. bindOS_can_draw :: MethodBind bindOS_can_draw = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "can_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the host OS allows drawing. can_draw :: (OS :< cls, Object :< cls) => cls -> IO Bool can_draw cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_can_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "can_draw" '[] (IO Bool) where nodeMethod = Godot.Core.OS.can_draw {-# NOINLINE bindOS_can_use_threads #-} -- | Returns @true@ if the current host platform is using multiple threads. bindOS_can_use_threads :: MethodBind bindOS_can_use_threads = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "can_use_threads" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the current host platform is using multiple threads. can_use_threads :: (OS :< cls, Object :< cls) => cls -> IO Bool can_use_threads cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_can_use_threads (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "can_use_threads" '[] (IO Bool) where nodeMethod = Godot.Core.OS.can_use_threads {-# NOINLINE bindOS_center_window #-} -- | Centers the window on the screen if in windowed mode. bindOS_center_window :: MethodBind bindOS_center_window = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "center_window" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Centers the window on the screen if in windowed mode. center_window :: (OS :< cls, Object :< cls) => cls -> IO () center_window cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_center_window (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "center_window" '[] (IO ()) where nodeMethod = Godot.Core.OS.center_window {-# NOINLINE bindOS_close_midi_inputs #-} -- | Shuts down system MIDI driver. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_close_midi_inputs :: MethodBind bindOS_close_midi_inputs = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "close_midi_inputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shuts down system MIDI driver. -- __Note:__ This method is implemented on Linux, macOS and Windows. close_midi_inputs :: (OS :< cls, Object :< cls) => cls -> IO () close_midi_inputs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_close_midi_inputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "close_midi_inputs" '[] (IO ()) where nodeMethod = Godot.Core.OS.close_midi_inputs {-# NOINLINE bindOS_delay_msec #-} -- | Delay execution of the current thread by @msec@ milliseconds. bindOS_delay_msec :: MethodBind bindOS_delay_msec = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "delay_msec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Delay execution of the current thread by @msec@ milliseconds. delay_msec :: (OS :< cls, Object :< cls) => cls -> Int -> IO () delay_msec cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_delay_msec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "delay_msec" '[Int] (IO ()) where nodeMethod = Godot.Core.OS.delay_msec {-# NOINLINE bindOS_delay_usec #-} -- | Delay execution of the current thread by @usec@ microseconds. bindOS_delay_usec :: MethodBind bindOS_delay_usec = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "delay_usec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Delay execution of the current thread by @usec@ microseconds. delay_usec :: (OS :< cls, Object :< cls) => cls -> Int -> IO () delay_usec cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_delay_usec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "delay_usec" '[Int] (IO ()) where nodeMethod = Godot.Core.OS.delay_usec {-# NOINLINE bindOS_dump_memory_to_file #-} -- | Dumps the memory allocation ringlist to a file (only works in debug). -- Entry format per line: "Address - Size - Description". bindOS_dump_memory_to_file :: MethodBind bindOS_dump_memory_to_file = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "dump_memory_to_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dumps the memory allocation ringlist to a file (only works in debug). -- Entry format per line: "Address - Size - Description". dump_memory_to_file :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO () dump_memory_to_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_dump_memory_to_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "dump_memory_to_file" '[GodotString] (IO ()) where nodeMethod = Godot.Core.OS.dump_memory_to_file {-# NOINLINE bindOS_dump_resources_to_file #-} -- | Dumps all used resources to file (only works in debug). -- Entry format per line: "Resource Type : Resource Location". -- At the end of the file is a statistic of all used Resource Types. bindOS_dump_resources_to_file :: MethodBind bindOS_dump_resources_to_file = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "dump_resources_to_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Dumps all used resources to file (only works in debug). -- Entry format per line: "Resource Type : Resource Location". -- At the end of the file is a statistic of all used Resource Types. dump_resources_to_file :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO () dump_resources_to_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_dump_resources_to_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "dump_resources_to_file" '[GodotString] (IO ()) where nodeMethod = Godot.Core.OS.dump_resources_to_file {-# NOINLINE bindOS_execute #-} -- | Execute the file at the given path with the arguments passed as an array of strings. Platform path resolution will take place. The resolved file must exist and be executable. -- The arguments are used in the given order and separated by a space, so @OS.execute("ping", @"-w", "3", "godotengine.org"@, false)@ will resolve to @ping -w 3 godotengine.org@ in the system's shell. -- This method has slightly different behavior based on whether the @blocking@ mode is enabled. -- If @blocking@ is @true@, the Godot thread will pause its execution while waiting for the process to terminate. The shell output of the process will be written to the @output@ array as a single string. When the process terminates, the Godot thread will resume execution. -- If @blocking@ is @false@, the Godot thread will continue while the new process runs. It is not possible to retrieve the shell output in non-blocking mode, so @output@ will be empty. -- The return value also depends on the blocking mode. When blocking, the method will return an exit code of the process. When non-blocking, the method returns a process ID, which you can use to monitor the process (and potentially terminate it with @method kill@). If the process forking (non-blocking) or opening (blocking) fails, the method will return @-1@ or another exit code. -- Example of blocking mode and retrieving the shell output: -- -- @ -- -- var output = @@ -- var exit_code = OS.execute("ls", @"-l", "/tmp"@, true, output) -- -- @ -- -- Example of non-blocking mode, running another instance of the project and storing its process ID: -- -- @ -- -- var pid = OS.execute(OS.get_executable_path(), @@, false) -- -- @ -- -- If you wish to access a shell built-in or perform a composite command, a platform-specific shell can be invoked. For example: -- -- @ -- -- OS.execute("CMD.exe", @"/C", "cd %TEMP% && dir"@, true, output) -- -- @ -- -- __Note:__ This method is implemented on Android, iOS, Linux, macOS and Windows. bindOS_execute :: MethodBind bindOS_execute = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "execute" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Execute the file at the given path with the arguments passed as an array of strings. Platform path resolution will take place. The resolved file must exist and be executable. -- The arguments are used in the given order and separated by a space, so @OS.execute("ping", @"-w", "3", "godotengine.org"@, false)@ will resolve to @ping -w 3 godotengine.org@ in the system's shell. -- This method has slightly different behavior based on whether the @blocking@ mode is enabled. -- If @blocking@ is @true@, the Godot thread will pause its execution while waiting for the process to terminate. The shell output of the process will be written to the @output@ array as a single string. When the process terminates, the Godot thread will resume execution. -- If @blocking@ is @false@, the Godot thread will continue while the new process runs. It is not possible to retrieve the shell output in non-blocking mode, so @output@ will be empty. -- The return value also depends on the blocking mode. When blocking, the method will return an exit code of the process. When non-blocking, the method returns a process ID, which you can use to monitor the process (and potentially terminate it with @method kill@). If the process forking (non-blocking) or opening (blocking) fails, the method will return @-1@ or another exit code. -- Example of blocking mode and retrieving the shell output: -- -- @ -- -- var output = @@ -- var exit_code = OS.execute("ls", @"-l", "/tmp"@, true, output) -- -- @ -- -- Example of non-blocking mode, running another instance of the project and storing its process ID: -- -- @ -- -- var pid = OS.execute(OS.get_executable_path(), @@, false) -- -- @ -- -- If you wish to access a shell built-in or perform a composite command, a platform-specific shell can be invoked. For example: -- -- @ -- -- OS.execute("CMD.exe", @"/C", "cd %TEMP% && dir"@, true, output) -- -- @ -- -- __Note:__ This method is implemented on Android, iOS, Linux, macOS and Windows. execute :: (OS :< cls, Object :< cls) => cls -> GodotString -> PoolStringArray -> Maybe Bool -> Maybe Array -> Maybe Bool -> IO Int execute cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3, defaultedVariant VariantArray V.empty arg4, maybe (VariantBool False) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindOS_execute (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "execute" '[GodotString, PoolStringArray, Maybe Bool, Maybe Array, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.OS.execute {-# NOINLINE bindOS_find_scancode_from_string #-} -- | Returns the scancode of the given string (e.g. "Escape"). bindOS_find_scancode_from_string :: MethodBind bindOS_find_scancode_from_string = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "find_scancode_from_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the scancode of the given string (e.g. "Escape"). find_scancode_from_string :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO Int find_scancode_from_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_find_scancode_from_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "find_scancode_from_string" '[GodotString] (IO Int) where nodeMethod = Godot.Core.OS.find_scancode_from_string {-# NOINLINE bindOS_get_audio_driver_count #-} -- | Returns the total number of available audio drivers. bindOS_get_audio_driver_count :: MethodBind bindOS_get_audio_driver_count = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_audio_driver_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total number of available audio drivers. get_audio_driver_count :: (OS :< cls, Object :< cls) => cls -> IO Int get_audio_driver_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_audio_driver_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_audio_driver_count" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_audio_driver_count {-# NOINLINE bindOS_get_audio_driver_name #-} -- | Returns the audio driver name for the given index. bindOS_get_audio_driver_name :: MethodBind bindOS_get_audio_driver_name = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_audio_driver_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the audio driver name for the given index. get_audio_driver_name :: (OS :< cls, Object :< cls) => cls -> Int -> IO GodotString get_audio_driver_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_audio_driver_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_audio_driver_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.OS.get_audio_driver_name {-# NOINLINE bindOS_get_cmdline_args #-} -- | Returns the command-line arguments passed to the engine. -- Command-line arguments can be written in any form, including both @--key value@ and @--key=value@ forms so they can be properly parsed, as long as custom command-line arguments do not conflict with engine arguments. -- You can also incorporate environment variables using the @method get_environment@ method. -- You can set @editor/main_run_args@ in the Project Settings to define command-line arguments to be passed by the editor when running the project. -- Here's a minimal example on how to parse command-line arguments into a dictionary using the @--key=value@ form for arguments: -- -- @ -- -- var arguments = {} -- for argument in OS.get_cmdline_args(): -- if argument.find("=") > -1: -- var key_value = argument.split("=") -- arguments@key_value@0@.lstrip("--")@ = key_value@1@ -- -- @ bindOS_get_cmdline_args :: MethodBind bindOS_get_cmdline_args = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_cmdline_args" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the command-line arguments passed to the engine. -- Command-line arguments can be written in any form, including both @--key value@ and @--key=value@ forms so they can be properly parsed, as long as custom command-line arguments do not conflict with engine arguments. -- You can also incorporate environment variables using the @method get_environment@ method. -- You can set @editor/main_run_args@ in the Project Settings to define command-line arguments to be passed by the editor when running the project. -- Here's a minimal example on how to parse command-line arguments into a dictionary using the @--key=value@ form for arguments: -- -- @ -- -- var arguments = {} -- for argument in OS.get_cmdline_args(): -- if argument.find("=") > -1: -- var key_value = argument.split("=") -- arguments@key_value@0@.lstrip("--")@ = key_value@1@ -- -- @ get_cmdline_args :: (OS :< cls, Object :< cls) => cls -> IO PoolStringArray get_cmdline_args cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_cmdline_args (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_cmdline_args" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.OS.get_cmdline_args {-# NOINLINE bindOS_get_connected_midi_inputs #-} -- | Returns an array of MIDI device names. -- The returned array will be empty if the system MIDI driver has not previously been initialised with @method open_midi_inputs@. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_get_connected_midi_inputs :: MethodBind bindOS_get_connected_midi_inputs = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_connected_midi_inputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of MIDI device names. -- The returned array will be empty if the system MIDI driver has not previously been initialised with @method open_midi_inputs@. -- __Note:__ This method is implemented on Linux, macOS and Windows. get_connected_midi_inputs :: (OS :< cls, Object :< cls) => cls -> IO PoolStringArray get_connected_midi_inputs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_connected_midi_inputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_connected_midi_inputs" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.OS.get_connected_midi_inputs {-# NOINLINE bindOS_get_current_video_driver #-} -- | Returns the currently used video driver, using one of the values from @enum VideoDriver@. bindOS_get_current_video_driver :: MethodBind bindOS_get_current_video_driver = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_current_video_driver" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the currently used video driver, using one of the values from @enum VideoDriver@. get_current_video_driver :: (OS :< cls, Object :< cls) => cls -> IO Int get_current_video_driver cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_current_video_driver (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_current_video_driver" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_current_video_driver {-# NOINLINE bindOS_get_date #-} -- | Returns current date as a dictionary of keys: @year@, @month@, @day@, @weekday@, @dst@ (Daylight Savings Time). bindOS_get_date :: MethodBind bindOS_get_date = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_date" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns current date as a dictionary of keys: @year@, @month@, @day@, @weekday@, @dst@ (Daylight Savings Time). get_date :: (OS :< cls, Object :< cls) => cls -> Maybe Bool -> IO Dictionary get_date cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_date (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_date" '[Maybe Bool] (IO Dictionary) where nodeMethod = Godot.Core.OS.get_date {-# NOINLINE bindOS_get_datetime #-} -- | Returns current datetime as a dictionary of keys: @year@, @month@, @day@, @weekday@, @dst@ (Daylight Savings Time), @hour@, @minute@, @second@. bindOS_get_datetime :: MethodBind bindOS_get_datetime = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_datetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns current datetime as a dictionary of keys: @year@, @month@, @day@, @weekday@, @dst@ (Daylight Savings Time), @hour@, @minute@, @second@. get_datetime :: (OS :< cls, Object :< cls) => cls -> Maybe Bool -> IO Dictionary get_datetime cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_datetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_datetime" '[Maybe Bool] (IO Dictionary) where nodeMethod = Godot.Core.OS.get_datetime {-# NOINLINE bindOS_get_datetime_from_unix_time #-} -- | Gets a dictionary of time values corresponding to the given UNIX epoch time (in seconds). -- The returned Dictionary's values will be the same as @method get_datetime@, with the exception of Daylight Savings Time as it cannot be determined from the epoch. bindOS_get_datetime_from_unix_time :: MethodBind bindOS_get_datetime_from_unix_time = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_datetime_from_unix_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a dictionary of time values corresponding to the given UNIX epoch time (in seconds). -- The returned Dictionary's values will be the same as @method get_datetime@, with the exception of Daylight Savings Time as it cannot be determined from the epoch. get_datetime_from_unix_time :: (OS :< cls, Object :< cls) => cls -> Int -> IO Dictionary get_datetime_from_unix_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_datetime_from_unix_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_datetime_from_unix_time" '[Int] (IO Dictionary) where nodeMethod = Godot.Core.OS.get_datetime_from_unix_time {-# NOINLINE bindOS_get_dynamic_memory_usage #-} -- | Returns the total amount of dynamic memory used (only works in debug). bindOS_get_dynamic_memory_usage :: MethodBind bindOS_get_dynamic_memory_usage = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_dynamic_memory_usage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total amount of dynamic memory used (only works in debug). get_dynamic_memory_usage :: (OS :< cls, Object :< cls) => cls -> IO Int get_dynamic_memory_usage cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_dynamic_memory_usage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_dynamic_memory_usage" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_dynamic_memory_usage {-# NOINLINE bindOS_get_environment #-} -- | Returns an environment variable. bindOS_get_environment :: MethodBind bindOS_get_environment = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an environment variable. get_environment :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_environment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_environment" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.OS.get_environment {-# NOINLINE bindOS_get_executable_path #-} -- | Returns the path to the current engine executable. bindOS_get_executable_path :: MethodBind bindOS_get_executable_path = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_executable_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to the current engine executable. get_executable_path :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_executable_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_executable_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_executable_path" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_executable_path {-# NOINLINE bindOS_get_granted_permissions #-} -- | With this function you can get the list of dangerous permissions that have been granted to the Android application. -- __Note:__ This method is implemented on Android. bindOS_get_granted_permissions :: MethodBind bindOS_get_granted_permissions = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_granted_permissions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | With this function you can get the list of dangerous permissions that have been granted to the Android application. -- __Note:__ This method is implemented on Android. get_granted_permissions :: (OS :< cls, Object :< cls) => cls -> IO PoolStringArray get_granted_permissions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_granted_permissions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_granted_permissions" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.OS.get_granted_permissions {-# NOINLINE bindOS_get_ime_selection #-} -- | Returns the IME cursor position (the currently-edited portion of the string) relative to the characters in the composition string. -- @MainLoop.NOTIFICATION_OS_IME_UPDATE@ is sent to the application to notify it of changes to the IME cursor position. -- __Note:__ This method is implemented on macOS. bindOS_get_ime_selection :: MethodBind bindOS_get_ime_selection = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_ime_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the IME cursor position (the currently-edited portion of the string) relative to the characters in the composition string. -- @MainLoop.NOTIFICATION_OS_IME_UPDATE@ is sent to the application to notify it of changes to the IME cursor position. -- __Note:__ This method is implemented on macOS. get_ime_selection :: (OS :< cls, Object :< cls) => cls -> IO Vector2 get_ime_selection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_ime_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_ime_selection" '[] (IO Vector2) where nodeMethod = Godot.Core.OS.get_ime_selection {-# NOINLINE bindOS_get_ime_text #-} -- | Returns the IME intermediate composition string. -- @MainLoop.NOTIFICATION_OS_IME_UPDATE@ is sent to the application to notify it of changes to the IME composition string. -- __Note:__ This method is implemented on macOS. bindOS_get_ime_text :: MethodBind bindOS_get_ime_text = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_ime_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the IME intermediate composition string. -- @MainLoop.NOTIFICATION_OS_IME_UPDATE@ is sent to the application to notify it of changes to the IME composition string. -- __Note:__ This method is implemented on macOS. get_ime_text :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_ime_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_ime_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_ime_text" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_ime_text {-# NOINLINE bindOS_get_latin_keyboard_variant #-} -- | Returns the current latin keyboard variant as a String. -- Possible return values are: @"QWERTY"@, @"AZERTY"@, @"QZERTY"@, @"DVORAK"@, @"NEO"@, @"COLEMAK"@ or @"ERROR"@. -- __Note:__ This method is implemented on Linux, macOS and Windows. Returns @"QWERTY"@ on unsupported platforms. bindOS_get_latin_keyboard_variant :: MethodBind bindOS_get_latin_keyboard_variant = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_latin_keyboard_variant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current latin keyboard variant as a String. -- Possible return values are: @"QWERTY"@, @"AZERTY"@, @"QZERTY"@, @"DVORAK"@, @"NEO"@, @"COLEMAK"@ or @"ERROR"@. -- __Note:__ This method is implemented on Linux, macOS and Windows. Returns @"QWERTY"@ on unsupported platforms. get_latin_keyboard_variant :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_latin_keyboard_variant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_latin_keyboard_variant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_latin_keyboard_variant" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_latin_keyboard_variant {-# NOINLINE bindOS_get_locale #-} -- | Returns the host OS locale. bindOS_get_locale :: MethodBind bindOS_get_locale = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_locale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the host OS locale. get_locale :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_locale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_locale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_locale" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_locale {-# NOINLINE bindOS_get_model_name #-} -- | Returns the model name of the current device. -- __Note:__ This method is implemented on Android and iOS. Returns @"GenericDevice"@ on unsupported platforms. bindOS_get_model_name :: MethodBind bindOS_get_model_name = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_model_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the model name of the current device. -- __Note:__ This method is implemented on Android and iOS. Returns @"GenericDevice"@ on unsupported platforms. get_model_name :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_model_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_model_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_model_name" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_model_name {-# NOINLINE bindOS_get_name #-} -- | Returns the name of the host OS. Possible values are: @"Android"@, @"iOS"@, @"HTML5"@, @"OSX"@, @"Server"@, @"Windows"@, @"UWP"@, @"X11"@. bindOS_get_name :: MethodBind bindOS_get_name = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the host OS. Possible values are: @"Android"@, @"iOS"@, @"HTML5"@, @"OSX"@, @"Server"@, @"Windows"@, @"UWP"@, @"X11"@. get_name :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_name" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_name {-# NOINLINE bindOS_get_power_percent_left #-} -- | Returns the amount of battery left in the device as a percentage. Returns @-1@ if power state is unknown. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_get_power_percent_left :: MethodBind bindOS_get_power_percent_left = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_power_percent_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of battery left in the device as a percentage. Returns @-1@ if power state is unknown. -- __Note:__ This method is implemented on Linux, macOS and Windows. get_power_percent_left :: (OS :< cls, Object :< cls) => cls -> IO Int get_power_percent_left cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_power_percent_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_power_percent_left" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_power_percent_left {-# NOINLINE bindOS_get_power_seconds_left #-} -- | Returns an estimate of the time left in seconds before the device runs out of battery. Returns @-1@ if power state is unknown. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_get_power_seconds_left :: MethodBind bindOS_get_power_seconds_left = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_power_seconds_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an estimate of the time left in seconds before the device runs out of battery. Returns @-1@ if power state is unknown. -- __Note:__ This method is implemented on Linux, macOS and Windows. get_power_seconds_left :: (OS :< cls, Object :< cls) => cls -> IO Int get_power_seconds_left cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_power_seconds_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_power_seconds_left" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_power_seconds_left {-# NOINLINE bindOS_get_power_state #-} -- | Returns the current state of the device regarding battery and power. See @enum PowerState@ constants. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_get_power_state :: MethodBind bindOS_get_power_state = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_power_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current state of the device regarding battery and power. See @enum PowerState@ constants. -- __Note:__ This method is implemented on Linux, macOS and Windows. get_power_state :: (OS :< cls, Object :< cls) => cls -> IO Int get_power_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_power_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_power_state" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_power_state {-# NOINLINE bindOS_get_process_id #-} -- | Returns the project's process ID. -- __Note:__ This method is implemented on Android, iOS, Linux, macOS and Windows. bindOS_get_process_id :: MethodBind bindOS_get_process_id = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_process_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the project's process ID. -- __Note:__ This method is implemented on Android, iOS, Linux, macOS and Windows. get_process_id :: (OS :< cls, Object :< cls) => cls -> IO Int get_process_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_process_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_process_id" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_process_id {-# NOINLINE bindOS_get_processor_count #-} -- | Returns the number of threads available on the host machine. bindOS_get_processor_count :: MethodBind bindOS_get_processor_count = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_processor_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of threads available on the host machine. get_processor_count :: (OS :< cls, Object :< cls) => cls -> IO Int get_processor_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_processor_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_processor_count" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_processor_count {-# NOINLINE bindOS_get_real_window_size #-} -- | Returns the window size including decorations like window borders. bindOS_get_real_window_size :: MethodBind bindOS_get_real_window_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_real_window_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the window size including decorations like window borders. get_real_window_size :: (OS :< cls, Object :< cls) => cls -> IO Vector2 get_real_window_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_real_window_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_real_window_size" '[] (IO Vector2) where nodeMethod = Godot.Core.OS.get_real_window_size {-# NOINLINE bindOS_get_scancode_string #-} -- | Returns the given scancode as a string (e.g. Return values: @"Escape"@, @"Shift+Escape"@). -- See also @InputEventKey.scancode@ and @method InputEventKey.get_scancode_with_modifiers@. bindOS_get_scancode_string :: MethodBind bindOS_get_scancode_string = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_scancode_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given scancode as a string (e.g. Return values: @"Escape"@, @"Shift+Escape"@). -- See also @InputEventKey.scancode@ and @method InputEventKey.get_scancode_with_modifiers@. get_scancode_string :: (OS :< cls, Object :< cls) => cls -> Int -> IO GodotString get_scancode_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_scancode_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_scancode_string" '[Int] (IO GodotString) where nodeMethod = Godot.Core.OS.get_scancode_string {-# NOINLINE bindOS_get_screen_count #-} -- | Returns the number of displays attached to the host machine. bindOS_get_screen_count :: MethodBind bindOS_get_screen_count = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_screen_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of displays attached to the host machine. get_screen_count :: (OS :< cls, Object :< cls) => cls -> IO Int get_screen_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_screen_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_screen_count" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_screen_count {-# NOINLINE bindOS_get_screen_dpi #-} -- | Returns the dots per inch density of the specified screen. If @screen@ is @-1@ (the default value), the current screen will be used. -- On Android devices, the actual screen densities are grouped into six generalized densities: -- -- @ -- -- ldpi - 120 dpi -- mdpi - 160 dpi -- hdpi - 240 dpi -- xhdpi - 320 dpi -- xxhdpi - 480 dpi -- xxxhdpi - 640 dpi -- -- @ -- -- __Note:__ This method is implemented on Android, Linux, macOS and Windows. Returns @72@ on unsupported platforms. bindOS_get_screen_dpi :: MethodBind bindOS_get_screen_dpi = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_screen_dpi" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the dots per inch density of the specified screen. If @screen@ is @-1@ (the default value), the current screen will be used. -- On Android devices, the actual screen densities are grouped into six generalized densities: -- -- @ -- -- ldpi - 120 dpi -- mdpi - 160 dpi -- hdpi - 240 dpi -- xhdpi - 320 dpi -- xxhdpi - 480 dpi -- xxxhdpi - 640 dpi -- -- @ -- -- __Note:__ This method is implemented on Android, Linux, macOS and Windows. Returns @72@ on unsupported platforms. get_screen_dpi :: (OS :< cls, Object :< cls) => cls -> Maybe Int -> IO Int get_screen_dpi cls arg1 = withVariantArray [maybe (VariantInt (-1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_screen_dpi (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_screen_dpi" '[Maybe Int] (IO Int) where nodeMethod = Godot.Core.OS.get_screen_dpi {-# NOINLINE bindOS_get_screen_position #-} -- | Returns the position of the specified screen by index. If @screen@ is @-1@ (the default value), the current screen will be used. bindOS_get_screen_position :: MethodBind bindOS_get_screen_position = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_screen_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the specified screen by index. If @screen@ is @-1@ (the default value), the current screen will be used. get_screen_position :: (OS :< cls, Object :< cls) => cls -> Maybe Int -> IO Vector2 get_screen_position cls arg1 = withVariantArray [maybe (VariantInt (-1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_screen_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_screen_position" '[Maybe Int] (IO Vector2) where nodeMethod = Godot.Core.OS.get_screen_position {-# NOINLINE bindOS_get_screen_size #-} -- | Returns the dimensions in pixels of the specified screen. If @screen@ is @-1@ (the default value), the current screen will be used. bindOS_get_screen_size :: MethodBind bindOS_get_screen_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_screen_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the dimensions in pixels of the specified screen. If @screen@ is @-1@ (the default value), the current screen will be used. get_screen_size :: (OS :< cls, Object :< cls) => cls -> Maybe Int -> IO Vector2 get_screen_size cls arg1 = withVariantArray [maybe (VariantInt (-1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_screen_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_screen_size" '[Maybe Int] (IO Vector2) where nodeMethod = Godot.Core.OS.get_screen_size {-# NOINLINE bindOS_get_splash_tick_msec #-} -- | Returns the amount of time in milliseconds it took for the boot logo to appear. bindOS_get_splash_tick_msec :: MethodBind bindOS_get_splash_tick_msec = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_splash_tick_msec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of time in milliseconds it took for the boot logo to appear. get_splash_tick_msec :: (OS :< cls, Object :< cls) => cls -> IO Int get_splash_tick_msec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_splash_tick_msec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_splash_tick_msec" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_splash_tick_msec {-# NOINLINE bindOS_get_static_memory_peak_usage #-} -- | Returns the maximum amount of static memory used (only works in debug). bindOS_get_static_memory_peak_usage :: MethodBind bindOS_get_static_memory_peak_usage = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_static_memory_peak_usage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the maximum amount of static memory used (only works in debug). get_static_memory_peak_usage :: (OS :< cls, Object :< cls) => cls -> IO Int get_static_memory_peak_usage cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_static_memory_peak_usage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_static_memory_peak_usage" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_static_memory_peak_usage {-# NOINLINE bindOS_get_static_memory_usage #-} -- | Returns the amount of static memory being used by the program in bytes. bindOS_get_static_memory_usage :: MethodBind bindOS_get_static_memory_usage = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_static_memory_usage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of static memory being used by the program in bytes. get_static_memory_usage :: (OS :< cls, Object :< cls) => cls -> IO Int get_static_memory_usage cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_static_memory_usage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_static_memory_usage" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_static_memory_usage {-# NOINLINE bindOS_get_system_dir #-} -- | Returns the actual path to commonly used folders across different platforms. Available locations are specified in @enum SystemDir@. -- __Note:__ This method is implemented on Android, Linux, macOS and Windows. bindOS_get_system_dir :: MethodBind bindOS_get_system_dir = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_system_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the actual path to commonly used folders across different platforms. Available locations are specified in @enum SystemDir@. -- __Note:__ This method is implemented on Android, Linux, macOS and Windows. get_system_dir :: (OS :< cls, Object :< cls) => cls -> Int -> IO GodotString get_system_dir cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_system_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_system_dir" '[Int] (IO GodotString) where nodeMethod = Godot.Core.OS.get_system_dir {-# NOINLINE bindOS_get_system_time_msecs #-} -- | Returns the epoch time of the operating system in milliseconds. bindOS_get_system_time_msecs :: MethodBind bindOS_get_system_time_msecs = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_system_time_msecs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the epoch time of the operating system in milliseconds. get_system_time_msecs :: (OS :< cls, Object :< cls) => cls -> IO Int get_system_time_msecs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_system_time_msecs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_system_time_msecs" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_system_time_msecs {-# NOINLINE bindOS_get_system_time_secs #-} -- | Returns the epoch time of the operating system in seconds. bindOS_get_system_time_secs :: MethodBind bindOS_get_system_time_secs = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_system_time_secs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the epoch time of the operating system in seconds. get_system_time_secs :: (OS :< cls, Object :< cls) => cls -> IO Int get_system_time_secs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_system_time_secs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_system_time_secs" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_system_time_secs {-# NOINLINE bindOS_get_ticks_msec #-} -- | Returns the amount of time passed in milliseconds since the engine started. bindOS_get_ticks_msec :: MethodBind bindOS_get_ticks_msec = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_ticks_msec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of time passed in milliseconds since the engine started. get_ticks_msec :: (OS :< cls, Object :< cls) => cls -> IO Int get_ticks_msec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_ticks_msec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_ticks_msec" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_ticks_msec {-# NOINLINE bindOS_get_ticks_usec #-} -- | Returns the amount of time passed in microseconds since the engine started. bindOS_get_ticks_usec :: MethodBind bindOS_get_ticks_usec = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_ticks_usec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of time passed in microseconds since the engine started. get_ticks_usec :: (OS :< cls, Object :< cls) => cls -> IO Int get_ticks_usec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_ticks_usec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_ticks_usec" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_ticks_usec {-# NOINLINE bindOS_get_time #-} -- | Returns current time as a dictionary of keys: hour, minute, second. bindOS_get_time :: MethodBind bindOS_get_time = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns current time as a dictionary of keys: hour, minute, second. get_time :: (OS :< cls, Object :< cls) => cls -> Maybe Bool -> IO Dictionary get_time cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_time" '[Maybe Bool] (IO Dictionary) where nodeMethod = Godot.Core.OS.get_time {-# NOINLINE bindOS_get_time_zone_info #-} -- | Returns the current time zone as a dictionary with the keys: bias and name. bindOS_get_time_zone_info :: MethodBind bindOS_get_time_zone_info = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_time_zone_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current time zone as a dictionary with the keys: bias and name. get_time_zone_info :: (OS :< cls, Object :< cls) => cls -> IO Dictionary get_time_zone_info cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_time_zone_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_time_zone_info" '[] (IO Dictionary) where nodeMethod = Godot.Core.OS.get_time_zone_info {-# NOINLINE bindOS_get_unique_id #-} -- | Returns a string that is unique to the device. -- __Note:__ Returns an empty string on HTML5 and UWP, as this method isn't implemented on those platforms yet. bindOS_get_unique_id :: MethodBind bindOS_get_unique_id = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_unique_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a string that is unique to the device. -- __Note:__ Returns an empty string on HTML5 and UWP, as this method isn't implemented on those platforms yet. get_unique_id :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_unique_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_unique_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_unique_id" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_unique_id {-# NOINLINE bindOS_get_unix_time #-} -- | Returns the current UNIX epoch timestamp. bindOS_get_unix_time :: MethodBind bindOS_get_unix_time = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_unix_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current UNIX epoch timestamp. get_unix_time :: (OS :< cls, Object :< cls) => cls -> IO Int get_unix_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_unix_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_unix_time" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_unix_time {-# NOINLINE bindOS_get_unix_time_from_datetime #-} -- | Gets an epoch time value from a dictionary of time values. -- @datetime@ must be populated with the following keys: @year@, @month@, @day@, @hour@, @minute@, @second@. -- You can pass the output from @method get_datetime_from_unix_time@ directly into this function. Daylight Savings Time (@dst@), if present, is ignored. bindOS_get_unix_time_from_datetime :: MethodBind bindOS_get_unix_time_from_datetime = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_unix_time_from_datetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets an epoch time value from a dictionary of time values. -- @datetime@ must be populated with the following keys: @year@, @month@, @day@, @hour@, @minute@, @second@. -- You can pass the output from @method get_datetime_from_unix_time@ directly into this function. Daylight Savings Time (@dst@), if present, is ignored. get_unix_time_from_datetime :: (OS :< cls, Object :< cls) => cls -> Dictionary -> IO Int get_unix_time_from_datetime cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_unix_time_from_datetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_unix_time_from_datetime" '[Dictionary] (IO Int) where nodeMethod = Godot.Core.OS.get_unix_time_from_datetime {-# NOINLINE bindOS_get_user_data_dir #-} -- | Returns the absolute directory path where user data is written (@user://@). -- On Linux, this is @~/.local/share/godot/app_userdata/@project_name@@, or @~/.local/share/@custom_name@@ if @use_custom_user_dir@ is set. -- On macOS, this is @~/Library/Application Support/Godot/app_userdata/@project_name@@, or @~/Library/Application Support/@custom_name@@ if @use_custom_user_dir@ is set. -- On Windows, this is @%APPDATA%\Godot\app_userdata\@project_name@@, or @%APPDATA%\@custom_name@@ if @use_custom_user_dir@ is set. @%APPDATA%@ expands to @%USERPROFILE%\AppData\Roaming@. -- If the project name is empty, @user://@ falls back to @res://@. bindOS_get_user_data_dir :: MethodBind bindOS_get_user_data_dir = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_user_data_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the absolute directory path where user data is written (@user://@). -- On Linux, this is @~/.local/share/godot/app_userdata/@project_name@@, or @~/.local/share/@custom_name@@ if @use_custom_user_dir@ is set. -- On macOS, this is @~/Library/Application Support/Godot/app_userdata/@project_name@@, or @~/Library/Application Support/@custom_name@@ if @use_custom_user_dir@ is set. -- On Windows, this is @%APPDATA%\Godot\app_userdata\@project_name@@, or @%APPDATA%\@custom_name@@ if @use_custom_user_dir@ is set. @%APPDATA%@ expands to @%USERPROFILE%\AppData\Roaming@. -- If the project name is empty, @user://@ falls back to @res://@. get_user_data_dir :: (OS :< cls, Object :< cls) => cls -> IO GodotString get_user_data_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_user_data_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_user_data_dir" '[] (IO GodotString) where nodeMethod = Godot.Core.OS.get_user_data_dir {-# NOINLINE bindOS_get_video_driver_count #-} -- | Returns the number of video drivers supported on the current platform. bindOS_get_video_driver_count :: MethodBind bindOS_get_video_driver_count = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_video_driver_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of video drivers supported on the current platform. get_video_driver_count :: (OS :< cls, Object :< cls) => cls -> IO Int get_video_driver_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_video_driver_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_video_driver_count" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_video_driver_count {-# NOINLINE bindOS_get_video_driver_name #-} -- | Returns the name of the video driver matching the given @driver@ index. This index is a value from @enum VideoDriver@, and you can use @method get_current_video_driver@ to get the current backend's index. bindOS_get_video_driver_name :: MethodBind bindOS_get_video_driver_name = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_video_driver_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the video driver matching the given @driver@ index. This index is a value from @enum VideoDriver@, and you can use @method get_current_video_driver@ to get the current backend's index. get_video_driver_name :: (OS :< cls, Object :< cls) => cls -> Int -> IO GodotString get_video_driver_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_video_driver_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_video_driver_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.OS.get_video_driver_name {-# NOINLINE bindOS_get_virtual_keyboard_height #-} -- | Returns the on-screen keyboard's height in pixels. Returns 0 if there is no keyboard or if it is currently hidden. bindOS_get_virtual_keyboard_height :: MethodBind bindOS_get_virtual_keyboard_height = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_virtual_keyboard_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the on-screen keyboard's height in pixels. Returns 0 if there is no keyboard or if it is currently hidden. get_virtual_keyboard_height :: (OS :< cls, Object :< cls) => cls -> IO Int get_virtual_keyboard_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_virtual_keyboard_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_virtual_keyboard_height" '[] (IO Int) where nodeMethod = Godot.Core.OS.get_virtual_keyboard_height {-# NOINLINE bindOS_get_window_safe_area #-} -- | Returns unobscured area of the window where interactive controls should be rendered. bindOS_get_window_safe_area :: MethodBind bindOS_get_window_safe_area = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "get_window_safe_area" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns unobscured area of the window where interactive controls should be rendered. get_window_safe_area :: (OS :< cls, Object :< cls) => cls -> IO Rect2 get_window_safe_area cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_get_window_safe_area (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "get_window_safe_area" '[] (IO Rect2) where nodeMethod = Godot.Core.OS.get_window_safe_area {-# NOINLINE bindOS_global_menu_add_item #-} -- | Add a new item with text "label" to global menu. Use "_dock" menu to add item to the macOS dock icon menu. -- __Note:__ This method is implemented on macOS. bindOS_global_menu_add_item :: MethodBind bindOS_global_menu_add_item = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "global_menu_add_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Add a new item with text "label" to global menu. Use "_dock" menu to add item to the macOS dock icon menu. -- __Note:__ This method is implemented on macOS. global_menu_add_item :: (OS :< cls, Object :< cls) => cls -> GodotString -> GodotString -> GodotVariant -> GodotVariant -> IO () global_menu_add_item cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindOS_global_menu_add_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "global_menu_add_item" '[GodotString, GodotString, GodotVariant, GodotVariant] (IO ()) where nodeMethod = Godot.Core.OS.global_menu_add_item {-# NOINLINE bindOS_global_menu_add_separator #-} -- | Add a separator between items. Separators also occupy an index. -- __Note:__ This method is implemented on macOS. bindOS_global_menu_add_separator :: MethodBind bindOS_global_menu_add_separator = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "global_menu_add_separator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Add a separator between items. Separators also occupy an index. -- __Note:__ This method is implemented on macOS. global_menu_add_separator :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO () global_menu_add_separator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_global_menu_add_separator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "global_menu_add_separator" '[GodotString] (IO ()) where nodeMethod = Godot.Core.OS.global_menu_add_separator {-# NOINLINE bindOS_global_menu_clear #-} -- | Clear the global menu, in effect removing all items. -- __Note:__ This method is implemented on macOS. bindOS_global_menu_clear :: MethodBind bindOS_global_menu_clear = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "global_menu_clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear the global menu, in effect removing all items. -- __Note:__ This method is implemented on macOS. global_menu_clear :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO () global_menu_clear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_global_menu_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "global_menu_clear" '[GodotString] (IO ()) where nodeMethod = Godot.Core.OS.global_menu_clear {-# NOINLINE bindOS_global_menu_remove_item #-} -- | Removes the item at index "idx" from the global menu. Note that the indexes of items after the removed item are going to be shifted by one. -- __Note:__ This method is implemented on macOS. bindOS_global_menu_remove_item :: MethodBind bindOS_global_menu_remove_item = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "global_menu_remove_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the item at index "idx" from the global menu. Note that the indexes of items after the removed item are going to be shifted by one. -- __Note:__ This method is implemented on macOS. global_menu_remove_item :: (OS :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () global_menu_remove_item cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOS_global_menu_remove_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "global_menu_remove_item" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.OS.global_menu_remove_item {-# NOINLINE bindOS_has_environment #-} -- | Returns @true@ if an environment variable exists. bindOS_has_environment :: MethodBind bindOS_has_environment = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "has_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if an environment variable exists. has_environment :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_environment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_has_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "has_environment" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.OS.has_environment {-# NOINLINE bindOS_has_feature #-} -- | Returns @true@ if the feature for the given feature tag is supported in the currently running instance, depending on platform, build etc. Can be used to check whether you're currently running a debug build, on a certain platform or arch, etc. Refer to the @url=https://docs.godotengine.org/en/latest/getting_started/workflow/export/feature_tags.html@Feature Tags@/url@ documentation for more details. -- __Note:__ Tag names are case-sensitive. bindOS_has_feature :: MethodBind bindOS_has_feature = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "has_feature" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the feature for the given feature tag is supported in the currently running instance, depending on platform, build etc. Can be used to check whether you're currently running a debug build, on a certain platform or arch, etc. Refer to the @url=https://docs.godotengine.org/en/latest/getting_started/workflow/export/feature_tags.html@Feature Tags@/url@ documentation for more details. -- __Note:__ Tag names are case-sensitive. has_feature :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_feature cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_has_feature (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "has_feature" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.OS.has_feature {-# NOINLINE bindOS_has_touchscreen_ui_hint #-} -- | Returns @true@ if the device has a touchscreen or emulates one. bindOS_has_touchscreen_ui_hint :: MethodBind bindOS_has_touchscreen_ui_hint = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "has_touchscreen_ui_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the device has a touchscreen or emulates one. has_touchscreen_ui_hint :: (OS :< cls, Object :< cls) => cls -> IO Bool has_touchscreen_ui_hint cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_has_touchscreen_ui_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "has_touchscreen_ui_hint" '[] (IO Bool) where nodeMethod = Godot.Core.OS.has_touchscreen_ui_hint {-# NOINLINE bindOS_has_virtual_keyboard #-} -- | Returns @true@ if the platform has a virtual keyboard, @false@ otherwise. bindOS_has_virtual_keyboard :: MethodBind bindOS_has_virtual_keyboard = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "has_virtual_keyboard" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the platform has a virtual keyboard, @false@ otherwise. has_virtual_keyboard :: (OS :< cls, Object :< cls) => cls -> IO Bool has_virtual_keyboard cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_has_virtual_keyboard (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "has_virtual_keyboard" '[] (IO Bool) where nodeMethod = Godot.Core.OS.has_virtual_keyboard {-# NOINLINE bindOS_hide_virtual_keyboard #-} -- | Hides the virtual keyboard if it is shown, does nothing otherwise. bindOS_hide_virtual_keyboard :: MethodBind bindOS_hide_virtual_keyboard = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "hide_virtual_keyboard" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Hides the virtual keyboard if it is shown, does nothing otherwise. hide_virtual_keyboard :: (OS :< cls, Object :< cls) => cls -> IO () hide_virtual_keyboard cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_hide_virtual_keyboard (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "hide_virtual_keyboard" '[] (IO ()) where nodeMethod = Godot.Core.OS.hide_virtual_keyboard {-# NOINLINE bindOS_is_debug_build #-} -- | Returns @true@ if the Godot binary used to run the project is a @i@debug@/i@ export template, or when running in the editor. -- Returns @false@ if the Godot binary used to run the project is a @i@release@/i@ export template. -- To check whether the Godot binary used to run the project is an export template (debug or release), use @OS.has_feature("standalone")@ instead. bindOS_is_debug_build :: MethodBind bindOS_is_debug_build = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_debug_build" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the Godot binary used to run the project is a @i@debug@/i@ export template, or when running in the editor. -- Returns @false@ if the Godot binary used to run the project is a @i@release@/i@ export template. -- To check whether the Godot binary used to run the project is an export template (debug or release), use @OS.has_feature("standalone")@ instead. is_debug_build :: (OS :< cls, Object :< cls) => cls -> IO Bool is_debug_build cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_debug_build (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_debug_build" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_debug_build {-# NOINLINE bindOS_is_ok_left_and_cancel_right #-} -- | Returns @true@ if the __OK__ button should appear on the left and __Cancel__ on the right. bindOS_is_ok_left_and_cancel_right :: MethodBind bindOS_is_ok_left_and_cancel_right = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_ok_left_and_cancel_right" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the __OK__ button should appear on the left and __Cancel__ on the right. is_ok_left_and_cancel_right :: (OS :< cls, Object :< cls) => cls -> IO Bool is_ok_left_and_cancel_right cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_ok_left_and_cancel_right (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_ok_left_and_cancel_right" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_ok_left_and_cancel_right {-# NOINLINE bindOS_is_scancode_unicode #-} -- | Returns @true@ if the input scancode corresponds to a Unicode character. bindOS_is_scancode_unicode :: MethodBind bindOS_is_scancode_unicode = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_scancode_unicode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the input scancode corresponds to a Unicode character. is_scancode_unicode :: (OS :< cls, Object :< cls) => cls -> Int -> IO Bool is_scancode_unicode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_scancode_unicode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_scancode_unicode" '[Int] (IO Bool) where nodeMethod = Godot.Core.OS.is_scancode_unicode {-# NOINLINE bindOS_is_stdout_verbose #-} -- | Returns @true@ if the engine was executed with @-v@ (verbose stdout). bindOS_is_stdout_verbose :: MethodBind bindOS_is_stdout_verbose = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_stdout_verbose" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the engine was executed with @-v@ (verbose stdout). is_stdout_verbose :: (OS :< cls, Object :< cls) => cls -> IO Bool is_stdout_verbose cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_stdout_verbose (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_stdout_verbose" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_stdout_verbose {-# NOINLINE bindOS_is_userfs_persistent #-} -- | If @true@, the @user://@ file system is persistent, so that its state is the same after a player quits and starts the game again. Relevant to the HTML5 platform, where this persistence may be unavailable. bindOS_is_userfs_persistent :: MethodBind bindOS_is_userfs_persistent = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_userfs_persistent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @user://@ file system is persistent, so that its state is the same after a player quits and starts the game again. Relevant to the HTML5 platform, where this persistence may be unavailable. is_userfs_persistent :: (OS :< cls, Object :< cls) => cls -> IO Bool is_userfs_persistent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_userfs_persistent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_userfs_persistent" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_userfs_persistent {-# NOINLINE bindOS_is_window_always_on_top #-} -- | Returns @true@ if the window should always be on top of other windows. bindOS_is_window_always_on_top :: MethodBind bindOS_is_window_always_on_top = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_window_always_on_top" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the window should always be on top of other windows. is_window_always_on_top :: (OS :< cls, Object :< cls) => cls -> IO Bool is_window_always_on_top cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_window_always_on_top (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_window_always_on_top" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_window_always_on_top {-# NOINLINE bindOS_is_window_focused #-} -- | Returns @true@ if the window is currently focused. -- __Note:__ Only implemented on desktop platforms. On other platforms, it will always return @true@. bindOS_is_window_focused :: MethodBind bindOS_is_window_focused = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "is_window_focused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the window is currently focused. -- __Note:__ Only implemented on desktop platforms. On other platforms, it will always return @true@. is_window_focused :: (OS :< cls, Object :< cls) => cls -> IO Bool is_window_focused cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_is_window_focused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "is_window_focused" '[] (IO Bool) where nodeMethod = Godot.Core.OS.is_window_focused {-# NOINLINE bindOS_kill #-} -- | Kill (terminate) the process identified by the given process ID (@pid@), e.g. the one returned by @method execute@ in non-blocking mode. -- __Note:__ This method can also be used to kill processes that were not spawned by the game. -- __Note:__ This method is implemented on Android, iOS, Linux, macOS and Windows. bindOS_kill :: MethodBind bindOS_kill = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "kill" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Kill (terminate) the process identified by the given process ID (@pid@), e.g. the one returned by @method execute@ in non-blocking mode. -- __Note:__ This method can also be used to kill processes that were not spawned by the game. -- __Note:__ This method is implemented on Android, iOS, Linux, macOS and Windows. kill :: (OS :< cls, Object :< cls) => cls -> Int -> IO Int kill cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_kill (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "kill" '[Int] (IO Int) where nodeMethod = Godot.Core.OS.kill {-# NOINLINE bindOS_move_window_to_foreground #-} -- | Moves the window to the front. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_move_window_to_foreground :: MethodBind bindOS_move_window_to_foreground = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "move_window_to_foreground" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the window to the front. -- __Note:__ This method is implemented on Linux, macOS and Windows. move_window_to_foreground :: (OS :< cls, Object :< cls) => cls -> IO () move_window_to_foreground cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_move_window_to_foreground (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "move_window_to_foreground" '[] (IO ()) where nodeMethod = Godot.Core.OS.move_window_to_foreground {-# NOINLINE bindOS_native_video_is_playing #-} -- | Returns @true@ if native video is playing. -- __Note:__ This method is implemented on Android and iOS. bindOS_native_video_is_playing :: MethodBind bindOS_native_video_is_playing = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "native_video_is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if native video is playing. -- __Note:__ This method is implemented on Android and iOS. native_video_is_playing :: (OS :< cls, Object :< cls) => cls -> IO Bool native_video_is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_native_video_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "native_video_is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.OS.native_video_is_playing {-# NOINLINE bindOS_native_video_pause #-} -- | Pauses native video playback. -- __Note:__ This method is implemented on Android and iOS. bindOS_native_video_pause :: MethodBind bindOS_native_video_pause = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "native_video_pause" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pauses native video playback. -- __Note:__ This method is implemented on Android and iOS. native_video_pause :: (OS :< cls, Object :< cls) => cls -> IO () native_video_pause cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_native_video_pause (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "native_video_pause" '[] (IO ()) where nodeMethod = Godot.Core.OS.native_video_pause {-# NOINLINE bindOS_native_video_play #-} -- | Plays native video from the specified path, at the given volume and with audio and subtitle tracks. -- __Note:__ This method is implemented on Android and iOS, and the current Android implementation does not support the @volume@, @audio_track@ and @subtitle_track@ options. bindOS_native_video_play :: MethodBind bindOS_native_video_play = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "native_video_play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Plays native video from the specified path, at the given volume and with audio and subtitle tracks. -- __Note:__ This method is implemented on Android and iOS, and the current Android implementation does not support the @volume@, @audio_track@ and @subtitle_track@ options. native_video_play :: (OS :< cls, Object :< cls) => cls -> GodotString -> Float -> GodotString -> GodotString -> IO Int native_video_play cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindOS_native_video_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "native_video_play" '[GodotString, Float, GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.OS.native_video_play {-# NOINLINE bindOS_native_video_stop #-} -- | Stops native video playback. -- __Note:__ This method is implemented on Android and iOS. bindOS_native_video_stop :: MethodBind bindOS_native_video_stop = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "native_video_stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops native video playback. -- __Note:__ This method is implemented on Android and iOS. native_video_stop :: (OS :< cls, Object :< cls) => cls -> IO () native_video_stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_native_video_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "native_video_stop" '[] (IO ()) where nodeMethod = Godot.Core.OS.native_video_stop {-# NOINLINE bindOS_native_video_unpause #-} -- | Resumes native video playback. -- __Note:__ This method is implemented on Android and iOS. bindOS_native_video_unpause :: MethodBind bindOS_native_video_unpause = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "native_video_unpause" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resumes native video playback. -- __Note:__ This method is implemented on Android and iOS. native_video_unpause :: (OS :< cls, Object :< cls) => cls -> IO () native_video_unpause cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_native_video_unpause (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "native_video_unpause" '[] (IO ()) where nodeMethod = Godot.Core.OS.native_video_unpause {-# NOINLINE bindOS_open_midi_inputs #-} -- | Initialises the singleton for the system MIDI driver. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_open_midi_inputs :: MethodBind bindOS_open_midi_inputs = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "open_midi_inputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Initialises the singleton for the system MIDI driver. -- __Note:__ This method is implemented on Linux, macOS and Windows. open_midi_inputs :: (OS :< cls, Object :< cls) => cls -> IO () open_midi_inputs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_open_midi_inputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "open_midi_inputs" '[] (IO ()) where nodeMethod = Godot.Core.OS.open_midi_inputs {-# NOINLINE bindOS_print_all_resources #-} -- | Shows all resources in the game. Optionally, the list can be written to a file by specifying a file path in @tofile@. bindOS_print_all_resources :: MethodBind bindOS_print_all_resources = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "print_all_resources" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shows all resources in the game. Optionally, the list can be written to a file by specifying a file path in @tofile@. print_all_resources :: (OS :< cls, Object :< cls) => cls -> Maybe GodotString -> IO () print_all_resources cls arg1 = withVariantArray [defaultedVariant VariantString "" arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_print_all_resources (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "print_all_resources" '[Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.OS.print_all_resources {-# NOINLINE bindOS_print_all_textures_by_size #-} -- | Shows the list of loaded textures sorted by size in memory. bindOS_print_all_textures_by_size :: MethodBind bindOS_print_all_textures_by_size = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "print_all_textures_by_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shows the list of loaded textures sorted by size in memory. print_all_textures_by_size :: (OS :< cls, Object :< cls) => cls -> IO () print_all_textures_by_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_print_all_textures_by_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "print_all_textures_by_size" '[] (IO ()) where nodeMethod = Godot.Core.OS.print_all_textures_by_size {-# NOINLINE bindOS_print_resources_by_type #-} -- | Shows the number of resources loaded by the game of the given types. bindOS_print_resources_by_type :: MethodBind bindOS_print_resources_by_type = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "print_resources_by_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shows the number of resources loaded by the game of the given types. print_resources_by_type :: (OS :< cls, Object :< cls) => cls -> PoolStringArray -> IO () print_resources_by_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_print_resources_by_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "print_resources_by_type" '[PoolStringArray] (IO ()) where nodeMethod = Godot.Core.OS.print_resources_by_type {-# NOINLINE bindOS_print_resources_in_use #-} -- | Shows all resources currently used by the game. bindOS_print_resources_in_use :: MethodBind bindOS_print_resources_in_use = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "print_resources_in_use" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shows all resources currently used by the game. print_resources_in_use :: (OS :< cls, Object :< cls) => cls -> Maybe Bool -> IO () print_resources_in_use cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_print_resources_in_use (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "print_resources_in_use" '[Maybe Bool] (IO ()) where nodeMethod = Godot.Core.OS.print_resources_in_use {-# NOINLINE bindOS_request_attention #-} -- | Request the user attention to the window. It'll flash the taskbar button on Windows or bounce the dock icon on OSX. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_request_attention :: MethodBind bindOS_request_attention = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "request_attention" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Request the user attention to the window. It'll flash the taskbar button on Windows or bounce the dock icon on OSX. -- __Note:__ This method is implemented on Linux, macOS and Windows. request_attention :: (OS :< cls, Object :< cls) => cls -> IO () request_attention cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_request_attention (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "request_attention" '[] (IO ()) where nodeMethod = Godot.Core.OS.request_attention {-# NOINLINE bindOS_request_permission #-} -- | At the moment this function is only used by @AudioDriverOpenSL@ to request permission for @RECORD_AUDIO@ on Android. bindOS_request_permission :: MethodBind bindOS_request_permission = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "request_permission" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | At the moment this function is only used by @AudioDriverOpenSL@ to request permission for @RECORD_AUDIO@ on Android. request_permission :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO Bool request_permission cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_request_permission (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "request_permission" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.OS.request_permission {-# NOINLINE bindOS_request_permissions #-} -- | With this function you can request dangerous permissions since normal permissions are automatically granted at install time in Android application. -- __Note:__ This method is implemented on Android. bindOS_request_permissions :: MethodBind bindOS_request_permissions = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "request_permissions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | With this function you can request dangerous permissions since normal permissions are automatically granted at install time in Android application. -- __Note:__ This method is implemented on Android. request_permissions :: (OS :< cls, Object :< cls) => cls -> IO Bool request_permissions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOS_request_permissions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "request_permissions" '[] (IO Bool) where nodeMethod = Godot.Core.OS.request_permissions {-# NOINLINE bindOS_set_icon #-} -- | Sets the game's icon using an @Image@ resource. -- The same image is used for window caption, taskbar/dock and window selection dialog. Image is scaled as needed. -- __Note:__ This method is implemented on HTML5, Linux, macOS and Windows. bindOS_set_icon :: MethodBind bindOS_set_icon = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the game's icon using an @Image@ resource. -- The same image is used for window caption, taskbar/dock and window selection dialog. Image is scaled as needed. -- __Note:__ This method is implemented on HTML5, Linux, macOS and Windows. set_icon :: (OS :< cls, Object :< cls) => cls -> Image -> IO () set_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_icon" '[Image] (IO ()) where nodeMethod = Godot.Core.OS.set_icon {-# NOINLINE bindOS_set_ime_active #-} -- | Sets whether IME input mode should be enabled. -- If active IME handles key events before the application and creates an composition string and suggestion list. -- Application can retrieve the composition status by using @method get_ime_selection@ and @method get_ime_text@ functions. -- Completed composition string is committed when input is finished. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_set_ime_active :: MethodBind bindOS_set_ime_active = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_ime_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether IME input mode should be enabled. -- If active IME handles key events before the application and creates an composition string and suggestion list. -- Application can retrieve the composition status by using @method get_ime_selection@ and @method get_ime_text@ functions. -- Completed composition string is committed when input is finished. -- __Note:__ This method is implemented on Linux, macOS and Windows. set_ime_active :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_ime_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_ime_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_ime_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_ime_active {-# NOINLINE bindOS_set_ime_position #-} -- | Sets position of IME suggestion list popup (in window coordinates). -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_set_ime_position :: MethodBind bindOS_set_ime_position = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_ime_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets position of IME suggestion list popup (in window coordinates). -- __Note:__ This method is implemented on Linux, macOS and Windows. set_ime_position :: (OS :< cls, Object :< cls) => cls -> Vector2 -> IO () set_ime_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_ime_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_ime_position" '[Vector2] (IO ()) where nodeMethod = Godot.Core.OS.set_ime_position {-# NOINLINE bindOS_set_native_icon #-} -- | Sets the game's icon using a multi-size platform-specific icon file (@*.ico@ on Windows and @*.icns@ on macOS). -- Appropriate size sub-icons are used for window caption, taskbar/dock and window selection dialog. -- __Note:__ This method is implemented on macOS and Windows. bindOS_set_native_icon :: MethodBind bindOS_set_native_icon = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_native_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the game's icon using a multi-size platform-specific icon file (@*.ico@ on Windows and @*.icns@ on macOS). -- Appropriate size sub-icons are used for window caption, taskbar/dock and window selection dialog. -- __Note:__ This method is implemented on macOS and Windows. set_native_icon :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO () set_native_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_native_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_native_icon" '[GodotString] (IO ()) where nodeMethod = Godot.Core.OS.set_native_icon {-# NOINLINE bindOS_set_thread_name #-} -- | Sets the name of the current thread. bindOS_set_thread_name :: MethodBind bindOS_set_thread_name = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_thread_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the name of the current thread. set_thread_name :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO Int set_thread_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_thread_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_thread_name" '[GodotString] (IO Int) where nodeMethod = Godot.Core.OS.set_thread_name {-# NOINLINE bindOS_set_use_file_access_save_and_swap #-} -- | Enables backup saves if @enabled@ is @true@. bindOS_set_use_file_access_save_and_swap :: MethodBind bindOS_set_use_file_access_save_and_swap = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_use_file_access_save_and_swap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables backup saves if @enabled@ is @true@. set_use_file_access_save_and_swap :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_use_file_access_save_and_swap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_use_file_access_save_and_swap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_use_file_access_save_and_swap" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_use_file_access_save_and_swap {-# NOINLINE bindOS_set_window_always_on_top #-} -- | Sets whether the window should always be on top. -- __Note:__ This method is implemented on Linux, macOS and Windows. bindOS_set_window_always_on_top :: MethodBind bindOS_set_window_always_on_top = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_always_on_top" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the window should always be on top. -- __Note:__ This method is implemented on Linux, macOS and Windows. set_window_always_on_top :: (OS :< cls, Object :< cls) => cls -> Bool -> IO () set_window_always_on_top cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_always_on_top (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_always_on_top" '[Bool] (IO ()) where nodeMethod = Godot.Core.OS.set_window_always_on_top {-# NOINLINE bindOS_set_window_title #-} -- | Sets the window title to the specified string. -- __Note:__ This should be used sporadically. Don't set this every frame, as that will negatively affect performance on some window managers. -- __Note:__ This method is implemented on HTML5, Linux, macOS and Windows. bindOS_set_window_title :: MethodBind bindOS_set_window_title = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "set_window_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the window title to the specified string. -- __Note:__ This should be used sporadically. Don't set this every frame, as that will negatively affect performance on some window managers. -- __Note:__ This method is implemented on HTML5, Linux, macOS and Windows. set_window_title :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO () set_window_title cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_set_window_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "set_window_title" '[GodotString] (IO ()) where nodeMethod = Godot.Core.OS.set_window_title {-# NOINLINE bindOS_shell_open #-} -- | Requests the OS to open a resource with the most appropriate program. For example: -- - @OS.shell_open("C:\\Users\name\Downloads")@ on Windows opens the file explorer at the user's Downloads folder. -- - @OS.shell_open("https://godotengine.org")@ opens the default web browser on the official Godot website. -- - @OS.shell_open("mailto:example@example.com")@ opens the default email client with the "To" field set to @example@example.com@. See @url=https://blog.escapecreative.com/customizing-mailto-links/@Customizing @mailto:@ Links@/url@ for a list of fields that can be added. -- Use @method ProjectSettings.globalize_path@ to convert a @res://@ or @user://@ path into a system path for use with this method. -- __Note:__ This method is implemented on Android, iOS, HTML5, Linux, macOS and Windows. bindOS_shell_open :: MethodBind bindOS_shell_open = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "shell_open" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Requests the OS to open a resource with the most appropriate program. For example: -- - @OS.shell_open("C:\\Users\name\Downloads")@ on Windows opens the file explorer at the user's Downloads folder. -- - @OS.shell_open("https://godotengine.org")@ opens the default web browser on the official Godot website. -- - @OS.shell_open("mailto:example@example.com")@ opens the default email client with the "To" field set to @example@example.com@. See @url=https://blog.escapecreative.com/customizing-mailto-links/@Customizing @mailto:@ Links@/url@ for a list of fields that can be added. -- Use @method ProjectSettings.globalize_path@ to convert a @res://@ or @user://@ path into a system path for use with this method. -- __Note:__ This method is implemented on Android, iOS, HTML5, Linux, macOS and Windows. shell_open :: (OS :< cls, Object :< cls) => cls -> GodotString -> IO Int shell_open cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_shell_open (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "shell_open" '[GodotString] (IO Int) where nodeMethod = Godot.Core.OS.shell_open {-# NOINLINE bindOS_show_virtual_keyboard #-} -- | Shows the virtual keyboard if the platform has one. -- The @existing_text@ parameter is useful for implementing your own @LineEdit@ or @TextEdit@, as it tells the virtual keyboard what text has already been typed (the virtual keyboard uses it for auto-correct and predictions). -- The @multiline@ parameter needs to be set to @true@ to be able to enter multiple lines of text, as in @TextEdit@. -- __Note:__ This method is implemented on Android, iOS and UWP. bindOS_show_virtual_keyboard :: MethodBind bindOS_show_virtual_keyboard = unsafePerformIO $ withCString "_OS" $ \ clsNamePtr -> withCString "show_virtual_keyboard" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shows the virtual keyboard if the platform has one. -- The @existing_text@ parameter is useful for implementing your own @LineEdit@ or @TextEdit@, as it tells the virtual keyboard what text has already been typed (the virtual keyboard uses it for auto-correct and predictions). -- The @multiline@ parameter needs to be set to @true@ to be able to enter multiple lines of text, as in @TextEdit@. -- __Note:__ This method is implemented on Android, iOS and UWP. show_virtual_keyboard :: (OS :< cls, Object :< cls) => cls -> Maybe GodotString -> IO () show_virtual_keyboard cls arg1 = withVariantArray [defaultedVariant VariantString "" arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOS_show_virtual_keyboard (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OS "show_virtual_keyboard" '[Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.OS.show_virtual_keyboard ================================================ FILE: src/Godot/Core/Object.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Object (Godot.Core.Object._CONNECT_REFERENCE_COUNTED, Godot.Core.Object._CONNECT_DEFERRED, Godot.Core.Object._NOTIFICATION_POSTINITIALIZE, Godot.Core.Object._CONNECT_ONESHOT, Godot.Core.Object._CONNECT_PERSIST, Godot.Core.Object._NOTIFICATION_PREDELETE, Godot.Core.Object.sig_script_changed, Godot.Core.Object._get, Godot.Core.Object._get_property_list, Godot.Core.Object._init, Godot.Core.Object._notification, Godot.Core.Object._set, Godot.Core.Object._to_string, Godot.Core.Object.add_user_signal, Godot.Core.Object.call, Godot.Core.Object.call_deferred, Godot.Core.Object.callv, Godot.Core.Object.can_translate_messages, Godot.Core.Object.connect, Godot.Core.Object.disconnect, Godot.Core.Object.emit_signal, Godot.Core.Object.free, Godot.Core.Object.get, Godot.Core.Object.get_class, Godot.Core.Object.get_incoming_connections, Godot.Core.Object.get_indexed, Godot.Core.Object.get_instance_id, Godot.Core.Object.get_meta, Godot.Core.Object.get_meta_list, Godot.Core.Object.get_method_list, Godot.Core.Object.get_property_list, Godot.Core.Object.get_script, Godot.Core.Object.get_signal_connection_list, Godot.Core.Object.get_signal_list, Godot.Core.Object.has_meta, Godot.Core.Object.has_method, Godot.Core.Object.has_user_signal, Godot.Core.Object.is_blocking_signals, Godot.Core.Object.is_class, Godot.Core.Object.is_connected, Godot.Core.Object.is_queued_for_deletion, Godot.Core.Object.notification, Godot.Core.Object.property_list_changed_notify, Godot.Core.Object.remove_meta, Godot.Core.Object.set, Godot.Core.Object.set_block_signals, Godot.Core.Object.set_deferred, Godot.Core.Object.set_indexed, Godot.Core.Object.set_message_translation, Godot.Core.Object.set_meta, Godot.Core.Object.set_script, Godot.Core.Object.to_string, Godot.Core.Object.tr) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types _CONNECT_REFERENCE_COUNTED :: Int _CONNECT_REFERENCE_COUNTED = 8 _CONNECT_DEFERRED :: Int _CONNECT_DEFERRED = 1 _NOTIFICATION_POSTINITIALIZE :: Int _NOTIFICATION_POSTINITIALIZE = 0 _CONNECT_ONESHOT :: Int _CONNECT_ONESHOT = 4 _CONNECT_PERSIST :: Int _CONNECT_PERSIST = 2 _NOTIFICATION_PREDELETE :: Int _NOTIFICATION_PREDELETE = 1 -- | Emitted whenever the object's script is changed. sig_script_changed :: Godot.Internal.Dispatch.Signal Object sig_script_changed = Godot.Internal.Dispatch.Signal "script_changed" instance NodeSignal Object "script_changed" '[] {-# NOINLINE bindObject__get #-} -- | Virtual method which can be overridden to customize the return value of @method get@. -- Returns the given property. Returns @null@ if the @property@ does not exist. bindObject__get :: MethodBind bindObject__get = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "_get" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method which can be overridden to customize the return value of @method get@. -- Returns the given property. Returns @null@ if the @property@ does not exist. _get :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant _get cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject__get (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "_get" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.Object._get {-# NOINLINE bindObject__get_property_list #-} -- | Virtual method which can be overridden to customize the return value of @method get_property_list@. -- Returns the object's property list as an @Array@ of dictionaries. -- Each property's @Dictionary@ must contain at least @name: String@ and @type: int@ (see @enum Variant.Type@) entries. Optionally, it can also include @hint: int@ (see @enum PropertyHint@), @hint_string: String@, and @usage: int@ (see @enum PropertyUsageFlags@). bindObject__get_property_list :: MethodBind bindObject__get_property_list = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "_get_property_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method which can be overridden to customize the return value of @method get_property_list@. -- Returns the object's property list as an @Array@ of dictionaries. -- Each property's @Dictionary@ must contain at least @name: String@ and @type: int@ (see @enum Variant.Type@) entries. Optionally, it can also include @hint: int@ (see @enum PropertyHint@), @hint_string: String@, and @usage: int@ (see @enum PropertyUsageFlags@). _get_property_list :: (Object :< cls, Object :< cls) => cls -> IO Array _get_property_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject__get_property_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "_get_property_list" '[] (IO Array) where nodeMethod = Godot.Core.Object._get_property_list {-# NOINLINE bindObject__init #-} -- | Called when the object is initialized. bindObject__init :: MethodBind bindObject__init = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "_init" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when the object is initialized. _init :: (Object :< cls, Object :< cls) => cls -> IO () _init cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject__init (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "_init" '[] (IO ()) where nodeMethod = Godot.Core.Object._init {-# NOINLINE bindObject__notification #-} -- | Called whenever the object receives a notification, which is identified in @what@ by a constant. The base @Object@ has two constants @NOTIFICATION_POSTINITIALIZE@ and @NOTIFICATION_PREDELETE@, but subclasses such as @Node@ define a lot more notifications which are also received by this method. bindObject__notification :: MethodBind bindObject__notification = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "_notification" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called whenever the object receives a notification, which is identified in @what@ by a constant. The base @Object@ has two constants @NOTIFICATION_POSTINITIALIZE@ and @NOTIFICATION_PREDELETE@, but subclasses such as @Node@ define a lot more notifications which are also received by this method. _notification :: (Object :< cls, Object :< cls) => cls -> Int -> IO () _notification cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject__notification (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "_notification" '[Int] (IO ()) where nodeMethod = Godot.Core.Object._notification {-# NOINLINE bindObject__set #-} -- | Virtual method which can be overridden to customize the return value of @method set@. -- Sets a property. Returns @true@ if the @property@ exists. bindObject__set :: MethodBind bindObject__set = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "_set" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method which can be overridden to customize the return value of @method set@. -- Sets a property. Returns @true@ if the @property@ exists. _set :: (Object :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO Bool _set cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindObject__set (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "_set" '[GodotString, GodotVariant] (IO Bool) where nodeMethod = Godot.Core.Object._set {-# NOINLINE bindObject__to_string #-} -- | Virtual method which can be overridden to customize the return value of @method to_string@, and thus the object's representation where it is converted to a string, e.g. with @print(obj)@. -- Returns a @String@ representing the object. If not overridden, defaults to @"@ClassName:RID@"@. bindObject__to_string :: MethodBind bindObject__to_string = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "_to_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method which can be overridden to customize the return value of @method to_string@, and thus the object's representation where it is converted to a string, e.g. with @print(obj)@. -- Returns a @String@ representing the object. If not overridden, defaults to @"@ClassName:RID@"@. _to_string :: (Object :< cls, Object :< cls) => cls -> IO GodotString _to_string cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject__to_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "_to_string" '[] (IO GodotString) where nodeMethod = Godot.Core.Object._to_string {-# NOINLINE bindObject_add_user_signal #-} -- | Adds a user-defined @signal@. Arguments are optional, but can be added as an @Array@ of dictionaries, each containing @name: String@ and @type: int@ (see @enum Variant.Type@) entries. bindObject_add_user_signal :: MethodBind bindObject_add_user_signal = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "add_user_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a user-defined @signal@. Arguments are optional, but can be added as an @Array@ of dictionaries, each containing @name: String@ and @type: int@ (see @enum Variant.Type@) entries. add_user_signal :: (Object :< cls, Object :< cls) => cls -> GodotString -> Maybe Array -> IO () add_user_signal cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantArray V.empty arg2] (\ (arrPtr, len) -> godot_method_bind_call bindObject_add_user_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "add_user_signal" '[GodotString, Maybe Array] (IO ()) where nodeMethod = Godot.Core.Object.add_user_signal {-# NOINLINE bindObject_call #-} -- | Calls the @method@ on the object and returns the result. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example: -- -- @ -- -- call("set", "position", Vector2(42.0, 0.0)) -- -- @ -- -- __Note:__ In C#, the method name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined methods where you should use the same convention as in the C# source (typically PascalCase). bindObject_call :: MethodBind bindObject_call = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "call" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the @method@ on the object and returns the result. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example: -- -- @ -- -- call("set", "position", Vector2(42.0, 0.0)) -- -- @ -- -- __Note:__ In C#, the method name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined methods where you should use the same convention as in the C# source (typically PascalCase). call :: (Object :< cls, Object :< cls) => cls -> GodotString -> [Variant 'GodotTy] -> IO GodotVariant call cls arg1 varargs = withVariantArray ([toVariant arg1] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindObject_call (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "call" '[GodotString, [Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.Object.call {-# NOINLINE bindObject_call_deferred #-} -- | Calls the @method@ on the object during idle time. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example: -- -- @ -- -- call_deferred("set", "position", Vector2(42.0, 0.0)) -- -- @ -- -- __Note:__ In C#, the method name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined methods where you should use the same convention as in the C# source (typically PascalCase). bindObject_call_deferred :: MethodBind bindObject_call_deferred = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "call_deferred" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the @method@ on the object during idle time. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example: -- -- @ -- -- call_deferred("set", "position", Vector2(42.0, 0.0)) -- -- @ -- -- __Note:__ In C#, the method name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined methods where you should use the same convention as in the C# source (typically PascalCase). call_deferred :: (Object :< cls, Object :< cls) => cls -> GodotString -> [Variant 'GodotTy] -> IO () call_deferred cls arg1 varargs = withVariantArray ([toVariant arg1] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindObject_call_deferred (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "call_deferred" '[GodotString, [Variant 'GodotTy]] (IO ()) where nodeMethod = Godot.Core.Object.call_deferred {-# NOINLINE bindObject_callv #-} -- | Calls the @method@ on the object and returns the result. Contrarily to @method call@, this method does not support a variable number of arguments but expects all parameters to be via a single @Array@. -- -- @ -- -- callv("set", @ "position", Vector2(42.0, 0.0) @) -- -- @ bindObject_callv :: MethodBind bindObject_callv = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "callv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the @method@ on the object and returns the result. Contrarily to @method call@, this method does not support a variable number of arguments but expects all parameters to be via a single @Array@. -- -- @ -- -- callv("set", @ "position", Vector2(42.0, 0.0) @) -- -- @ callv :: (Object :< cls, Object :< cls) => cls -> GodotString -> Array -> IO GodotVariant callv cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindObject_callv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "callv" '[GodotString, Array] (IO GodotVariant) where nodeMethod = Godot.Core.Object.callv {-# NOINLINE bindObject_can_translate_messages #-} -- | Returns @true@ if the object can translate strings. See @method set_message_translation@ and @method tr@. bindObject_can_translate_messages :: MethodBind bindObject_can_translate_messages = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "can_translate_messages" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the object can translate strings. See @method set_message_translation@ and @method tr@. can_translate_messages :: (Object :< cls, Object :< cls) => cls -> IO Bool can_translate_messages cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_can_translate_messages (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "can_translate_messages" '[] (IO Bool) where nodeMethod = Godot.Core.Object.can_translate_messages {-# NOINLINE bindObject_connect #-} -- | Connects a @signal@ to a @method@ on a @target@ object. Pass optional @binds@ to the call as an @Array@ of parameters. These parameters will be passed to the method after any parameter used in the call to @method emit_signal@. Use @flags@ to set deferred or one-shot connections. See @enum ConnectFlags@ constants. -- A @signal@ can only be connected once to a @method@. It will throw an error if already connected, unless the signal was connected with @CONNECT_REFERENCE_COUNTED@. To avoid this, first, use @method is_connected@ to check for existing connections. -- If the @target@ is destroyed in the game's lifecycle, the connection will be lost. -- Examples: -- -- @ -- -- connect("pressed", self, "_on_Button_pressed") # BaseButton signal -- connect("text_entered", self, "_on_LineEdit_text_entered") # LineEdit signal -- connect("hit", self, "_on_Player_hit", @ weapon_type, damage @) # User-defined signal -- -- @ -- -- An example of the relationship between @binds@ passed to @method connect@ and parameters used when calling @method emit_signal@: -- -- @ -- -- connect("hit", self, "_on_Player_hit", @ weapon_type, damage @) # weapon_type and damage are passed last -- emit_signal("hit", "Dark lord", 5) # "Dark lord" and 5 are passed first -- func _on_Player_hit(hit_by, level, weapon_type, damage): -- print("Hit by %s (lvl %d) with weapon %s for %d damage" % @hit_by, level, weapon_type, damage@) -- -- @ bindObject_connect :: MethodBind bindObject_connect = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "connect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects a @signal@ to a @method@ on a @target@ object. Pass optional @binds@ to the call as an @Array@ of parameters. These parameters will be passed to the method after any parameter used in the call to @method emit_signal@. Use @flags@ to set deferred or one-shot connections. See @enum ConnectFlags@ constants. -- A @signal@ can only be connected once to a @method@. It will throw an error if already connected, unless the signal was connected with @CONNECT_REFERENCE_COUNTED@. To avoid this, first, use @method is_connected@ to check for existing connections. -- If the @target@ is destroyed in the game's lifecycle, the connection will be lost. -- Examples: -- -- @ -- -- connect("pressed", self, "_on_Button_pressed") # BaseButton signal -- connect("text_entered", self, "_on_LineEdit_text_entered") # LineEdit signal -- connect("hit", self, "_on_Player_hit", @ weapon_type, damage @) # User-defined signal -- -- @ -- -- An example of the relationship between @binds@ passed to @method connect@ and parameters used when calling @method emit_signal@: -- -- @ -- -- connect("hit", self, "_on_Player_hit", @ weapon_type, damage @) # weapon_type and damage are passed last -- emit_signal("hit", "Dark lord", 5) # "Dark lord" and 5 are passed first -- func _on_Player_hit(hit_by, level, weapon_type, damage): -- print("Hit by %s (lvl %d) with weapon %s for %d damage" % @hit_by, level, weapon_type, damage@) -- -- @ connect :: (Object :< cls, Object :< cls) => cls -> GodotString -> Object -> GodotString -> Maybe Array -> Maybe Int -> IO Int connect cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantArray V.empty arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindObject_connect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "connect" '[GodotString, Object, GodotString, Maybe Array, Maybe Int] (IO Int) where nodeMethod = Godot.Core.Object.connect {-# NOINLINE bindObject_disconnect #-} -- | Disconnects a @signal@ from a @method@ on the given @target@. -- If you try to disconnect a connection that does not exist, the method will throw an error. Use @method is_connected@ to ensure that the connection exists. bindObject_disconnect :: MethodBind bindObject_disconnect = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "disconnect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disconnects a @signal@ from a @method@ on the given @target@. -- If you try to disconnect a connection that does not exist, the method will throw an error. Use @method is_connected@ to ensure that the connection exists. disconnect :: (Object :< cls, Object :< cls) => cls -> GodotString -> Object -> GodotString -> IO () disconnect cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindObject_disconnect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "disconnect" '[GodotString, Object, GodotString] (IO ()) where nodeMethod = Godot.Core.Object.disconnect {-# NOINLINE bindObject_emit_signal #-} -- | Emits the given @signal@. The signal must exist, so it should be a built-in signal of this class or one of its parent classes, or a user-defined signal. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example: -- -- @ -- -- emit_signal("hit", weapon_type, damage) -- emit_signal("game_over") -- -- @ bindObject_emit_signal :: MethodBind bindObject_emit_signal = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "emit_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emits the given @signal@. The signal must exist, so it should be a built-in signal of this class or one of its parent classes, or a user-defined signal. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example: -- -- @ -- -- emit_signal("hit", weapon_type, damage) -- emit_signal("game_over") -- -- @ emit_signal :: (Object :< cls, Object :< cls) => cls -> GodotString -> [Variant 'GodotTy] -> IO () emit_signal cls arg1 varargs = withVariantArray ([toVariant arg1] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindObject_emit_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "emit_signal" '[GodotString, [Variant 'GodotTy]] (IO ()) where nodeMethod = Godot.Core.Object.emit_signal {-# NOINLINE bindObject_free #-} -- | Deletes the object from memory. Any pre-existing reference to the freed object will become invalid, e.g. @is_instance_valid(object)@ will return @false@. bindObject_free :: MethodBind bindObject_free = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "free" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deletes the object from memory. Any pre-existing reference to the freed object will become invalid, e.g. @is_instance_valid(object)@ will return @false@. free :: (Object :< cls, Object :< cls) => cls -> IO () free cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_free (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "free" '[] (IO ()) where nodeMethod = Godot.Core.Object.free {-# NOINLINE bindObject_get #-} -- | Returns the @Variant@ value of the given @property@. If the @property@ doesn't exist, this will return @null@. -- __Note:__ In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase). bindObject_get :: MethodBind bindObject_get = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Variant@ value of the given @property@. If the @property@ doesn't exist, this will return @null@. -- __Note:__ In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase). get :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.Object.get {-# NOINLINE bindObject_get_class #-} -- | Returns the object's class as a @String@. bindObject_get_class :: MethodBind bindObject_get_class = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_class" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's class as a @String@. get_class :: (Object :< cls, Object :< cls) => cls -> IO GodotString get_class cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_class (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_class" '[] (IO GodotString) where nodeMethod = Godot.Core.Object.get_class {-# NOINLINE bindObject_get_incoming_connections #-} -- | Returns an @Array@ of dictionaries with information about signals that are connected to the object. -- Each @Dictionary@ contains three String entries: -- - @source@ is a reference to the signal emitter. -- - @signal_name@ is the name of the connected signal. -- - @method_name@ is the name of the method to which the signal is connected. bindObject_get_incoming_connections :: MethodBind bindObject_get_incoming_connections = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_incoming_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ of dictionaries with information about signals that are connected to the object. -- Each @Dictionary@ contains three String entries: -- - @source@ is a reference to the signal emitter. -- - @signal_name@ is the name of the connected signal. -- - @method_name@ is the name of the method to which the signal is connected. get_incoming_connections :: (Object :< cls, Object :< cls) => cls -> IO Array get_incoming_connections cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_incoming_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_incoming_connections" '[] (IO Array) where nodeMethod = Godot.Core.Object.get_incoming_connections {-# NOINLINE bindObject_get_indexed #-} -- | Gets the object's property indexed by the given @NodePath@. The node path should be relative to the current object and can use the colon character (@:@) to access nested properties. Examples: @"position:x"@ or @"material:next_pass:blend_mode"@. bindObject_get_indexed :: MethodBind bindObject_get_indexed = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_indexed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the object's property indexed by the given @NodePath@. The node path should be relative to the current object and can use the colon character (@:@) to access nested properties. Examples: @"position:x"@ or @"material:next_pass:blend_mode"@. get_indexed :: (Object :< cls, Object :< cls) => cls -> NodePath -> IO GodotVariant get_indexed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_indexed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_indexed" '[NodePath] (IO GodotVariant) where nodeMethod = Godot.Core.Object.get_indexed {-# NOINLINE bindObject_get_instance_id #-} -- | Returns the object's unique instance ID. -- This ID can be saved in @EncodedObjectAsID@, and can be used to retrieve the object instance with @method @GDScript.instance_from_id@. bindObject_get_instance_id :: MethodBind bindObject_get_instance_id = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's unique instance ID. -- This ID can be saved in @EncodedObjectAsID@, and can be used to retrieve the object instance with @method @GDScript.instance_from_id@. get_instance_id :: (Object :< cls, Object :< cls) => cls -> IO Int get_instance_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_instance_id" '[] (IO Int) where nodeMethod = Godot.Core.Object.get_instance_id {-# NOINLINE bindObject_get_meta #-} -- | Returns the object's metadata entry for the given @name@. bindObject_get_meta :: MethodBind bindObject_get_meta = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's metadata entry for the given @name@. get_meta :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get_meta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_meta" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.Object.get_meta {-# NOINLINE bindObject_get_meta_list #-} -- | Returns the object's metadata as a @PoolStringArray@. bindObject_get_meta_list :: MethodBind bindObject_get_meta_list = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_meta_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's metadata as a @PoolStringArray@. get_meta_list :: (Object :< cls, Object :< cls) => cls -> IO PoolStringArray get_meta_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_meta_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_meta_list" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.Object.get_meta_list {-# NOINLINE bindObject_get_method_list #-} -- | Returns the object's methods and their signatures as an @Array@. bindObject_get_method_list :: MethodBind bindObject_get_method_list = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_method_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's methods and their signatures as an @Array@. get_method_list :: (Object :< cls, Object :< cls) => cls -> IO Array get_method_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_method_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_method_list" '[] (IO Array) where nodeMethod = Godot.Core.Object.get_method_list {-# NOINLINE bindObject_get_property_list #-} -- | Returns the object's property list as an @Array@ of dictionaries. -- Each property's @Dictionary@ contain at least @name: String@ and @type: int@ (see @enum Variant.Type@) entries. Optionally, it can also include @hint: int@ (see @enum PropertyHint@), @hint_string: String@, and @usage: int@ (see @enum PropertyUsageFlags@). bindObject_get_property_list :: MethodBind bindObject_get_property_list = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_property_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's property list as an @Array@ of dictionaries. -- Each property's @Dictionary@ contain at least @name: String@ and @type: int@ (see @enum Variant.Type@) entries. Optionally, it can also include @hint: int@ (see @enum PropertyHint@), @hint_string: String@, and @usage: int@ (see @enum PropertyUsageFlags@). get_property_list :: (Object :< cls, Object :< cls) => cls -> IO Array get_property_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_property_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_property_list" '[] (IO Array) where nodeMethod = Godot.Core.Object.get_property_list {-# NOINLINE bindObject_get_script #-} -- | Returns the object's @Script@ instance, or @null@ if none is assigned. bindObject_get_script :: MethodBind bindObject_get_script = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the object's @Script@ instance, or @null@ if none is assigned. get_script :: (Object :< cls, Object :< cls) => cls -> IO Reference get_script cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_script" '[] (IO Reference) where nodeMethod = Godot.Core.Object.get_script {-# NOINLINE bindObject_get_signal_connection_list #-} -- | Returns an @Array@ of connections for the given @signal@. bindObject_get_signal_connection_list :: MethodBind bindObject_get_signal_connection_list = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_signal_connection_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ of connections for the given @signal@. get_signal_connection_list :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO Array get_signal_connection_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_signal_connection_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_signal_connection_list" '[GodotString] (IO Array) where nodeMethod = Godot.Core.Object.get_signal_connection_list {-# NOINLINE bindObject_get_signal_list #-} -- | Returns the list of signals as an @Array@ of dictionaries. bindObject_get_signal_list :: MethodBind bindObject_get_signal_list = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "get_signal_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of signals as an @Array@ of dictionaries. get_signal_list :: (Object :< cls, Object :< cls) => cls -> IO Array get_signal_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_get_signal_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "get_signal_list" '[] (IO Array) where nodeMethod = Godot.Core.Object.get_signal_list {-# NOINLINE bindObject_has_meta #-} -- | Returns @true@ if a metadata entry is found with the given @name@. bindObject_has_meta :: MethodBind bindObject_has_meta = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "has_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a metadata entry is found with the given @name@. has_meta :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_meta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_has_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "has_meta" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Object.has_meta {-# NOINLINE bindObject_has_method #-} -- | Returns @true@ if the object contains the given @method@. bindObject_has_method :: MethodBind bindObject_has_method = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "has_method" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the object contains the given @method@. has_method :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_method cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_has_method (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "has_method" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Object.has_method {-# NOINLINE bindObject_has_user_signal #-} -- | Returns @true@ if the given user-defined @signal@ exists. Only signals added using @method add_user_signal@ are taken into account. bindObject_has_user_signal :: MethodBind bindObject_has_user_signal = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "has_user_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given user-defined @signal@ exists. Only signals added using @method add_user_signal@ are taken into account. has_user_signal :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_user_signal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_has_user_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "has_user_signal" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Object.has_user_signal {-# NOINLINE bindObject_is_blocking_signals #-} -- | Returns @true@ if signal emission blocking is enabled. bindObject_is_blocking_signals :: MethodBind bindObject_is_blocking_signals = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "is_blocking_signals" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if signal emission blocking is enabled. is_blocking_signals :: (Object :< cls, Object :< cls) => cls -> IO Bool is_blocking_signals cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_is_blocking_signals (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "is_blocking_signals" '[] (IO Bool) where nodeMethod = Godot.Core.Object.is_blocking_signals {-# NOINLINE bindObject_is_class #-} -- | Returns @true@ if the object inherits from the given @class@. bindObject_is_class :: MethodBind bindObject_is_class = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "is_class" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the object inherits from the given @class@. is_class :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_class cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_is_class (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "is_class" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Object.is_class {-# NOINLINE bindObject_is_connected #-} -- | Returns @true@ if a connection exists for a given @signal@, @target@, and @method@. bindObject_is_connected :: MethodBind bindObject_is_connected = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "is_connected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a connection exists for a given @signal@, @target@, and @method@. is_connected :: (Object :< cls, Object :< cls) => cls -> GodotString -> Object -> GodotString -> IO Bool is_connected cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindObject_is_connected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "is_connected" '[GodotString, Object, GodotString] (IO Bool) where nodeMethod = Godot.Core.Object.is_connected {-# NOINLINE bindObject_is_queued_for_deletion #-} -- | Returns @true@ if the @method Node.queue_free@ method was called for the object. bindObject_is_queued_for_deletion :: MethodBind bindObject_is_queued_for_deletion = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "is_queued_for_deletion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the @method Node.queue_free@ method was called for the object. is_queued_for_deletion :: (Object :< cls, Object :< cls) => cls -> IO Bool is_queued_for_deletion cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_is_queued_for_deletion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "is_queued_for_deletion" '[] (IO Bool) where nodeMethod = Godot.Core.Object.is_queued_for_deletion {-# NOINLINE bindObject_notification #-} -- | Send a given notification to the object, which will also trigger a call to the @method _notification@ method of all classes that the object inherits from. -- If @reversed@ is @true@, @method _notification@ is called first on the object's own class, and then up to its successive parent classes. If @reversed@ is @false@, @method _notification@ is called first on the highest ancestor (@Object@ itself), and then down to its successive inheriting classes. bindObject_notification :: MethodBind bindObject_notification = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "notification" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Send a given notification to the object, which will also trigger a call to the @method _notification@ method of all classes that the object inherits from. -- If @reversed@ is @true@, @method _notification@ is called first on the object's own class, and then up to its successive parent classes. If @reversed@ is @false@, @method _notification@ is called first on the highest ancestor (@Object@ itself), and then down to its successive inheriting classes. notification :: (Object :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO () notification cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindObject_notification (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "notification" '[Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Object.notification {-# NOINLINE bindObject_property_list_changed_notify #-} -- | Notify the editor that the property list has changed, so that editor plugins can take the new values into account. Does nothing on export builds. bindObject_property_list_changed_notify :: MethodBind bindObject_property_list_changed_notify = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "property_list_changed_notify" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Notify the editor that the property list has changed, so that editor plugins can take the new values into account. Does nothing on export builds. property_list_changed_notify :: (Object :< cls, Object :< cls) => cls -> IO () property_list_changed_notify cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_property_list_changed_notify (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "property_list_changed_notify" '[] (IO ()) where nodeMethod = Godot.Core.Object.property_list_changed_notify {-# NOINLINE bindObject_remove_meta #-} -- | Removes a given entry from the object's metadata. See also @method set_meta@. bindObject_remove_meta :: MethodBind bindObject_remove_meta = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "remove_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a given entry from the object's metadata. See also @method set_meta@. remove_meta :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO () remove_meta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_remove_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "remove_meta" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Object.remove_meta {-# NOINLINE bindObject_set #-} -- | Assigns a new value to the given property. If the @property@ does not exist, nothing will happen. -- __Note:__ In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase). bindObject_set :: MethodBind bindObject_set = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "set" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a new value to the given property. If the @property@ does not exist, nothing will happen. -- __Note:__ In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase). set :: (Object :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindObject_set (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "set" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Object.set {-# NOINLINE bindObject_set_block_signals #-} -- | If set to @true@, signal emission is blocked. bindObject_set_block_signals :: MethodBind bindObject_set_block_signals = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "set_block_signals" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If set to @true@, signal emission is blocked. set_block_signals :: (Object :< cls, Object :< cls) => cls -> Bool -> IO () set_block_signals cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_set_block_signals (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "set_block_signals" '[Bool] (IO ()) where nodeMethod = Godot.Core.Object.set_block_signals {-# NOINLINE bindObject_set_deferred #-} -- | Assigns a new value to the given property, after the current frame's physics step. This is equivalent to calling @method set@ via @method call_deferred@, i.e. @call_deferred("set", property, value)@. -- __Note:__ In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase). bindObject_set_deferred :: MethodBind bindObject_set_deferred = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "set_deferred" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a new value to the given property, after the current frame's physics step. This is equivalent to calling @method set@ via @method call_deferred@, i.e. @call_deferred("set", property, value)@. -- __Note:__ In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase). set_deferred :: (Object :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set_deferred cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindObject_set_deferred (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "set_deferred" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Object.set_deferred {-# NOINLINE bindObject_set_indexed #-} -- | Assigns a new value to the property identified by the @NodePath@. The node path should be relative to the current object and can use the colon character (@:@) to access nested properties. Example: -- -- @ -- -- set_indexed("position", Vector2(42, 0)) -- set_indexed("position:y", -10) -- print(position) # (42, -10) -- -- @ bindObject_set_indexed :: MethodBind bindObject_set_indexed = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "set_indexed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a new value to the property identified by the @NodePath@. The node path should be relative to the current object and can use the colon character (@:@) to access nested properties. Example: -- -- @ -- -- set_indexed("position", Vector2(42, 0)) -- set_indexed("position:y", -10) -- print(position) # (42, -10) -- -- @ set_indexed :: (Object :< cls, Object :< cls) => cls -> NodePath -> GodotVariant -> IO () set_indexed cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindObject_set_indexed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "set_indexed" '[NodePath, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Object.set_indexed {-# NOINLINE bindObject_set_message_translation #-} -- | Defines whether the object can translate strings (with calls to @method tr@). Enabled by default. bindObject_set_message_translation :: MethodBind bindObject_set_message_translation = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "set_message_translation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines whether the object can translate strings (with calls to @method tr@). Enabled by default. set_message_translation :: (Object :< cls, Object :< cls) => cls -> Bool -> IO () set_message_translation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_set_message_translation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "set_message_translation" '[Bool] (IO ()) where nodeMethod = Godot.Core.Object.set_message_translation {-# NOINLINE bindObject_set_meta #-} -- | Adds, changes or removes a given entry in the object's metadata. Metadata are serialized and can take any @Variant@ value. -- To remove a given entry from the object's metadata, use @method remove_meta@. Metadata is also removed if its value is set to @null@. This means you can also use @set_meta("name", null)@ to remove metadata for @"name"@. bindObject_set_meta :: MethodBind bindObject_set_meta = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "set_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds, changes or removes a given entry in the object's metadata. Metadata are serialized and can take any @Variant@ value. -- To remove a given entry from the object's metadata, use @method remove_meta@. Metadata is also removed if its value is set to @null@. This means you can also use @set_meta("name", null)@ to remove metadata for @"name"@. set_meta :: (Object :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set_meta cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindObject_set_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "set_meta" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Object.set_meta {-# NOINLINE bindObject_set_script #-} -- | Assigns a script to the object. Each object can have a single script assigned to it, which are used to extend its functionality. -- If the object already had a script, the previous script instance will be freed and its variables and state will be lost. The new script's @method _init@ method will be called. bindObject_set_script :: MethodBind bindObject_set_script = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "set_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a script to the object. Each object can have a single script assigned to it, which are used to extend its functionality. -- If the object already had a script, the previous script instance will be freed and its variables and state will be lost. The new script's @method _init@ method will be called. set_script :: (Object :< cls, Object :< cls) => cls -> Reference -> IO () set_script cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_set_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "set_script" '[Reference] (IO ()) where nodeMethod = Godot.Core.Object.set_script {-# NOINLINE bindObject_to_string #-} -- | Returns a @String@ representing the object. If not overridden, defaults to @"@ClassName:RID@"@. -- Override the method @method _to_string@ to customize the @String@ representation. bindObject_to_string :: MethodBind bindObject_to_string = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "to_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @String@ representing the object. If not overridden, defaults to @"@ClassName:RID@"@. -- Override the method @method _to_string@ to customize the @String@ representation. to_string :: (Object :< cls, Object :< cls) => cls -> IO GodotString to_string cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindObject_to_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "to_string" '[] (IO GodotString) where nodeMethod = Godot.Core.Object.to_string {-# NOINLINE bindObject_tr #-} -- | Translates a message using translation catalogs configured in the Project Settings. -- Only works if message translation is enabled (which it is by default), otherwise it returns the @message@ unchanged. See @method set_message_translation@. bindObject_tr :: MethodBind bindObject_tr = unsafePerformIO $ withCString "Object" $ \ clsNamePtr -> withCString "tr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Translates a message using translation catalogs configured in the Project Settings. -- Only works if message translation is enabled (which it is by default), otherwise it returns the @message@ unchanged. See @method set_message_translation@. tr :: (Object :< cls, Object :< cls) => cls -> GodotString -> IO GodotString tr cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindObject_tr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Object "tr" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.Object.tr ================================================ FILE: src/Godot/Core/OccluderPolygon2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.OccluderPolygon2D (Godot.Core.OccluderPolygon2D._CULL_CLOCKWISE, Godot.Core.OccluderPolygon2D._CULL_DISABLED, Godot.Core.OccluderPolygon2D._CULL_COUNTER_CLOCKWISE, Godot.Core.OccluderPolygon2D.get_cull_mode, Godot.Core.OccluderPolygon2D.get_polygon, Godot.Core.OccluderPolygon2D.is_closed, Godot.Core.OccluderPolygon2D.set_closed, Godot.Core.OccluderPolygon2D.set_cull_mode, Godot.Core.OccluderPolygon2D.set_polygon) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _CULL_CLOCKWISE :: Int _CULL_CLOCKWISE = 1 _CULL_DISABLED :: Int _CULL_DISABLED = 0 _CULL_COUNTER_CLOCKWISE :: Int _CULL_COUNTER_CLOCKWISE = 2 instance NodeProperty OccluderPolygon2D "closed" Bool 'False where nodeProperty = (is_closed, wrapDroppingSetter set_closed, Nothing) instance NodeProperty OccluderPolygon2D "cull_mode" Int 'False where nodeProperty = (get_cull_mode, wrapDroppingSetter set_cull_mode, Nothing) instance NodeProperty OccluderPolygon2D "polygon" PoolVector2Array 'False where nodeProperty = (get_polygon, wrapDroppingSetter set_polygon, Nothing) {-# NOINLINE bindOccluderPolygon2D_get_cull_mode #-} -- | The culling mode to use. bindOccluderPolygon2D_get_cull_mode :: MethodBind bindOccluderPolygon2D_get_cull_mode = unsafePerformIO $ withCString "OccluderPolygon2D" $ \ clsNamePtr -> withCString "get_cull_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The culling mode to use. get_cull_mode :: (OccluderPolygon2D :< cls, Object :< cls) => cls -> IO Int get_cull_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOccluderPolygon2D_get_cull_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OccluderPolygon2D "get_cull_mode" '[] (IO Int) where nodeMethod = Godot.Core.OccluderPolygon2D.get_cull_mode {-# NOINLINE bindOccluderPolygon2D_get_polygon #-} -- | A @Vector2@ array with the index for polygon's vertices positions. -- __Note:__ The returned value is a copy of the underlying array, rather than a reference. bindOccluderPolygon2D_get_polygon :: MethodBind bindOccluderPolygon2D_get_polygon = unsafePerformIO $ withCString "OccluderPolygon2D" $ \ clsNamePtr -> withCString "get_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Vector2@ array with the index for polygon's vertices positions. -- __Note:__ The returned value is a copy of the underlying array, rather than a reference. get_polygon :: (OccluderPolygon2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOccluderPolygon2D_get_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OccluderPolygon2D "get_polygon" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.OccluderPolygon2D.get_polygon {-# NOINLINE bindOccluderPolygon2D_is_closed #-} -- | If @true@, closes the polygon. A closed OccluderPolygon2D occludes the light coming from any direction. An opened OccluderPolygon2D occludes the light only at its outline's direction. bindOccluderPolygon2D_is_closed :: MethodBind bindOccluderPolygon2D_is_closed = unsafePerformIO $ withCString "OccluderPolygon2D" $ \ clsNamePtr -> withCString "is_closed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, closes the polygon. A closed OccluderPolygon2D occludes the light coming from any direction. An opened OccluderPolygon2D occludes the light only at its outline's direction. is_closed :: (OccluderPolygon2D :< cls, Object :< cls) => cls -> IO Bool is_closed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOccluderPolygon2D_is_closed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OccluderPolygon2D "is_closed" '[] (IO Bool) where nodeMethod = Godot.Core.OccluderPolygon2D.is_closed {-# NOINLINE bindOccluderPolygon2D_set_closed #-} -- | If @true@, closes the polygon. A closed OccluderPolygon2D occludes the light coming from any direction. An opened OccluderPolygon2D occludes the light only at its outline's direction. bindOccluderPolygon2D_set_closed :: MethodBind bindOccluderPolygon2D_set_closed = unsafePerformIO $ withCString "OccluderPolygon2D" $ \ clsNamePtr -> withCString "set_closed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, closes the polygon. A closed OccluderPolygon2D occludes the light coming from any direction. An opened OccluderPolygon2D occludes the light only at its outline's direction. set_closed :: (OccluderPolygon2D :< cls, Object :< cls) => cls -> Bool -> IO () set_closed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOccluderPolygon2D_set_closed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OccluderPolygon2D "set_closed" '[Bool] (IO ()) where nodeMethod = Godot.Core.OccluderPolygon2D.set_closed {-# NOINLINE bindOccluderPolygon2D_set_cull_mode #-} -- | The culling mode to use. bindOccluderPolygon2D_set_cull_mode :: MethodBind bindOccluderPolygon2D_set_cull_mode = unsafePerformIO $ withCString "OccluderPolygon2D" $ \ clsNamePtr -> withCString "set_cull_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The culling mode to use. set_cull_mode :: (OccluderPolygon2D :< cls, Object :< cls) => cls -> Int -> IO () set_cull_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOccluderPolygon2D_set_cull_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OccluderPolygon2D "set_cull_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.OccluderPolygon2D.set_cull_mode {-# NOINLINE bindOccluderPolygon2D_set_polygon #-} -- | A @Vector2@ array with the index for polygon's vertices positions. -- __Note:__ The returned value is a copy of the underlying array, rather than a reference. bindOccluderPolygon2D_set_polygon :: MethodBind bindOccluderPolygon2D_set_polygon = unsafePerformIO $ withCString "OccluderPolygon2D" $ \ clsNamePtr -> withCString "set_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Vector2@ array with the index for polygon's vertices positions. -- __Note:__ The returned value is a copy of the underlying array, rather than a reference. set_polygon :: (OccluderPolygon2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOccluderPolygon2D_set_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OccluderPolygon2D "set_polygon" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.OccluderPolygon2D.set_polygon ================================================ FILE: src/Godot/Core/OmniLight.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.OmniLight (Godot.Core.OmniLight._SHADOW_DUAL_PARABOLOID, Godot.Core.OmniLight._SHADOW_DETAIL_HORIZONTAL, Godot.Core.OmniLight._SHADOW_DETAIL_VERTICAL, Godot.Core.OmniLight._SHADOW_CUBE, Godot.Core.OmniLight.get_param, Godot.Core.OmniLight.set_param, Godot.Core.OmniLight.get_shadow_detail, Godot.Core.OmniLight.get_shadow_mode, Godot.Core.OmniLight.set_shadow_detail, Godot.Core.OmniLight.set_shadow_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Light() _SHADOW_DUAL_PARABOLOID :: Int _SHADOW_DUAL_PARABOLOID = 0 _SHADOW_DETAIL_HORIZONTAL :: Int _SHADOW_DETAIL_HORIZONTAL = 1 _SHADOW_DETAIL_VERTICAL :: Int _SHADOW_DETAIL_VERTICAL = 0 _SHADOW_CUBE :: Int _SHADOW_CUBE = 1 {-# NOINLINE bindOmniLight_get_param #-} -- | The light's attenuation (drop-off) curve. A number of presets are available in the __Inspector__ by right-clicking the curve. bindOmniLight_get_param :: MethodBind bindOmniLight_get_param = unsafePerformIO $ withCString "OmniLight" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light's attenuation (drop-off) curve. A number of presets are available in the __Inspector__ by right-clicking the curve. get_param :: (OmniLight :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOmniLight_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OmniLight "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.OmniLight.get_param {-# NOINLINE bindOmniLight_set_param #-} -- | The light's attenuation (drop-off) curve. A number of presets are available in the __Inspector__ by right-clicking the curve. bindOmniLight_set_param :: MethodBind bindOmniLight_set_param = unsafePerformIO $ withCString "OmniLight" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light's attenuation (drop-off) curve. A number of presets are available in the __Inspector__ by right-clicking the curve. set_param :: (OmniLight :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOmniLight_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OmniLight "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.OmniLight.set_param instance NodeProperty OmniLight "omni_attenuation" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param, wrapIndexedSetter 4 set_param, Nothing) instance NodeProperty OmniLight "omni_range" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param, wrapIndexedSetter 3 set_param, Nothing) instance NodeProperty OmniLight "omni_shadow_detail" Int 'False where nodeProperty = (get_shadow_detail, wrapDroppingSetter set_shadow_detail, Nothing) instance NodeProperty OmniLight "omni_shadow_mode" Int 'False where nodeProperty = (get_shadow_mode, wrapDroppingSetter set_shadow_mode, Nothing) {-# NOINLINE bindOmniLight_get_shadow_detail #-} -- | See @enum ShadowDetail@. bindOmniLight_get_shadow_detail :: MethodBind bindOmniLight_get_shadow_detail = unsafePerformIO $ withCString "OmniLight" $ \ clsNamePtr -> withCString "get_shadow_detail" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | See @enum ShadowDetail@. get_shadow_detail :: (OmniLight :< cls, Object :< cls) => cls -> IO Int get_shadow_detail cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOmniLight_get_shadow_detail (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OmniLight "get_shadow_detail" '[] (IO Int) where nodeMethod = Godot.Core.OmniLight.get_shadow_detail {-# NOINLINE bindOmniLight_get_shadow_mode #-} -- | See @enum ShadowMode@. bindOmniLight_get_shadow_mode :: MethodBind bindOmniLight_get_shadow_mode = unsafePerformIO $ withCString "OmniLight" $ \ clsNamePtr -> withCString "get_shadow_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | See @enum ShadowMode@. get_shadow_mode :: (OmniLight :< cls, Object :< cls) => cls -> IO Int get_shadow_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOmniLight_get_shadow_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OmniLight "get_shadow_mode" '[] (IO Int) where nodeMethod = Godot.Core.OmniLight.get_shadow_mode {-# NOINLINE bindOmniLight_set_shadow_detail #-} -- | See @enum ShadowDetail@. bindOmniLight_set_shadow_detail :: MethodBind bindOmniLight_set_shadow_detail = unsafePerformIO $ withCString "OmniLight" $ \ clsNamePtr -> withCString "set_shadow_detail" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | See @enum ShadowDetail@. set_shadow_detail :: (OmniLight :< cls, Object :< cls) => cls -> Int -> IO () set_shadow_detail cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOmniLight_set_shadow_detail (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OmniLight "set_shadow_detail" '[Int] (IO ()) where nodeMethod = Godot.Core.OmniLight.set_shadow_detail {-# NOINLINE bindOmniLight_set_shadow_mode #-} -- | See @enum ShadowMode@. bindOmniLight_set_shadow_mode :: MethodBind bindOmniLight_set_shadow_mode = unsafePerformIO $ withCString "OmniLight" $ \ clsNamePtr -> withCString "set_shadow_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | See @enum ShadowMode@. set_shadow_mode :: (OmniLight :< cls, Object :< cls) => cls -> Int -> IO () set_shadow_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOmniLight_set_shadow_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OmniLight "set_shadow_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.OmniLight.set_shadow_mode ================================================ FILE: src/Godot/Core/OpenSimplexNoise.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.OpenSimplexNoise (Godot.Core.OpenSimplexNoise.get_image, Godot.Core.OpenSimplexNoise.get_lacunarity, Godot.Core.OpenSimplexNoise.get_noise_1d, Godot.Core.OpenSimplexNoise.get_noise_2d, Godot.Core.OpenSimplexNoise.get_noise_2dv, Godot.Core.OpenSimplexNoise.get_noise_3d, Godot.Core.OpenSimplexNoise.get_noise_3dv, Godot.Core.OpenSimplexNoise.get_noise_4d, Godot.Core.OpenSimplexNoise.get_octaves, Godot.Core.OpenSimplexNoise.get_period, Godot.Core.OpenSimplexNoise.get_persistence, Godot.Core.OpenSimplexNoise.get_seamless_image, Godot.Core.OpenSimplexNoise.get_seed, Godot.Core.OpenSimplexNoise.set_lacunarity, Godot.Core.OpenSimplexNoise.set_octaves, Godot.Core.OpenSimplexNoise.set_period, Godot.Core.OpenSimplexNoise.set_persistence, Godot.Core.OpenSimplexNoise.set_seed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty OpenSimplexNoise "lacunarity" Float 'False where nodeProperty = (get_lacunarity, wrapDroppingSetter set_lacunarity, Nothing) instance NodeProperty OpenSimplexNoise "octaves" Int 'False where nodeProperty = (get_octaves, wrapDroppingSetter set_octaves, Nothing) instance NodeProperty OpenSimplexNoise "period" Float 'False where nodeProperty = (get_period, wrapDroppingSetter set_period, Nothing) instance NodeProperty OpenSimplexNoise "persistence" Float 'False where nodeProperty = (get_persistence, wrapDroppingSetter set_persistence, Nothing) instance NodeProperty OpenSimplexNoise "seed" Int 'False where nodeProperty = (get_seed, wrapDroppingSetter set_seed, Nothing) {-# NOINLINE bindOpenSimplexNoise_get_image #-} bindOpenSimplexNoise_get_image :: MethodBind bindOpenSimplexNoise_get_image = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_image" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_image :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Int -> Int -> IO Image get_image cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_image (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_image" '[Int, Int] (IO Image) where nodeMethod = Godot.Core.OpenSimplexNoise.get_image {-# NOINLINE bindOpenSimplexNoise_get_lacunarity #-} bindOpenSimplexNoise_get_lacunarity :: MethodBind bindOpenSimplexNoise_get_lacunarity = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_lacunarity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_lacunarity :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> IO Float get_lacunarity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_lacunarity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_lacunarity" '[] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_lacunarity {-# NOINLINE bindOpenSimplexNoise_get_noise_1d #-} bindOpenSimplexNoise_get_noise_1d :: MethodBind bindOpenSimplexNoise_get_noise_1d = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_noise_1d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_noise_1d :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Float -> IO Float get_noise_1d cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_noise_1d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_noise_1d" '[Float] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_noise_1d {-# NOINLINE bindOpenSimplexNoise_get_noise_2d #-} bindOpenSimplexNoise_get_noise_2d :: MethodBind bindOpenSimplexNoise_get_noise_2d = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_noise_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_noise_2d :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Float -> Float -> IO Float get_noise_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_noise_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_noise_2d" '[Float, Float] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_noise_2d {-# NOINLINE bindOpenSimplexNoise_get_noise_2dv #-} bindOpenSimplexNoise_get_noise_2dv :: MethodBind bindOpenSimplexNoise_get_noise_2dv = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_noise_2dv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_noise_2dv :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Vector2 -> IO Float get_noise_2dv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_noise_2dv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_noise_2dv" '[Vector2] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_noise_2dv {-# NOINLINE bindOpenSimplexNoise_get_noise_3d #-} bindOpenSimplexNoise_get_noise_3d :: MethodBind bindOpenSimplexNoise_get_noise_3d = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_noise_3d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_noise_3d :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Float -> Float -> Float -> IO Float get_noise_3d cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_noise_3d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_noise_3d" '[Float, Float, Float] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_noise_3d {-# NOINLINE bindOpenSimplexNoise_get_noise_3dv #-} bindOpenSimplexNoise_get_noise_3dv :: MethodBind bindOpenSimplexNoise_get_noise_3dv = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_noise_3dv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_noise_3dv :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Vector3 -> IO Float get_noise_3dv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_noise_3dv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_noise_3dv" '[Vector3] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_noise_3dv {-# NOINLINE bindOpenSimplexNoise_get_noise_4d #-} bindOpenSimplexNoise_get_noise_4d :: MethodBind bindOpenSimplexNoise_get_noise_4d = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_noise_4d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_noise_4d :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Float -> Float -> Float -> Float -> IO Float get_noise_4d cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_noise_4d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_noise_4d" '[Float, Float, Float, Float] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_noise_4d {-# NOINLINE bindOpenSimplexNoise_get_octaves #-} bindOpenSimplexNoise_get_octaves :: MethodBind bindOpenSimplexNoise_get_octaves = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_octaves" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_octaves :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> IO Int get_octaves cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_octaves (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_octaves" '[] (IO Int) where nodeMethod = Godot.Core.OpenSimplexNoise.get_octaves {-# NOINLINE bindOpenSimplexNoise_get_period #-} bindOpenSimplexNoise_get_period :: MethodBind bindOpenSimplexNoise_get_period = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_period" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_period :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> IO Float get_period cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_period (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_period" '[] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_period {-# NOINLINE bindOpenSimplexNoise_get_persistence #-} bindOpenSimplexNoise_get_persistence :: MethodBind bindOpenSimplexNoise_get_persistence = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_persistence" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_persistence :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> IO Float get_persistence cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_persistence (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_persistence" '[] (IO Float) where nodeMethod = Godot.Core.OpenSimplexNoise.get_persistence {-# NOINLINE bindOpenSimplexNoise_get_seamless_image #-} bindOpenSimplexNoise_get_seamless_image :: MethodBind bindOpenSimplexNoise_get_seamless_image = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_seamless_image" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_seamless_image :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Int -> IO Image get_seamless_image cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_seamless_image (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_seamless_image" '[Int] (IO Image) where nodeMethod = Godot.Core.OpenSimplexNoise.get_seamless_image {-# NOINLINE bindOpenSimplexNoise_get_seed #-} bindOpenSimplexNoise_get_seed :: MethodBind bindOpenSimplexNoise_get_seed = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "get_seed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_seed :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> IO Int get_seed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_get_seed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "get_seed" '[] (IO Int) where nodeMethod = Godot.Core.OpenSimplexNoise.get_seed {-# NOINLINE bindOpenSimplexNoise_set_lacunarity #-} bindOpenSimplexNoise_set_lacunarity :: MethodBind bindOpenSimplexNoise_set_lacunarity = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "set_lacunarity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_lacunarity :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Float -> IO () set_lacunarity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_set_lacunarity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "set_lacunarity" '[Float] (IO ()) where nodeMethod = Godot.Core.OpenSimplexNoise.set_lacunarity {-# NOINLINE bindOpenSimplexNoise_set_octaves #-} bindOpenSimplexNoise_set_octaves :: MethodBind bindOpenSimplexNoise_set_octaves = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "set_octaves" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_octaves :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Int -> IO () set_octaves cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_set_octaves (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "set_octaves" '[Int] (IO ()) where nodeMethod = Godot.Core.OpenSimplexNoise.set_octaves {-# NOINLINE bindOpenSimplexNoise_set_period #-} bindOpenSimplexNoise_set_period :: MethodBind bindOpenSimplexNoise_set_period = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "set_period" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_period :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Float -> IO () set_period cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_set_period (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "set_period" '[Float] (IO ()) where nodeMethod = Godot.Core.OpenSimplexNoise.set_period {-# NOINLINE bindOpenSimplexNoise_set_persistence #-} bindOpenSimplexNoise_set_persistence :: MethodBind bindOpenSimplexNoise_set_persistence = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "set_persistence" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_persistence :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Float -> IO () set_persistence cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_set_persistence (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "set_persistence" '[Float] (IO ()) where nodeMethod = Godot.Core.OpenSimplexNoise.set_persistence {-# NOINLINE bindOpenSimplexNoise_set_seed #-} bindOpenSimplexNoise_set_seed :: MethodBind bindOpenSimplexNoise_set_seed = unsafePerformIO $ withCString "OpenSimplexNoise" $ \ clsNamePtr -> withCString "set_seed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_seed :: (OpenSimplexNoise :< cls, Object :< cls) => cls -> Int -> IO () set_seed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOpenSimplexNoise_set_seed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OpenSimplexNoise "set_seed" '[Int] (IO ()) where nodeMethod = Godot.Core.OpenSimplexNoise.set_seed ================================================ FILE: src/Godot/Core/OptionButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.OptionButton (Godot.Core.OptionButton.sig_item_focused, Godot.Core.OptionButton.sig_item_selected, Godot.Core.OptionButton._focused, Godot.Core.OptionButton._get_items, Godot.Core.OptionButton._select_int, Godot.Core.OptionButton._selected, Godot.Core.OptionButton._set_items, Godot.Core.OptionButton.add_icon_item, Godot.Core.OptionButton.add_item, Godot.Core.OptionButton.add_separator, Godot.Core.OptionButton.clear, Godot.Core.OptionButton.get_item_count, Godot.Core.OptionButton.get_item_icon, Godot.Core.OptionButton.get_item_id, Godot.Core.OptionButton.get_item_index, Godot.Core.OptionButton.get_item_metadata, Godot.Core.OptionButton.get_item_text, Godot.Core.OptionButton.get_popup, Godot.Core.OptionButton.get_selected, Godot.Core.OptionButton.get_selected_id, Godot.Core.OptionButton.get_selected_metadata, Godot.Core.OptionButton.is_item_disabled, Godot.Core.OptionButton.remove_item, Godot.Core.OptionButton.select, Godot.Core.OptionButton.set_item_disabled, Godot.Core.OptionButton.set_item_icon, Godot.Core.OptionButton.set_item_id, Godot.Core.OptionButton.set_item_metadata, Godot.Core.OptionButton.set_item_text) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Button() -- | Emitted when the user navigates to an item using the @ui_up@ or @ui_down@ actions. The index of the item selected is passed as argument. sig_item_focused :: Godot.Internal.Dispatch.Signal OptionButton sig_item_focused = Godot.Internal.Dispatch.Signal "item_focused" instance NodeSignal OptionButton "item_focused" '[Int] -- | Emitted when the current item has been changed by the user. The index of the item selected is passed as argument. sig_item_selected :: Godot.Internal.Dispatch.Signal OptionButton sig_item_selected = Godot.Internal.Dispatch.Signal "item_selected" instance NodeSignal OptionButton "item_selected" '[Int] instance NodeProperty OptionButton "items" Array 'False where nodeProperty = (_get_items, wrapDroppingSetter _set_items, Nothing) instance NodeProperty OptionButton "selected" Int 'False where nodeProperty = (get_selected, wrapDroppingSetter _select_int, Nothing) {-# NOINLINE bindOptionButton__focused #-} bindOptionButton__focused :: MethodBind bindOptionButton__focused = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "_focused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _focused :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO () _focused cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton__focused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "_focused" '[Int] (IO ()) where nodeMethod = Godot.Core.OptionButton._focused {-# NOINLINE bindOptionButton__get_items #-} bindOptionButton__get_items :: MethodBind bindOptionButton__get_items = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "_get_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_items :: (OptionButton :< cls, Object :< cls) => cls -> IO Array _get_items cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton__get_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "_get_items" '[] (IO Array) where nodeMethod = Godot.Core.OptionButton._get_items {-# NOINLINE bindOptionButton__select_int #-} -- | The index of the currently selected item, or @-1@ if no item is selected. bindOptionButton__select_int :: MethodBind bindOptionButton__select_int = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "_select_int" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The index of the currently selected item, or @-1@ if no item is selected. _select_int :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO () _select_int cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton__select_int (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "_select_int" '[Int] (IO ()) where nodeMethod = Godot.Core.OptionButton._select_int {-# NOINLINE bindOptionButton__selected #-} bindOptionButton__selected :: MethodBind bindOptionButton__selected = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _selected :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO () _selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton__selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "_selected" '[Int] (IO ()) where nodeMethod = Godot.Core.OptionButton._selected {-# NOINLINE bindOptionButton__set_items #-} bindOptionButton__set_items :: MethodBind bindOptionButton__set_items = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "_set_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_items :: (OptionButton :< cls, Object :< cls) => cls -> Array -> IO () _set_items cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton__set_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "_set_items" '[Array] (IO ()) where nodeMethod = Godot.Core.OptionButton._set_items {-# NOINLINE bindOptionButton_add_icon_item #-} -- | Adds an item, with a @texture@ icon, text @label@ and (optionally) @id@. If no @id@ is passed, the item index will be used as the item's ID. New items are appended at the end. bindOptionButton_add_icon_item :: MethodBind bindOptionButton_add_icon_item = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "add_icon_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an item, with a @texture@ icon, text @label@ and (optionally) @id@. If no @id@ is passed, the item index will be used as the item's ID. New items are appended at the end. add_icon_item :: (OptionButton :< cls, Object :< cls) => cls -> Texture -> GodotString -> Maybe Int -> IO () add_icon_item cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_add_icon_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "add_icon_item" '[Texture, GodotString, Maybe Int] (IO ()) where nodeMethod = Godot.Core.OptionButton.add_icon_item {-# NOINLINE bindOptionButton_add_item #-} -- | Adds an item, with text @label@ and (optionally) @id@. If no @id@ is passed, the item index will be used as the item's ID. New items are appended at the end. bindOptionButton_add_item :: MethodBind bindOptionButton_add_item = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "add_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an item, with text @label@ and (optionally) @id@. If no @id@ is passed, the item index will be used as the item's ID. New items are appended at the end. add_item :: (OptionButton :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> IO () add_item cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_add_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "add_item" '[GodotString, Maybe Int] (IO ()) where nodeMethod = Godot.Core.OptionButton.add_item {-# NOINLINE bindOptionButton_add_separator #-} -- | Adds a separator to the list of items. Separators help to group items. Separator also takes up an index and is appended at the end. bindOptionButton_add_separator :: MethodBind bindOptionButton_add_separator = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "add_separator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a separator to the list of items. Separators help to group items. Separator also takes up an index and is appended at the end. add_separator :: (OptionButton :< cls, Object :< cls) => cls -> IO () add_separator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_add_separator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "add_separator" '[] (IO ()) where nodeMethod = Godot.Core.OptionButton.add_separator {-# NOINLINE bindOptionButton_clear #-} -- | Clears all the items in the @OptionButton@. bindOptionButton_clear :: MethodBind bindOptionButton_clear = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all the items in the @OptionButton@. clear :: (OptionButton :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "clear" '[] (IO ()) where nodeMethod = Godot.Core.OptionButton.clear {-# NOINLINE bindOptionButton_get_item_count #-} -- | Returns the amount of items in the OptionButton, including separators. bindOptionButton_get_item_count :: MethodBind bindOptionButton_get_item_count = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_item_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of items in the OptionButton, including separators. get_item_count :: (OptionButton :< cls, Object :< cls) => cls -> IO Int get_item_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_item_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_item_count" '[] (IO Int) where nodeMethod = Godot.Core.OptionButton.get_item_count {-# NOINLINE bindOptionButton_get_item_icon #-} -- | Returns the icon of the item at index @idx@. bindOptionButton_get_item_icon :: MethodBind bindOptionButton_get_item_icon = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_item_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the icon of the item at index @idx@. get_item_icon :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO Texture get_item_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_item_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_item_icon" '[Int] (IO Texture) where nodeMethod = Godot.Core.OptionButton.get_item_icon {-# NOINLINE bindOptionButton_get_item_id #-} -- | Returns the ID of the item at index @idx@. bindOptionButton_get_item_id :: MethodBind bindOptionButton_get_item_id = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_item_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the ID of the item at index @idx@. get_item_id :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO Int get_item_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_item_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_item_id" '[Int] (IO Int) where nodeMethod = Godot.Core.OptionButton.get_item_id {-# NOINLINE bindOptionButton_get_item_index #-} -- | Returns the index of the item with the given @id@. bindOptionButton_get_item_index :: MethodBind bindOptionButton_get_item_index = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_item_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the item with the given @id@. get_item_index :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO Int get_item_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_item_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_item_index" '[Int] (IO Int) where nodeMethod = Godot.Core.OptionButton.get_item_index {-# NOINLINE bindOptionButton_get_item_metadata #-} -- | Retrieves the metadata of an item. Metadata may be any type and can be used to store extra information about an item, such as an external string ID. bindOptionButton_get_item_metadata :: MethodBind bindOptionButton_get_item_metadata = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_item_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Retrieves the metadata of an item. Metadata may be any type and can be used to store extra information about an item, such as an external string ID. get_item_metadata :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_item_metadata cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_item_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_item_metadata" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.OptionButton.get_item_metadata {-# NOINLINE bindOptionButton_get_item_text #-} -- | Returns the text of the item at index @idx@. bindOptionButton_get_item_text :: MethodBind bindOptionButton_get_item_text = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_item_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the text of the item at index @idx@. get_item_text :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO GodotString get_item_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_item_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_item_text" '[Int] (IO GodotString) where nodeMethod = Godot.Core.OptionButton.get_item_text {-# NOINLINE bindOptionButton_get_popup #-} -- | Returns the @PopupMenu@ contained in this button. bindOptionButton_get_popup :: MethodBind bindOptionButton_get_popup = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_popup" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @PopupMenu@ contained in this button. get_popup :: (OptionButton :< cls, Object :< cls) => cls -> IO PopupMenu get_popup cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_popup (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_popup" '[] (IO PopupMenu) where nodeMethod = Godot.Core.OptionButton.get_popup {-# NOINLINE bindOptionButton_get_selected #-} -- | The index of the currently selected item, or @-1@ if no item is selected. bindOptionButton_get_selected :: MethodBind bindOptionButton_get_selected = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The index of the currently selected item, or @-1@ if no item is selected. get_selected :: (OptionButton :< cls, Object :< cls) => cls -> IO Int get_selected cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_selected" '[] (IO Int) where nodeMethod = Godot.Core.OptionButton.get_selected {-# NOINLINE bindOptionButton_get_selected_id #-} -- | Returns the ID of the selected item, or @0@ if no item is selected. bindOptionButton_get_selected_id :: MethodBind bindOptionButton_get_selected_id = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_selected_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the ID of the selected item, or @0@ if no item is selected. get_selected_id :: (OptionButton :< cls, Object :< cls) => cls -> IO Int get_selected_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_selected_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_selected_id" '[] (IO Int) where nodeMethod = Godot.Core.OptionButton.get_selected_id {-# NOINLINE bindOptionButton_get_selected_metadata #-} -- | Gets the metadata of the selected item. Metadata for items can be set using @method set_item_metadata@. bindOptionButton_get_selected_metadata :: MethodBind bindOptionButton_get_selected_metadata = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "get_selected_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the metadata of the selected item. Metadata for items can be set using @method set_item_metadata@. get_selected_metadata :: (OptionButton :< cls, Object :< cls) => cls -> IO GodotVariant get_selected_metadata cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_get_selected_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "get_selected_metadata" '[] (IO GodotVariant) where nodeMethod = Godot.Core.OptionButton.get_selected_metadata {-# NOINLINE bindOptionButton_is_item_disabled #-} -- | Returns @true@ if the item at index @idx@ is disabled. bindOptionButton_is_item_disabled :: MethodBind bindOptionButton_is_item_disabled = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "is_item_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item at index @idx@ is disabled. is_item_disabled :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_is_item_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "is_item_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.OptionButton.is_item_disabled {-# NOINLINE bindOptionButton_remove_item #-} -- | Removes the item at index @idx@. bindOptionButton_remove_item :: MethodBind bindOptionButton_remove_item = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "remove_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the item at index @idx@. remove_item :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO () remove_item cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_remove_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "remove_item" '[Int] (IO ()) where nodeMethod = Godot.Core.OptionButton.remove_item {-# NOINLINE bindOptionButton_select #-} -- | Selects an item by index and makes it the current item. This will work even if the item is disabled. bindOptionButton_select :: MethodBind bindOptionButton_select = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Selects an item by index and makes it the current item. This will work even if the item is disabled. select :: (OptionButton :< cls, Object :< cls) => cls -> Int -> IO () select cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "select" '[Int] (IO ()) where nodeMethod = Godot.Core.OptionButton.select {-# NOINLINE bindOptionButton_set_item_disabled #-} -- | Sets whether the item at index @idx@ is disabled. -- Disabled items are drawn differently in the dropdown and are not selectable by the user. If the current selected item is set as disabled, it will remain selected. bindOptionButton_set_item_disabled :: MethodBind bindOptionButton_set_item_disabled = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "set_item_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the item at index @idx@ is disabled. -- Disabled items are drawn differently in the dropdown and are not selectable by the user. If the current selected item is set as disabled, it will remain selected. set_item_disabled :: (OptionButton :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_set_item_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "set_item_disabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.OptionButton.set_item_disabled {-# NOINLINE bindOptionButton_set_item_icon #-} -- | Sets the icon of the item at index @idx@. bindOptionButton_set_item_icon :: MethodBind bindOptionButton_set_item_icon = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "set_item_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the icon of the item at index @idx@. set_item_icon :: (OptionButton :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_item_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_set_item_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "set_item_icon" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.OptionButton.set_item_icon {-# NOINLINE bindOptionButton_set_item_id #-} -- | Sets the ID of the item at index @idx@. bindOptionButton_set_item_id :: MethodBind bindOptionButton_set_item_id = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "set_item_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the ID of the item at index @idx@. set_item_id :: (OptionButton :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_item_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_set_item_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "set_item_id" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.OptionButton.set_item_id {-# NOINLINE bindOptionButton_set_item_metadata #-} -- | Sets the metadata of an item. Metadata may be of any type and can be used to store extra information about an item, such as an external string ID. bindOptionButton_set_item_metadata :: MethodBind bindOptionButton_set_item_metadata = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "set_item_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the metadata of an item. Metadata may be of any type and can be used to store extra information about an item, such as an external string ID. set_item_metadata :: (OptionButton :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_item_metadata cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_set_item_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "set_item_metadata" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.OptionButton.set_item_metadata {-# NOINLINE bindOptionButton_set_item_text #-} -- | Sets the text of the item at index @idx@. bindOptionButton_set_item_text :: MethodBind bindOptionButton_set_item_text = unsafePerformIO $ withCString "OptionButton" $ \ clsNamePtr -> withCString "set_item_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the text of the item at index @idx@. set_item_text :: (OptionButton :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_item_text cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindOptionButton_set_item_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod OptionButton "set_item_text" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.OptionButton.set_item_text ================================================ FILE: src/Godot/Core/PCKPacker.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PCKPacker (Godot.Core.PCKPacker.add_file, Godot.Core.PCKPacker.flush, Godot.Core.PCKPacker.pck_start) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindPCKPacker_add_file #-} -- | Adds the @source_path@ file to the current PCK package at the @pck_path@ internal path (should start with @res://@). bindPCKPacker_add_file :: MethodBind bindPCKPacker_add_file = unsafePerformIO $ withCString "PCKPacker" $ \ clsNamePtr -> withCString "add_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the @source_path@ file to the current PCK package at the @pck_path@ internal path (should start with @res://@). add_file :: (PCKPacker :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int add_file cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPCKPacker_add_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PCKPacker "add_file" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.PCKPacker.add_file {-# NOINLINE bindPCKPacker_flush #-} -- | Writes the files specified using all @method add_file@ calls since the last flush. If @verbose@ is @true@, a list of files added will be printed to the console for easier debugging. bindPCKPacker_flush :: MethodBind bindPCKPacker_flush = unsafePerformIO $ withCString "PCKPacker" $ \ clsNamePtr -> withCString "flush" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Writes the files specified using all @method add_file@ calls since the last flush. If @verbose@ is @true@, a list of files added will be printed to the console for easier debugging. flush :: (PCKPacker :< cls, Object :< cls) => cls -> Maybe Bool -> IO Int flush cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPCKPacker_flush (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PCKPacker "flush" '[Maybe Bool] (IO Int) where nodeMethod = Godot.Core.PCKPacker.flush {-# NOINLINE bindPCKPacker_pck_start #-} -- | Creates a new PCK file with the name @pck_name@. The @.pck@ file extension isn't added automatically, so it should be part of @pck_name@ (even though it's not required). bindPCKPacker_pck_start :: MethodBind bindPCKPacker_pck_start = unsafePerformIO $ withCString "PCKPacker" $ \ clsNamePtr -> withCString "pck_start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new PCK file with the name @pck_name@. The @.pck@ file extension isn't added automatically, so it should be part of @pck_name@ (even though it's not required). pck_start :: (PCKPacker :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> IO Int pck_start cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPCKPacker_pck_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PCKPacker "pck_start" '[GodotString, Maybe Int] (IO Int) where nodeMethod = Godot.Core.PCKPacker.pck_start ================================================ FILE: src/Godot/Core/PHashTranslation.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PHashTranslation (Godot.Core.PHashTranslation.generate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Translation() {-# NOINLINE bindPHashTranslation_generate #-} -- | Generates and sets an optimized translation from the given @Translation@ resource. bindPHashTranslation_generate :: MethodBind bindPHashTranslation_generate = unsafePerformIO $ withCString "PHashTranslation" $ \ clsNamePtr -> withCString "generate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates and sets an optimized translation from the given @Translation@ resource. generate :: (PHashTranslation :< cls, Object :< cls) => cls -> Translation -> IO () generate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPHashTranslation_generate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PHashTranslation "generate" '[Translation] (IO ()) where nodeMethod = Godot.Core.PHashTranslation.generate ================================================ FILE: src/Godot/Core/PackedDataContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PackedDataContainer (Godot.Core.PackedDataContainer._get_data, Godot.Core.PackedDataContainer._iter_get, Godot.Core.PackedDataContainer._iter_init, Godot.Core.PackedDataContainer._iter_next, Godot.Core.PackedDataContainer._set_data, Godot.Core.PackedDataContainer.pack, Godot.Core.PackedDataContainer.size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty PackedDataContainer "__data__" PoolByteArray 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) {-# NOINLINE bindPackedDataContainer__get_data #-} bindPackedDataContainer__get_data :: MethodBind bindPackedDataContainer__get_data = unsafePerformIO $ withCString "PackedDataContainer" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_data :: (PackedDataContainer :< cls, Object :< cls) => cls -> IO PoolByteArray _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainer__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainer "_get_data" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.PackedDataContainer._get_data {-# NOINLINE bindPackedDataContainer__iter_get #-} bindPackedDataContainer__iter_get :: MethodBind bindPackedDataContainer__iter_get = unsafePerformIO $ withCString "PackedDataContainer" $ \ clsNamePtr -> withCString "_iter_get" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _iter_get :: (PackedDataContainer :< cls, Object :< cls) => cls -> GodotVariant -> IO GodotVariant _iter_get cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainer__iter_get (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainer "_iter_get" '[GodotVariant] (IO GodotVariant) where nodeMethod = Godot.Core.PackedDataContainer._iter_get {-# NOINLINE bindPackedDataContainer__iter_init #-} bindPackedDataContainer__iter_init :: MethodBind bindPackedDataContainer__iter_init = unsafePerformIO $ withCString "PackedDataContainer" $ \ clsNamePtr -> withCString "_iter_init" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _iter_init :: (PackedDataContainer :< cls, Object :< cls) => cls -> Array -> IO GodotVariant _iter_init cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainer__iter_init (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainer "_iter_init" '[Array] (IO GodotVariant) where nodeMethod = Godot.Core.PackedDataContainer._iter_init {-# NOINLINE bindPackedDataContainer__iter_next #-} bindPackedDataContainer__iter_next :: MethodBind bindPackedDataContainer__iter_next = unsafePerformIO $ withCString "PackedDataContainer" $ \ clsNamePtr -> withCString "_iter_next" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _iter_next :: (PackedDataContainer :< cls, Object :< cls) => cls -> Array -> IO GodotVariant _iter_next cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainer__iter_next (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainer "_iter_next" '[Array] (IO GodotVariant) where nodeMethod = Godot.Core.PackedDataContainer._iter_next {-# NOINLINE bindPackedDataContainer__set_data #-} bindPackedDataContainer__set_data :: MethodBind bindPackedDataContainer__set_data = unsafePerformIO $ withCString "PackedDataContainer" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_data :: (PackedDataContainer :< cls, Object :< cls) => cls -> PoolByteArray -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainer__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainer "_set_data" '[PoolByteArray] (IO ()) where nodeMethod = Godot.Core.PackedDataContainer._set_data {-# NOINLINE bindPackedDataContainer_pack #-} bindPackedDataContainer_pack :: MethodBind bindPackedDataContainer_pack = unsafePerformIO $ withCString "PackedDataContainer" $ \ clsNamePtr -> withCString "pack" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr pack :: (PackedDataContainer :< cls, Object :< cls) => cls -> GodotVariant -> IO Int pack cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainer_pack (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainer "pack" '[GodotVariant] (IO Int) where nodeMethod = Godot.Core.PackedDataContainer.pack {-# NOINLINE bindPackedDataContainer_size #-} bindPackedDataContainer_size :: MethodBind bindPackedDataContainer_size = unsafePerformIO $ withCString "PackedDataContainer" $ \ clsNamePtr -> withCString "size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr size :: (PackedDataContainer :< cls, Object :< cls) => cls -> IO Int size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainer_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainer "size" '[] (IO Int) where nodeMethod = Godot.Core.PackedDataContainer.size ================================================ FILE: src/Godot/Core/PackedDataContainerRef.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PackedDataContainerRef (Godot.Core.PackedDataContainerRef._is_dictionary, Godot.Core.PackedDataContainerRef._iter_get, Godot.Core.PackedDataContainerRef._iter_init, Godot.Core.PackedDataContainerRef._iter_next, Godot.Core.PackedDataContainerRef.size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindPackedDataContainerRef__is_dictionary #-} bindPackedDataContainerRef__is_dictionary :: MethodBind bindPackedDataContainerRef__is_dictionary = unsafePerformIO $ withCString "PackedDataContainerRef" $ \ clsNamePtr -> withCString "_is_dictionary" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _is_dictionary :: (PackedDataContainerRef :< cls, Object :< cls) => cls -> IO Bool _is_dictionary cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainerRef__is_dictionary (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainerRef "_is_dictionary" '[] (IO Bool) where nodeMethod = Godot.Core.PackedDataContainerRef._is_dictionary {-# NOINLINE bindPackedDataContainerRef__iter_get #-} bindPackedDataContainerRef__iter_get :: MethodBind bindPackedDataContainerRef__iter_get = unsafePerformIO $ withCString "PackedDataContainerRef" $ \ clsNamePtr -> withCString "_iter_get" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _iter_get :: (PackedDataContainerRef :< cls, Object :< cls) => cls -> GodotVariant -> IO GodotVariant _iter_get cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainerRef__iter_get (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainerRef "_iter_get" '[GodotVariant] (IO GodotVariant) where nodeMethod = Godot.Core.PackedDataContainerRef._iter_get {-# NOINLINE bindPackedDataContainerRef__iter_init #-} bindPackedDataContainerRef__iter_init :: MethodBind bindPackedDataContainerRef__iter_init = unsafePerformIO $ withCString "PackedDataContainerRef" $ \ clsNamePtr -> withCString "_iter_init" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _iter_init :: (PackedDataContainerRef :< cls, Object :< cls) => cls -> Array -> IO GodotVariant _iter_init cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainerRef__iter_init (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainerRef "_iter_init" '[Array] (IO GodotVariant) where nodeMethod = Godot.Core.PackedDataContainerRef._iter_init {-# NOINLINE bindPackedDataContainerRef__iter_next #-} bindPackedDataContainerRef__iter_next :: MethodBind bindPackedDataContainerRef__iter_next = unsafePerformIO $ withCString "PackedDataContainerRef" $ \ clsNamePtr -> withCString "_iter_next" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _iter_next :: (PackedDataContainerRef :< cls, Object :< cls) => cls -> Array -> IO GodotVariant _iter_next cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainerRef__iter_next (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainerRef "_iter_next" '[Array] (IO GodotVariant) where nodeMethod = Godot.Core.PackedDataContainerRef._iter_next {-# NOINLINE bindPackedDataContainerRef_size #-} bindPackedDataContainerRef_size :: MethodBind bindPackedDataContainerRef_size = unsafePerformIO $ withCString "PackedDataContainerRef" $ \ clsNamePtr -> withCString "size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr size :: (PackedDataContainerRef :< cls, Object :< cls) => cls -> IO Int size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPackedDataContainerRef_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedDataContainerRef "size" '[] (IO Int) where nodeMethod = Godot.Core.PackedDataContainerRef.size ================================================ FILE: src/Godot/Core/PackedScene.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PackedScene (Godot.Core.PackedScene._GEN_EDIT_STATE_DISABLED, Godot.Core.PackedScene._GEN_EDIT_STATE_MAIN, Godot.Core.PackedScene._GEN_EDIT_STATE_INSTANCE, Godot.Core.PackedScene._get_bundled_scene, Godot.Core.PackedScene._set_bundled_scene, Godot.Core.PackedScene.can_instance, Godot.Core.PackedScene.get_state, Godot.Core.PackedScene.instance', Godot.Core.PackedScene.pack) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _GEN_EDIT_STATE_DISABLED :: Int _GEN_EDIT_STATE_DISABLED = 0 _GEN_EDIT_STATE_MAIN :: Int _GEN_EDIT_STATE_MAIN = 2 _GEN_EDIT_STATE_INSTANCE :: Int _GEN_EDIT_STATE_INSTANCE = 1 instance NodeProperty PackedScene "_bundled" Dictionary 'False where nodeProperty = (_get_bundled_scene, wrapDroppingSetter _set_bundled_scene, Nothing) {-# NOINLINE bindPackedScene__get_bundled_scene #-} -- | A dictionary representation of the scene contents. -- Available keys include "rnames" and "variants" for resources, "node_count", "nodes", "node_paths" for nodes, "editable_instances" for base scene children overrides, "conn_count" and "conns" for signal connections, and "version" for the format style of the PackedScene. bindPackedScene__get_bundled_scene :: MethodBind bindPackedScene__get_bundled_scene = unsafePerformIO $ withCString "PackedScene" $ \ clsNamePtr -> withCString "_get_bundled_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A dictionary representation of the scene contents. -- Available keys include "rnames" and "variants" for resources, "node_count", "nodes", "node_paths" for nodes, "editable_instances" for base scene children overrides, "conn_count" and "conns" for signal connections, and "version" for the format style of the PackedScene. _get_bundled_scene :: (PackedScene :< cls, Object :< cls) => cls -> IO Dictionary _get_bundled_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPackedScene__get_bundled_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedScene "_get_bundled_scene" '[] (IO Dictionary) where nodeMethod = Godot.Core.PackedScene._get_bundled_scene {-# NOINLINE bindPackedScene__set_bundled_scene #-} -- | A dictionary representation of the scene contents. -- Available keys include "rnames" and "variants" for resources, "node_count", "nodes", "node_paths" for nodes, "editable_instances" for base scene children overrides, "conn_count" and "conns" for signal connections, and "version" for the format style of the PackedScene. bindPackedScene__set_bundled_scene :: MethodBind bindPackedScene__set_bundled_scene = unsafePerformIO $ withCString "PackedScene" $ \ clsNamePtr -> withCString "_set_bundled_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A dictionary representation of the scene contents. -- Available keys include "rnames" and "variants" for resources, "node_count", "nodes", "node_paths" for nodes, "editable_instances" for base scene children overrides, "conn_count" and "conns" for signal connections, and "version" for the format style of the PackedScene. _set_bundled_scene :: (PackedScene :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_bundled_scene cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedScene__set_bundled_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedScene "_set_bundled_scene" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.PackedScene._set_bundled_scene {-# NOINLINE bindPackedScene_can_instance #-} -- | Returns @true@ if the scene file has nodes. bindPackedScene_can_instance :: MethodBind bindPackedScene_can_instance = unsafePerformIO $ withCString "PackedScene" $ \ clsNamePtr -> withCString "can_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the scene file has nodes. can_instance :: (PackedScene :< cls, Object :< cls) => cls -> IO Bool can_instance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPackedScene_can_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedScene "can_instance" '[] (IO Bool) where nodeMethod = Godot.Core.PackedScene.can_instance {-# NOINLINE bindPackedScene_get_state #-} -- | Returns the @SceneState@ representing the scene file contents. bindPackedScene_get_state :: MethodBind bindPackedScene_get_state = unsafePerformIO $ withCString "PackedScene" $ \ clsNamePtr -> withCString "get_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @SceneState@ representing the scene file contents. get_state :: (PackedScene :< cls, Object :< cls) => cls -> IO SceneState get_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPackedScene_get_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedScene "get_state" '[] (IO SceneState) where nodeMethod = Godot.Core.PackedScene.get_state {-# NOINLINE bindPackedScene_instance' #-} -- | Instantiates the scene's node hierarchy. Triggers child scene instantiation(s). Triggers a @Node.NOTIFICATION_INSTANCED@ notification on the root node. bindPackedScene_instance' :: MethodBind bindPackedScene_instance' = unsafePerformIO $ withCString "PackedScene" $ \ clsNamePtr -> withCString "instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Instantiates the scene's node hierarchy. Triggers child scene instantiation(s). Triggers a @Node.NOTIFICATION_INSTANCED@ notification on the root node. instance' :: (PackedScene :< cls, Object :< cls) => cls -> Maybe Int -> IO Node instance' cls arg1 = withVariantArray [maybe (VariantInt (0)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedScene_instance' (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedScene "instance" '[Maybe Int] (IO Node) where nodeMethod = Godot.Core.PackedScene.instance' {-# NOINLINE bindPackedScene_pack #-} -- | Pack will ignore any sub-nodes not owned by given node. See @Node.owner@. bindPackedScene_pack :: MethodBind bindPackedScene_pack = unsafePerformIO $ withCString "PackedScene" $ \ clsNamePtr -> withCString "pack" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pack will ignore any sub-nodes not owned by given node. See @Node.owner@. pack :: (PackedScene :< cls, Object :< cls) => cls -> Node -> IO Int pack cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPackedScene_pack (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PackedScene "pack" '[Node] (IO Int) where nodeMethod = Godot.Core.PackedScene.pack ================================================ FILE: src/Godot/Core/PacketPeer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PacketPeer (Godot.Core.PacketPeer.get_available_packet_count, Godot.Core.PacketPeer.get_encode_buffer_max_size, Godot.Core.PacketPeer.get_packet, Godot.Core.PacketPeer.get_packet_error, Godot.Core.PacketPeer.get_var, Godot.Core.PacketPeer.is_object_decoding_allowed, Godot.Core.PacketPeer.put_packet, Godot.Core.PacketPeer.put_var, Godot.Core.PacketPeer.set_allow_object_decoding, Godot.Core.PacketPeer.set_encode_buffer_max_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty PacketPeer "allow_object_decoding" Bool 'False where nodeProperty = (is_object_decoding_allowed, wrapDroppingSetter set_allow_object_decoding, Nothing) instance NodeProperty PacketPeer "encode_buffer_max_size" Int 'False where nodeProperty = (get_encode_buffer_max_size, wrapDroppingSetter set_encode_buffer_max_size, Nothing) {-# NOINLINE bindPacketPeer_get_available_packet_count #-} -- | Returns the number of packets currently available in the ring-buffer. bindPacketPeer_get_available_packet_count :: MethodBind bindPacketPeer_get_available_packet_count = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "get_available_packet_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of packets currently available in the ring-buffer. get_available_packet_count :: (PacketPeer :< cls, Object :< cls) => cls -> IO Int get_available_packet_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_get_available_packet_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "get_available_packet_count" '[] (IO Int) where nodeMethod = Godot.Core.PacketPeer.get_available_packet_count {-# NOINLINE bindPacketPeer_get_encode_buffer_max_size #-} -- | Maximum buffer size allowed when encoding @Variant@s. Raise this value to support heavier memory allocations. -- The @method put_var@ method allocates memory on the stack, and the buffer used will grow automatically to the closest power of two to match the size of the @Variant@. If the @Variant@ is bigger than @encode_buffer_max_size@, the method will error out with @ERR_OUT_OF_MEMORY@. bindPacketPeer_get_encode_buffer_max_size :: MethodBind bindPacketPeer_get_encode_buffer_max_size = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "get_encode_buffer_max_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum buffer size allowed when encoding @Variant@s. Raise this value to support heavier memory allocations. -- The @method put_var@ method allocates memory on the stack, and the buffer used will grow automatically to the closest power of two to match the size of the @Variant@. If the @Variant@ is bigger than @encode_buffer_max_size@, the method will error out with @ERR_OUT_OF_MEMORY@. get_encode_buffer_max_size :: (PacketPeer :< cls, Object :< cls) => cls -> IO Int get_encode_buffer_max_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_get_encode_buffer_max_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "get_encode_buffer_max_size" '[] (IO Int) where nodeMethod = Godot.Core.PacketPeer.get_encode_buffer_max_size {-# NOINLINE bindPacketPeer_get_packet #-} -- | Gets a raw packet. bindPacketPeer_get_packet :: MethodBind bindPacketPeer_get_packet = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "get_packet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a raw packet. get_packet :: (PacketPeer :< cls, Object :< cls) => cls -> IO PoolByteArray get_packet cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_get_packet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "get_packet" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.PacketPeer.get_packet {-# NOINLINE bindPacketPeer_get_packet_error #-} -- | Returns the error state of the last packet received (via @method get_packet@ and @method get_var@). bindPacketPeer_get_packet_error :: MethodBind bindPacketPeer_get_packet_error = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "get_packet_error" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the error state of the last packet received (via @method get_packet@ and @method get_var@). get_packet_error :: (PacketPeer :< cls, Object :< cls) => cls -> IO Int get_packet_error cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_get_packet_error (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "get_packet_error" '[] (IO Int) where nodeMethod = Godot.Core.PacketPeer.get_packet_error {-# NOINLINE bindPacketPeer_get_var #-} -- | Gets a Variant. If @allow_objects@ (or @allow_object_decoding@) is @true@, decoding objects is allowed. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. bindPacketPeer_get_var :: MethodBind bindPacketPeer_get_var = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "get_var" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a Variant. If @allow_objects@ (or @allow_object_decoding@) is @true@, decoding objects is allowed. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. get_var :: (PacketPeer :< cls, Object :< cls) => cls -> Maybe Bool -> IO GodotVariant get_var cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_get_var (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "get_var" '[Maybe Bool] (IO GodotVariant) where nodeMethod = Godot.Core.PacketPeer.get_var {-# NOINLINE bindPacketPeer_is_object_decoding_allowed #-} -- | @i@Deprecated.@/i@ Use @get_var@ and @put_var@ parameters instead. -- If @true@, the PacketPeer will allow encoding and decoding of object via @method get_var@ and @method put_var@. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. bindPacketPeer_is_object_decoding_allowed :: MethodBind bindPacketPeer_is_object_decoding_allowed = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "is_object_decoding_allowed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @i@Deprecated.@/i@ Use @get_var@ and @put_var@ parameters instead. -- If @true@, the PacketPeer will allow encoding and decoding of object via @method get_var@ and @method put_var@. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. is_object_decoding_allowed :: (PacketPeer :< cls, Object :< cls) => cls -> IO Bool is_object_decoding_allowed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_is_object_decoding_allowed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "is_object_decoding_allowed" '[] (IO Bool) where nodeMethod = Godot.Core.PacketPeer.is_object_decoding_allowed {-# NOINLINE bindPacketPeer_put_packet #-} -- | Sends a raw packet. bindPacketPeer_put_packet :: MethodBind bindPacketPeer_put_packet = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "put_packet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a raw packet. put_packet :: (PacketPeer :< cls, Object :< cls) => cls -> PoolByteArray -> IO Int put_packet cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_put_packet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "put_packet" '[PoolByteArray] (IO Int) where nodeMethod = Godot.Core.PacketPeer.put_packet {-# NOINLINE bindPacketPeer_put_var #-} -- | Sends a @Variant@ as a packet. If @full_objects@ (or @allow_object_decoding@) is @true@, encoding objects is allowed (and can potentially include code). bindPacketPeer_put_var :: MethodBind bindPacketPeer_put_var = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "put_var" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a @Variant@ as a packet. If @full_objects@ (or @allow_object_decoding@) is @true@, encoding objects is allowed (and can potentially include code). put_var :: (PacketPeer :< cls, Object :< cls) => cls -> GodotVariant -> Maybe Bool -> IO Int put_var cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_put_var (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "put_var" '[GodotVariant, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.PacketPeer.put_var {-# NOINLINE bindPacketPeer_set_allow_object_decoding #-} -- | @i@Deprecated.@/i@ Use @get_var@ and @put_var@ parameters instead. -- If @true@, the PacketPeer will allow encoding and decoding of object via @method get_var@ and @method put_var@. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. bindPacketPeer_set_allow_object_decoding :: MethodBind bindPacketPeer_set_allow_object_decoding = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "set_allow_object_decoding" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @i@Deprecated.@/i@ Use @get_var@ and @put_var@ parameters instead. -- If @true@, the PacketPeer will allow encoding and decoding of object via @method get_var@ and @method put_var@. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. set_allow_object_decoding :: (PacketPeer :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_object_decoding cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_set_allow_object_decoding (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "set_allow_object_decoding" '[Bool] (IO ()) where nodeMethod = Godot.Core.PacketPeer.set_allow_object_decoding {-# NOINLINE bindPacketPeer_set_encode_buffer_max_size #-} -- | Maximum buffer size allowed when encoding @Variant@s. Raise this value to support heavier memory allocations. -- The @method put_var@ method allocates memory on the stack, and the buffer used will grow automatically to the closest power of two to match the size of the @Variant@. If the @Variant@ is bigger than @encode_buffer_max_size@, the method will error out with @ERR_OUT_OF_MEMORY@. bindPacketPeer_set_encode_buffer_max_size :: MethodBind bindPacketPeer_set_encode_buffer_max_size = unsafePerformIO $ withCString "PacketPeer" $ \ clsNamePtr -> withCString "set_encode_buffer_max_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum buffer size allowed when encoding @Variant@s. Raise this value to support heavier memory allocations. -- The @method put_var@ method allocates memory on the stack, and the buffer used will grow automatically to the closest power of two to match the size of the @Variant@. If the @Variant@ is bigger than @encode_buffer_max_size@, the method will error out with @ERR_OUT_OF_MEMORY@. set_encode_buffer_max_size :: (PacketPeer :< cls, Object :< cls) => cls -> Int -> IO () set_encode_buffer_max_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeer_set_encode_buffer_max_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeer "set_encode_buffer_max_size" '[Int] (IO ()) where nodeMethod = Godot.Core.PacketPeer.set_encode_buffer_max_size ================================================ FILE: src/Godot/Core/PacketPeerGDNative.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PacketPeerGDNative () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PacketPeer() ================================================ FILE: src/Godot/Core/PacketPeerStream.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PacketPeerStream (Godot.Core.PacketPeerStream.get_input_buffer_max_size, Godot.Core.PacketPeerStream.get_output_buffer_max_size, Godot.Core.PacketPeerStream.get_stream_peer, Godot.Core.PacketPeerStream.set_input_buffer_max_size, Godot.Core.PacketPeerStream.set_output_buffer_max_size, Godot.Core.PacketPeerStream.set_stream_peer) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PacketPeer() instance NodeProperty PacketPeerStream "input_buffer_max_size" Int 'False where nodeProperty = (get_input_buffer_max_size, wrapDroppingSetter set_input_buffer_max_size, Nothing) instance NodeProperty PacketPeerStream "output_buffer_max_size" Int 'False where nodeProperty = (get_output_buffer_max_size, wrapDroppingSetter set_output_buffer_max_size, Nothing) instance NodeProperty PacketPeerStream "stream_peer" StreamPeer 'False where nodeProperty = (get_stream_peer, wrapDroppingSetter set_stream_peer, Nothing) {-# NOINLINE bindPacketPeerStream_get_input_buffer_max_size #-} bindPacketPeerStream_get_input_buffer_max_size :: MethodBind bindPacketPeerStream_get_input_buffer_max_size = unsafePerformIO $ withCString "PacketPeerStream" $ \ clsNamePtr -> withCString "get_input_buffer_max_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_input_buffer_max_size :: (PacketPeerStream :< cls, Object :< cls) => cls -> IO Int get_input_buffer_max_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerStream_get_input_buffer_max_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerStream "get_input_buffer_max_size" '[] (IO Int) where nodeMethod = Godot.Core.PacketPeerStream.get_input_buffer_max_size {-# NOINLINE bindPacketPeerStream_get_output_buffer_max_size #-} bindPacketPeerStream_get_output_buffer_max_size :: MethodBind bindPacketPeerStream_get_output_buffer_max_size = unsafePerformIO $ withCString "PacketPeerStream" $ \ clsNamePtr -> withCString "get_output_buffer_max_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_output_buffer_max_size :: (PacketPeerStream :< cls, Object :< cls) => cls -> IO Int get_output_buffer_max_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerStream_get_output_buffer_max_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerStream "get_output_buffer_max_size" '[] (IO Int) where nodeMethod = Godot.Core.PacketPeerStream.get_output_buffer_max_size {-# NOINLINE bindPacketPeerStream_get_stream_peer #-} -- | The wrapped @StreamPeer@ object. bindPacketPeerStream_get_stream_peer :: MethodBind bindPacketPeerStream_get_stream_peer = unsafePerformIO $ withCString "PacketPeerStream" $ \ clsNamePtr -> withCString "get_stream_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The wrapped @StreamPeer@ object. get_stream_peer :: (PacketPeerStream :< cls, Object :< cls) => cls -> IO StreamPeer get_stream_peer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerStream_get_stream_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerStream "get_stream_peer" '[] (IO StreamPeer) where nodeMethod = Godot.Core.PacketPeerStream.get_stream_peer {-# NOINLINE bindPacketPeerStream_set_input_buffer_max_size #-} bindPacketPeerStream_set_input_buffer_max_size :: MethodBind bindPacketPeerStream_set_input_buffer_max_size = unsafePerformIO $ withCString "PacketPeerStream" $ \ clsNamePtr -> withCString "set_input_buffer_max_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_input_buffer_max_size :: (PacketPeerStream :< cls, Object :< cls) => cls -> Int -> IO () set_input_buffer_max_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerStream_set_input_buffer_max_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerStream "set_input_buffer_max_size" '[Int] (IO ()) where nodeMethod = Godot.Core.PacketPeerStream.set_input_buffer_max_size {-# NOINLINE bindPacketPeerStream_set_output_buffer_max_size #-} bindPacketPeerStream_set_output_buffer_max_size :: MethodBind bindPacketPeerStream_set_output_buffer_max_size = unsafePerformIO $ withCString "PacketPeerStream" $ \ clsNamePtr -> withCString "set_output_buffer_max_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_output_buffer_max_size :: (PacketPeerStream :< cls, Object :< cls) => cls -> Int -> IO () set_output_buffer_max_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerStream_set_output_buffer_max_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerStream "set_output_buffer_max_size" '[Int] (IO ()) where nodeMethod = Godot.Core.PacketPeerStream.set_output_buffer_max_size {-# NOINLINE bindPacketPeerStream_set_stream_peer #-} -- | The wrapped @StreamPeer@ object. bindPacketPeerStream_set_stream_peer :: MethodBind bindPacketPeerStream_set_stream_peer = unsafePerformIO $ withCString "PacketPeerStream" $ \ clsNamePtr -> withCString "set_stream_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The wrapped @StreamPeer@ object. set_stream_peer :: (PacketPeerStream :< cls, Object :< cls) => cls -> StreamPeer -> IO () set_stream_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerStream_set_stream_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerStream "set_stream_peer" '[StreamPeer] (IO ()) where nodeMethod = Godot.Core.PacketPeerStream.set_stream_peer ================================================ FILE: src/Godot/Core/PacketPeerUDP.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PacketPeerUDP (Godot.Core.PacketPeerUDP.close, Godot.Core.PacketPeerUDP.get_packet_ip, Godot.Core.PacketPeerUDP.get_packet_port, Godot.Core.PacketPeerUDP.is_listening, Godot.Core.PacketPeerUDP.join_multicast_group, Godot.Core.PacketPeerUDP.leave_multicast_group, Godot.Core.PacketPeerUDP.listen, Godot.Core.PacketPeerUDP.set_broadcast_enabled, Godot.Core.PacketPeerUDP.set_dest_address, Godot.Core.PacketPeerUDP.wait) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PacketPeer() {-# NOINLINE bindPacketPeerUDP_close #-} -- | Closes the UDP socket the @PacketPeerUDP@ is currently listening on. bindPacketPeerUDP_close :: MethodBind bindPacketPeerUDP_close = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "close" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Closes the UDP socket the @PacketPeerUDP@ is currently listening on. close :: (PacketPeerUDP :< cls, Object :< cls) => cls -> IO () close cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_close (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "close" '[] (IO ()) where nodeMethod = Godot.Core.PacketPeerUDP.close {-# NOINLINE bindPacketPeerUDP_get_packet_ip #-} -- | Returns the IP of the remote peer that sent the last packet(that was received with @method PacketPeer.get_packet@ or @method PacketPeer.get_var@). bindPacketPeerUDP_get_packet_ip :: MethodBind bindPacketPeerUDP_get_packet_ip = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "get_packet_ip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the IP of the remote peer that sent the last packet(that was received with @method PacketPeer.get_packet@ or @method PacketPeer.get_var@). get_packet_ip :: (PacketPeerUDP :< cls, Object :< cls) => cls -> IO GodotString get_packet_ip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_get_packet_ip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "get_packet_ip" '[] (IO GodotString) where nodeMethod = Godot.Core.PacketPeerUDP.get_packet_ip {-# NOINLINE bindPacketPeerUDP_get_packet_port #-} -- | Returns the port of the remote peer that sent the last packet(that was received with @method PacketPeer.get_packet@ or @method PacketPeer.get_var@). bindPacketPeerUDP_get_packet_port :: MethodBind bindPacketPeerUDP_get_packet_port = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "get_packet_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the port of the remote peer that sent the last packet(that was received with @method PacketPeer.get_packet@ or @method PacketPeer.get_var@). get_packet_port :: (PacketPeerUDP :< cls, Object :< cls) => cls -> IO Int get_packet_port cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_get_packet_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "get_packet_port" '[] (IO Int) where nodeMethod = Godot.Core.PacketPeerUDP.get_packet_port {-# NOINLINE bindPacketPeerUDP_is_listening #-} -- | Returns whether this @PacketPeerUDP@ is listening. bindPacketPeerUDP_is_listening :: MethodBind bindPacketPeerUDP_is_listening = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "is_listening" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether this @PacketPeerUDP@ is listening. is_listening :: (PacketPeerUDP :< cls, Object :< cls) => cls -> IO Bool is_listening cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_is_listening (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "is_listening" '[] (IO Bool) where nodeMethod = Godot.Core.PacketPeerUDP.is_listening {-# NOINLINE bindPacketPeerUDP_join_multicast_group #-} -- | Joins the multicast group specified by @multicast_address@ using the interface identified by @interface_name@. -- You can join the same multicast group with multiple interfaces. Use @method IP.get_local_interfaces@ to know which are available. -- Note: Some Android devices might require the @CHANGE_WIFI_MULTICAST_STATE@ permission for multicast to work. bindPacketPeerUDP_join_multicast_group :: MethodBind bindPacketPeerUDP_join_multicast_group = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "join_multicast_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Joins the multicast group specified by @multicast_address@ using the interface identified by @interface_name@. -- You can join the same multicast group with multiple interfaces. Use @method IP.get_local_interfaces@ to know which are available. -- Note: Some Android devices might require the @CHANGE_WIFI_MULTICAST_STATE@ permission for multicast to work. join_multicast_group :: (PacketPeerUDP :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int join_multicast_group cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_join_multicast_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "join_multicast_group" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.PacketPeerUDP.join_multicast_group {-# NOINLINE bindPacketPeerUDP_leave_multicast_group #-} -- | Removes the interface identified by @interface_name@ from the multicast group specified by @multicast_address@. bindPacketPeerUDP_leave_multicast_group :: MethodBind bindPacketPeerUDP_leave_multicast_group = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "leave_multicast_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the interface identified by @interface_name@ from the multicast group specified by @multicast_address@. leave_multicast_group :: (PacketPeerUDP :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int leave_multicast_group cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_leave_multicast_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "leave_multicast_group" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.PacketPeerUDP.leave_multicast_group {-# NOINLINE bindPacketPeerUDP_listen #-} -- | Makes this @PacketPeerUDP@ listen on the @port@ binding to @bind_address@ with a buffer size @recv_buf_size@. -- If @bind_address@ is set to @"*"@ (default), the peer will listen on all available addresses (both IPv4 and IPv6). -- If @bind_address@ is set to @"0.0.0.0"@ (for IPv4) or @"::"@ (for IPv6), the peer will listen on all available addresses matching that IP type. -- If @bind_address@ is set to any valid address (e.g. @"192.168.1.101"@, @"::1"@, etc), the peer will only listen on the interface with that addresses (or fail if no interface with the given address exists). bindPacketPeerUDP_listen :: MethodBind bindPacketPeerUDP_listen = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "listen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Makes this @PacketPeerUDP@ listen on the @port@ binding to @bind_address@ with a buffer size @recv_buf_size@. -- If @bind_address@ is set to @"*"@ (default), the peer will listen on all available addresses (both IPv4 and IPv6). -- If @bind_address@ is set to @"0.0.0.0"@ (for IPv4) or @"::"@ (for IPv6), the peer will listen on all available addresses matching that IP type. -- If @bind_address@ is set to any valid address (e.g. @"192.168.1.101"@, @"::1"@, etc), the peer will only listen on the interface with that addresses (or fail if no interface with the given address exists). listen :: (PacketPeerUDP :< cls, Object :< cls) => cls -> Int -> Maybe GodotString -> Maybe Int -> IO Int listen cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, defaultedVariant VariantString "*" arg2, maybe (VariantInt (65536)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_listen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "listen" '[Int, Maybe GodotString, Maybe Int] (IO Int) where nodeMethod = Godot.Core.PacketPeerUDP.listen {-# NOINLINE bindPacketPeerUDP_set_broadcast_enabled #-} -- | Enable or disable sending of broadcast packets (e.g. @set_dest_address("255.255.255.255", 4343)@. This option is disabled by default. -- Note: Some Android devices might require the @CHANGE_WIFI_MULTICAST_STATE@ permission and this option to be enabled to receive broadcast packets too. bindPacketPeerUDP_set_broadcast_enabled :: MethodBind bindPacketPeerUDP_set_broadcast_enabled = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "set_broadcast_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enable or disable sending of broadcast packets (e.g. @set_dest_address("255.255.255.255", 4343)@. This option is disabled by default. -- Note: Some Android devices might require the @CHANGE_WIFI_MULTICAST_STATE@ permission and this option to be enabled to receive broadcast packets too. set_broadcast_enabled :: (PacketPeerUDP :< cls, Object :< cls) => cls -> Bool -> IO () set_broadcast_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_set_broadcast_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "set_broadcast_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.PacketPeerUDP.set_broadcast_enabled {-# NOINLINE bindPacketPeerUDP_set_dest_address #-} -- | Sets the destination address and port for sending packets and variables. A hostname will be resolved using DNS if needed. -- Note: @method set_broadcast_enabled@ must be enabled before sending packets to a broadcast address (e.g. @255.255.255.255@). bindPacketPeerUDP_set_dest_address :: MethodBind bindPacketPeerUDP_set_dest_address = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "set_dest_address" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the destination address and port for sending packets and variables. A hostname will be resolved using DNS if needed. -- Note: @method set_broadcast_enabled@ must be enabled before sending packets to a broadcast address (e.g. @255.255.255.255@). set_dest_address :: (PacketPeerUDP :< cls, Object :< cls) => cls -> GodotString -> Int -> IO Int set_dest_address cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_set_dest_address (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "set_dest_address" '[GodotString, Int] (IO Int) where nodeMethod = Godot.Core.PacketPeerUDP.set_dest_address {-# NOINLINE bindPacketPeerUDP_wait #-} -- | Waits for a packet to arrive on the listening port. See @method listen@. bindPacketPeerUDP_wait :: MethodBind bindPacketPeerUDP_wait = unsafePerformIO $ withCString "PacketPeerUDP" $ \ clsNamePtr -> withCString "wait" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Waits for a packet to arrive on the listening port. See @method listen@. wait :: (PacketPeerUDP :< cls, Object :< cls) => cls -> IO Int wait cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPacketPeerUDP_wait (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PacketPeerUDP "wait" '[] (IO Int) where nodeMethod = Godot.Core.PacketPeerUDP.wait ================================================ FILE: src/Godot/Core/Panel.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Panel () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() ================================================ FILE: src/Godot/Core/PanelContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PanelContainer () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() ================================================ FILE: src/Godot/Core/PanoramaSky.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PanoramaSky (Godot.Core.PanoramaSky.get_panorama, Godot.Core.PanoramaSky.set_panorama) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Sky() instance NodeProperty PanoramaSky "panorama" Texture 'False where nodeProperty = (get_panorama, wrapDroppingSetter set_panorama, Nothing) {-# NOINLINE bindPanoramaSky_get_panorama #-} -- | @Texture@ to be applied to the PanoramaSky. bindPanoramaSky_get_panorama :: MethodBind bindPanoramaSky_get_panorama = unsafePerformIO $ withCString "PanoramaSky" $ \ clsNamePtr -> withCString "get_panorama" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ to be applied to the PanoramaSky. get_panorama :: (PanoramaSky :< cls, Object :< cls) => cls -> IO Texture get_panorama cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPanoramaSky_get_panorama (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PanoramaSky "get_panorama" '[] (IO Texture) where nodeMethod = Godot.Core.PanoramaSky.get_panorama {-# NOINLINE bindPanoramaSky_set_panorama #-} -- | @Texture@ to be applied to the PanoramaSky. bindPanoramaSky_set_panorama :: MethodBind bindPanoramaSky_set_panorama = unsafePerformIO $ withCString "PanoramaSky" $ \ clsNamePtr -> withCString "set_panorama" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ to be applied to the PanoramaSky. set_panorama :: (PanoramaSky :< cls, Object :< cls) => cls -> Texture -> IO () set_panorama cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPanoramaSky_set_panorama (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PanoramaSky "set_panorama" '[Texture] (IO ()) where nodeMethod = Godot.Core.PanoramaSky.set_panorama ================================================ FILE: src/Godot/Core/ParallaxBackground.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ParallaxBackground (Godot.Core.ParallaxBackground._camera_moved, Godot.Core.ParallaxBackground.get_limit_begin, Godot.Core.ParallaxBackground.get_limit_end, Godot.Core.ParallaxBackground.get_scroll_base_offset, Godot.Core.ParallaxBackground.get_scroll_base_scale, Godot.Core.ParallaxBackground.get_scroll_offset, Godot.Core.ParallaxBackground.is_ignore_camera_zoom, Godot.Core.ParallaxBackground.set_ignore_camera_zoom, Godot.Core.ParallaxBackground.set_limit_begin, Godot.Core.ParallaxBackground.set_limit_end, Godot.Core.ParallaxBackground.set_scroll_base_offset, Godot.Core.ParallaxBackground.set_scroll_base_scale, Godot.Core.ParallaxBackground.set_scroll_offset) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CanvasLayer() instance NodeProperty ParallaxBackground "scroll_base_offset" Vector2 'False where nodeProperty = (get_scroll_base_offset, wrapDroppingSetter set_scroll_base_offset, Nothing) instance NodeProperty ParallaxBackground "scroll_base_scale" Vector2 'False where nodeProperty = (get_scroll_base_scale, wrapDroppingSetter set_scroll_base_scale, Nothing) instance NodeProperty ParallaxBackground "scroll_ignore_camera_zoom" Bool 'False where nodeProperty = (is_ignore_camera_zoom, wrapDroppingSetter set_ignore_camera_zoom, Nothing) instance NodeProperty ParallaxBackground "scroll_limit_begin" Vector2 'False where nodeProperty = (get_limit_begin, wrapDroppingSetter set_limit_begin, Nothing) instance NodeProperty ParallaxBackground "scroll_limit_end" Vector2 'False where nodeProperty = (get_limit_end, wrapDroppingSetter set_limit_end, Nothing) instance NodeProperty ParallaxBackground "scroll_offset" Vector2 'False where nodeProperty = (get_scroll_offset, wrapDroppingSetter set_scroll_offset, Nothing) {-# NOINLINE bindParallaxBackground__camera_moved #-} bindParallaxBackground__camera_moved :: MethodBind bindParallaxBackground__camera_moved = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "_camera_moved" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _camera_moved :: (ParallaxBackground :< cls, Object :< cls) => cls -> Transform2d -> Vector2 -> IO () _camera_moved cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground__camera_moved (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "_camera_moved" '[Transform2d, Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxBackground._camera_moved {-# NOINLINE bindParallaxBackground_get_limit_begin #-} -- | Top-left limits for scrolling to begin. If the camera is outside of this limit, the background will stop scrolling. Must be lower than @scroll_limit_end@ to work. bindParallaxBackground_get_limit_begin :: MethodBind bindParallaxBackground_get_limit_begin = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "get_limit_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Top-left limits for scrolling to begin. If the camera is outside of this limit, the background will stop scrolling. Must be lower than @scroll_limit_end@ to work. get_limit_begin :: (ParallaxBackground :< cls, Object :< cls) => cls -> IO Vector2 get_limit_begin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_get_limit_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "get_limit_begin" '[] (IO Vector2) where nodeMethod = Godot.Core.ParallaxBackground.get_limit_begin {-# NOINLINE bindParallaxBackground_get_limit_end #-} -- | Bottom-right limits for scrolling to end. If the camera is outside of this limit, the background will stop scrolling. Must be higher than @scroll_limit_begin@ to work. bindParallaxBackground_get_limit_end :: MethodBind bindParallaxBackground_get_limit_end = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "get_limit_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bottom-right limits for scrolling to end. If the camera is outside of this limit, the background will stop scrolling. Must be higher than @scroll_limit_begin@ to work. get_limit_end :: (ParallaxBackground :< cls, Object :< cls) => cls -> IO Vector2 get_limit_end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_get_limit_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "get_limit_end" '[] (IO Vector2) where nodeMethod = Godot.Core.ParallaxBackground.get_limit_end {-# NOINLINE bindParallaxBackground_get_scroll_base_offset #-} -- | The base position offset for all @ParallaxLayer@ children. bindParallaxBackground_get_scroll_base_offset :: MethodBind bindParallaxBackground_get_scroll_base_offset = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "get_scroll_base_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The base position offset for all @ParallaxLayer@ children. get_scroll_base_offset :: (ParallaxBackground :< cls, Object :< cls) => cls -> IO Vector2 get_scroll_base_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_get_scroll_base_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "get_scroll_base_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.ParallaxBackground.get_scroll_base_offset {-# NOINLINE bindParallaxBackground_get_scroll_base_scale #-} -- | The base motion scale for all @ParallaxLayer@ children. bindParallaxBackground_get_scroll_base_scale :: MethodBind bindParallaxBackground_get_scroll_base_scale = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "get_scroll_base_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The base motion scale for all @ParallaxLayer@ children. get_scroll_base_scale :: (ParallaxBackground :< cls, Object :< cls) => cls -> IO Vector2 get_scroll_base_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_get_scroll_base_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "get_scroll_base_scale" '[] (IO Vector2) where nodeMethod = Godot.Core.ParallaxBackground.get_scroll_base_scale {-# NOINLINE bindParallaxBackground_get_scroll_offset #-} -- | The ParallaxBackground's scroll value. Calculated automatically when using a @Camera2D@, but can be used to manually manage scrolling when no camera is present. bindParallaxBackground_get_scroll_offset :: MethodBind bindParallaxBackground_get_scroll_offset = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "get_scroll_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ParallaxBackground's scroll value. Calculated automatically when using a @Camera2D@, but can be used to manually manage scrolling when no camera is present. get_scroll_offset :: (ParallaxBackground :< cls, Object :< cls) => cls -> IO Vector2 get_scroll_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_get_scroll_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "get_scroll_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.ParallaxBackground.get_scroll_offset {-# NOINLINE bindParallaxBackground_is_ignore_camera_zoom #-} -- | If @true@, elements in @ParallaxLayer@ child aren't affected by the zoom level of the camera. bindParallaxBackground_is_ignore_camera_zoom :: MethodBind bindParallaxBackground_is_ignore_camera_zoom = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "is_ignore_camera_zoom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, elements in @ParallaxLayer@ child aren't affected by the zoom level of the camera. is_ignore_camera_zoom :: (ParallaxBackground :< cls, Object :< cls) => cls -> IO Bool is_ignore_camera_zoom cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_is_ignore_camera_zoom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "is_ignore_camera_zoom" '[] (IO Bool) where nodeMethod = Godot.Core.ParallaxBackground.is_ignore_camera_zoom {-# NOINLINE bindParallaxBackground_set_ignore_camera_zoom #-} -- | If @true@, elements in @ParallaxLayer@ child aren't affected by the zoom level of the camera. bindParallaxBackground_set_ignore_camera_zoom :: MethodBind bindParallaxBackground_set_ignore_camera_zoom = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "set_ignore_camera_zoom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, elements in @ParallaxLayer@ child aren't affected by the zoom level of the camera. set_ignore_camera_zoom :: (ParallaxBackground :< cls, Object :< cls) => cls -> Bool -> IO () set_ignore_camera_zoom cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_set_ignore_camera_zoom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "set_ignore_camera_zoom" '[Bool] (IO ()) where nodeMethod = Godot.Core.ParallaxBackground.set_ignore_camera_zoom {-# NOINLINE bindParallaxBackground_set_limit_begin #-} -- | Top-left limits for scrolling to begin. If the camera is outside of this limit, the background will stop scrolling. Must be lower than @scroll_limit_end@ to work. bindParallaxBackground_set_limit_begin :: MethodBind bindParallaxBackground_set_limit_begin = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "set_limit_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Top-left limits for scrolling to begin. If the camera is outside of this limit, the background will stop scrolling. Must be lower than @scroll_limit_end@ to work. set_limit_begin :: (ParallaxBackground :< cls, Object :< cls) => cls -> Vector2 -> IO () set_limit_begin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_set_limit_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "set_limit_begin" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxBackground.set_limit_begin {-# NOINLINE bindParallaxBackground_set_limit_end #-} -- | Bottom-right limits for scrolling to end. If the camera is outside of this limit, the background will stop scrolling. Must be higher than @scroll_limit_begin@ to work. bindParallaxBackground_set_limit_end :: MethodBind bindParallaxBackground_set_limit_end = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "set_limit_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bottom-right limits for scrolling to end. If the camera is outside of this limit, the background will stop scrolling. Must be higher than @scroll_limit_begin@ to work. set_limit_end :: (ParallaxBackground :< cls, Object :< cls) => cls -> Vector2 -> IO () set_limit_end cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_set_limit_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "set_limit_end" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxBackground.set_limit_end {-# NOINLINE bindParallaxBackground_set_scroll_base_offset #-} -- | The base position offset for all @ParallaxLayer@ children. bindParallaxBackground_set_scroll_base_offset :: MethodBind bindParallaxBackground_set_scroll_base_offset = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "set_scroll_base_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The base position offset for all @ParallaxLayer@ children. set_scroll_base_offset :: (ParallaxBackground :< cls, Object :< cls) => cls -> Vector2 -> IO () set_scroll_base_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_set_scroll_base_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "set_scroll_base_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxBackground.set_scroll_base_offset {-# NOINLINE bindParallaxBackground_set_scroll_base_scale #-} -- | The base motion scale for all @ParallaxLayer@ children. bindParallaxBackground_set_scroll_base_scale :: MethodBind bindParallaxBackground_set_scroll_base_scale = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "set_scroll_base_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The base motion scale for all @ParallaxLayer@ children. set_scroll_base_scale :: (ParallaxBackground :< cls, Object :< cls) => cls -> Vector2 -> IO () set_scroll_base_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_set_scroll_base_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "set_scroll_base_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxBackground.set_scroll_base_scale {-# NOINLINE bindParallaxBackground_set_scroll_offset #-} -- | The ParallaxBackground's scroll value. Calculated automatically when using a @Camera2D@, but can be used to manually manage scrolling when no camera is present. bindParallaxBackground_set_scroll_offset :: MethodBind bindParallaxBackground_set_scroll_offset = unsafePerformIO $ withCString "ParallaxBackground" $ \ clsNamePtr -> withCString "set_scroll_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ParallaxBackground's scroll value. Calculated automatically when using a @Camera2D@, but can be used to manually manage scrolling when no camera is present. set_scroll_offset :: (ParallaxBackground :< cls, Object :< cls) => cls -> Vector2 -> IO () set_scroll_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxBackground_set_scroll_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxBackground "set_scroll_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxBackground.set_scroll_offset ================================================ FILE: src/Godot/Core/ParallaxLayer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ParallaxLayer (Godot.Core.ParallaxLayer.get_mirroring, Godot.Core.ParallaxLayer.get_motion_offset, Godot.Core.ParallaxLayer.get_motion_scale, Godot.Core.ParallaxLayer.set_mirroring, Godot.Core.ParallaxLayer.set_motion_offset, Godot.Core.ParallaxLayer.set_motion_scale) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty ParallaxLayer "motion_mirroring" Vector2 'False where nodeProperty = (get_mirroring, wrapDroppingSetter set_mirroring, Nothing) instance NodeProperty ParallaxLayer "motion_offset" Vector2 'False where nodeProperty = (get_motion_offset, wrapDroppingSetter set_motion_offset, Nothing) instance NodeProperty ParallaxLayer "motion_scale" Vector2 'False where nodeProperty = (get_motion_scale, wrapDroppingSetter set_motion_scale, Nothing) {-# NOINLINE bindParallaxLayer_get_mirroring #-} -- | The ParallaxLayer's @Texture@ mirroring. Useful for creating an infinite scrolling background. If an axis is set to @0@, the @Texture@ will not be mirrored. bindParallaxLayer_get_mirroring :: MethodBind bindParallaxLayer_get_mirroring = unsafePerformIO $ withCString "ParallaxLayer" $ \ clsNamePtr -> withCString "get_mirroring" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ParallaxLayer's @Texture@ mirroring. Useful for creating an infinite scrolling background. If an axis is set to @0@, the @Texture@ will not be mirrored. get_mirroring :: (ParallaxLayer :< cls, Object :< cls) => cls -> IO Vector2 get_mirroring cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxLayer_get_mirroring (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxLayer "get_mirroring" '[] (IO Vector2) where nodeMethod = Godot.Core.ParallaxLayer.get_mirroring {-# NOINLINE bindParallaxLayer_get_motion_offset #-} -- | The ParallaxLayer's offset relative to the parent ParallaxBackground's @ParallaxBackground.scroll_offset@. bindParallaxLayer_get_motion_offset :: MethodBind bindParallaxLayer_get_motion_offset = unsafePerformIO $ withCString "ParallaxLayer" $ \ clsNamePtr -> withCString "get_motion_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ParallaxLayer's offset relative to the parent ParallaxBackground's @ParallaxBackground.scroll_offset@. get_motion_offset :: (ParallaxLayer :< cls, Object :< cls) => cls -> IO Vector2 get_motion_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxLayer_get_motion_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxLayer "get_motion_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.ParallaxLayer.get_motion_offset {-# NOINLINE bindParallaxLayer_get_motion_scale #-} -- | Multiplies the ParallaxLayer's motion. If an axis is set to @0@, it will not scroll. bindParallaxLayer_get_motion_scale :: MethodBind bindParallaxLayer_get_motion_scale = unsafePerformIO $ withCString "ParallaxLayer" $ \ clsNamePtr -> withCString "get_motion_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the ParallaxLayer's motion. If an axis is set to @0@, it will not scroll. get_motion_scale :: (ParallaxLayer :< cls, Object :< cls) => cls -> IO Vector2 get_motion_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxLayer_get_motion_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxLayer "get_motion_scale" '[] (IO Vector2) where nodeMethod = Godot.Core.ParallaxLayer.get_motion_scale {-# NOINLINE bindParallaxLayer_set_mirroring #-} -- | The ParallaxLayer's @Texture@ mirroring. Useful for creating an infinite scrolling background. If an axis is set to @0@, the @Texture@ will not be mirrored. bindParallaxLayer_set_mirroring :: MethodBind bindParallaxLayer_set_mirroring = unsafePerformIO $ withCString "ParallaxLayer" $ \ clsNamePtr -> withCString "set_mirroring" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ParallaxLayer's @Texture@ mirroring. Useful for creating an infinite scrolling background. If an axis is set to @0@, the @Texture@ will not be mirrored. set_mirroring :: (ParallaxLayer :< cls, Object :< cls) => cls -> Vector2 -> IO () set_mirroring cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxLayer_set_mirroring (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxLayer "set_mirroring" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxLayer.set_mirroring {-# NOINLINE bindParallaxLayer_set_motion_offset #-} -- | The ParallaxLayer's offset relative to the parent ParallaxBackground's @ParallaxBackground.scroll_offset@. bindParallaxLayer_set_motion_offset :: MethodBind bindParallaxLayer_set_motion_offset = unsafePerformIO $ withCString "ParallaxLayer" $ \ clsNamePtr -> withCString "set_motion_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ParallaxLayer's offset relative to the parent ParallaxBackground's @ParallaxBackground.scroll_offset@. set_motion_offset :: (ParallaxLayer :< cls, Object :< cls) => cls -> Vector2 -> IO () set_motion_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxLayer_set_motion_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxLayer "set_motion_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxLayer.set_motion_offset {-# NOINLINE bindParallaxLayer_set_motion_scale #-} -- | Multiplies the ParallaxLayer's motion. If an axis is set to @0@, it will not scroll. bindParallaxLayer_set_motion_scale :: MethodBind bindParallaxLayer_set_motion_scale = unsafePerformIO $ withCString "ParallaxLayer" $ \ clsNamePtr -> withCString "set_motion_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the ParallaxLayer's motion. If an axis is set to @0@, it will not scroll. set_motion_scale :: (ParallaxLayer :< cls, Object :< cls) => cls -> Vector2 -> IO () set_motion_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParallaxLayer_set_motion_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParallaxLayer "set_motion_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.ParallaxLayer.set_motion_scale ================================================ FILE: src/Godot/Core/Particles.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Particles (Godot.Core.Particles._MAX_DRAW_PASSES, Godot.Core.Particles._DRAW_ORDER_LIFETIME, Godot.Core.Particles._DRAW_ORDER_INDEX, Godot.Core.Particles._DRAW_ORDER_VIEW_DEPTH, Godot.Core.Particles.capture_aabb, Godot.Core.Particles.get_amount, Godot.Core.Particles.get_draw_order, Godot.Core.Particles.get_draw_pass_mesh, Godot.Core.Particles.get_draw_passes, Godot.Core.Particles.get_explosiveness_ratio, Godot.Core.Particles.get_fixed_fps, Godot.Core.Particles.get_fractional_delta, Godot.Core.Particles.get_lifetime, Godot.Core.Particles.get_one_shot, Godot.Core.Particles.get_pre_process_time, Godot.Core.Particles.get_process_material, Godot.Core.Particles.get_randomness_ratio, Godot.Core.Particles.get_speed_scale, Godot.Core.Particles.get_use_local_coordinates, Godot.Core.Particles.get_visibility_aabb, Godot.Core.Particles.is_emitting, Godot.Core.Particles.restart, Godot.Core.Particles.set_amount, Godot.Core.Particles.set_draw_order, Godot.Core.Particles.set_draw_pass_mesh, Godot.Core.Particles.set_draw_passes, Godot.Core.Particles.set_emitting, Godot.Core.Particles.set_explosiveness_ratio, Godot.Core.Particles.set_fixed_fps, Godot.Core.Particles.set_fractional_delta, Godot.Core.Particles.set_lifetime, Godot.Core.Particles.set_one_shot, Godot.Core.Particles.set_pre_process_time, Godot.Core.Particles.set_process_material, Godot.Core.Particles.set_randomness_ratio, Godot.Core.Particles.set_speed_scale, Godot.Core.Particles.set_use_local_coordinates, Godot.Core.Particles.set_visibility_aabb) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.GeometryInstance() _MAX_DRAW_PASSES :: Int _MAX_DRAW_PASSES = 4 _DRAW_ORDER_LIFETIME :: Int _DRAW_ORDER_LIFETIME = 1 _DRAW_ORDER_INDEX :: Int _DRAW_ORDER_INDEX = 0 _DRAW_ORDER_VIEW_DEPTH :: Int _DRAW_ORDER_VIEW_DEPTH = 2 instance NodeProperty Particles "amount" Int 'False where nodeProperty = (get_amount, wrapDroppingSetter set_amount, Nothing) instance NodeProperty Particles "draw_order" Int 'False where nodeProperty = (get_draw_order, wrapDroppingSetter set_draw_order, Nothing) instance NodeProperty Particles "draw_pass_1" Mesh 'False where nodeProperty = (wrapIndexedGetter 0 get_draw_pass_mesh, wrapIndexedSetter 0 set_draw_pass_mesh, Nothing) instance NodeProperty Particles "draw_pass_2" Mesh 'False where nodeProperty = (wrapIndexedGetter 1 get_draw_pass_mesh, wrapIndexedSetter 1 set_draw_pass_mesh, Nothing) instance NodeProperty Particles "draw_pass_3" Mesh 'False where nodeProperty = (wrapIndexedGetter 2 get_draw_pass_mesh, wrapIndexedSetter 2 set_draw_pass_mesh, Nothing) instance NodeProperty Particles "draw_pass_4" Mesh 'False where nodeProperty = (wrapIndexedGetter 3 get_draw_pass_mesh, wrapIndexedSetter 3 set_draw_pass_mesh, Nothing) instance NodeProperty Particles "draw_passes" Int 'False where nodeProperty = (get_draw_passes, wrapDroppingSetter set_draw_passes, Nothing) instance NodeProperty Particles "emitting" Bool 'False where nodeProperty = (is_emitting, wrapDroppingSetter set_emitting, Nothing) instance NodeProperty Particles "explosiveness" Float 'False where nodeProperty = (get_explosiveness_ratio, wrapDroppingSetter set_explosiveness_ratio, Nothing) instance NodeProperty Particles "fixed_fps" Int 'False where nodeProperty = (get_fixed_fps, wrapDroppingSetter set_fixed_fps, Nothing) instance NodeProperty Particles "fract_delta" Bool 'False where nodeProperty = (get_fractional_delta, wrapDroppingSetter set_fractional_delta, Nothing) instance NodeProperty Particles "lifetime" Float 'False where nodeProperty = (get_lifetime, wrapDroppingSetter set_lifetime, Nothing) instance NodeProperty Particles "local_coords" Bool 'False where nodeProperty = (get_use_local_coordinates, wrapDroppingSetter set_use_local_coordinates, Nothing) instance NodeProperty Particles "one_shot" Bool 'False where nodeProperty = (get_one_shot, wrapDroppingSetter set_one_shot, Nothing) instance NodeProperty Particles "preprocess" Float 'False where nodeProperty = (get_pre_process_time, wrapDroppingSetter set_pre_process_time, Nothing) instance NodeProperty Particles "process_material" Material 'False where nodeProperty = (get_process_material, wrapDroppingSetter set_process_material, Nothing) instance NodeProperty Particles "randomness" Float 'False where nodeProperty = (get_randomness_ratio, wrapDroppingSetter set_randomness_ratio, Nothing) instance NodeProperty Particles "speed_scale" Float 'False where nodeProperty = (get_speed_scale, wrapDroppingSetter set_speed_scale, Nothing) instance NodeProperty Particles "visibility_aabb" Aabb 'False where nodeProperty = (get_visibility_aabb, wrapDroppingSetter set_visibility_aabb, Nothing) {-# NOINLINE bindParticles_capture_aabb #-} -- | Returns the axis-aligned bounding box that contains all the particles that are active in the current frame. bindParticles_capture_aabb :: MethodBind bindParticles_capture_aabb = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "capture_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the axis-aligned bounding box that contains all the particles that are active in the current frame. capture_aabb :: (Particles :< cls, Object :< cls) => cls -> IO Aabb capture_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_capture_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "capture_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.Particles.capture_aabb {-# NOINLINE bindParticles_get_amount #-} -- | Number of particles to emit. bindParticles_get_amount :: MethodBind bindParticles_get_amount = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of particles to emit. get_amount :: (Particles :< cls, Object :< cls) => cls -> IO Int get_amount cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_amount" '[] (IO Int) where nodeMethod = Godot.Core.Particles.get_amount {-# NOINLINE bindParticles_get_draw_order #-} -- | Particle draw order. Uses @enum DrawOrder@ values. bindParticles_get_draw_order :: MethodBind bindParticles_get_draw_order = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle draw order. Uses @enum DrawOrder@ values. get_draw_order :: (Particles :< cls, Object :< cls) => cls -> IO Int get_draw_order cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_draw_order" '[] (IO Int) where nodeMethod = Godot.Core.Particles.get_draw_order {-# NOINLINE bindParticles_get_draw_pass_mesh #-} -- | Returns the @Mesh@ that is drawn at index @pass@. bindParticles_get_draw_pass_mesh :: MethodBind bindParticles_get_draw_pass_mesh = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_draw_pass_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Mesh@ that is drawn at index @pass@. get_draw_pass_mesh :: (Particles :< cls, Object :< cls) => cls -> Int -> IO Mesh get_draw_pass_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_draw_pass_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_draw_pass_mesh" '[Int] (IO Mesh) where nodeMethod = Godot.Core.Particles.get_draw_pass_mesh {-# NOINLINE bindParticles_get_draw_passes #-} -- | The number of draw passes when rendering particles. bindParticles_get_draw_passes :: MethodBind bindParticles_get_draw_passes = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_draw_passes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of draw passes when rendering particles. get_draw_passes :: (Particles :< cls, Object :< cls) => cls -> IO Int get_draw_passes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_draw_passes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_draw_passes" '[] (IO Int) where nodeMethod = Godot.Core.Particles.get_draw_passes {-# NOINLINE bindParticles_get_explosiveness_ratio #-} -- | Time ratio between each emission. If @0@, particles are emitted continuously. If @1@, all particles are emitted simultaneously. bindParticles_get_explosiveness_ratio :: MethodBind bindParticles_get_explosiveness_ratio = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Time ratio between each emission. If @0@, particles are emitted continuously. If @1@, all particles are emitted simultaneously. get_explosiveness_ratio :: (Particles :< cls, Object :< cls) => cls -> IO Float get_explosiveness_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_explosiveness_ratio" '[] (IO Float) where nodeMethod = Godot.Core.Particles.get_explosiveness_ratio {-# NOINLINE bindParticles_get_fixed_fps #-} -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. bindParticles_get_fixed_fps :: MethodBind bindParticles_get_fixed_fps = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. get_fixed_fps :: (Particles :< cls, Object :< cls) => cls -> IO Int get_fixed_fps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_fixed_fps" '[] (IO Int) where nodeMethod = Godot.Core.Particles.get_fixed_fps {-# NOINLINE bindParticles_get_fractional_delta #-} -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. bindParticles_get_fractional_delta :: MethodBind bindParticles_get_fractional_delta = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. get_fractional_delta :: (Particles :< cls, Object :< cls) => cls -> IO Bool get_fractional_delta cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_fractional_delta" '[] (IO Bool) where nodeMethod = Godot.Core.Particles.get_fractional_delta {-# NOINLINE bindParticles_get_lifetime #-} -- | Amount of time each particle will exist. bindParticles_get_lifetime :: MethodBind bindParticles_get_lifetime = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time each particle will exist. get_lifetime :: (Particles :< cls, Object :< cls) => cls -> IO Float get_lifetime cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_lifetime" '[] (IO Float) where nodeMethod = Godot.Core.Particles.get_lifetime {-# NOINLINE bindParticles_get_one_shot #-} -- | If @true@, only @amount@ particles will be emitted. bindParticles_get_one_shot :: MethodBind bindParticles_get_one_shot = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only @amount@ particles will be emitted. get_one_shot :: (Particles :< cls, Object :< cls) => cls -> IO Bool get_one_shot cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_one_shot" '[] (IO Bool) where nodeMethod = Godot.Core.Particles.get_one_shot {-# NOINLINE bindParticles_get_pre_process_time #-} -- | Amount of time to preprocess the particles before animation starts. Lets you start the animation some time after particles have started emitting. bindParticles_get_pre_process_time :: MethodBind bindParticles_get_pre_process_time = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time to preprocess the particles before animation starts. Lets you start the animation some time after particles have started emitting. get_pre_process_time :: (Particles :< cls, Object :< cls) => cls -> IO Float get_pre_process_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_pre_process_time" '[] (IO Float) where nodeMethod = Godot.Core.Particles.get_pre_process_time {-# NOINLINE bindParticles_get_process_material #-} -- | @Material@ for processing particles. Can be a @ParticlesMaterial@ or a @ShaderMaterial@. bindParticles_get_process_material :: MethodBind bindParticles_get_process_material = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_process_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Material@ for processing particles. Can be a @ParticlesMaterial@ or a @ShaderMaterial@. get_process_material :: (Particles :< cls, Object :< cls) => cls -> IO Material get_process_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_process_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_process_material" '[] (IO Material) where nodeMethod = Godot.Core.Particles.get_process_material {-# NOINLINE bindParticles_get_randomness_ratio #-} -- | Emission randomness ratio. bindParticles_get_randomness_ratio :: MethodBind bindParticles_get_randomness_ratio = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emission randomness ratio. get_randomness_ratio :: (Particles :< cls, Object :< cls) => cls -> IO Float get_randomness_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_randomness_ratio" '[] (IO Float) where nodeMethod = Godot.Core.Particles.get_randomness_ratio {-# NOINLINE bindParticles_get_speed_scale #-} -- | Speed scaling ratio. A value of @0@ can be used to pause the particles. bindParticles_get_speed_scale :: MethodBind bindParticles_get_speed_scale = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Speed scaling ratio. A value of @0@ can be used to pause the particles. get_speed_scale :: (Particles :< cls, Object :< cls) => cls -> IO Float get_speed_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_speed_scale" '[] (IO Float) where nodeMethod = Godot.Core.Particles.get_speed_scale {-# NOINLINE bindParticles_get_use_local_coordinates #-} -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. bindParticles_get_use_local_coordinates :: MethodBind bindParticles_get_use_local_coordinates = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. get_use_local_coordinates :: (Particles :< cls, Object :< cls) => cls -> IO Bool get_use_local_coordinates cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_use_local_coordinates" '[] (IO Bool) where nodeMethod = Godot.Core.Particles.get_use_local_coordinates {-# NOINLINE bindParticles_get_visibility_aabb #-} -- | The @AABB@ that determines the area of the world part of which needs to be visible on screen for the particle system to be active. -- __Note:__ If the @ParticlesMaterial@ in use is configured to cast shadows, you may want to enlarge this AABB to ensure the shadow is updated when particles are off-screen. bindParticles_get_visibility_aabb :: MethodBind bindParticles_get_visibility_aabb = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "get_visibility_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @AABB@ that determines the area of the world part of which needs to be visible on screen for the particle system to be active. -- __Note:__ If the @ParticlesMaterial@ in use is configured to cast shadows, you may want to enlarge this AABB to ensure the shadow is updated when particles are off-screen. get_visibility_aabb :: (Particles :< cls, Object :< cls) => cls -> IO Aabb get_visibility_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_get_visibility_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "get_visibility_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.Particles.get_visibility_aabb {-# NOINLINE bindParticles_is_emitting #-} -- | If @true@, particles are being emitted. bindParticles_is_emitting :: MethodBind bindParticles_is_emitting = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "is_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles are being emitted. is_emitting :: (Particles :< cls, Object :< cls) => cls -> IO Bool is_emitting cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_is_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "is_emitting" '[] (IO Bool) where nodeMethod = Godot.Core.Particles.is_emitting {-# NOINLINE bindParticles_restart #-} -- | Restarts the particle emission, clearing existing particles. bindParticles_restart :: MethodBind bindParticles_restart = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "restart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Restarts the particle emission, clearing existing particles. restart :: (Particles :< cls, Object :< cls) => cls -> IO () restart cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_restart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "restart" '[] (IO ()) where nodeMethod = Godot.Core.Particles.restart {-# NOINLINE bindParticles_set_amount #-} -- | Number of particles to emit. bindParticles_set_amount :: MethodBind bindParticles_set_amount = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of particles to emit. set_amount :: (Particles :< cls, Object :< cls) => cls -> Int -> IO () set_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_amount" '[Int] (IO ()) where nodeMethod = Godot.Core.Particles.set_amount {-# NOINLINE bindParticles_set_draw_order #-} -- | Particle draw order. Uses @enum DrawOrder@ values. bindParticles_set_draw_order :: MethodBind bindParticles_set_draw_order = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle draw order. Uses @enum DrawOrder@ values. set_draw_order :: (Particles :< cls, Object :< cls) => cls -> Int -> IO () set_draw_order cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_draw_order" '[Int] (IO ()) where nodeMethod = Godot.Core.Particles.set_draw_order {-# NOINLINE bindParticles_set_draw_pass_mesh #-} -- | Sets the @Mesh@ that is drawn at index @pass@. bindParticles_set_draw_pass_mesh :: MethodBind bindParticles_set_draw_pass_mesh = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_draw_pass_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Mesh@ that is drawn at index @pass@. set_draw_pass_mesh :: (Particles :< cls, Object :< cls) => cls -> Int -> Mesh -> IO () set_draw_pass_mesh cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_draw_pass_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_draw_pass_mesh" '[Int, Mesh] (IO ()) where nodeMethod = Godot.Core.Particles.set_draw_pass_mesh {-# NOINLINE bindParticles_set_draw_passes #-} -- | The number of draw passes when rendering particles. bindParticles_set_draw_passes :: MethodBind bindParticles_set_draw_passes = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_draw_passes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of draw passes when rendering particles. set_draw_passes :: (Particles :< cls, Object :< cls) => cls -> Int -> IO () set_draw_passes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_draw_passes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_draw_passes" '[Int] (IO ()) where nodeMethod = Godot.Core.Particles.set_draw_passes {-# NOINLINE bindParticles_set_emitting #-} -- | If @true@, particles are being emitted. bindParticles_set_emitting :: MethodBind bindParticles_set_emitting = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles are being emitted. set_emitting :: (Particles :< cls, Object :< cls) => cls -> Bool -> IO () set_emitting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_emitting" '[Bool] (IO ()) where nodeMethod = Godot.Core.Particles.set_emitting {-# NOINLINE bindParticles_set_explosiveness_ratio #-} -- | Time ratio between each emission. If @0@, particles are emitted continuously. If @1@, all particles are emitted simultaneously. bindParticles_set_explosiveness_ratio :: MethodBind bindParticles_set_explosiveness_ratio = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Time ratio between each emission. If @0@, particles are emitted continuously. If @1@, all particles are emitted simultaneously. set_explosiveness_ratio :: (Particles :< cls, Object :< cls) => cls -> Float -> IO () set_explosiveness_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_explosiveness_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles.set_explosiveness_ratio {-# NOINLINE bindParticles_set_fixed_fps #-} -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. bindParticles_set_fixed_fps :: MethodBind bindParticles_set_fixed_fps = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. set_fixed_fps :: (Particles :< cls, Object :< cls) => cls -> Int -> IO () set_fixed_fps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_fixed_fps" '[Int] (IO ()) where nodeMethod = Godot.Core.Particles.set_fixed_fps {-# NOINLINE bindParticles_set_fractional_delta #-} -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. bindParticles_set_fractional_delta :: MethodBind bindParticles_set_fractional_delta = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. set_fractional_delta :: (Particles :< cls, Object :< cls) => cls -> Bool -> IO () set_fractional_delta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_fractional_delta" '[Bool] (IO ()) where nodeMethod = Godot.Core.Particles.set_fractional_delta {-# NOINLINE bindParticles_set_lifetime #-} -- | Amount of time each particle will exist. bindParticles_set_lifetime :: MethodBind bindParticles_set_lifetime = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time each particle will exist. set_lifetime :: (Particles :< cls, Object :< cls) => cls -> Float -> IO () set_lifetime cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_lifetime" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles.set_lifetime {-# NOINLINE bindParticles_set_one_shot #-} -- | If @true@, only @amount@ particles will be emitted. bindParticles_set_one_shot :: MethodBind bindParticles_set_one_shot = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only @amount@ particles will be emitted. set_one_shot :: (Particles :< cls, Object :< cls) => cls -> Bool -> IO () set_one_shot cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_one_shot" '[Bool] (IO ()) where nodeMethod = Godot.Core.Particles.set_one_shot {-# NOINLINE bindParticles_set_pre_process_time #-} -- | Amount of time to preprocess the particles before animation starts. Lets you start the animation some time after particles have started emitting. bindParticles_set_pre_process_time :: MethodBind bindParticles_set_pre_process_time = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time to preprocess the particles before animation starts. Lets you start the animation some time after particles have started emitting. set_pre_process_time :: (Particles :< cls, Object :< cls) => cls -> Float -> IO () set_pre_process_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_pre_process_time" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles.set_pre_process_time {-# NOINLINE bindParticles_set_process_material #-} -- | @Material@ for processing particles. Can be a @ParticlesMaterial@ or a @ShaderMaterial@. bindParticles_set_process_material :: MethodBind bindParticles_set_process_material = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_process_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Material@ for processing particles. Can be a @ParticlesMaterial@ or a @ShaderMaterial@. set_process_material :: (Particles :< cls, Object :< cls) => cls -> Material -> IO () set_process_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_process_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_process_material" '[Material] (IO ()) where nodeMethod = Godot.Core.Particles.set_process_material {-# NOINLINE bindParticles_set_randomness_ratio #-} -- | Emission randomness ratio. bindParticles_set_randomness_ratio :: MethodBind bindParticles_set_randomness_ratio = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emission randomness ratio. set_randomness_ratio :: (Particles :< cls, Object :< cls) => cls -> Float -> IO () set_randomness_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_randomness_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles.set_randomness_ratio {-# NOINLINE bindParticles_set_speed_scale #-} -- | Speed scaling ratio. A value of @0@ can be used to pause the particles. bindParticles_set_speed_scale :: MethodBind bindParticles_set_speed_scale = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Speed scaling ratio. A value of @0@ can be used to pause the particles. set_speed_scale :: (Particles :< cls, Object :< cls) => cls -> Float -> IO () set_speed_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_speed_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles.set_speed_scale {-# NOINLINE bindParticles_set_use_local_coordinates #-} -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. bindParticles_set_use_local_coordinates :: MethodBind bindParticles_set_use_local_coordinates = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. set_use_local_coordinates :: (Particles :< cls, Object :< cls) => cls -> Bool -> IO () set_use_local_coordinates cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_use_local_coordinates" '[Bool] (IO ()) where nodeMethod = Godot.Core.Particles.set_use_local_coordinates {-# NOINLINE bindParticles_set_visibility_aabb #-} -- | The @AABB@ that determines the area of the world part of which needs to be visible on screen for the particle system to be active. -- __Note:__ If the @ParticlesMaterial@ in use is configured to cast shadows, you may want to enlarge this AABB to ensure the shadow is updated when particles are off-screen. bindParticles_set_visibility_aabb :: MethodBind bindParticles_set_visibility_aabb = unsafePerformIO $ withCString "Particles" $ \ clsNamePtr -> withCString "set_visibility_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @AABB@ that determines the area of the world part of which needs to be visible on screen for the particle system to be active. -- __Note:__ If the @ParticlesMaterial@ in use is configured to cast shadows, you may want to enlarge this AABB to ensure the shadow is updated when particles are off-screen. set_visibility_aabb :: (Particles :< cls, Object :< cls) => cls -> Aabb -> IO () set_visibility_aabb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles_set_visibility_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles "set_visibility_aabb" '[Aabb] (IO ()) where nodeMethod = Godot.Core.Particles.set_visibility_aabb ================================================ FILE: src/Godot/Core/Particles2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Particles2D (Godot.Core.Particles2D._DRAW_ORDER_LIFETIME, Godot.Core.Particles2D._DRAW_ORDER_INDEX, Godot.Core.Particles2D.capture_rect, Godot.Core.Particles2D.get_amount, Godot.Core.Particles2D.get_draw_order, Godot.Core.Particles2D.get_explosiveness_ratio, Godot.Core.Particles2D.get_fixed_fps, Godot.Core.Particles2D.get_fractional_delta, Godot.Core.Particles2D.get_lifetime, Godot.Core.Particles2D.get_normal_map, Godot.Core.Particles2D.get_one_shot, Godot.Core.Particles2D.get_pre_process_time, Godot.Core.Particles2D.get_process_material, Godot.Core.Particles2D.get_randomness_ratio, Godot.Core.Particles2D.get_speed_scale, Godot.Core.Particles2D.get_texture, Godot.Core.Particles2D.get_use_local_coordinates, Godot.Core.Particles2D.get_visibility_rect, Godot.Core.Particles2D.is_emitting, Godot.Core.Particles2D.restart, Godot.Core.Particles2D.set_amount, Godot.Core.Particles2D.set_draw_order, Godot.Core.Particles2D.set_emitting, Godot.Core.Particles2D.set_explosiveness_ratio, Godot.Core.Particles2D.set_fixed_fps, Godot.Core.Particles2D.set_fractional_delta, Godot.Core.Particles2D.set_lifetime, Godot.Core.Particles2D.set_normal_map, Godot.Core.Particles2D.set_one_shot, Godot.Core.Particles2D.set_pre_process_time, Godot.Core.Particles2D.set_process_material, Godot.Core.Particles2D.set_randomness_ratio, Godot.Core.Particles2D.set_speed_scale, Godot.Core.Particles2D.set_texture, Godot.Core.Particles2D.set_use_local_coordinates, Godot.Core.Particles2D.set_visibility_rect) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _DRAW_ORDER_LIFETIME :: Int _DRAW_ORDER_LIFETIME = 1 _DRAW_ORDER_INDEX :: Int _DRAW_ORDER_INDEX = 0 instance NodeProperty Particles2D "amount" Int 'False where nodeProperty = (get_amount, wrapDroppingSetter set_amount, Nothing) instance NodeProperty Particles2D "draw_order" Int 'False where nodeProperty = (get_draw_order, wrapDroppingSetter set_draw_order, Nothing) instance NodeProperty Particles2D "emitting" Bool 'False where nodeProperty = (is_emitting, wrapDroppingSetter set_emitting, Nothing) instance NodeProperty Particles2D "explosiveness" Float 'False where nodeProperty = (get_explosiveness_ratio, wrapDroppingSetter set_explosiveness_ratio, Nothing) instance NodeProperty Particles2D "fixed_fps" Int 'False where nodeProperty = (get_fixed_fps, wrapDroppingSetter set_fixed_fps, Nothing) instance NodeProperty Particles2D "fract_delta" Bool 'False where nodeProperty = (get_fractional_delta, wrapDroppingSetter set_fractional_delta, Nothing) instance NodeProperty Particles2D "lifetime" Float 'False where nodeProperty = (get_lifetime, wrapDroppingSetter set_lifetime, Nothing) instance NodeProperty Particles2D "local_coords" Bool 'False where nodeProperty = (get_use_local_coordinates, wrapDroppingSetter set_use_local_coordinates, Nothing) instance NodeProperty Particles2D "normal_map" Texture 'False where nodeProperty = (get_normal_map, wrapDroppingSetter set_normal_map, Nothing) instance NodeProperty Particles2D "one_shot" Bool 'False where nodeProperty = (get_one_shot, wrapDroppingSetter set_one_shot, Nothing) instance NodeProperty Particles2D "preprocess" Float 'False where nodeProperty = (get_pre_process_time, wrapDroppingSetter set_pre_process_time, Nothing) instance NodeProperty Particles2D "process_material" Material 'False where nodeProperty = (get_process_material, wrapDroppingSetter set_process_material, Nothing) instance NodeProperty Particles2D "randomness" Float 'False where nodeProperty = (get_randomness_ratio, wrapDroppingSetter set_randomness_ratio, Nothing) instance NodeProperty Particles2D "speed_scale" Float 'False where nodeProperty = (get_speed_scale, wrapDroppingSetter set_speed_scale, Nothing) instance NodeProperty Particles2D "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) instance NodeProperty Particles2D "visibility_rect" Rect2 'False where nodeProperty = (get_visibility_rect, wrapDroppingSetter set_visibility_rect, Nothing) {-# NOINLINE bindParticles2D_capture_rect #-} -- | Returns a rectangle containing the positions of all existing particles. bindParticles2D_capture_rect :: MethodBind bindParticles2D_capture_rect = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "capture_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a rectangle containing the positions of all existing particles. capture_rect :: (Particles2D :< cls, Object :< cls) => cls -> IO Rect2 capture_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_capture_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "capture_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Particles2D.capture_rect {-# NOINLINE bindParticles2D_get_amount #-} -- | Number of particles emitted in one emission cycle. bindParticles2D_get_amount :: MethodBind bindParticles2D_get_amount = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of particles emitted in one emission cycle. get_amount :: (Particles2D :< cls, Object :< cls) => cls -> IO Int get_amount cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_amount" '[] (IO Int) where nodeMethod = Godot.Core.Particles2D.get_amount {-# NOINLINE bindParticles2D_get_draw_order #-} -- | Particle draw order. Uses @enum DrawOrder@ values. bindParticles2D_get_draw_order :: MethodBind bindParticles2D_get_draw_order = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle draw order. Uses @enum DrawOrder@ values. get_draw_order :: (Particles2D :< cls, Object :< cls) => cls -> IO Int get_draw_order cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_draw_order" '[] (IO Int) where nodeMethod = Godot.Core.Particles2D.get_draw_order {-# NOINLINE bindParticles2D_get_explosiveness_ratio #-} -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. bindParticles2D_get_explosiveness_ratio :: MethodBind bindParticles2D_get_explosiveness_ratio = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. get_explosiveness_ratio :: (Particles2D :< cls, Object :< cls) => cls -> IO Float get_explosiveness_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_explosiveness_ratio" '[] (IO Float) where nodeMethod = Godot.Core.Particles2D.get_explosiveness_ratio {-# NOINLINE bindParticles2D_get_fixed_fps #-} -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. bindParticles2D_get_fixed_fps :: MethodBind bindParticles2D_get_fixed_fps = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. get_fixed_fps :: (Particles2D :< cls, Object :< cls) => cls -> IO Int get_fixed_fps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_fixed_fps" '[] (IO Int) where nodeMethod = Godot.Core.Particles2D.get_fixed_fps {-# NOINLINE bindParticles2D_get_fractional_delta #-} -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. bindParticles2D_get_fractional_delta :: MethodBind bindParticles2D_get_fractional_delta = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. get_fractional_delta :: (Particles2D :< cls, Object :< cls) => cls -> IO Bool get_fractional_delta cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_fractional_delta" '[] (IO Bool) where nodeMethod = Godot.Core.Particles2D.get_fractional_delta {-# NOINLINE bindParticles2D_get_lifetime #-} -- | Amount of time each particle will exist. bindParticles2D_get_lifetime :: MethodBind bindParticles2D_get_lifetime = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time each particle will exist. get_lifetime :: (Particles2D :< cls, Object :< cls) => cls -> IO Float get_lifetime cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_lifetime" '[] (IO Float) where nodeMethod = Godot.Core.Particles2D.get_lifetime {-# NOINLINE bindParticles2D_get_normal_map #-} -- | Normal map to be used for the @texture@ property. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindParticles2D_get_normal_map :: MethodBind bindParticles2D_get_normal_map = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Normal map to be used for the @texture@ property. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. get_normal_map :: (Particles2D :< cls, Object :< cls) => cls -> IO Texture get_normal_map cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_normal_map" '[] (IO Texture) where nodeMethod = Godot.Core.Particles2D.get_normal_map {-# NOINLINE bindParticles2D_get_one_shot #-} -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. bindParticles2D_get_one_shot :: MethodBind bindParticles2D_get_one_shot = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. get_one_shot :: (Particles2D :< cls, Object :< cls) => cls -> IO Bool get_one_shot cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_one_shot" '[] (IO Bool) where nodeMethod = Godot.Core.Particles2D.get_one_shot {-# NOINLINE bindParticles2D_get_pre_process_time #-} -- | Particle system starts as if it had already run for this many seconds. bindParticles2D_get_pre_process_time :: MethodBind bindParticles2D_get_pre_process_time = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system starts as if it had already run for this many seconds. get_pre_process_time :: (Particles2D :< cls, Object :< cls) => cls -> IO Float get_pre_process_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_pre_process_time" '[] (IO Float) where nodeMethod = Godot.Core.Particles2D.get_pre_process_time {-# NOINLINE bindParticles2D_get_process_material #-} -- | @Material@ for processing particles. Can be a @ParticlesMaterial@ or a @ShaderMaterial@. bindParticles2D_get_process_material :: MethodBind bindParticles2D_get_process_material = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_process_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Material@ for processing particles. Can be a @ParticlesMaterial@ or a @ShaderMaterial@. get_process_material :: (Particles2D :< cls, Object :< cls) => cls -> IO Material get_process_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_process_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_process_material" '[] (IO Material) where nodeMethod = Godot.Core.Particles2D.get_process_material {-# NOINLINE bindParticles2D_get_randomness_ratio #-} -- | Emission lifetime randomness ratio. bindParticles2D_get_randomness_ratio :: MethodBind bindParticles2D_get_randomness_ratio = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emission lifetime randomness ratio. get_randomness_ratio :: (Particles2D :< cls, Object :< cls) => cls -> IO Float get_randomness_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_randomness_ratio" '[] (IO Float) where nodeMethod = Godot.Core.Particles2D.get_randomness_ratio {-# NOINLINE bindParticles2D_get_speed_scale #-} -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. bindParticles2D_get_speed_scale :: MethodBind bindParticles2D_get_speed_scale = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. get_speed_scale :: (Particles2D :< cls, Object :< cls) => cls -> IO Float get_speed_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_speed_scale" '[] (IO Float) where nodeMethod = Godot.Core.Particles2D.get_speed_scale {-# NOINLINE bindParticles2D_get_texture #-} -- | Particle texture. If @null@, particles will be squares. bindParticles2D_get_texture :: MethodBind bindParticles2D_get_texture = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle texture. If @null@, particles will be squares. get_texture :: (Particles2D :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.Particles2D.get_texture {-# NOINLINE bindParticles2D_get_use_local_coordinates #-} -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. bindParticles2D_get_use_local_coordinates :: MethodBind bindParticles2D_get_use_local_coordinates = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. get_use_local_coordinates :: (Particles2D :< cls, Object :< cls) => cls -> IO Bool get_use_local_coordinates cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_use_local_coordinates" '[] (IO Bool) where nodeMethod = Godot.Core.Particles2D.get_use_local_coordinates {-# NOINLINE bindParticles2D_get_visibility_rect #-} -- | Editor visibility helper. bindParticles2D_get_visibility_rect :: MethodBind bindParticles2D_get_visibility_rect = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "get_visibility_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Editor visibility helper. get_visibility_rect :: (Particles2D :< cls, Object :< cls) => cls -> IO Rect2 get_visibility_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_get_visibility_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "get_visibility_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Particles2D.get_visibility_rect {-# NOINLINE bindParticles2D_is_emitting #-} -- | If @true@, particles are being emitted. bindParticles2D_is_emitting :: MethodBind bindParticles2D_is_emitting = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "is_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles are being emitted. is_emitting :: (Particles2D :< cls, Object :< cls) => cls -> IO Bool is_emitting cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_is_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "is_emitting" '[] (IO Bool) where nodeMethod = Godot.Core.Particles2D.is_emitting {-# NOINLINE bindParticles2D_restart #-} -- | Restarts all the existing particles. bindParticles2D_restart :: MethodBind bindParticles2D_restart = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "restart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Restarts all the existing particles. restart :: (Particles2D :< cls, Object :< cls) => cls -> IO () restart cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_restart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "restart" '[] (IO ()) where nodeMethod = Godot.Core.Particles2D.restart {-# NOINLINE bindParticles2D_set_amount #-} -- | Number of particles emitted in one emission cycle. bindParticles2D_set_amount :: MethodBind bindParticles2D_set_amount = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of particles emitted in one emission cycle. set_amount :: (Particles2D :< cls, Object :< cls) => cls -> Int -> IO () set_amount cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_amount" '[Int] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_amount {-# NOINLINE bindParticles2D_set_draw_order #-} -- | Particle draw order. Uses @enum DrawOrder@ values. bindParticles2D_set_draw_order :: MethodBind bindParticles2D_set_draw_order = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle draw order. Uses @enum DrawOrder@ values. set_draw_order :: (Particles2D :< cls, Object :< cls) => cls -> Int -> IO () set_draw_order cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_draw_order" '[Int] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_draw_order {-# NOINLINE bindParticles2D_set_emitting #-} -- | If @true@, particles are being emitted. bindParticles2D_set_emitting :: MethodBind bindParticles2D_set_emitting = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles are being emitted. set_emitting :: (Particles2D :< cls, Object :< cls) => cls -> Bool -> IO () set_emitting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_emitting" '[Bool] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_emitting {-# NOINLINE bindParticles2D_set_explosiveness_ratio #-} -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. bindParticles2D_set_explosiveness_ratio :: MethodBind bindParticles2D_set_explosiveness_ratio = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How rapidly particles in an emission cycle are emitted. If greater than @0@, there will be a gap in emissions before the next cycle begins. set_explosiveness_ratio :: (Particles2D :< cls, Object :< cls) => cls -> Float -> IO () set_explosiveness_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_explosiveness_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_explosiveness_ratio {-# NOINLINE bindParticles2D_set_fixed_fps #-} -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. bindParticles2D_set_fixed_fps :: MethodBind bindParticles2D_set_fixed_fps = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself. set_fixed_fps :: (Particles2D :< cls, Object :< cls) => cls -> Int -> IO () set_fixed_fps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_fixed_fps" '[Int] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_fixed_fps {-# NOINLINE bindParticles2D_set_fractional_delta #-} -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. bindParticles2D_set_fractional_delta :: MethodBind bindParticles2D_set_fractional_delta = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, results in fractional delta calculation which has a smoother particles display effect. set_fractional_delta :: (Particles2D :< cls, Object :< cls) => cls -> Bool -> IO () set_fractional_delta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_fractional_delta" '[Bool] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_fractional_delta {-# NOINLINE bindParticles2D_set_lifetime #-} -- | Amount of time each particle will exist. bindParticles2D_set_lifetime :: MethodBind bindParticles2D_set_lifetime = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time each particle will exist. set_lifetime :: (Particles2D :< cls, Object :< cls) => cls -> Float -> IO () set_lifetime cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_lifetime" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_lifetime {-# NOINLINE bindParticles2D_set_normal_map #-} -- | Normal map to be used for the @texture@ property. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindParticles2D_set_normal_map :: MethodBind bindParticles2D_set_normal_map = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Normal map to be used for the @texture@ property. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. set_normal_map :: (Particles2D :< cls, Object :< cls) => cls -> Texture -> IO () set_normal_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_normal_map" '[Texture] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_normal_map {-# NOINLINE bindParticles2D_set_one_shot #-} -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. bindParticles2D_set_one_shot :: MethodBind bindParticles2D_set_one_shot = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, only one emission cycle occurs. If set @true@ during a cycle, emission will stop at the cycle's end. set_one_shot :: (Particles2D :< cls, Object :< cls) => cls -> Bool -> IO () set_one_shot cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_one_shot" '[Bool] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_one_shot {-# NOINLINE bindParticles2D_set_pre_process_time #-} -- | Particle system starts as if it had already run for this many seconds. bindParticles2D_set_pre_process_time :: MethodBind bindParticles2D_set_pre_process_time = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system starts as if it had already run for this many seconds. set_pre_process_time :: (Particles2D :< cls, Object :< cls) => cls -> Float -> IO () set_pre_process_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_pre_process_time" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_pre_process_time {-# NOINLINE bindParticles2D_set_process_material #-} -- | @Material@ for processing particles. Can be a @ParticlesMaterial@ or a @ShaderMaterial@. bindParticles2D_set_process_material :: MethodBind bindParticles2D_set_process_material = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_process_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Material@ for processing particles. Can be a @ParticlesMaterial@ or a @ShaderMaterial@. set_process_material :: (Particles2D :< cls, Object :< cls) => cls -> Material -> IO () set_process_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_process_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_process_material" '[Material] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_process_material {-# NOINLINE bindParticles2D_set_randomness_ratio #-} -- | Emission lifetime randomness ratio. bindParticles2D_set_randomness_ratio :: MethodBind bindParticles2D_set_randomness_ratio = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emission lifetime randomness ratio. set_randomness_ratio :: (Particles2D :< cls, Object :< cls) => cls -> Float -> IO () set_randomness_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_randomness_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_randomness_ratio {-# NOINLINE bindParticles2D_set_speed_scale #-} -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. bindParticles2D_set_speed_scale :: MethodBind bindParticles2D_set_speed_scale = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle system's running speed scaling ratio. A value of @0@ can be used to pause the particles. set_speed_scale :: (Particles2D :< cls, Object :< cls) => cls -> Float -> IO () set_speed_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_speed_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_speed_scale {-# NOINLINE bindParticles2D_set_texture #-} -- | Particle texture. If @null@, particles will be squares. bindParticles2D_set_texture :: MethodBind bindParticles2D_set_texture = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle texture. If @null@, particles will be squares. set_texture :: (Particles2D :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_texture {-# NOINLINE bindParticles2D_set_use_local_coordinates #-} -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. bindParticles2D_set_use_local_coordinates :: MethodBind bindParticles2D_set_use_local_coordinates = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use the parent node's coordinate space. If @false@, they use global coordinates. set_use_local_coordinates :: (Particles2D :< cls, Object :< cls) => cls -> Bool -> IO () set_use_local_coordinates cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_use_local_coordinates" '[Bool] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_use_local_coordinates {-# NOINLINE bindParticles2D_set_visibility_rect #-} -- | Editor visibility helper. bindParticles2D_set_visibility_rect :: MethodBind bindParticles2D_set_visibility_rect = unsafePerformIO $ withCString "Particles2D" $ \ clsNamePtr -> withCString "set_visibility_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Editor visibility helper. set_visibility_rect :: (Particles2D :< cls, Object :< cls) => cls -> Rect2 -> IO () set_visibility_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticles2D_set_visibility_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Particles2D "set_visibility_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.Particles2D.set_visibility_rect ================================================ FILE: src/Godot/Core/ParticlesMaterial.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ParticlesMaterial (Godot.Core.ParticlesMaterial._FLAG_ALIGN_Y_TO_VELOCITY, Godot.Core.ParticlesMaterial._PARAM_RADIAL_ACCEL, Godot.Core.ParticlesMaterial._FLAG_ROTATE_Y, Godot.Core.ParticlesMaterial._EMISSION_SHAPE_SPHERE, Godot.Core.ParticlesMaterial._FLAG_DISABLE_Z, Godot.Core.ParticlesMaterial._PARAM_ANGULAR_VELOCITY, Godot.Core.ParticlesMaterial._EMISSION_SHAPE_MAX, Godot.Core.ParticlesMaterial._PARAM_TANGENTIAL_ACCEL, Godot.Core.ParticlesMaterial._PARAM_ANIM_SPEED, Godot.Core.ParticlesMaterial._EMISSION_SHAPE_BOX, Godot.Core.ParticlesMaterial._EMISSION_SHAPE_POINTS, Godot.Core.ParticlesMaterial._PARAM_MAX, Godot.Core.ParticlesMaterial._PARAM_INITIAL_LINEAR_VELOCITY, Godot.Core.ParticlesMaterial._FLAG_MAX, Godot.Core.ParticlesMaterial._PARAM_LINEAR_ACCEL, Godot.Core.ParticlesMaterial._EMISSION_SHAPE_DIRECTED_POINTS, Godot.Core.ParticlesMaterial._EMISSION_SHAPE_POINT, Godot.Core.ParticlesMaterial._PARAM_ORBIT_VELOCITY, Godot.Core.ParticlesMaterial._PARAM_SCALE, Godot.Core.ParticlesMaterial._PARAM_DAMPING, Godot.Core.ParticlesMaterial._PARAM_HUE_VARIATION, Godot.Core.ParticlesMaterial._PARAM_ANIM_OFFSET, Godot.Core.ParticlesMaterial._PARAM_ANGLE, Godot.Core.ParticlesMaterial.get_color, Godot.Core.ParticlesMaterial.get_color_ramp, Godot.Core.ParticlesMaterial.get_direction, Godot.Core.ParticlesMaterial.get_emission_box_extents, Godot.Core.ParticlesMaterial.get_emission_color_texture, Godot.Core.ParticlesMaterial.get_emission_normal_texture, Godot.Core.ParticlesMaterial.get_emission_point_count, Godot.Core.ParticlesMaterial.get_emission_point_texture, Godot.Core.ParticlesMaterial.get_emission_shape, Godot.Core.ParticlesMaterial.get_emission_sphere_radius, Godot.Core.ParticlesMaterial.get_flag, Godot.Core.ParticlesMaterial.get_flatness, Godot.Core.ParticlesMaterial.get_gravity, Godot.Core.ParticlesMaterial.get_lifetime_randomness, Godot.Core.ParticlesMaterial.get_param, Godot.Core.ParticlesMaterial.get_param_randomness, Godot.Core.ParticlesMaterial.get_param_texture, Godot.Core.ParticlesMaterial.get_spread, Godot.Core.ParticlesMaterial.get_trail_color_modifier, Godot.Core.ParticlesMaterial.get_trail_divisor, Godot.Core.ParticlesMaterial.get_trail_size_modifier, Godot.Core.ParticlesMaterial.set_color, Godot.Core.ParticlesMaterial.set_color_ramp, Godot.Core.ParticlesMaterial.set_direction, Godot.Core.ParticlesMaterial.set_emission_box_extents, Godot.Core.ParticlesMaterial.set_emission_color_texture, Godot.Core.ParticlesMaterial.set_emission_normal_texture, Godot.Core.ParticlesMaterial.set_emission_point_count, Godot.Core.ParticlesMaterial.set_emission_point_texture, Godot.Core.ParticlesMaterial.set_emission_shape, Godot.Core.ParticlesMaterial.set_emission_sphere_radius, Godot.Core.ParticlesMaterial.set_flag, Godot.Core.ParticlesMaterial.set_flatness, Godot.Core.ParticlesMaterial.set_gravity, Godot.Core.ParticlesMaterial.set_lifetime_randomness, Godot.Core.ParticlesMaterial.set_param, Godot.Core.ParticlesMaterial.set_param_randomness, Godot.Core.ParticlesMaterial.set_param_texture, Godot.Core.ParticlesMaterial.set_spread, Godot.Core.ParticlesMaterial.set_trail_color_modifier, Godot.Core.ParticlesMaterial.set_trail_divisor, Godot.Core.ParticlesMaterial.set_trail_size_modifier) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Material() _FLAG_ALIGN_Y_TO_VELOCITY :: Int _FLAG_ALIGN_Y_TO_VELOCITY = 0 _PARAM_RADIAL_ACCEL :: Int _PARAM_RADIAL_ACCEL = 4 _FLAG_ROTATE_Y :: Int _FLAG_ROTATE_Y = 1 _EMISSION_SHAPE_SPHERE :: Int _EMISSION_SHAPE_SPHERE = 1 _FLAG_DISABLE_Z :: Int _FLAG_DISABLE_Z = 2 _PARAM_ANGULAR_VELOCITY :: Int _PARAM_ANGULAR_VELOCITY = 1 _EMISSION_SHAPE_MAX :: Int _EMISSION_SHAPE_MAX = 5 _PARAM_TANGENTIAL_ACCEL :: Int _PARAM_TANGENTIAL_ACCEL = 5 _PARAM_ANIM_SPEED :: Int _PARAM_ANIM_SPEED = 10 _EMISSION_SHAPE_BOX :: Int _EMISSION_SHAPE_BOX = 2 _EMISSION_SHAPE_POINTS :: Int _EMISSION_SHAPE_POINTS = 3 _PARAM_MAX :: Int _PARAM_MAX = 12 _PARAM_INITIAL_LINEAR_VELOCITY :: Int _PARAM_INITIAL_LINEAR_VELOCITY = 0 _FLAG_MAX :: Int _FLAG_MAX = 3 _PARAM_LINEAR_ACCEL :: Int _PARAM_LINEAR_ACCEL = 3 _EMISSION_SHAPE_DIRECTED_POINTS :: Int _EMISSION_SHAPE_DIRECTED_POINTS = 4 _EMISSION_SHAPE_POINT :: Int _EMISSION_SHAPE_POINT = 0 _PARAM_ORBIT_VELOCITY :: Int _PARAM_ORBIT_VELOCITY = 2 _PARAM_SCALE :: Int _PARAM_SCALE = 8 _PARAM_DAMPING :: Int _PARAM_DAMPING = 6 _PARAM_HUE_VARIATION :: Int _PARAM_HUE_VARIATION = 9 _PARAM_ANIM_OFFSET :: Int _PARAM_ANIM_OFFSET = 11 _PARAM_ANGLE :: Int _PARAM_ANGLE = 7 instance NodeProperty ParticlesMaterial "angle" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param, wrapIndexedSetter 7 set_param, Nothing) instance NodeProperty ParticlesMaterial "angle_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 7 get_param_texture, wrapIndexedSetter 7 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "angle_random" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param_randomness, wrapIndexedSetter 7 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "angular_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param, wrapIndexedSetter 1 set_param, Nothing) instance NodeProperty ParticlesMaterial "angular_velocity_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 1 get_param_texture, wrapIndexedSetter 1 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "angular_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param_randomness, wrapIndexedSetter 1 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "anim_offset" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_param, wrapIndexedSetter 11 set_param, Nothing) instance NodeProperty ParticlesMaterial "anim_offset_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 11 get_param_texture, wrapIndexedSetter 11 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "anim_offset_random" Float 'False where nodeProperty = (wrapIndexedGetter 11 get_param_randomness, wrapIndexedSetter 11 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "anim_speed" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_param, wrapIndexedSetter 10 set_param, Nothing) instance NodeProperty ParticlesMaterial "anim_speed_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 10 get_param_texture, wrapIndexedSetter 10 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "anim_speed_random" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_param_randomness, wrapIndexedSetter 10 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) instance NodeProperty ParticlesMaterial "color_ramp" Texture 'False where nodeProperty = (get_color_ramp, wrapDroppingSetter set_color_ramp, Nothing) instance NodeProperty ParticlesMaterial "damping" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param, wrapIndexedSetter 6 set_param, Nothing) instance NodeProperty ParticlesMaterial "damping_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 6 get_param_texture, wrapIndexedSetter 6 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "damping_random" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param_randomness, wrapIndexedSetter 6 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "direction" Vector3 'False where nodeProperty = (get_direction, wrapDroppingSetter set_direction, Nothing) instance NodeProperty ParticlesMaterial "emission_box_extents" Vector3 'False where nodeProperty = (get_emission_box_extents, wrapDroppingSetter set_emission_box_extents, Nothing) instance NodeProperty ParticlesMaterial "emission_color_texture" Texture 'False where nodeProperty = (get_emission_color_texture, wrapDroppingSetter set_emission_color_texture, Nothing) instance NodeProperty ParticlesMaterial "emission_normal_texture" Texture 'False where nodeProperty = (get_emission_normal_texture, wrapDroppingSetter set_emission_normal_texture, Nothing) instance NodeProperty ParticlesMaterial "emission_point_count" Int 'False where nodeProperty = (get_emission_point_count, wrapDroppingSetter set_emission_point_count, Nothing) instance NodeProperty ParticlesMaterial "emission_point_texture" Texture 'False where nodeProperty = (get_emission_point_texture, wrapDroppingSetter set_emission_point_texture, Nothing) instance NodeProperty ParticlesMaterial "emission_shape" Int 'False where nodeProperty = (get_emission_shape, wrapDroppingSetter set_emission_shape, Nothing) instance NodeProperty ParticlesMaterial "emission_sphere_radius" Float 'False where nodeProperty = (get_emission_sphere_radius, wrapDroppingSetter set_emission_sphere_radius, Nothing) instance NodeProperty ParticlesMaterial "flag_align_y" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_flag, wrapIndexedSetter 0 set_flag, Nothing) instance NodeProperty ParticlesMaterial "flag_disable_z" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_flag, wrapIndexedSetter 2 set_flag, Nothing) instance NodeProperty ParticlesMaterial "flag_rotate_y" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_flag, wrapIndexedSetter 1 set_flag, Nothing) instance NodeProperty ParticlesMaterial "flatness" Float 'False where nodeProperty = (get_flatness, wrapDroppingSetter set_flatness, Nothing) instance NodeProperty ParticlesMaterial "gravity" Vector3 'False where nodeProperty = (get_gravity, wrapDroppingSetter set_gravity, Nothing) instance NodeProperty ParticlesMaterial "hue_variation" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param, wrapIndexedSetter 9 set_param, Nothing) instance NodeProperty ParticlesMaterial "hue_variation_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 9 get_param_texture, wrapIndexedSetter 9 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "hue_variation_random" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param_randomness, wrapIndexedSetter 9 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "initial_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param, wrapIndexedSetter 0 set_param, Nothing) instance NodeProperty ParticlesMaterial "initial_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param_randomness, wrapIndexedSetter 0 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "lifetime_randomness" Float 'False where nodeProperty = (get_lifetime_randomness, wrapDroppingSetter set_lifetime_randomness, Nothing) instance NodeProperty ParticlesMaterial "linear_accel" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param, wrapIndexedSetter 3 set_param, Nothing) instance NodeProperty ParticlesMaterial "linear_accel_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 3 get_param_texture, wrapIndexedSetter 3 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "linear_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param_randomness, wrapIndexedSetter 3 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "orbit_velocity" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param, wrapIndexedSetter 2 set_param, Nothing) instance NodeProperty ParticlesMaterial "orbit_velocity_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 2 get_param_texture, wrapIndexedSetter 2 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "orbit_velocity_random" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param_randomness, wrapIndexedSetter 2 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "radial_accel" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param, wrapIndexedSetter 4 set_param, Nothing) instance NodeProperty ParticlesMaterial "radial_accel_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 4 get_param_texture, wrapIndexedSetter 4 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "radial_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param_randomness, wrapIndexedSetter 4 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "scale" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param, wrapIndexedSetter 8 set_param, Nothing) instance NodeProperty ParticlesMaterial "scale_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 8 get_param_texture, wrapIndexedSetter 8 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "scale_random" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param_randomness, wrapIndexedSetter 8 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "spread" Float 'False where nodeProperty = (get_spread, wrapDroppingSetter set_spread, Nothing) instance NodeProperty ParticlesMaterial "tangential_accel" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param, wrapIndexedSetter 5 set_param, Nothing) instance NodeProperty ParticlesMaterial "tangential_accel_curve" Texture 'False where nodeProperty = (wrapIndexedGetter 5 get_param_texture, wrapIndexedSetter 5 set_param_texture, Nothing) instance NodeProperty ParticlesMaterial "tangential_accel_random" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param_randomness, wrapIndexedSetter 5 set_param_randomness, Nothing) instance NodeProperty ParticlesMaterial "trail_color_modifier" GradientTexture 'False where nodeProperty = (get_trail_color_modifier, wrapDroppingSetter set_trail_color_modifier, Nothing) instance NodeProperty ParticlesMaterial "trail_divisor" Int 'False where nodeProperty = (get_trail_divisor, wrapDroppingSetter set_trail_divisor, Nothing) instance NodeProperty ParticlesMaterial "trail_size_modifier" CurveTexture 'False where nodeProperty = (get_trail_size_modifier, wrapDroppingSetter set_trail_size_modifier, Nothing) {-# NOINLINE bindParticlesMaterial_get_color #-} -- | Each particle's initial color. If the @Particles2D@'s @texture@ is defined, it will be multiplied by this color. To have particle display color in a @SpatialMaterial@ make sure to set @SpatialMaterial.vertex_color_use_as_albedo@ to @true@. bindParticlesMaterial_get_color :: MethodBind bindParticlesMaterial_get_color = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial color. If the @Particles2D@'s @texture@ is defined, it will be multiplied by this color. To have particle display color in a @SpatialMaterial@ make sure to set @SpatialMaterial.vertex_color_use_as_albedo@ to @true@. get_color :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_color" '[] (IO Color) where nodeMethod = Godot.Core.ParticlesMaterial.get_color {-# NOINLINE bindParticlesMaterial_get_color_ramp #-} -- | Each particle's color will vary along this @GradientTexture@. bindParticlesMaterial_get_color_ramp :: MethodBind bindParticlesMaterial_get_color_ramp = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_color_ramp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's color will vary along this @GradientTexture@. get_color_ramp :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Texture get_color_ramp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_color_ramp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_color_ramp" '[] (IO Texture) where nodeMethod = Godot.Core.ParticlesMaterial.get_color_ramp {-# NOINLINE bindParticlesMaterial_get_direction #-} -- | Unit vector specifying the particles' emission direction. bindParticlesMaterial_get_direction :: MethodBind bindParticlesMaterial_get_direction = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unit vector specifying the particles' emission direction. get_direction :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Vector3 get_direction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_direction" '[] (IO Vector3) where nodeMethod = Godot.Core.ParticlesMaterial.get_direction {-# NOINLINE bindParticlesMaterial_get_emission_box_extents #-} -- | The box's extents if @emission_shape@ is set to @EMISSION_SHAPE_BOX@. bindParticlesMaterial_get_emission_box_extents :: MethodBind bindParticlesMaterial_get_emission_box_extents = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_emission_box_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The box's extents if @emission_shape@ is set to @EMISSION_SHAPE_BOX@. get_emission_box_extents :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Vector3 get_emission_box_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_emission_box_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_emission_box_extents" '[] (IO Vector3) where nodeMethod = Godot.Core.ParticlesMaterial.get_emission_box_extents {-# NOINLINE bindParticlesMaterial_get_emission_color_texture #-} -- | Particle color will be modulated by color determined by sampling this texture at the same point as the @emission_point_texture@. bindParticlesMaterial_get_emission_color_texture :: MethodBind bindParticlesMaterial_get_emission_color_texture = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_emission_color_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle color will be modulated by color determined by sampling this texture at the same point as the @emission_point_texture@. get_emission_color_texture :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Texture get_emission_color_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_emission_color_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_emission_color_texture" '[] (IO Texture) where nodeMethod = Godot.Core.ParticlesMaterial.get_emission_color_texture {-# NOINLINE bindParticlesMaterial_get_emission_normal_texture #-} -- | Particle velocity and rotation will be set by sampling this texture at the same point as the @emission_point_texture@. Used only in @EMISSION_SHAPE_DIRECTED_POINTS@. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar. bindParticlesMaterial_get_emission_normal_texture :: MethodBind bindParticlesMaterial_get_emission_normal_texture = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_emission_normal_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle velocity and rotation will be set by sampling this texture at the same point as the @emission_point_texture@. Used only in @EMISSION_SHAPE_DIRECTED_POINTS@. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar. get_emission_normal_texture :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Texture get_emission_normal_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_emission_normal_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_emission_normal_texture" '[] (IO Texture) where nodeMethod = Godot.Core.ParticlesMaterial.get_emission_normal_texture {-# NOINLINE bindParticlesMaterial_get_emission_point_count #-} -- | The number of emission points if @emission_shape@ is set to @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindParticlesMaterial_get_emission_point_count :: MethodBind bindParticlesMaterial_get_emission_point_count = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_emission_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of emission points if @emission_shape@ is set to @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. get_emission_point_count :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Int get_emission_point_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_emission_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_emission_point_count" '[] (IO Int) where nodeMethod = Godot.Core.ParticlesMaterial.get_emission_point_count {-# NOINLINE bindParticlesMaterial_get_emission_point_texture #-} -- | Particles will be emitted at positions determined by sampling this texture at a random position. Used with @EMISSION_SHAPE_POINTS@ and @EMISSION_SHAPE_DIRECTED_POINTS@. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar. bindParticlesMaterial_get_emission_point_texture :: MethodBind bindParticlesMaterial_get_emission_point_texture = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_emission_point_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particles will be emitted at positions determined by sampling this texture at a random position. Used with @EMISSION_SHAPE_POINTS@ and @EMISSION_SHAPE_DIRECTED_POINTS@. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar. get_emission_point_texture :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Texture get_emission_point_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_emission_point_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_emission_point_texture" '[] (IO Texture) where nodeMethod = Godot.Core.ParticlesMaterial.get_emission_point_texture {-# NOINLINE bindParticlesMaterial_get_emission_shape #-} -- | Particles will be emitted inside this region. Use @enum EmissionShape@ constants for values. bindParticlesMaterial_get_emission_shape :: MethodBind bindParticlesMaterial_get_emission_shape = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_emission_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particles will be emitted inside this region. Use @enum EmissionShape@ constants for values. get_emission_shape :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Int get_emission_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_emission_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_emission_shape" '[] (IO Int) where nodeMethod = Godot.Core.ParticlesMaterial.get_emission_shape {-# NOINLINE bindParticlesMaterial_get_emission_sphere_radius #-} -- | The sphere's radius if @emission_shape@ is set to @EMISSION_SHAPE_SPHERE@. bindParticlesMaterial_get_emission_sphere_radius :: MethodBind bindParticlesMaterial_get_emission_sphere_radius = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_emission_sphere_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sphere's radius if @emission_shape@ is set to @EMISSION_SHAPE_SPHERE@. get_emission_sphere_radius :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Float get_emission_sphere_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_emission_sphere_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_emission_sphere_radius" '[] (IO Float) where nodeMethod = Godot.Core.ParticlesMaterial.get_emission_sphere_radius {-# NOINLINE bindParticlesMaterial_get_flag #-} -- | Returns @true@ if the specified flag is enabled. bindParticlesMaterial_get_flag :: MethodBind bindParticlesMaterial_get_flag = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified flag is enabled. get_flag :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> IO Bool get_flag cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_flag" '[Int] (IO Bool) where nodeMethod = Godot.Core.ParticlesMaterial.get_flag {-# NOINLINE bindParticlesMaterial_get_flatness #-} -- | Amount of @spread@ in Y/Z plane. A value of @1@ restricts particles to X/Z plane. bindParticlesMaterial_get_flatness :: MethodBind bindParticlesMaterial_get_flatness = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_flatness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of @spread@ in Y/Z plane. A value of @1@ restricts particles to X/Z plane. get_flatness :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Float get_flatness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_flatness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_flatness" '[] (IO Float) where nodeMethod = Godot.Core.ParticlesMaterial.get_flatness {-# NOINLINE bindParticlesMaterial_get_gravity #-} -- | Gravity applied to every particle. bindParticlesMaterial_get_gravity :: MethodBind bindParticlesMaterial_get_gravity = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gravity applied to every particle. get_gravity :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Vector3 get_gravity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_gravity" '[] (IO Vector3) where nodeMethod = Godot.Core.ParticlesMaterial.get_gravity {-# NOINLINE bindParticlesMaterial_get_lifetime_randomness #-} -- | Particle lifetime randomness ratio. bindParticlesMaterial_get_lifetime_randomness :: MethodBind bindParticlesMaterial_get_lifetime_randomness = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_lifetime_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle lifetime randomness ratio. get_lifetime_randomness :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Float get_lifetime_randomness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_lifetime_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_lifetime_randomness" '[] (IO Float) where nodeMethod = Godot.Core.ParticlesMaterial.get_lifetime_randomness {-# NOINLINE bindParticlesMaterial_get_param #-} -- | Returns the value of the specified parameter. bindParticlesMaterial_get_param :: MethodBind bindParticlesMaterial_get_param = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the specified parameter. get_param :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.ParticlesMaterial.get_param {-# NOINLINE bindParticlesMaterial_get_param_randomness #-} -- | Returns the randomness ratio associated with the specified parameter. bindParticlesMaterial_get_param_randomness :: MethodBind bindParticlesMaterial_get_param_randomness = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_param_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the randomness ratio associated with the specified parameter. get_param_randomness :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> IO Float get_param_randomness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_param_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_param_randomness" '[Int] (IO Float) where nodeMethod = Godot.Core.ParticlesMaterial.get_param_randomness {-# NOINLINE bindParticlesMaterial_get_param_texture #-} -- | Returns the @Texture@ used by the specified parameter. bindParticlesMaterial_get_param_texture :: MethodBind bindParticlesMaterial_get_param_texture = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_param_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Texture@ used by the specified parameter. get_param_texture :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> IO Texture get_param_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_param_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_param_texture" '[Int] (IO Texture) where nodeMethod = Godot.Core.ParticlesMaterial.get_param_texture {-# NOINLINE bindParticlesMaterial_get_spread #-} -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. Applied to X/Z plane and Y/Z planes. bindParticlesMaterial_get_spread :: MethodBind bindParticlesMaterial_get_spread = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_spread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. Applied to X/Z plane and Y/Z planes. get_spread :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Float get_spread cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_spread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_spread" '[] (IO Float) where nodeMethod = Godot.Core.ParticlesMaterial.get_spread {-# NOINLINE bindParticlesMaterial_get_trail_color_modifier #-} -- | Trail particles' color will vary along this @GradientTexture@. bindParticlesMaterial_get_trail_color_modifier :: MethodBind bindParticlesMaterial_get_trail_color_modifier = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_trail_color_modifier" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Trail particles' color will vary along this @GradientTexture@. get_trail_color_modifier :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO GradientTexture get_trail_color_modifier cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_trail_color_modifier (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_trail_color_modifier" '[] (IO GradientTexture) where nodeMethod = Godot.Core.ParticlesMaterial.get_trail_color_modifier {-# NOINLINE bindParticlesMaterial_get_trail_divisor #-} -- | Emitter will emit @amount@ divided by @trail_divisor@ particles. The remaining particles will be used as trail(s). bindParticlesMaterial_get_trail_divisor :: MethodBind bindParticlesMaterial_get_trail_divisor = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_trail_divisor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emitter will emit @amount@ divided by @trail_divisor@ particles. The remaining particles will be used as trail(s). get_trail_divisor :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO Int get_trail_divisor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_trail_divisor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_trail_divisor" '[] (IO Int) where nodeMethod = Godot.Core.ParticlesMaterial.get_trail_divisor {-# NOINLINE bindParticlesMaterial_get_trail_size_modifier #-} -- | Trail particles' size will vary along this @CurveTexture@. bindParticlesMaterial_get_trail_size_modifier :: MethodBind bindParticlesMaterial_get_trail_size_modifier = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "get_trail_size_modifier" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Trail particles' size will vary along this @CurveTexture@. get_trail_size_modifier :: (ParticlesMaterial :< cls, Object :< cls) => cls -> IO CurveTexture get_trail_size_modifier cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_get_trail_size_modifier (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "get_trail_size_modifier" '[] (IO CurveTexture) where nodeMethod = Godot.Core.ParticlesMaterial.get_trail_size_modifier {-# NOINLINE bindParticlesMaterial_set_color #-} -- | Each particle's initial color. If the @Particles2D@'s @texture@ is defined, it will be multiplied by this color. To have particle display color in a @SpatialMaterial@ make sure to set @SpatialMaterial.vertex_color_use_as_albedo@ to @true@. bindParticlesMaterial_set_color :: MethodBind bindParticlesMaterial_set_color = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial color. If the @Particles2D@'s @texture@ is defined, it will be multiplied by this color. To have particle display color in a @SpatialMaterial@ make sure to set @SpatialMaterial.vertex_color_use_as_albedo@ to @true@. set_color :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_color {-# NOINLINE bindParticlesMaterial_set_color_ramp #-} -- | Each particle's color will vary along this @GradientTexture@. bindParticlesMaterial_set_color_ramp :: MethodBind bindParticlesMaterial_set_color_ramp = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_color_ramp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's color will vary along this @GradientTexture@. set_color_ramp :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Texture -> IO () set_color_ramp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_color_ramp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_color_ramp" '[Texture] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_color_ramp {-# NOINLINE bindParticlesMaterial_set_direction #-} -- | Unit vector specifying the particles' emission direction. bindParticlesMaterial_set_direction :: MethodBind bindParticlesMaterial_set_direction = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_direction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unit vector specifying the particles' emission direction. set_direction :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_direction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_direction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_direction" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_direction {-# NOINLINE bindParticlesMaterial_set_emission_box_extents #-} -- | The box's extents if @emission_shape@ is set to @EMISSION_SHAPE_BOX@. bindParticlesMaterial_set_emission_box_extents :: MethodBind bindParticlesMaterial_set_emission_box_extents = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_emission_box_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The box's extents if @emission_shape@ is set to @EMISSION_SHAPE_BOX@. set_emission_box_extents :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_emission_box_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_emission_box_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_emission_box_extents" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_emission_box_extents {-# NOINLINE bindParticlesMaterial_set_emission_color_texture #-} -- | Particle color will be modulated by color determined by sampling this texture at the same point as the @emission_point_texture@. bindParticlesMaterial_set_emission_color_texture :: MethodBind bindParticlesMaterial_set_emission_color_texture = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_emission_color_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle color will be modulated by color determined by sampling this texture at the same point as the @emission_point_texture@. set_emission_color_texture :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Texture -> IO () set_emission_color_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_emission_color_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_emission_color_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_emission_color_texture {-# NOINLINE bindParticlesMaterial_set_emission_normal_texture #-} -- | Particle velocity and rotation will be set by sampling this texture at the same point as the @emission_point_texture@. Used only in @EMISSION_SHAPE_DIRECTED_POINTS@. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar. bindParticlesMaterial_set_emission_normal_texture :: MethodBind bindParticlesMaterial_set_emission_normal_texture = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_emission_normal_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle velocity and rotation will be set by sampling this texture at the same point as the @emission_point_texture@. Used only in @EMISSION_SHAPE_DIRECTED_POINTS@. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar. set_emission_normal_texture :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Texture -> IO () set_emission_normal_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_emission_normal_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_emission_normal_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_emission_normal_texture {-# NOINLINE bindParticlesMaterial_set_emission_point_count #-} -- | The number of emission points if @emission_shape@ is set to @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. bindParticlesMaterial_set_emission_point_count :: MethodBind bindParticlesMaterial_set_emission_point_count = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_emission_point_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of emission points if @emission_shape@ is set to @EMISSION_SHAPE_POINTS@ or @EMISSION_SHAPE_DIRECTED_POINTS@. set_emission_point_count :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_emission_point_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_emission_point_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_emission_point_count" '[Int] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_emission_point_count {-# NOINLINE bindParticlesMaterial_set_emission_point_texture #-} -- | Particles will be emitted at positions determined by sampling this texture at a random position. Used with @EMISSION_SHAPE_POINTS@ and @EMISSION_SHAPE_DIRECTED_POINTS@. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar. bindParticlesMaterial_set_emission_point_texture :: MethodBind bindParticlesMaterial_set_emission_point_texture = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_emission_point_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particles will be emitted at positions determined by sampling this texture at a random position. Used with @EMISSION_SHAPE_POINTS@ and @EMISSION_SHAPE_DIRECTED_POINTS@. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar. set_emission_point_texture :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Texture -> IO () set_emission_point_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_emission_point_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_emission_point_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_emission_point_texture {-# NOINLINE bindParticlesMaterial_set_emission_shape #-} -- | Particles will be emitted inside this region. Use @enum EmissionShape@ constants for values. bindParticlesMaterial_set_emission_shape :: MethodBind bindParticlesMaterial_set_emission_shape = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_emission_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particles will be emitted inside this region. Use @enum EmissionShape@ constants for values. set_emission_shape :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_emission_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_emission_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_emission_shape" '[Int] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_emission_shape {-# NOINLINE bindParticlesMaterial_set_emission_sphere_radius #-} -- | The sphere's radius if @emission_shape@ is set to @EMISSION_SHAPE_SPHERE@. bindParticlesMaterial_set_emission_sphere_radius :: MethodBind bindParticlesMaterial_set_emission_sphere_radius = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_emission_sphere_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sphere's radius if @emission_shape@ is set to @EMISSION_SHAPE_SPHERE@. set_emission_sphere_radius :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_emission_sphere_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_emission_sphere_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_emission_sphere_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_emission_sphere_radius {-# NOINLINE bindParticlesMaterial_set_flag #-} -- | If @true@, enables the specified flag. See @enum Flags@ for options. bindParticlesMaterial_set_flag :: MethodBind bindParticlesMaterial_set_flag = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the specified flag. See @enum Flags@ for options. set_flag :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_flag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_flag" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_flag {-# NOINLINE bindParticlesMaterial_set_flatness #-} -- | Amount of @spread@ in Y/Z plane. A value of @1@ restricts particles to X/Z plane. bindParticlesMaterial_set_flatness :: MethodBind bindParticlesMaterial_set_flatness = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_flatness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of @spread@ in Y/Z plane. A value of @1@ restricts particles to X/Z plane. set_flatness :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_flatness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_flatness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_flatness" '[Float] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_flatness {-# NOINLINE bindParticlesMaterial_set_gravity #-} -- | Gravity applied to every particle. bindParticlesMaterial_set_gravity :: MethodBind bindParticlesMaterial_set_gravity = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gravity applied to every particle. set_gravity :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_gravity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_gravity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_gravity {-# NOINLINE bindParticlesMaterial_set_lifetime_randomness #-} -- | Particle lifetime randomness ratio. bindParticlesMaterial_set_lifetime_randomness :: MethodBind bindParticlesMaterial_set_lifetime_randomness = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_lifetime_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Particle lifetime randomness ratio. set_lifetime_randomness :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_lifetime_randomness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_lifetime_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_lifetime_randomness" '[Float] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_lifetime_randomness {-# NOINLINE bindParticlesMaterial_set_param #-} -- | Sets the specified @enum Parameter@. bindParticlesMaterial_set_param :: MethodBind bindParticlesMaterial_set_param = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified @enum Parameter@. set_param :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_param {-# NOINLINE bindParticlesMaterial_set_param_randomness #-} -- | Sets the randomness ratio for the specified @enum Parameter@. bindParticlesMaterial_set_param_randomness :: MethodBind bindParticlesMaterial_set_param_randomness = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_param_randomness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the randomness ratio for the specified @enum Parameter@. set_param_randomness :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param_randomness cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_param_randomness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_param_randomness" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_param_randomness {-# NOINLINE bindParticlesMaterial_set_param_texture #-} -- | Sets the @Texture@ for the specified @enum Parameter@. bindParticlesMaterial_set_param_texture :: MethodBind bindParticlesMaterial_set_param_texture = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_param_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Texture@ for the specified @enum Parameter@. set_param_texture :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_param_texture cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_param_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_param_texture" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_param_texture {-# NOINLINE bindParticlesMaterial_set_spread #-} -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. Applied to X/Z plane and Y/Z planes. bindParticlesMaterial_set_spread :: MethodBind bindParticlesMaterial_set_spread = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_spread" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Each particle's initial direction range from @+spread@ to @-spread@ degrees. Applied to X/Z plane and Y/Z planes. set_spread :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_spread cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_spread (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_spread" '[Float] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_spread {-# NOINLINE bindParticlesMaterial_set_trail_color_modifier #-} -- | Trail particles' color will vary along this @GradientTexture@. bindParticlesMaterial_set_trail_color_modifier :: MethodBind bindParticlesMaterial_set_trail_color_modifier = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_trail_color_modifier" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Trail particles' color will vary along this @GradientTexture@. set_trail_color_modifier :: (ParticlesMaterial :< cls, Object :< cls) => cls -> GradientTexture -> IO () set_trail_color_modifier cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_trail_color_modifier (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_trail_color_modifier" '[GradientTexture] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_trail_color_modifier {-# NOINLINE bindParticlesMaterial_set_trail_divisor #-} -- | Emitter will emit @amount@ divided by @trail_divisor@ particles. The remaining particles will be used as trail(s). bindParticlesMaterial_set_trail_divisor :: MethodBind bindParticlesMaterial_set_trail_divisor = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_trail_divisor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Emitter will emit @amount@ divided by @trail_divisor@ particles. The remaining particles will be used as trail(s). set_trail_divisor :: (ParticlesMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_trail_divisor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_trail_divisor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_trail_divisor" '[Int] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_trail_divisor {-# NOINLINE bindParticlesMaterial_set_trail_size_modifier #-} -- | Trail particles' size will vary along this @CurveTexture@. bindParticlesMaterial_set_trail_size_modifier :: MethodBind bindParticlesMaterial_set_trail_size_modifier = unsafePerformIO $ withCString "ParticlesMaterial" $ \ clsNamePtr -> withCString "set_trail_size_modifier" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Trail particles' size will vary along this @CurveTexture@. set_trail_size_modifier :: (ParticlesMaterial :< cls, Object :< cls) => cls -> CurveTexture -> IO () set_trail_size_modifier cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindParticlesMaterial_set_trail_size_modifier (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ParticlesMaterial "set_trail_size_modifier" '[CurveTexture] (IO ()) where nodeMethod = Godot.Core.ParticlesMaterial.set_trail_size_modifier ================================================ FILE: src/Godot/Core/Path.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Path (Godot.Core.Path.sig_curve_changed, Godot.Core.Path._curve_changed, Godot.Core.Path.get_curve, Godot.Core.Path.set_curve) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() -- | Emitted when the @curve@ changes. sig_curve_changed :: Godot.Internal.Dispatch.Signal Path sig_curve_changed = Godot.Internal.Dispatch.Signal "curve_changed" instance NodeSignal Path "curve_changed" '[] instance NodeProperty Path "curve" Curve3D 'False where nodeProperty = (get_curve, wrapDroppingSetter set_curve, Nothing) {-# NOINLINE bindPath__curve_changed #-} bindPath__curve_changed :: MethodBind bindPath__curve_changed = unsafePerformIO $ withCString "Path" $ \ clsNamePtr -> withCString "_curve_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _curve_changed :: (Path :< cls, Object :< cls) => cls -> IO () _curve_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPath__curve_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Path "_curve_changed" '[] (IO ()) where nodeMethod = Godot.Core.Path._curve_changed {-# NOINLINE bindPath_get_curve #-} -- | A @Curve3D@ describing the path. bindPath_get_curve :: MethodBind bindPath_get_curve = unsafePerformIO $ withCString "Path" $ \ clsNamePtr -> withCString "get_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Curve3D@ describing the path. get_curve :: (Path :< cls, Object :< cls) => cls -> IO Curve3D get_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPath_get_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Path "get_curve" '[] (IO Curve3D) where nodeMethod = Godot.Core.Path.get_curve {-# NOINLINE bindPath_set_curve #-} -- | A @Curve3D@ describing the path. bindPath_set_curve :: MethodBind bindPath_set_curve = unsafePerformIO $ withCString "Path" $ \ clsNamePtr -> withCString "set_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Curve3D@ describing the path. set_curve :: (Path :< cls, Object :< cls) => cls -> Curve3D -> IO () set_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPath_set_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Path "set_curve" '[Curve3D] (IO ()) where nodeMethod = Godot.Core.Path.set_curve ================================================ FILE: src/Godot/Core/Path2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Path2D (Godot.Core.Path2D._curve_changed, Godot.Core.Path2D.get_curve, Godot.Core.Path2D.set_curve) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty Path2D "curve" Curve2D 'False where nodeProperty = (get_curve, wrapDroppingSetter set_curve, Nothing) {-# NOINLINE bindPath2D__curve_changed #-} bindPath2D__curve_changed :: MethodBind bindPath2D__curve_changed = unsafePerformIO $ withCString "Path2D" $ \ clsNamePtr -> withCString "_curve_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _curve_changed :: (Path2D :< cls, Object :< cls) => cls -> IO () _curve_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPath2D__curve_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Path2D "_curve_changed" '[] (IO ()) where nodeMethod = Godot.Core.Path2D._curve_changed {-# NOINLINE bindPath2D_get_curve #-} -- | A @Curve2D@ describing the path. bindPath2D_get_curve :: MethodBind bindPath2D_get_curve = unsafePerformIO $ withCString "Path2D" $ \ clsNamePtr -> withCString "get_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Curve2D@ describing the path. get_curve :: (Path2D :< cls, Object :< cls) => cls -> IO Curve2D get_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPath2D_get_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Path2D "get_curve" '[] (IO Curve2D) where nodeMethod = Godot.Core.Path2D.get_curve {-# NOINLINE bindPath2D_set_curve #-} -- | A @Curve2D@ describing the path. bindPath2D_set_curve :: MethodBind bindPath2D_set_curve = unsafePerformIO $ withCString "Path2D" $ \ clsNamePtr -> withCString "set_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Curve2D@ describing the path. set_curve :: (Path2D :< cls, Object :< cls) => cls -> Curve2D -> IO () set_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPath2D_set_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Path2D "set_curve" '[Curve2D] (IO ()) where nodeMethod = Godot.Core.Path2D.set_curve ================================================ FILE: src/Godot/Core/PathFollow.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PathFollow (Godot.Core.PathFollow._ROTATION_ORIENTED, Godot.Core.PathFollow._ROTATION_XY, Godot.Core.PathFollow._ROTATION_Y, Godot.Core.PathFollow._ROTATION_XYZ, Godot.Core.PathFollow._ROTATION_NONE, Godot.Core.PathFollow.get_cubic_interpolation, Godot.Core.PathFollow.get_h_offset, Godot.Core.PathFollow.get_offset, Godot.Core.PathFollow.get_rotation_mode, Godot.Core.PathFollow.get_unit_offset, Godot.Core.PathFollow.get_v_offset, Godot.Core.PathFollow.has_loop, Godot.Core.PathFollow.set_cubic_interpolation, Godot.Core.PathFollow.set_h_offset, Godot.Core.PathFollow.set_loop, Godot.Core.PathFollow.set_offset, Godot.Core.PathFollow.set_rotation_mode, Godot.Core.PathFollow.set_unit_offset, Godot.Core.PathFollow.set_v_offset) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() _ROTATION_ORIENTED :: Int _ROTATION_ORIENTED = 4 _ROTATION_XY :: Int _ROTATION_XY = 2 _ROTATION_Y :: Int _ROTATION_Y = 1 _ROTATION_XYZ :: Int _ROTATION_XYZ = 3 _ROTATION_NONE :: Int _ROTATION_NONE = 0 instance NodeProperty PathFollow "cubic_interp" Bool 'False where nodeProperty = (get_cubic_interpolation, wrapDroppingSetter set_cubic_interpolation, Nothing) instance NodeProperty PathFollow "h_offset" Float 'False where nodeProperty = (get_h_offset, wrapDroppingSetter set_h_offset, Nothing) instance NodeProperty PathFollow "loop" Bool 'False where nodeProperty = (has_loop, wrapDroppingSetter set_loop, Nothing) instance NodeProperty PathFollow "offset" Float 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty PathFollow "rotation_mode" Int 'False where nodeProperty = (get_rotation_mode, wrapDroppingSetter set_rotation_mode, Nothing) instance NodeProperty PathFollow "unit_offset" Float 'False where nodeProperty = (get_unit_offset, wrapDroppingSetter set_unit_offset, Nothing) instance NodeProperty PathFollow "v_offset" Float 'False where nodeProperty = (get_v_offset, wrapDroppingSetter set_v_offset, Nothing) {-# NOINLINE bindPathFollow_get_cubic_interpolation #-} -- | If @true@, the position between two cached points is interpolated cubically, and linearly otherwise. -- The points along the @Curve3D@ of the @Path@ are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough. -- There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations. bindPathFollow_get_cubic_interpolation :: MethodBind bindPathFollow_get_cubic_interpolation = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "get_cubic_interpolation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the position between two cached points is interpolated cubically, and linearly otherwise. -- The points along the @Curve3D@ of the @Path@ are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough. -- There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations. get_cubic_interpolation :: (PathFollow :< cls, Object :< cls) => cls -> IO Bool get_cubic_interpolation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_get_cubic_interpolation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "get_cubic_interpolation" '[] (IO Bool) where nodeMethod = Godot.Core.PathFollow.get_cubic_interpolation {-# NOINLINE bindPathFollow_get_h_offset #-} -- | The node's offset along the curve. bindPathFollow_get_h_offset :: MethodBind bindPathFollow_get_h_offset = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "get_h_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's offset along the curve. get_h_offset :: (PathFollow :< cls, Object :< cls) => cls -> IO Float get_h_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_get_h_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "get_h_offset" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow.get_h_offset {-# NOINLINE bindPathFollow_get_offset #-} -- | The distance from the first vertex, measured in 3D units along the path. This sets this node's position to a point within the path. bindPathFollow_get_offset :: MethodBind bindPathFollow_get_offset = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance from the first vertex, measured in 3D units along the path. This sets this node's position to a point within the path. get_offset :: (PathFollow :< cls, Object :< cls) => cls -> IO Float get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "get_offset" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow.get_offset {-# NOINLINE bindPathFollow_get_rotation_mode #-} -- | Allows or forbids rotation on one or more axes, depending on the @enum RotationMode@ constants being used. bindPathFollow_get_rotation_mode :: MethodBind bindPathFollow_get_rotation_mode = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "get_rotation_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows or forbids rotation on one or more axes, depending on the @enum RotationMode@ constants being used. get_rotation_mode :: (PathFollow :< cls, Object :< cls) => cls -> IO Int get_rotation_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_get_rotation_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "get_rotation_mode" '[] (IO Int) where nodeMethod = Godot.Core.PathFollow.get_rotation_mode {-# NOINLINE bindPathFollow_get_unit_offset #-} -- | The distance from the first vertex, considering 0.0 as the first vertex and 1.0 as the last. This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length. bindPathFollow_get_unit_offset :: MethodBind bindPathFollow_get_unit_offset = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "get_unit_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance from the first vertex, considering 0.0 as the first vertex and 1.0 as the last. This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length. get_unit_offset :: (PathFollow :< cls, Object :< cls) => cls -> IO Float get_unit_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_get_unit_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "get_unit_offset" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow.get_unit_offset {-# NOINLINE bindPathFollow_get_v_offset #-} -- | The node's offset perpendicular to the curve. bindPathFollow_get_v_offset :: MethodBind bindPathFollow_get_v_offset = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "get_v_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's offset perpendicular to the curve. get_v_offset :: (PathFollow :< cls, Object :< cls) => cls -> IO Float get_v_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_get_v_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "get_v_offset" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow.get_v_offset {-# NOINLINE bindPathFollow_has_loop #-} -- | If @true@, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths. bindPathFollow_has_loop :: MethodBind bindPathFollow_has_loop = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "has_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths. has_loop :: (PathFollow :< cls, Object :< cls) => cls -> IO Bool has_loop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_has_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "has_loop" '[] (IO Bool) where nodeMethod = Godot.Core.PathFollow.has_loop {-# NOINLINE bindPathFollow_set_cubic_interpolation #-} -- | If @true@, the position between two cached points is interpolated cubically, and linearly otherwise. -- The points along the @Curve3D@ of the @Path@ are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough. -- There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations. bindPathFollow_set_cubic_interpolation :: MethodBind bindPathFollow_set_cubic_interpolation = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "set_cubic_interpolation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the position between two cached points is interpolated cubically, and linearly otherwise. -- The points along the @Curve3D@ of the @Path@ are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough. -- There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations. set_cubic_interpolation :: (PathFollow :< cls, Object :< cls) => cls -> Bool -> IO () set_cubic_interpolation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_set_cubic_interpolation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "set_cubic_interpolation" '[Bool] (IO ()) where nodeMethod = Godot.Core.PathFollow.set_cubic_interpolation {-# NOINLINE bindPathFollow_set_h_offset #-} -- | The node's offset along the curve. bindPathFollow_set_h_offset :: MethodBind bindPathFollow_set_h_offset = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "set_h_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's offset along the curve. set_h_offset :: (PathFollow :< cls, Object :< cls) => cls -> Float -> IO () set_h_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_set_h_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "set_h_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow.set_h_offset {-# NOINLINE bindPathFollow_set_loop #-} -- | If @true@, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths. bindPathFollow_set_loop :: MethodBind bindPathFollow_set_loop = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "set_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths. set_loop :: (PathFollow :< cls, Object :< cls) => cls -> Bool -> IO () set_loop cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_set_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "set_loop" '[Bool] (IO ()) where nodeMethod = Godot.Core.PathFollow.set_loop {-# NOINLINE bindPathFollow_set_offset #-} -- | The distance from the first vertex, measured in 3D units along the path. This sets this node's position to a point within the path. bindPathFollow_set_offset :: MethodBind bindPathFollow_set_offset = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance from the first vertex, measured in 3D units along the path. This sets this node's position to a point within the path. set_offset :: (PathFollow :< cls, Object :< cls) => cls -> Float -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "set_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow.set_offset {-# NOINLINE bindPathFollow_set_rotation_mode #-} -- | Allows or forbids rotation on one or more axes, depending on the @enum RotationMode@ constants being used. bindPathFollow_set_rotation_mode :: MethodBind bindPathFollow_set_rotation_mode = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "set_rotation_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows or forbids rotation on one or more axes, depending on the @enum RotationMode@ constants being used. set_rotation_mode :: (PathFollow :< cls, Object :< cls) => cls -> Int -> IO () set_rotation_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_set_rotation_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "set_rotation_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.PathFollow.set_rotation_mode {-# NOINLINE bindPathFollow_set_unit_offset #-} -- | The distance from the first vertex, considering 0.0 as the first vertex and 1.0 as the last. This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length. bindPathFollow_set_unit_offset :: MethodBind bindPathFollow_set_unit_offset = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "set_unit_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance from the first vertex, considering 0.0 as the first vertex and 1.0 as the last. This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length. set_unit_offset :: (PathFollow :< cls, Object :< cls) => cls -> Float -> IO () set_unit_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_set_unit_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "set_unit_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow.set_unit_offset {-# NOINLINE bindPathFollow_set_v_offset #-} -- | The node's offset perpendicular to the curve. bindPathFollow_set_v_offset :: MethodBind bindPathFollow_set_v_offset = unsafePerformIO $ withCString "PathFollow" $ \ clsNamePtr -> withCString "set_v_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's offset perpendicular to the curve. set_v_offset :: (PathFollow :< cls, Object :< cls) => cls -> Float -> IO () set_v_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow_set_v_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow "set_v_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow.set_v_offset ================================================ FILE: src/Godot/Core/PathFollow2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PathFollow2D (Godot.Core.PathFollow2D.get_cubic_interpolation, Godot.Core.PathFollow2D.get_h_offset, Godot.Core.PathFollow2D.get_lookahead, Godot.Core.PathFollow2D.get_offset, Godot.Core.PathFollow2D.get_unit_offset, Godot.Core.PathFollow2D.get_v_offset, Godot.Core.PathFollow2D.has_loop, Godot.Core.PathFollow2D.is_rotating, Godot.Core.PathFollow2D.set_cubic_interpolation, Godot.Core.PathFollow2D.set_h_offset, Godot.Core.PathFollow2D.set_lookahead, Godot.Core.PathFollow2D.set_loop, Godot.Core.PathFollow2D.set_offset, Godot.Core.PathFollow2D.set_rotate, Godot.Core.PathFollow2D.set_unit_offset, Godot.Core.PathFollow2D.set_v_offset) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty PathFollow2D "cubic_interp" Bool 'False where nodeProperty = (get_cubic_interpolation, wrapDroppingSetter set_cubic_interpolation, Nothing) instance NodeProperty PathFollow2D "h_offset" Float 'False where nodeProperty = (get_h_offset, wrapDroppingSetter set_h_offset, Nothing) instance NodeProperty PathFollow2D "lookahead" Float 'False where nodeProperty = (get_lookahead, wrapDroppingSetter set_lookahead, Nothing) instance NodeProperty PathFollow2D "loop" Bool 'False where nodeProperty = (has_loop, wrapDroppingSetter set_loop, Nothing) instance NodeProperty PathFollow2D "offset" Float 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty PathFollow2D "rotate" Bool 'False where nodeProperty = (is_rotating, wrapDroppingSetter set_rotate, Nothing) instance NodeProperty PathFollow2D "unit_offset" Float 'False where nodeProperty = (get_unit_offset, wrapDroppingSetter set_unit_offset, Nothing) instance NodeProperty PathFollow2D "v_offset" Float 'False where nodeProperty = (get_v_offset, wrapDroppingSetter set_v_offset, Nothing) {-# NOINLINE bindPathFollow2D_get_cubic_interpolation #-} -- | If @true@, the position between two cached points is interpolated cubically, and linearly otherwise. -- The points along the @Curve2D@ of the @Path2D@ are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough. -- There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations. bindPathFollow2D_get_cubic_interpolation :: MethodBind bindPathFollow2D_get_cubic_interpolation = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "get_cubic_interpolation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the position between two cached points is interpolated cubically, and linearly otherwise. -- The points along the @Curve2D@ of the @Path2D@ are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough. -- There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations. get_cubic_interpolation :: (PathFollow2D :< cls, Object :< cls) => cls -> IO Bool get_cubic_interpolation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_get_cubic_interpolation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "get_cubic_interpolation" '[] (IO Bool) where nodeMethod = Godot.Core.PathFollow2D.get_cubic_interpolation {-# NOINLINE bindPathFollow2D_get_h_offset #-} -- | The node's offset along the curve. bindPathFollow2D_get_h_offset :: MethodBind bindPathFollow2D_get_h_offset = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "get_h_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's offset along the curve. get_h_offset :: (PathFollow2D :< cls, Object :< cls) => cls -> IO Float get_h_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_get_h_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "get_h_offset" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow2D.get_h_offset {-# NOINLINE bindPathFollow2D_get_lookahead #-} -- | How far to look ahead of the curve to calculate the tangent if the node is rotating. E.g. shorter lookaheads will lead to faster rotations. bindPathFollow2D_get_lookahead :: MethodBind bindPathFollow2D_get_lookahead = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "get_lookahead" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How far to look ahead of the curve to calculate the tangent if the node is rotating. E.g. shorter lookaheads will lead to faster rotations. get_lookahead :: (PathFollow2D :< cls, Object :< cls) => cls -> IO Float get_lookahead cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_get_lookahead (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "get_lookahead" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow2D.get_lookahead {-# NOINLINE bindPathFollow2D_get_offset #-} -- | The distance along the path in pixels. bindPathFollow2D_get_offset :: MethodBind bindPathFollow2D_get_offset = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance along the path in pixels. get_offset :: (PathFollow2D :< cls, Object :< cls) => cls -> IO Float get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "get_offset" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow2D.get_offset {-# NOINLINE bindPathFollow2D_get_unit_offset #-} -- | The distance along the path as a number in the range 0.0 (for the first vertex) to 1.0 (for the last). This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length. bindPathFollow2D_get_unit_offset :: MethodBind bindPathFollow2D_get_unit_offset = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "get_unit_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance along the path as a number in the range 0.0 (for the first vertex) to 1.0 (for the last). This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length. get_unit_offset :: (PathFollow2D :< cls, Object :< cls) => cls -> IO Float get_unit_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_get_unit_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "get_unit_offset" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow2D.get_unit_offset {-# NOINLINE bindPathFollow2D_get_v_offset #-} -- | The node's offset perpendicular to the curve. bindPathFollow2D_get_v_offset :: MethodBind bindPathFollow2D_get_v_offset = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "get_v_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's offset perpendicular to the curve. get_v_offset :: (PathFollow2D :< cls, Object :< cls) => cls -> IO Float get_v_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_get_v_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "get_v_offset" '[] (IO Float) where nodeMethod = Godot.Core.PathFollow2D.get_v_offset {-# NOINLINE bindPathFollow2D_has_loop #-} -- | If @true@, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths. bindPathFollow2D_has_loop :: MethodBind bindPathFollow2D_has_loop = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "has_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths. has_loop :: (PathFollow2D :< cls, Object :< cls) => cls -> IO Bool has_loop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_has_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "has_loop" '[] (IO Bool) where nodeMethod = Godot.Core.PathFollow2D.has_loop {-# NOINLINE bindPathFollow2D_is_rotating #-} -- | If @true@, this node rotates to follow the path, making its descendants rotate. bindPathFollow2D_is_rotating :: MethodBind bindPathFollow2D_is_rotating = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "is_rotating" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this node rotates to follow the path, making its descendants rotate. is_rotating :: (PathFollow2D :< cls, Object :< cls) => cls -> IO Bool is_rotating cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_is_rotating (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "is_rotating" '[] (IO Bool) where nodeMethod = Godot.Core.PathFollow2D.is_rotating {-# NOINLINE bindPathFollow2D_set_cubic_interpolation #-} -- | If @true@, the position between two cached points is interpolated cubically, and linearly otherwise. -- The points along the @Curve2D@ of the @Path2D@ are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough. -- There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations. bindPathFollow2D_set_cubic_interpolation :: MethodBind bindPathFollow2D_set_cubic_interpolation = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "set_cubic_interpolation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the position between two cached points is interpolated cubically, and linearly otherwise. -- The points along the @Curve2D@ of the @Path2D@ are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough. -- There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations. set_cubic_interpolation :: (PathFollow2D :< cls, Object :< cls) => cls -> Bool -> IO () set_cubic_interpolation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_set_cubic_interpolation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "set_cubic_interpolation" '[Bool] (IO ()) where nodeMethod = Godot.Core.PathFollow2D.set_cubic_interpolation {-# NOINLINE bindPathFollow2D_set_h_offset #-} -- | The node's offset along the curve. bindPathFollow2D_set_h_offset :: MethodBind bindPathFollow2D_set_h_offset = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "set_h_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's offset along the curve. set_h_offset :: (PathFollow2D :< cls, Object :< cls) => cls -> Float -> IO () set_h_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_set_h_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "set_h_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow2D.set_h_offset {-# NOINLINE bindPathFollow2D_set_lookahead #-} -- | How far to look ahead of the curve to calculate the tangent if the node is rotating. E.g. shorter lookaheads will lead to faster rotations. bindPathFollow2D_set_lookahead :: MethodBind bindPathFollow2D_set_lookahead = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "set_lookahead" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How far to look ahead of the curve to calculate the tangent if the node is rotating. E.g. shorter lookaheads will lead to faster rotations. set_lookahead :: (PathFollow2D :< cls, Object :< cls) => cls -> Float -> IO () set_lookahead cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_set_lookahead (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "set_lookahead" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow2D.set_lookahead {-# NOINLINE bindPathFollow2D_set_loop #-} -- | If @true@, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths. bindPathFollow2D_set_loop :: MethodBind bindPathFollow2D_set_loop = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "set_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths. set_loop :: (PathFollow2D :< cls, Object :< cls) => cls -> Bool -> IO () set_loop cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_set_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "set_loop" '[Bool] (IO ()) where nodeMethod = Godot.Core.PathFollow2D.set_loop {-# NOINLINE bindPathFollow2D_set_offset #-} -- | The distance along the path in pixels. bindPathFollow2D_set_offset :: MethodBind bindPathFollow2D_set_offset = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance along the path in pixels. set_offset :: (PathFollow2D :< cls, Object :< cls) => cls -> Float -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "set_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow2D.set_offset {-# NOINLINE bindPathFollow2D_set_rotate #-} -- | If @true@, this node rotates to follow the path, making its descendants rotate. bindPathFollow2D_set_rotate :: MethodBind bindPathFollow2D_set_rotate = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "set_rotate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this node rotates to follow the path, making its descendants rotate. set_rotate :: (PathFollow2D :< cls, Object :< cls) => cls -> Bool -> IO () set_rotate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_set_rotate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "set_rotate" '[Bool] (IO ()) where nodeMethod = Godot.Core.PathFollow2D.set_rotate {-# NOINLINE bindPathFollow2D_set_unit_offset #-} -- | The distance along the path as a number in the range 0.0 (for the first vertex) to 1.0 (for the last). This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length. bindPathFollow2D_set_unit_offset :: MethodBind bindPathFollow2D_set_unit_offset = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "set_unit_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The distance along the path as a number in the range 0.0 (for the first vertex) to 1.0 (for the last). This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length. set_unit_offset :: (PathFollow2D :< cls, Object :< cls) => cls -> Float -> IO () set_unit_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_set_unit_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "set_unit_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow2D.set_unit_offset {-# NOINLINE bindPathFollow2D_set_v_offset #-} -- | The node's offset perpendicular to the curve. bindPathFollow2D_set_v_offset :: MethodBind bindPathFollow2D_set_v_offset = unsafePerformIO $ withCString "PathFollow2D" $ \ clsNamePtr -> withCString "set_v_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's offset perpendicular to the curve. set_v_offset :: (PathFollow2D :< cls, Object :< cls) => cls -> Float -> IO () set_v_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPathFollow2D_set_v_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PathFollow2D "set_v_offset" '[Float] (IO ()) where nodeMethod = Godot.Core.PathFollow2D.set_v_offset ================================================ FILE: src/Godot/Core/Performance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Performance (Godot.Core.Performance._PHYSICS_2D_ISLAND_COUNT, Godot.Core.Performance._OBJECT_RESOURCE_COUNT, Godot.Core.Performance._RENDER_VERTEX_MEM_USED, Godot.Core.Performance._PHYSICS_3D_ISLAND_COUNT, Godot.Core.Performance._PHYSICS_2D_COLLISION_PAIRS, Godot.Core.Performance._MEMORY_STATIC_MAX, Godot.Core.Performance._TIME_PHYSICS_PROCESS, Godot.Core.Performance._RENDER_TEXTURE_MEM_USED, Godot.Core.Performance._MEMORY_DYNAMIC_MAX, Godot.Core.Performance._OBJECT_ORPHAN_NODE_COUNT, Godot.Core.Performance._MEMORY_DYNAMIC, Godot.Core.Performance._RENDER_MATERIAL_CHANGES_IN_FRAME, Godot.Core.Performance._OBJECT_NODE_COUNT, Godot.Core.Performance._AUDIO_OUTPUT_LATENCY, Godot.Core.Performance._RENDER_OBJECTS_IN_FRAME, Godot.Core.Performance._RENDER_DRAW_CALLS_IN_FRAME, Godot.Core.Performance._TIME_PROCESS, Godot.Core.Performance._MEMORY_MESSAGE_BUFFER_MAX, Godot.Core.Performance._PHYSICS_3D_COLLISION_PAIRS, Godot.Core.Performance._RENDER_SHADER_CHANGES_IN_FRAME, Godot.Core.Performance._MONITOR_MAX, Godot.Core.Performance._TIME_FPS, Godot.Core.Performance._PHYSICS_2D_ACTIVE_OBJECTS, Godot.Core.Performance._RENDER_SURFACE_CHANGES_IN_FRAME, Godot.Core.Performance._RENDER_VIDEO_MEM_USED, Godot.Core.Performance._MEMORY_STATIC, Godot.Core.Performance._RENDER_VERTICES_IN_FRAME, Godot.Core.Performance._OBJECT_COUNT, Godot.Core.Performance._PHYSICS_3D_ACTIVE_OBJECTS, Godot.Core.Performance._RENDER_USAGE_VIDEO_MEM_TOTAL, Godot.Core.Performance.get_monitor) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _PHYSICS_2D_ISLAND_COUNT :: Int _PHYSICS_2D_ISLAND_COUNT = 24 _OBJECT_RESOURCE_COUNT :: Int _OBJECT_RESOURCE_COUNT = 9 _RENDER_VERTEX_MEM_USED :: Int _RENDER_VERTEX_MEM_USED = 20 _PHYSICS_3D_ISLAND_COUNT :: Int _PHYSICS_3D_ISLAND_COUNT = 27 _PHYSICS_2D_COLLISION_PAIRS :: Int _PHYSICS_2D_COLLISION_PAIRS = 23 _MEMORY_STATIC_MAX :: Int _MEMORY_STATIC_MAX = 5 _TIME_PHYSICS_PROCESS :: Int _TIME_PHYSICS_PROCESS = 2 _RENDER_TEXTURE_MEM_USED :: Int _RENDER_TEXTURE_MEM_USED = 19 _MEMORY_DYNAMIC_MAX :: Int _MEMORY_DYNAMIC_MAX = 6 _OBJECT_ORPHAN_NODE_COUNT :: Int _OBJECT_ORPHAN_NODE_COUNT = 11 _MEMORY_DYNAMIC :: Int _MEMORY_DYNAMIC = 4 _RENDER_MATERIAL_CHANGES_IN_FRAME :: Int _RENDER_MATERIAL_CHANGES_IN_FRAME = 14 _OBJECT_NODE_COUNT :: Int _OBJECT_NODE_COUNT = 10 _AUDIO_OUTPUT_LATENCY :: Int _AUDIO_OUTPUT_LATENCY = 28 _RENDER_OBJECTS_IN_FRAME :: Int _RENDER_OBJECTS_IN_FRAME = 12 _RENDER_DRAW_CALLS_IN_FRAME :: Int _RENDER_DRAW_CALLS_IN_FRAME = 17 _TIME_PROCESS :: Int _TIME_PROCESS = 1 _MEMORY_MESSAGE_BUFFER_MAX :: Int _MEMORY_MESSAGE_BUFFER_MAX = 7 _PHYSICS_3D_COLLISION_PAIRS :: Int _PHYSICS_3D_COLLISION_PAIRS = 26 _RENDER_SHADER_CHANGES_IN_FRAME :: Int _RENDER_SHADER_CHANGES_IN_FRAME = 15 _MONITOR_MAX :: Int _MONITOR_MAX = 29 _TIME_FPS :: Int _TIME_FPS = 0 _PHYSICS_2D_ACTIVE_OBJECTS :: Int _PHYSICS_2D_ACTIVE_OBJECTS = 22 _RENDER_SURFACE_CHANGES_IN_FRAME :: Int _RENDER_SURFACE_CHANGES_IN_FRAME = 16 _RENDER_VIDEO_MEM_USED :: Int _RENDER_VIDEO_MEM_USED = 18 _MEMORY_STATIC :: Int _MEMORY_STATIC = 3 _RENDER_VERTICES_IN_FRAME :: Int _RENDER_VERTICES_IN_FRAME = 13 _OBJECT_COUNT :: Int _OBJECT_COUNT = 8 _PHYSICS_3D_ACTIVE_OBJECTS :: Int _PHYSICS_3D_ACTIVE_OBJECTS = 25 _RENDER_USAGE_VIDEO_MEM_TOTAL :: Int _RENDER_USAGE_VIDEO_MEM_TOTAL = 21 {-# NOINLINE bindPerformance_get_monitor #-} -- | Returns the value of one of the available monitors. You should provide one of the @enum Monitor@ constants as the argument, like this: -- -- @ -- -- print(Performance.get_monitor(Performance.TIME_FPS)) # Prints the FPS to the console -- -- @ bindPerformance_get_monitor :: MethodBind bindPerformance_get_monitor = unsafePerformIO $ withCString "Performance" $ \ clsNamePtr -> withCString "get_monitor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of one of the available monitors. You should provide one of the @enum Monitor@ constants as the argument, like this: -- -- @ -- -- print(Performance.get_monitor(Performance.TIME_FPS)) # Prints the FPS to the console -- -- @ get_monitor :: (Performance :< cls, Object :< cls) => cls -> Int -> IO Float get_monitor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPerformance_get_monitor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Performance "get_monitor" '[Int] (IO Float) where nodeMethod = Godot.Core.Performance.get_monitor ================================================ FILE: src/Godot/Core/PhysicalBone.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicalBone (Godot.Core.PhysicalBone._JOINT_TYPE_6DOF, Godot.Core.PhysicalBone._JOINT_TYPE_PIN, Godot.Core.PhysicalBone._JOINT_TYPE_CONE, Godot.Core.PhysicalBone._JOINT_TYPE_NONE, Godot.Core.PhysicalBone._JOINT_TYPE_SLIDER, Godot.Core.PhysicalBone._JOINT_TYPE_HINGE, Godot.Core.PhysicalBone._direct_state_changed, Godot.Core.PhysicalBone.apply_central_impulse, Godot.Core.PhysicalBone.apply_impulse, Godot.Core.PhysicalBone.get_body_offset, Godot.Core.PhysicalBone.get_bone_id, Godot.Core.PhysicalBone.get_bounce, Godot.Core.PhysicalBone.get_friction, Godot.Core.PhysicalBone.get_gravity_scale, Godot.Core.PhysicalBone.get_joint_offset, Godot.Core.PhysicalBone.get_joint_type, Godot.Core.PhysicalBone.get_mass, Godot.Core.PhysicalBone.get_simulate_physics, Godot.Core.PhysicalBone.get_weight, Godot.Core.PhysicalBone.is_simulating_physics, Godot.Core.PhysicalBone.is_static_body, Godot.Core.PhysicalBone.set_body_offset, Godot.Core.PhysicalBone.set_bounce, Godot.Core.PhysicalBone.set_friction, Godot.Core.PhysicalBone.set_gravity_scale, Godot.Core.PhysicalBone.set_joint_offset, Godot.Core.PhysicalBone.set_joint_type, Godot.Core.PhysicalBone.set_mass, Godot.Core.PhysicalBone.set_weight) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsBody() _JOINT_TYPE_6DOF :: Int _JOINT_TYPE_6DOF = 5 _JOINT_TYPE_PIN :: Int _JOINT_TYPE_PIN = 1 _JOINT_TYPE_CONE :: Int _JOINT_TYPE_CONE = 2 _JOINT_TYPE_NONE :: Int _JOINT_TYPE_NONE = 0 _JOINT_TYPE_SLIDER :: Int _JOINT_TYPE_SLIDER = 4 _JOINT_TYPE_HINGE :: Int _JOINT_TYPE_HINGE = 3 instance NodeProperty PhysicalBone "body_offset" Transform 'False where nodeProperty = (get_body_offset, wrapDroppingSetter set_body_offset, Nothing) instance NodeProperty PhysicalBone "bounce" Float 'False where nodeProperty = (get_bounce, wrapDroppingSetter set_bounce, Nothing) instance NodeProperty PhysicalBone "friction" Float 'False where nodeProperty = (get_friction, wrapDroppingSetter set_friction, Nothing) instance NodeProperty PhysicalBone "gravity_scale" Float 'False where nodeProperty = (get_gravity_scale, wrapDroppingSetter set_gravity_scale, Nothing) instance NodeProperty PhysicalBone "joint_offset" Transform 'False where nodeProperty = (get_joint_offset, wrapDroppingSetter set_joint_offset, Nothing) instance NodeProperty PhysicalBone "joint_type" Int 'False where nodeProperty = (get_joint_type, wrapDroppingSetter set_joint_type, Nothing) instance NodeProperty PhysicalBone "mass" Float 'False where nodeProperty = (get_mass, wrapDroppingSetter set_mass, Nothing) instance NodeProperty PhysicalBone "weight" Float 'False where nodeProperty = (get_weight, wrapDroppingSetter set_weight, Nothing) {-# NOINLINE bindPhysicalBone__direct_state_changed #-} bindPhysicalBone__direct_state_changed :: MethodBind bindPhysicalBone__direct_state_changed = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "_direct_state_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _direct_state_changed :: (PhysicalBone :< cls, Object :< cls) => cls -> Object -> IO () _direct_state_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone__direct_state_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "_direct_state_changed" '[Object] (IO ()) where nodeMethod = Godot.Core.PhysicalBone._direct_state_changed {-# NOINLINE bindPhysicalBone_apply_central_impulse #-} bindPhysicalBone_apply_central_impulse :: MethodBind bindPhysicalBone_apply_central_impulse = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "apply_central_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr apply_central_impulse :: (PhysicalBone :< cls, Object :< cls) => cls -> Vector3 -> IO () apply_central_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_apply_central_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "apply_central_impulse" '[Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.apply_central_impulse {-# NOINLINE bindPhysicalBone_apply_impulse #-} bindPhysicalBone_apply_impulse :: MethodBind bindPhysicalBone_apply_impulse = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "apply_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr apply_impulse :: (PhysicalBone :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> IO () apply_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_apply_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "apply_impulse" '[Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.apply_impulse {-# NOINLINE bindPhysicalBone_get_body_offset #-} bindPhysicalBone_get_body_offset :: MethodBind bindPhysicalBone_get_body_offset = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_body_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_body_offset :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Transform get_body_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_body_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_body_offset" '[] (IO Transform) where nodeMethod = Godot.Core.PhysicalBone.get_body_offset {-# NOINLINE bindPhysicalBone_get_bone_id #-} bindPhysicalBone_get_bone_id :: MethodBind bindPhysicalBone_get_bone_id = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_bone_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bone_id :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Int get_bone_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_bone_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_bone_id" '[] (IO Int) where nodeMethod = Godot.Core.PhysicalBone.get_bone_id {-# NOINLINE bindPhysicalBone_get_bounce #-} bindPhysicalBone_get_bounce :: MethodBind bindPhysicalBone_get_bounce = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bounce :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Float get_bounce cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_bounce" '[] (IO Float) where nodeMethod = Godot.Core.PhysicalBone.get_bounce {-# NOINLINE bindPhysicalBone_get_friction #-} bindPhysicalBone_get_friction :: MethodBind bindPhysicalBone_get_friction = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_friction :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Float get_friction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_friction" '[] (IO Float) where nodeMethod = Godot.Core.PhysicalBone.get_friction {-# NOINLINE bindPhysicalBone_get_gravity_scale #-} bindPhysicalBone_get_gravity_scale :: MethodBind bindPhysicalBone_get_gravity_scale = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_gravity_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_gravity_scale :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Float get_gravity_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_gravity_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_gravity_scale" '[] (IO Float) where nodeMethod = Godot.Core.PhysicalBone.get_gravity_scale {-# NOINLINE bindPhysicalBone_get_joint_offset #-} bindPhysicalBone_get_joint_offset :: MethodBind bindPhysicalBone_get_joint_offset = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_joint_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_joint_offset :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Transform get_joint_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_joint_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_joint_offset" '[] (IO Transform) where nodeMethod = Godot.Core.PhysicalBone.get_joint_offset {-# NOINLINE bindPhysicalBone_get_joint_type #-} bindPhysicalBone_get_joint_type :: MethodBind bindPhysicalBone_get_joint_type = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_joint_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_joint_type :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Int get_joint_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_joint_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_joint_type" '[] (IO Int) where nodeMethod = Godot.Core.PhysicalBone.get_joint_type {-# NOINLINE bindPhysicalBone_get_mass #-} bindPhysicalBone_get_mass :: MethodBind bindPhysicalBone_get_mass = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_mass :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Float get_mass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_mass" '[] (IO Float) where nodeMethod = Godot.Core.PhysicalBone.get_mass {-# NOINLINE bindPhysicalBone_get_simulate_physics #-} bindPhysicalBone_get_simulate_physics :: MethodBind bindPhysicalBone_get_simulate_physics = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_simulate_physics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_simulate_physics :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Bool get_simulate_physics cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_simulate_physics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_simulate_physics" '[] (IO Bool) where nodeMethod = Godot.Core.PhysicalBone.get_simulate_physics {-# NOINLINE bindPhysicalBone_get_weight #-} bindPhysicalBone_get_weight :: MethodBind bindPhysicalBone_get_weight = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "get_weight" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_weight :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Float get_weight cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_get_weight (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "get_weight" '[] (IO Float) where nodeMethod = Godot.Core.PhysicalBone.get_weight {-# NOINLINE bindPhysicalBone_is_simulating_physics #-} bindPhysicalBone_is_simulating_physics :: MethodBind bindPhysicalBone_is_simulating_physics = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "is_simulating_physics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_simulating_physics :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Bool is_simulating_physics cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_is_simulating_physics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "is_simulating_physics" '[] (IO Bool) where nodeMethod = Godot.Core.PhysicalBone.is_simulating_physics {-# NOINLINE bindPhysicalBone_is_static_body #-} bindPhysicalBone_is_static_body :: MethodBind bindPhysicalBone_is_static_body = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "is_static_body" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_static_body :: (PhysicalBone :< cls, Object :< cls) => cls -> IO Bool is_static_body cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_is_static_body (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "is_static_body" '[] (IO Bool) where nodeMethod = Godot.Core.PhysicalBone.is_static_body {-# NOINLINE bindPhysicalBone_set_body_offset #-} bindPhysicalBone_set_body_offset :: MethodBind bindPhysicalBone_set_body_offset = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "set_body_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_body_offset :: (PhysicalBone :< cls, Object :< cls) => cls -> Transform -> IO () set_body_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_set_body_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "set_body_offset" '[Transform] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.set_body_offset {-# NOINLINE bindPhysicalBone_set_bounce #-} bindPhysicalBone_set_bounce :: MethodBind bindPhysicalBone_set_bounce = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "set_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bounce :: (PhysicalBone :< cls, Object :< cls) => cls -> Float -> IO () set_bounce cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_set_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "set_bounce" '[Float] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.set_bounce {-# NOINLINE bindPhysicalBone_set_friction #-} bindPhysicalBone_set_friction :: MethodBind bindPhysicalBone_set_friction = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "set_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_friction :: (PhysicalBone :< cls, Object :< cls) => cls -> Float -> IO () set_friction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_set_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "set_friction" '[Float] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.set_friction {-# NOINLINE bindPhysicalBone_set_gravity_scale #-} bindPhysicalBone_set_gravity_scale :: MethodBind bindPhysicalBone_set_gravity_scale = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "set_gravity_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_gravity_scale :: (PhysicalBone :< cls, Object :< cls) => cls -> Float -> IO () set_gravity_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_set_gravity_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "set_gravity_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.set_gravity_scale {-# NOINLINE bindPhysicalBone_set_joint_offset #-} bindPhysicalBone_set_joint_offset :: MethodBind bindPhysicalBone_set_joint_offset = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "set_joint_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_joint_offset :: (PhysicalBone :< cls, Object :< cls) => cls -> Transform -> IO () set_joint_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_set_joint_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "set_joint_offset" '[Transform] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.set_joint_offset {-# NOINLINE bindPhysicalBone_set_joint_type #-} bindPhysicalBone_set_joint_type :: MethodBind bindPhysicalBone_set_joint_type = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "set_joint_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_joint_type :: (PhysicalBone :< cls, Object :< cls) => cls -> Int -> IO () set_joint_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_set_joint_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "set_joint_type" '[Int] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.set_joint_type {-# NOINLINE bindPhysicalBone_set_mass #-} bindPhysicalBone_set_mass :: MethodBind bindPhysicalBone_set_mass = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "set_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_mass :: (PhysicalBone :< cls, Object :< cls) => cls -> Float -> IO () set_mass cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_set_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "set_mass" '[Float] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.set_mass {-# NOINLINE bindPhysicalBone_set_weight #-} bindPhysicalBone_set_weight :: MethodBind bindPhysicalBone_set_weight = unsafePerformIO $ withCString "PhysicalBone" $ \ clsNamePtr -> withCString "set_weight" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_weight :: (PhysicalBone :< cls, Object :< cls) => cls -> Float -> IO () set_weight cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicalBone_set_weight (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicalBone "set_weight" '[Float] (IO ()) where nodeMethod = Godot.Core.PhysicalBone.set_weight ================================================ FILE: src/Godot/Core/Physics2DDirectBodyState.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Physics2DDirectBodyState (Godot.Core.Physics2DDirectBodyState.add_central_force, Godot.Core.Physics2DDirectBodyState.add_force, Godot.Core.Physics2DDirectBodyState.add_torque, Godot.Core.Physics2DDirectBodyState.apply_central_impulse, Godot.Core.Physics2DDirectBodyState.apply_impulse, Godot.Core.Physics2DDirectBodyState.apply_torque_impulse, Godot.Core.Physics2DDirectBodyState.get_angular_velocity, Godot.Core.Physics2DDirectBodyState.get_contact_collider, Godot.Core.Physics2DDirectBodyState.get_contact_collider_id, Godot.Core.Physics2DDirectBodyState.get_contact_collider_object, Godot.Core.Physics2DDirectBodyState.get_contact_collider_position, Godot.Core.Physics2DDirectBodyState.get_contact_collider_shape, Godot.Core.Physics2DDirectBodyState.get_contact_collider_shape_metadata, Godot.Core.Physics2DDirectBodyState.get_contact_collider_velocity_at_position, Godot.Core.Physics2DDirectBodyState.get_contact_count, Godot.Core.Physics2DDirectBodyState.get_contact_local_normal, Godot.Core.Physics2DDirectBodyState.get_contact_local_position, Godot.Core.Physics2DDirectBodyState.get_contact_local_shape, Godot.Core.Physics2DDirectBodyState.get_inverse_inertia, Godot.Core.Physics2DDirectBodyState.get_inverse_mass, Godot.Core.Physics2DDirectBodyState.get_linear_velocity, Godot.Core.Physics2DDirectBodyState.get_space_state, Godot.Core.Physics2DDirectBodyState.get_step, Godot.Core.Physics2DDirectBodyState.get_total_angular_damp, Godot.Core.Physics2DDirectBodyState.get_total_gravity, Godot.Core.Physics2DDirectBodyState.get_total_linear_damp, Godot.Core.Physics2DDirectBodyState.get_transform, Godot.Core.Physics2DDirectBodyState.integrate_forces, Godot.Core.Physics2DDirectBodyState.is_sleeping, Godot.Core.Physics2DDirectBodyState.set_angular_velocity, Godot.Core.Physics2DDirectBodyState.set_linear_velocity, Godot.Core.Physics2DDirectBodyState.set_sleep_state, Godot.Core.Physics2DDirectBodyState.set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() instance NodeProperty Physics2DDirectBodyState "angular_velocity" Float 'False where nodeProperty = (get_angular_velocity, wrapDroppingSetter set_angular_velocity, Nothing) instance NodeProperty Physics2DDirectBodyState "inverse_inertia" Float 'True where nodeProperty = (get_inverse_inertia, (), Nothing) instance NodeProperty Physics2DDirectBodyState "inverse_mass" Float 'True where nodeProperty = (get_inverse_mass, (), Nothing) instance NodeProperty Physics2DDirectBodyState "linear_velocity" Vector2 'False where nodeProperty = (get_linear_velocity, wrapDroppingSetter set_linear_velocity, Nothing) instance NodeProperty Physics2DDirectBodyState "sleeping" Bool 'False where nodeProperty = (is_sleeping, wrapDroppingSetter set_sleep_state, Nothing) instance NodeProperty Physics2DDirectBodyState "step" Float 'True where nodeProperty = (get_step, (), Nothing) instance NodeProperty Physics2DDirectBodyState "total_angular_damp" Float 'True where nodeProperty = (get_total_angular_damp, (), Nothing) instance NodeProperty Physics2DDirectBodyState "total_gravity" Vector2 'True where nodeProperty = (get_total_gravity, (), Nothing) instance NodeProperty Physics2DDirectBodyState "total_linear_damp" Float 'True where nodeProperty = (get_total_linear_damp, (), Nothing) instance NodeProperty Physics2DDirectBodyState "transform" Transform2d 'False where nodeProperty = (get_transform, wrapDroppingSetter set_transform, Nothing) {-# NOINLINE bindPhysics2DDirectBodyState_add_central_force #-} -- | Adds a constant directional force without affecting rotation. bindPhysics2DDirectBodyState_add_central_force :: MethodBind bindPhysics2DDirectBodyState_add_central_force = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "add_central_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant directional force without affecting rotation. add_central_force :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Vector2 -> IO () add_central_force cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_add_central_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "add_central_force" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.add_central_force {-# NOINLINE bindPhysics2DDirectBodyState_add_force #-} -- | Adds a positioned force to the body. Both the force and the offset from the body origin are in global coordinates. bindPhysics2DDirectBodyState_add_force :: MethodBind bindPhysics2DDirectBodyState_add_force = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "add_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a positioned force to the body. Both the force and the offset from the body origin are in global coordinates. add_force :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> IO () add_force cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_add_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "add_force" '[Vector2, Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.add_force {-# NOINLINE bindPhysics2DDirectBodyState_add_torque #-} -- | Adds a constant rotational force. bindPhysics2DDirectBodyState_add_torque :: MethodBind bindPhysics2DDirectBodyState_add_torque = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "add_torque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant rotational force. add_torque :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Float -> IO () add_torque cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_add_torque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "add_torque" '[Float] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.add_torque {-# NOINLINE bindPhysics2DDirectBodyState_apply_central_impulse #-} -- | Applies a directional impulse without affecting rotation. bindPhysics2DDirectBodyState_apply_central_impulse :: MethodBind bindPhysics2DDirectBodyState_apply_central_impulse = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "apply_central_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a directional impulse without affecting rotation. apply_central_impulse :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Vector2 -> IO () apply_central_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_apply_central_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "apply_central_impulse" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.apply_central_impulse {-# NOINLINE bindPhysics2DDirectBodyState_apply_impulse #-} -- | Applies a positioned impulse to the body. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise). The offset uses the rotation of the global coordinate system, but is centered at the object's origin. bindPhysics2DDirectBodyState_apply_impulse :: MethodBind bindPhysics2DDirectBodyState_apply_impulse = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "apply_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a positioned impulse to the body. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise). The offset uses the rotation of the global coordinate system, but is centered at the object's origin. apply_impulse :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> IO () apply_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_apply_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "apply_impulse" '[Vector2, Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.apply_impulse {-# NOINLINE bindPhysics2DDirectBodyState_apply_torque_impulse #-} -- | Applies a rotational impulse to the body. bindPhysics2DDirectBodyState_apply_torque_impulse :: MethodBind bindPhysics2DDirectBodyState_apply_torque_impulse = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "apply_torque_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a rotational impulse to the body. apply_torque_impulse :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Float -> IO () apply_torque_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_apply_torque_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "apply_torque_impulse" '[Float] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.apply_torque_impulse {-# NOINLINE bindPhysics2DDirectBodyState_get_angular_velocity #-} -- | The body's rotational velocity. bindPhysics2DDirectBodyState_get_angular_velocity :: MethodBind bindPhysics2DDirectBodyState_get_angular_velocity = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's rotational velocity. get_angular_velocity :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_angular_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_angular_velocity" '[] (IO Float) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_angular_velocity {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_collider #-} -- | Returns the collider's @RID@. bindPhysics2DDirectBodyState_get_contact_collider :: MethodBind bindPhysics2DDirectBodyState_get_contact_collider = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collider's @RID@. get_contact_collider :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Rid get_contact_collider cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_collider (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_collider" '[Int] (IO Rid) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_collider {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_collider_id #-} -- | Returns the collider's object id. bindPhysics2DDirectBodyState_get_contact_collider_id :: MethodBind bindPhysics2DDirectBodyState_get_contact_collider_id = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collider's object id. get_contact_collider_id :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Int get_contact_collider_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_collider_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_collider_id" '[Int] (IO Int) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_collider_id {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_collider_object #-} -- | Returns the collider object. This depends on how it was created (will return a scene node if such was used to create it). bindPhysics2DDirectBodyState_get_contact_collider_object :: MethodBind bindPhysics2DDirectBodyState_get_contact_collider_object = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collider object. This depends on how it was created (will return a scene node if such was used to create it). get_contact_collider_object :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Object get_contact_collider_object cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_collider_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_collider_object" '[Int] (IO Object) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_collider_object {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_collider_position #-} -- | Returns the contact position in the collider. bindPhysics2DDirectBodyState_get_contact_collider_position :: MethodBind bindPhysics2DDirectBodyState_get_contact_collider_position = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the contact position in the collider. get_contact_collider_position :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_contact_collider_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_collider_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_collider_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_collider_position {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_collider_shape #-} -- | Returns the collider's shape index. bindPhysics2DDirectBodyState_get_contact_collider_shape :: MethodBind bindPhysics2DDirectBodyState_get_contact_collider_shape = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collider's shape index. get_contact_collider_shape :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Int get_contact_collider_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_collider_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_collider_shape" '[Int] (IO Int) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_collider_shape {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_collider_shape_metadata #-} -- | Returns the collided shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. bindPhysics2DDirectBodyState_get_contact_collider_shape_metadata :: MethodBind bindPhysics2DDirectBodyState_get_contact_collider_shape_metadata = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_shape_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collided shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. get_contact_collider_shape_metadata :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_contact_collider_shape_metadata cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_collider_shape_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_collider_shape_metadata" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_collider_shape_metadata {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_collider_velocity_at_position #-} -- | Returns the linear velocity vector at the collider's contact point. bindPhysics2DDirectBodyState_get_contact_collider_velocity_at_position :: MethodBind bindPhysics2DDirectBodyState_get_contact_collider_velocity_at_position = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_velocity_at_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the linear velocity vector at the collider's contact point. get_contact_collider_velocity_at_position :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_contact_collider_velocity_at_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_collider_velocity_at_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_collider_velocity_at_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_collider_velocity_at_position {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_count #-} -- | Returns the number of contacts this body has with other bodies. -- __Note:__ By default, this returns 0 unless bodies are configured to monitor contacts. See @RigidBody2D.contact_monitor@. bindPhysics2DDirectBodyState_get_contact_count :: MethodBind bindPhysics2DDirectBodyState_get_contact_count = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of contacts this body has with other bodies. -- __Note:__ By default, this returns 0 unless bodies are configured to monitor contacts. See @RigidBody2D.contact_monitor@. get_contact_count :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Int get_contact_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_count" '[] (IO Int) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_count {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_local_normal #-} -- | Returns the local normal at the contact point. bindPhysics2DDirectBodyState_get_contact_local_normal :: MethodBind bindPhysics2DDirectBodyState_get_contact_local_normal = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_local_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the local normal at the contact point. get_contact_local_normal :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_contact_local_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_local_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_local_normal" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_local_normal {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_local_position #-} -- | Returns the local position of the contact point. bindPhysics2DDirectBodyState_get_contact_local_position :: MethodBind bindPhysics2DDirectBodyState_get_contact_local_position = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_local_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the local position of the contact point. get_contact_local_position :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Vector2 get_contact_local_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_local_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_local_position" '[Int] (IO Vector2) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_local_position {-# NOINLINE bindPhysics2DDirectBodyState_get_contact_local_shape #-} -- | Returns the local shape index of the collision. bindPhysics2DDirectBodyState_get_contact_local_shape :: MethodBind bindPhysics2DDirectBodyState_get_contact_local_shape = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_local_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the local shape index of the collision. get_contact_local_shape :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Int get_contact_local_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_contact_local_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_contact_local_shape" '[Int] (IO Int) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_contact_local_shape {-# NOINLINE bindPhysics2DDirectBodyState_get_inverse_inertia #-} -- | The inverse of the inertia of the body. bindPhysics2DDirectBodyState_get_inverse_inertia :: MethodBind bindPhysics2DDirectBodyState_get_inverse_inertia = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_inverse_inertia" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The inverse of the inertia of the body. get_inverse_inertia :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_inverse_inertia cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_inverse_inertia (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_inverse_inertia" '[] (IO Float) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_inverse_inertia {-# NOINLINE bindPhysics2DDirectBodyState_get_inverse_mass #-} -- | The inverse of the mass of the body. bindPhysics2DDirectBodyState_get_inverse_mass :: MethodBind bindPhysics2DDirectBodyState_get_inverse_mass = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_inverse_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The inverse of the mass of the body. get_inverse_mass :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_inverse_mass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_inverse_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_inverse_mass" '[] (IO Float) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_inverse_mass {-# NOINLINE bindPhysics2DDirectBodyState_get_linear_velocity #-} -- | The body's linear velocity. bindPhysics2DDirectBodyState_get_linear_velocity :: MethodBind bindPhysics2DDirectBodyState_get_linear_velocity = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear velocity. get_linear_velocity :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Vector2 get_linear_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_linear_velocity" '[] (IO Vector2) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_linear_velocity {-# NOINLINE bindPhysics2DDirectBodyState_get_space_state #-} -- | Returns the current state of the space, useful for queries. bindPhysics2DDirectBodyState_get_space_state :: MethodBind bindPhysics2DDirectBodyState_get_space_state = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_space_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current state of the space, useful for queries. get_space_state :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Physics2DDirectSpaceState get_space_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_space_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_space_state" '[] (IO Physics2DDirectSpaceState) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_space_state {-# NOINLINE bindPhysics2DDirectBodyState_get_step #-} -- | The timestep (delta) used for the simulation. bindPhysics2DDirectBodyState_get_step :: MethodBind bindPhysics2DDirectBodyState_get_step = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The timestep (delta) used for the simulation. get_step :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_step cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_step" '[] (IO Float) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_step {-# NOINLINE bindPhysics2DDirectBodyState_get_total_angular_damp #-} -- | The rate at which the body stops rotating, if there are not any other forces moving it. bindPhysics2DDirectBodyState_get_total_angular_damp :: MethodBind bindPhysics2DDirectBodyState_get_total_angular_damp = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_total_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which the body stops rotating, if there are not any other forces moving it. get_total_angular_damp :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_total_angular_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_total_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_total_angular_damp" '[] (IO Float) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_total_angular_damp {-# NOINLINE bindPhysics2DDirectBodyState_get_total_gravity #-} -- | The total gravity vector being currently applied to this body. bindPhysics2DDirectBodyState_get_total_gravity :: MethodBind bindPhysics2DDirectBodyState_get_total_gravity = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_total_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The total gravity vector being currently applied to this body. get_total_gravity :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Vector2 get_total_gravity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_total_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_total_gravity" '[] (IO Vector2) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_total_gravity {-# NOINLINE bindPhysics2DDirectBodyState_get_total_linear_damp #-} -- | The rate at which the body stops moving, if there are not any other forces moving it. bindPhysics2DDirectBodyState_get_total_linear_damp :: MethodBind bindPhysics2DDirectBodyState_get_total_linear_damp = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_total_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which the body stops moving, if there are not any other forces moving it. get_total_linear_damp :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_total_linear_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_total_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_total_linear_damp" '[] (IO Float) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_total_linear_damp {-# NOINLINE bindPhysics2DDirectBodyState_get_transform #-} -- | The body's transformation matrix. bindPhysics2DDirectBodyState_get_transform :: MethodBind bindPhysics2DDirectBodyState_get_transform = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's transformation matrix. get_transform :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Transform2d get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "get_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.Physics2DDirectBodyState.get_transform {-# NOINLINE bindPhysics2DDirectBodyState_integrate_forces #-} -- | Calls the built-in force integration code. bindPhysics2DDirectBodyState_integrate_forces :: MethodBind bindPhysics2DDirectBodyState_integrate_forces = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "integrate_forces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the built-in force integration code. integrate_forces :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO () integrate_forces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_integrate_forces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "integrate_forces" '[] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.integrate_forces {-# NOINLINE bindPhysics2DDirectBodyState_is_sleeping #-} -- | If @true@, this body is currently sleeping (not active). bindPhysics2DDirectBodyState_is_sleeping :: MethodBind bindPhysics2DDirectBodyState_is_sleeping = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "is_sleeping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this body is currently sleeping (not active). is_sleeping :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> IO Bool is_sleeping cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_is_sleeping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "is_sleeping" '[] (IO Bool) where nodeMethod = Godot.Core.Physics2DDirectBodyState.is_sleeping {-# NOINLINE bindPhysics2DDirectBodyState_set_angular_velocity #-} -- | The body's rotational velocity. bindPhysics2DDirectBodyState_set_angular_velocity :: MethodBind bindPhysics2DDirectBodyState_set_angular_velocity = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "set_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's rotational velocity. set_angular_velocity :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Float -> IO () set_angular_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_set_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "set_angular_velocity" '[Float] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.set_angular_velocity {-# NOINLINE bindPhysics2DDirectBodyState_set_linear_velocity #-} -- | The body's linear velocity. bindPhysics2DDirectBodyState_set_linear_velocity :: MethodBind bindPhysics2DDirectBodyState_set_linear_velocity = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "set_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear velocity. set_linear_velocity :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Vector2 -> IO () set_linear_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_set_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "set_linear_velocity" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.set_linear_velocity {-# NOINLINE bindPhysics2DDirectBodyState_set_sleep_state #-} -- | If @true@, this body is currently sleeping (not active). bindPhysics2DDirectBodyState_set_sleep_state :: MethodBind bindPhysics2DDirectBodyState_set_sleep_state = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "set_sleep_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this body is currently sleeping (not active). set_sleep_state :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Bool -> IO () set_sleep_state cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_set_sleep_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "set_sleep_state" '[Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.set_sleep_state {-# NOINLINE bindPhysics2DDirectBodyState_set_transform #-} -- | The body's transformation matrix. bindPhysics2DDirectBodyState_set_transform :: MethodBind bindPhysics2DDirectBodyState_set_transform = unsafePerformIO $ withCString "Physics2DDirectBodyState" $ \ clsNamePtr -> withCString "set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's transformation matrix. set_transform :: (Physics2DDirectBodyState :< cls, Object :< cls) => cls -> Transform2d -> IO () set_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectBodyState_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectBodyState "set_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.Physics2DDirectBodyState.set_transform ================================================ FILE: src/Godot/Core/Physics2DDirectBodyStateSW.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Physics2DDirectBodyStateSW () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Physics2DDirectBodyState() ================================================ FILE: src/Godot/Core/Physics2DDirectSpaceState.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Physics2DDirectSpaceState (Godot.Core.Physics2DDirectSpaceState.cast_motion, Godot.Core.Physics2DDirectSpaceState.collide_shape, Godot.Core.Physics2DDirectSpaceState.get_rest_info, Godot.Core.Physics2DDirectSpaceState.intersect_point, Godot.Core.Physics2DDirectSpaceState.intersect_point_on_canvas, Godot.Core.Physics2DDirectSpaceState.intersect_ray, Godot.Core.Physics2DDirectSpaceState.intersect_shape) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindPhysics2DDirectSpaceState_cast_motion #-} -- | Checks how far the shape can travel toward a point. If the shape can not move, the array will be empty. -- __Note:__ Both the shape and the motion are supplied through a @Physics2DShapeQueryParameters@ object. The method will return an array with two floats between 0 and 1, both representing a fraction of @motion@. The first is how far the shape can move without triggering a collision, and the second is the point at which a collision will occur. If no collision is detected, the returned array will be @@1, 1@@. bindPhysics2DDirectSpaceState_cast_motion :: MethodBind bindPhysics2DDirectSpaceState_cast_motion = unsafePerformIO $ withCString "Physics2DDirectSpaceState" $ \ clsNamePtr -> withCString "cast_motion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks how far the shape can travel toward a point. If the shape can not move, the array will be empty. -- __Note:__ Both the shape and the motion are supplied through a @Physics2DShapeQueryParameters@ object. The method will return an array with two floats between 0 and 1, both representing a fraction of @motion@. The first is how far the shape can move without triggering a collision, and the second is the point at which a collision will occur. If no collision is detected, the returned array will be @@1, 1@@. cast_motion :: (Physics2DDirectSpaceState :< cls, Object :< cls) => cls -> Physics2DShapeQueryParameters -> IO Array cast_motion cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectSpaceState_cast_motion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectSpaceState "cast_motion" '[Physics2DShapeQueryParameters] (IO Array) where nodeMethod = Godot.Core.Physics2DDirectSpaceState.cast_motion {-# NOINLINE bindPhysics2DDirectSpaceState_collide_shape #-} -- | Checks the intersections of a shape, given through a @Physics2DShapeQueryParameters@ object, against the space. The resulting array contains a list of points where the shape intersects another. Like with @method intersect_shape@, the number of returned results can be limited to save processing time. bindPhysics2DDirectSpaceState_collide_shape :: MethodBind bindPhysics2DDirectSpaceState_collide_shape = unsafePerformIO $ withCString "Physics2DDirectSpaceState" $ \ clsNamePtr -> withCString "collide_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks the intersections of a shape, given through a @Physics2DShapeQueryParameters@ object, against the space. The resulting array contains a list of points where the shape intersects another. Like with @method intersect_shape@, the number of returned results can be limited to save processing time. collide_shape :: (Physics2DDirectSpaceState :< cls, Object :< cls) => cls -> Physics2DShapeQueryParameters -> Maybe Int -> IO Array collide_shape cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (32)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectSpaceState_collide_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectSpaceState "collide_shape" '[Physics2DShapeQueryParameters, Maybe Int] (IO Array) where nodeMethod = Godot.Core.Physics2DDirectSpaceState.collide_shape {-# NOINLINE bindPhysics2DDirectSpaceState_get_rest_info #-} -- | Checks the intersections of a shape, given through a @Physics2DShapeQueryParameters@ object, against the space. If it collides with more than one shape, the nearest one is selected. If the shape did not intersect anything, then an empty dictionary is returned instead. -- __Note:__ This method does not take into account the @motion@ property of the object. The returned object is a dictionary containing the following fields: -- @collider_id@: The colliding object's ID. -- @linear_velocity@: The colliding object's velocity @Vector2@. If the object is an @Area2D@, the result is @(0, 0)@. -- @metadata@: The intersecting shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. -- @normal@: The object's surface normal at the intersection point. -- @point@: The intersection point. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. bindPhysics2DDirectSpaceState_get_rest_info :: MethodBind bindPhysics2DDirectSpaceState_get_rest_info = unsafePerformIO $ withCString "Physics2DDirectSpaceState" $ \ clsNamePtr -> withCString "get_rest_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks the intersections of a shape, given through a @Physics2DShapeQueryParameters@ object, against the space. If it collides with more than one shape, the nearest one is selected. If the shape did not intersect anything, then an empty dictionary is returned instead. -- __Note:__ This method does not take into account the @motion@ property of the object. The returned object is a dictionary containing the following fields: -- @collider_id@: The colliding object's ID. -- @linear_velocity@: The colliding object's velocity @Vector2@. If the object is an @Area2D@, the result is @(0, 0)@. -- @metadata@: The intersecting shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. -- @normal@: The object's surface normal at the intersection point. -- @point@: The intersection point. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. get_rest_info :: (Physics2DDirectSpaceState :< cls, Object :< cls) => cls -> Physics2DShapeQueryParameters -> IO Dictionary get_rest_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectSpaceState_get_rest_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectSpaceState "get_rest_info" '[Physics2DShapeQueryParameters] (IO Dictionary) where nodeMethod = Godot.Core.Physics2DDirectSpaceState.get_rest_info {-# NOINLINE bindPhysics2DDirectSpaceState_intersect_point #-} -- | Checks whether a point is inside any shape. The shapes the point is inside of are returned in an array containing dictionaries with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @metadata@: The intersecting shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- Additionally, the method can take an @exclude@ array of objects or @RID@s that are to be excluded from collisions, a @collision_mask@ bitmask representing the physics layers to check in, or booleans to determine if the ray should collide with @PhysicsBody@s or @Area@s, respectively. bindPhysics2DDirectSpaceState_intersect_point :: MethodBind bindPhysics2DDirectSpaceState_intersect_point = unsafePerformIO $ withCString "Physics2DDirectSpaceState" $ \ clsNamePtr -> withCString "intersect_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks whether a point is inside any shape. The shapes the point is inside of are returned in an array containing dictionaries with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @metadata@: The intersecting shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- Additionally, the method can take an @exclude@ array of objects or @RID@s that are to be excluded from collisions, a @collision_mask@ bitmask representing the physics layers to check in, or booleans to determine if the ray should collide with @PhysicsBody@s or @Area@s, respectively. intersect_point :: (Physics2DDirectSpaceState :< cls, Object :< cls) => cls -> Vector2 -> Maybe Int -> Maybe Array -> Maybe Int -> Maybe Bool -> Maybe Bool -> IO Array intersect_point cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, maybe (VariantInt (32)) toVariant arg2, defaultedVariant VariantArray V.empty arg3, maybe (VariantInt (2147483647)) toVariant arg4, maybe (VariantBool True) toVariant arg5, maybe (VariantBool False) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectSpaceState_intersect_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectSpaceState "intersect_point" '[Vector2, Maybe Int, Maybe Array, Maybe Int, Maybe Bool, Maybe Bool] (IO Array) where nodeMethod = Godot.Core.Physics2DDirectSpaceState.intersect_point {-# NOINLINE bindPhysics2DDirectSpaceState_intersect_point_on_canvas #-} bindPhysics2DDirectSpaceState_intersect_point_on_canvas :: MethodBind bindPhysics2DDirectSpaceState_intersect_point_on_canvas = unsafePerformIO $ withCString "Physics2DDirectSpaceState" $ \ clsNamePtr -> withCString "intersect_point_on_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr intersect_point_on_canvas :: (Physics2DDirectSpaceState :< cls, Object :< cls) => cls -> Vector2 -> Int -> Maybe Int -> Maybe Array -> Maybe Int -> Maybe Bool -> Maybe Bool -> IO Array intersect_point_on_canvas cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (32)) toVariant arg3, defaultedVariant VariantArray V.empty arg4, maybe (VariantInt (2147483647)) toVariant arg5, maybe (VariantBool True) toVariant arg6, maybe (VariantBool False) toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectSpaceState_intersect_point_on_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectSpaceState "intersect_point_on_canvas" '[Vector2, Int, Maybe Int, Maybe Array, Maybe Int, Maybe Bool, Maybe Bool] (IO Array) where nodeMethod = Godot.Core.Physics2DDirectSpaceState.intersect_point_on_canvas {-# NOINLINE bindPhysics2DDirectSpaceState_intersect_ray #-} -- | Intersects a ray in a given space. The returned object is a dictionary with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @metadata@: The intersecting shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. -- @normal@: The object's surface normal at the intersection point. -- @position@: The intersection point. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- If the ray did not intersect anything, then an empty dictionary is returned instead. -- Additionally, the method can take an @exclude@ array of objects or @RID@s that are to be excluded from collisions, a @collision_mask@ bitmask representing the physics layers to check in, or booleans to determine if the ray should collide with @PhysicsBody@s or @Area@s, respectively. bindPhysics2DDirectSpaceState_intersect_ray :: MethodBind bindPhysics2DDirectSpaceState_intersect_ray = unsafePerformIO $ withCString "Physics2DDirectSpaceState" $ \ clsNamePtr -> withCString "intersect_ray" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Intersects a ray in a given space. The returned object is a dictionary with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @metadata@: The intersecting shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. -- @normal@: The object's surface normal at the intersection point. -- @position@: The intersection point. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- If the ray did not intersect anything, then an empty dictionary is returned instead. -- Additionally, the method can take an @exclude@ array of objects or @RID@s that are to be excluded from collisions, a @collision_mask@ bitmask representing the physics layers to check in, or booleans to determine if the ray should collide with @PhysicsBody@s or @Area@s, respectively. intersect_ray :: (Physics2DDirectSpaceState :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Maybe Array -> Maybe Int -> Maybe Bool -> Maybe Bool -> IO Dictionary intersect_ray cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantArray V.empty arg3, maybe (VariantInt (2147483647)) toVariant arg4, maybe (VariantBool True) toVariant arg5, maybe (VariantBool False) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectSpaceState_intersect_ray (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectSpaceState "intersect_ray" '[Vector2, Vector2, Maybe Array, Maybe Int, Maybe Bool, Maybe Bool] (IO Dictionary) where nodeMethod = Godot.Core.Physics2DDirectSpaceState.intersect_ray {-# NOINLINE bindPhysics2DDirectSpaceState_intersect_shape #-} -- | Checks the intersections of a shape, given through a @Physics2DShapeQueryParameters@ object, against the space. -- __Note:__ This method does not take into account the @motion@ property of the object. The intersected shapes are returned in an array containing dictionaries with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @metadata@: The intersecting shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- The number of intersections can be limited with the @max_results@ parameter, to reduce the processing time. bindPhysics2DDirectSpaceState_intersect_shape :: MethodBind bindPhysics2DDirectSpaceState_intersect_shape = unsafePerformIO $ withCString "Physics2DDirectSpaceState" $ \ clsNamePtr -> withCString "intersect_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks the intersections of a shape, given through a @Physics2DShapeQueryParameters@ object, against the space. -- __Note:__ This method does not take into account the @motion@ property of the object. The intersected shapes are returned in an array containing dictionaries with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @metadata@: The intersecting shape's metadata. This metadata is different from @method Object.get_meta@, and is set with @method Physics2DServer.shape_set_data@. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- The number of intersections can be limited with the @max_results@ parameter, to reduce the processing time. intersect_shape :: (Physics2DDirectSpaceState :< cls, Object :< cls) => cls -> Physics2DShapeQueryParameters -> Maybe Int -> IO Array intersect_shape cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (32)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DDirectSpaceState_intersect_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DDirectSpaceState "intersect_shape" '[Physics2DShapeQueryParameters, Maybe Int] (IO Array) where nodeMethod = Godot.Core.Physics2DDirectSpaceState.intersect_shape ================================================ FILE: src/Godot/Core/Physics2DServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Physics2DServer (Godot.Core.Physics2DServer._SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS, Godot.Core.Physics2DServer._AREA_SPACE_OVERRIDE_REPLACE, Godot.Core.Physics2DServer._SPACE_PARAM_TEST_MOTION_MIN_CONTACT_DEPTH, Godot.Core.Physics2DServer._CCD_MODE_DISABLED, Godot.Core.Physics2DServer._JOINT_PARAM_MAX_FORCE, Godot.Core.Physics2DServer._CCD_MODE_CAST_RAY, Godot.Core.Physics2DServer._JOINT_GROOVE, Godot.Core.Physics2DServer._BODY_PARAM_BOUNCE, Godot.Core.Physics2DServer._BODY_MODE_CHARACTER, Godot.Core.Physics2DServer._SHAPE_RAY, Godot.Core.Physics2DServer._CCD_MODE_CAST_SHAPE, Godot.Core.Physics2DServer._BODY_STATE_LINEAR_VELOCITY, Godot.Core.Physics2DServer._AREA_PARAM_LINEAR_DAMP, Godot.Core.Physics2DServer._BODY_PARAM_ANGULAR_DAMP, Godot.Core.Physics2DServer._SPACE_PARAM_BODY_TIME_TO_SLEEP, Godot.Core.Physics2DServer._BODY_PARAM_LINEAR_DAMP, Godot.Core.Physics2DServer._AREA_PARAM_GRAVITY_DISTANCE_SCALE, Godot.Core.Physics2DServer._BODY_STATE_ANGULAR_VELOCITY, Godot.Core.Physics2DServer._AREA_BODY_REMOVED, Godot.Core.Physics2DServer._BODY_STATE_SLEEPING, Godot.Core.Physics2DServer._INFO_ISLAND_COUNT, Godot.Core.Physics2DServer._AREA_SPACE_OVERRIDE_DISABLED, Godot.Core.Physics2DServer._AREA_PARAM_GRAVITY_IS_POINT, Godot.Core.Physics2DServer._AREA_PARAM_GRAVITY_POINT_ATTENUATION, Godot.Core.Physics2DServer._BODY_STATE_TRANSFORM, Godot.Core.Physics2DServer._BODY_PARAM_INERTIA, Godot.Core.Physics2DServer._BODY_PARAM_MASS, Godot.Core.Physics2DServer._BODY_MODE_STATIC, Godot.Core.Physics2DServer._JOINT_PARAM_MAX_BIAS, Godot.Core.Physics2DServer._SHAPE_SEGMENT, Godot.Core.Physics2DServer._BODY_PARAM_GRAVITY_SCALE, Godot.Core.Physics2DServer._JOINT_DAMPED_SPRING, Godot.Core.Physics2DServer._AREA_PARAM_GRAVITY, Godot.Core.Physics2DServer._INFO_COLLISION_PAIRS, Godot.Core.Physics2DServer._SHAPE_RECTANGLE, Godot.Core.Physics2DServer._INFO_ACTIVE_OBJECTS, Godot.Core.Physics2DServer._DAMPED_STRING_DAMPING, Godot.Core.Physics2DServer._SPACE_PARAM_CONTACT_RECYCLE_RADIUS, Godot.Core.Physics2DServer._SPACE_PARAM_CONTACT_MAX_SEPARATION, Godot.Core.Physics2DServer._DAMPED_STRING_REST_LENGTH, Godot.Core.Physics2DServer._AREA_BODY_ADDED, Godot.Core.Physics2DServer._AREA_SPACE_OVERRIDE_COMBINE_REPLACE, Godot.Core.Physics2DServer._SHAPE_CIRCLE, Godot.Core.Physics2DServer._SHAPE_CONVEX_POLYGON, Godot.Core.Physics2DServer._AREA_PARAM_PRIORITY, Godot.Core.Physics2DServer._AREA_SPACE_OVERRIDE_REPLACE_COMBINE, Godot.Core.Physics2DServer._BODY_MODE_RIGID, Godot.Core.Physics2DServer._SPACE_PARAM_BODY_MAX_ALLOWED_PENETRATION, Godot.Core.Physics2DServer._BODY_PARAM_FRICTION, Godot.Core.Physics2DServer._SHAPE_CAPSULE, Godot.Core.Physics2DServer._AREA_PARAM_ANGULAR_DAMP, Godot.Core.Physics2DServer._BODY_MODE_KINEMATIC, Godot.Core.Physics2DServer._SHAPE_CONCAVE_POLYGON, Godot.Core.Physics2DServer._AREA_PARAM_GRAVITY_VECTOR, Godot.Core.Physics2DServer._JOINT_PARAM_BIAS, Godot.Core.Physics2DServer._SHAPE_CUSTOM, Godot.Core.Physics2DServer._BODY_STATE_CAN_SLEEP, Godot.Core.Physics2DServer._BODY_PARAM_MAX, Godot.Core.Physics2DServer._SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD, Godot.Core.Physics2DServer._SHAPE_LINE, Godot.Core.Physics2DServer._JOINT_PIN, Godot.Core.Physics2DServer._AREA_SPACE_OVERRIDE_COMBINE, Godot.Core.Physics2DServer._DAMPED_STRING_STIFFNESS, Godot.Core.Physics2DServer._SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD, Godot.Core.Physics2DServer.area_add_shape, Godot.Core.Physics2DServer.area_attach_canvas_instance_id, Godot.Core.Physics2DServer.area_attach_object_instance_id, Godot.Core.Physics2DServer.area_clear_shapes, Godot.Core.Physics2DServer.area_create, Godot.Core.Physics2DServer.area_get_canvas_instance_id, Godot.Core.Physics2DServer.area_get_object_instance_id, Godot.Core.Physics2DServer.area_get_param, Godot.Core.Physics2DServer.area_get_shape, Godot.Core.Physics2DServer.area_get_shape_count, Godot.Core.Physics2DServer.area_get_shape_transform, Godot.Core.Physics2DServer.area_get_space, Godot.Core.Physics2DServer.area_get_space_override_mode, Godot.Core.Physics2DServer.area_get_transform, Godot.Core.Physics2DServer.area_remove_shape, Godot.Core.Physics2DServer.area_set_area_monitor_callback, Godot.Core.Physics2DServer.area_set_collision_layer, Godot.Core.Physics2DServer.area_set_collision_mask, Godot.Core.Physics2DServer.area_set_monitor_callback, Godot.Core.Physics2DServer.area_set_monitorable, Godot.Core.Physics2DServer.area_set_param, Godot.Core.Physics2DServer.area_set_shape, Godot.Core.Physics2DServer.area_set_shape_disabled, Godot.Core.Physics2DServer.area_set_shape_transform, Godot.Core.Physics2DServer.area_set_space, Godot.Core.Physics2DServer.area_set_space_override_mode, Godot.Core.Physics2DServer.area_set_transform, Godot.Core.Physics2DServer.body_add_central_force, Godot.Core.Physics2DServer.body_add_collision_exception, Godot.Core.Physics2DServer.body_add_force, Godot.Core.Physics2DServer.body_add_shape, Godot.Core.Physics2DServer.body_add_torque, Godot.Core.Physics2DServer.body_apply_central_impulse, Godot.Core.Physics2DServer.body_apply_impulse, Godot.Core.Physics2DServer.body_apply_torque_impulse, Godot.Core.Physics2DServer.body_attach_canvas_instance_id, Godot.Core.Physics2DServer.body_attach_object_instance_id, Godot.Core.Physics2DServer.body_clear_shapes, Godot.Core.Physics2DServer.body_create, Godot.Core.Physics2DServer.body_get_canvas_instance_id, Godot.Core.Physics2DServer.body_get_collision_layer, Godot.Core.Physics2DServer.body_get_collision_mask, Godot.Core.Physics2DServer.body_get_continuous_collision_detection_mode, Godot.Core.Physics2DServer.body_get_direct_state, Godot.Core.Physics2DServer.body_get_max_contacts_reported, Godot.Core.Physics2DServer.body_get_mode, Godot.Core.Physics2DServer.body_get_object_instance_id, Godot.Core.Physics2DServer.body_get_param, Godot.Core.Physics2DServer.body_get_shape, Godot.Core.Physics2DServer.body_get_shape_count, Godot.Core.Physics2DServer.body_get_shape_metadata, Godot.Core.Physics2DServer.body_get_shape_transform, Godot.Core.Physics2DServer.body_get_space, Godot.Core.Physics2DServer.body_get_state, Godot.Core.Physics2DServer.body_is_omitting_force_integration, Godot.Core.Physics2DServer.body_remove_collision_exception, Godot.Core.Physics2DServer.body_remove_shape, Godot.Core.Physics2DServer.body_set_axis_velocity, Godot.Core.Physics2DServer.body_set_collision_layer, Godot.Core.Physics2DServer.body_set_collision_mask, Godot.Core.Physics2DServer.body_set_continuous_collision_detection_mode, Godot.Core.Physics2DServer.body_set_force_integration_callback, Godot.Core.Physics2DServer.body_set_max_contacts_reported, Godot.Core.Physics2DServer.body_set_mode, Godot.Core.Physics2DServer.body_set_omit_force_integration, Godot.Core.Physics2DServer.body_set_param, Godot.Core.Physics2DServer.body_set_shape, Godot.Core.Physics2DServer.body_set_shape_as_one_way_collision, Godot.Core.Physics2DServer.body_set_shape_disabled, Godot.Core.Physics2DServer.body_set_shape_metadata, Godot.Core.Physics2DServer.body_set_shape_transform, Godot.Core.Physics2DServer.body_set_space, Godot.Core.Physics2DServer.body_set_state, Godot.Core.Physics2DServer.body_test_motion, Godot.Core.Physics2DServer.capsule_shape_create, Godot.Core.Physics2DServer.circle_shape_create, Godot.Core.Physics2DServer.concave_polygon_shape_create, Godot.Core.Physics2DServer.convex_polygon_shape_create, Godot.Core.Physics2DServer.damped_spring_joint_create, Godot.Core.Physics2DServer.damped_string_joint_get_param, Godot.Core.Physics2DServer.damped_string_joint_set_param, Godot.Core.Physics2DServer.free_rid, Godot.Core.Physics2DServer.get_process_info, Godot.Core.Physics2DServer.groove_joint_create, Godot.Core.Physics2DServer.joint_get_param, Godot.Core.Physics2DServer.joint_get_type, Godot.Core.Physics2DServer.joint_set_param, Godot.Core.Physics2DServer.line_shape_create, Godot.Core.Physics2DServer.pin_joint_create, Godot.Core.Physics2DServer.ray_shape_create, Godot.Core.Physics2DServer.rectangle_shape_create, Godot.Core.Physics2DServer.segment_shape_create, Godot.Core.Physics2DServer.set_active, Godot.Core.Physics2DServer.shape_get_data, Godot.Core.Physics2DServer.shape_get_type, Godot.Core.Physics2DServer.shape_set_data, Godot.Core.Physics2DServer.space_create, Godot.Core.Physics2DServer.space_get_direct_state, Godot.Core.Physics2DServer.space_get_param, Godot.Core.Physics2DServer.space_is_active, Godot.Core.Physics2DServer.space_set_active, Godot.Core.Physics2DServer.space_set_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS :: Int _SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS = 6 _AREA_SPACE_OVERRIDE_REPLACE :: Int _AREA_SPACE_OVERRIDE_REPLACE = 3 _SPACE_PARAM_TEST_MOTION_MIN_CONTACT_DEPTH :: Int _SPACE_PARAM_TEST_MOTION_MIN_CONTACT_DEPTH = 7 _CCD_MODE_DISABLED :: Int _CCD_MODE_DISABLED = 0 _JOINT_PARAM_MAX_FORCE :: Int _JOINT_PARAM_MAX_FORCE = 2 _CCD_MODE_CAST_RAY :: Int _CCD_MODE_CAST_RAY = 1 _JOINT_GROOVE :: Int _JOINT_GROOVE = 1 _BODY_PARAM_BOUNCE :: Int _BODY_PARAM_BOUNCE = 0 _BODY_MODE_CHARACTER :: Int _BODY_MODE_CHARACTER = 3 _SHAPE_RAY :: Int _SHAPE_RAY = 1 _CCD_MODE_CAST_SHAPE :: Int _CCD_MODE_CAST_SHAPE = 2 _BODY_STATE_LINEAR_VELOCITY :: Int _BODY_STATE_LINEAR_VELOCITY = 1 _AREA_PARAM_LINEAR_DAMP :: Int _AREA_PARAM_LINEAR_DAMP = 5 _BODY_PARAM_ANGULAR_DAMP :: Int _BODY_PARAM_ANGULAR_DAMP = 6 _SPACE_PARAM_BODY_TIME_TO_SLEEP :: Int _SPACE_PARAM_BODY_TIME_TO_SLEEP = 5 _BODY_PARAM_LINEAR_DAMP :: Int _BODY_PARAM_LINEAR_DAMP = 5 _AREA_PARAM_GRAVITY_DISTANCE_SCALE :: Int _AREA_PARAM_GRAVITY_DISTANCE_SCALE = 3 _BODY_STATE_ANGULAR_VELOCITY :: Int _BODY_STATE_ANGULAR_VELOCITY = 2 _AREA_BODY_REMOVED :: Int _AREA_BODY_REMOVED = 1 _BODY_STATE_SLEEPING :: Int _BODY_STATE_SLEEPING = 3 _INFO_ISLAND_COUNT :: Int _INFO_ISLAND_COUNT = 2 _AREA_SPACE_OVERRIDE_DISABLED :: Int _AREA_SPACE_OVERRIDE_DISABLED = 0 _AREA_PARAM_GRAVITY_IS_POINT :: Int _AREA_PARAM_GRAVITY_IS_POINT = 2 _AREA_PARAM_GRAVITY_POINT_ATTENUATION :: Int _AREA_PARAM_GRAVITY_POINT_ATTENUATION = 4 _BODY_STATE_TRANSFORM :: Int _BODY_STATE_TRANSFORM = 0 _BODY_PARAM_INERTIA :: Int _BODY_PARAM_INERTIA = 3 _BODY_PARAM_MASS :: Int _BODY_PARAM_MASS = 2 _BODY_MODE_STATIC :: Int _BODY_MODE_STATIC = 0 _JOINT_PARAM_MAX_BIAS :: Int _JOINT_PARAM_MAX_BIAS = 1 _SHAPE_SEGMENT :: Int _SHAPE_SEGMENT = 2 _BODY_PARAM_GRAVITY_SCALE :: Int _BODY_PARAM_GRAVITY_SCALE = 4 _JOINT_DAMPED_SPRING :: Int _JOINT_DAMPED_SPRING = 2 _AREA_PARAM_GRAVITY :: Int _AREA_PARAM_GRAVITY = 0 _INFO_COLLISION_PAIRS :: Int _INFO_COLLISION_PAIRS = 1 _SHAPE_RECTANGLE :: Int _SHAPE_RECTANGLE = 4 _INFO_ACTIVE_OBJECTS :: Int _INFO_ACTIVE_OBJECTS = 0 _DAMPED_STRING_DAMPING :: Int _DAMPED_STRING_DAMPING = 2 _SPACE_PARAM_CONTACT_RECYCLE_RADIUS :: Int _SPACE_PARAM_CONTACT_RECYCLE_RADIUS = 0 _SPACE_PARAM_CONTACT_MAX_SEPARATION :: Int _SPACE_PARAM_CONTACT_MAX_SEPARATION = 1 _DAMPED_STRING_REST_LENGTH :: Int _DAMPED_STRING_REST_LENGTH = 0 _AREA_BODY_ADDED :: Int _AREA_BODY_ADDED = 0 _AREA_SPACE_OVERRIDE_COMBINE_REPLACE :: Int _AREA_SPACE_OVERRIDE_COMBINE_REPLACE = 2 _SHAPE_CIRCLE :: Int _SHAPE_CIRCLE = 3 _SHAPE_CONVEX_POLYGON :: Int _SHAPE_CONVEX_POLYGON = 6 _AREA_PARAM_PRIORITY :: Int _AREA_PARAM_PRIORITY = 7 _AREA_SPACE_OVERRIDE_REPLACE_COMBINE :: Int _AREA_SPACE_OVERRIDE_REPLACE_COMBINE = 4 _BODY_MODE_RIGID :: Int _BODY_MODE_RIGID = 2 _SPACE_PARAM_BODY_MAX_ALLOWED_PENETRATION :: Int _SPACE_PARAM_BODY_MAX_ALLOWED_PENETRATION = 2 _BODY_PARAM_FRICTION :: Int _BODY_PARAM_FRICTION = 1 _SHAPE_CAPSULE :: Int _SHAPE_CAPSULE = 5 _AREA_PARAM_ANGULAR_DAMP :: Int _AREA_PARAM_ANGULAR_DAMP = 6 _BODY_MODE_KINEMATIC :: Int _BODY_MODE_KINEMATIC = 1 _SHAPE_CONCAVE_POLYGON :: Int _SHAPE_CONCAVE_POLYGON = 7 _AREA_PARAM_GRAVITY_VECTOR :: Int _AREA_PARAM_GRAVITY_VECTOR = 1 _JOINT_PARAM_BIAS :: Int _JOINT_PARAM_BIAS = 0 _SHAPE_CUSTOM :: Int _SHAPE_CUSTOM = 8 _BODY_STATE_CAN_SLEEP :: Int _BODY_STATE_CAN_SLEEP = 4 _BODY_PARAM_MAX :: Int _BODY_PARAM_MAX = 7 _SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD :: Int _SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD = 4 _SHAPE_LINE :: Int _SHAPE_LINE = 0 _JOINT_PIN :: Int _JOINT_PIN = 0 _AREA_SPACE_OVERRIDE_COMBINE :: Int _AREA_SPACE_OVERRIDE_COMBINE = 1 _DAMPED_STRING_STIFFNESS :: Int _DAMPED_STRING_STIFFNESS = 1 _SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD :: Int _SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD = 3 {-# NOINLINE bindPhysics2DServer_area_add_shape #-} -- | Adds a shape to the area, along with a transform matrix. Shapes are usually referenced by their index, so you should track which shape has a given index. bindPhysics2DServer_area_add_shape :: MethodBind bindPhysics2DServer_area_add_shape = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_add_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a shape to the area, along with a transform matrix. Shapes are usually referenced by their index, so you should track which shape has a given index. area_add_shape :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Maybe Transform2d -> Maybe Bool -> IO () area_add_shape cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantTransform2d (TF2d (V2 1 0) (V2 0 1) (V2 0 0)) arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_add_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_add_shape" '[Rid, Rid, Maybe Transform2d, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_add_shape {-# NOINLINE bindPhysics2DServer_area_attach_canvas_instance_id #-} bindPhysics2DServer_area_attach_canvas_instance_id :: MethodBind bindPhysics2DServer_area_attach_canvas_instance_id = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_attach_canvas_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr area_attach_canvas_instance_id :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_attach_canvas_instance_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_attach_canvas_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_attach_canvas_instance_id" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_attach_canvas_instance_id {-# NOINLINE bindPhysics2DServer_area_attach_object_instance_id #-} -- | Assigns the area to a descendant of @Object@, so it can exist in the node tree. bindPhysics2DServer_area_attach_object_instance_id :: MethodBind bindPhysics2DServer_area_attach_object_instance_id = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_attach_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns the area to a descendant of @Object@, so it can exist in the node tree. area_attach_object_instance_id :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_attach_object_instance_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_attach_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_attach_object_instance_id" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_attach_object_instance_id {-# NOINLINE bindPhysics2DServer_area_clear_shapes #-} -- | Removes all shapes from an area. It does not delete the shapes, so they can be reassigned later. bindPhysics2DServer_area_clear_shapes :: MethodBind bindPhysics2DServer_area_clear_shapes = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_clear_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all shapes from an area. It does not delete the shapes, so they can be reassigned later. area_clear_shapes :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO () area_clear_shapes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_clear_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_clear_shapes" '[Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_clear_shapes {-# NOINLINE bindPhysics2DServer_area_create #-} -- | Creates an @Area2D@. bindPhysics2DServer_area_create :: MethodBind bindPhysics2DServer_area_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an @Area2D@. area_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid area_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.area_create {-# NOINLINE bindPhysics2DServer_area_get_canvas_instance_id #-} bindPhysics2DServer_area_get_canvas_instance_id :: MethodBind bindPhysics2DServer_area_get_canvas_instance_id = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_canvas_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr area_get_canvas_instance_id :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int area_get_canvas_instance_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_canvas_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_canvas_instance_id" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.area_get_canvas_instance_id {-# NOINLINE bindPhysics2DServer_area_get_object_instance_id #-} -- | Gets the instance ID of the object the area is assigned to. bindPhysics2DServer_area_get_object_instance_id :: MethodBind bindPhysics2DServer_area_get_object_instance_id = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the instance ID of the object the area is assigned to. area_get_object_instance_id :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int area_get_object_instance_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_object_instance_id" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.area_get_object_instance_id {-# NOINLINE bindPhysics2DServer_area_get_param #-} -- | Returns an area parameter value. See @enum AreaParameter@ for a list of available parameters. bindPhysics2DServer_area_get_param :: MethodBind bindPhysics2DServer_area_get_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an area parameter value. See @enum AreaParameter@ for a list of available parameters. area_get_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO GodotVariant area_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_param" '[Rid, Int] (IO GodotVariant) where nodeMethod = Godot.Core.Physics2DServer.area_get_param {-# NOINLINE bindPhysics2DServer_area_get_shape #-} -- | Returns the @RID@ of the nth shape of an area. bindPhysics2DServer_area_get_shape :: MethodBind bindPhysics2DServer_area_get_shape = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the nth shape of an area. area_get_shape :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Rid area_get_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_shape" '[Rid, Int] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.area_get_shape {-# NOINLINE bindPhysics2DServer_area_get_shape_count #-} -- | Returns the number of shapes assigned to an area. bindPhysics2DServer_area_get_shape_count :: MethodBind bindPhysics2DServer_area_get_shape_count = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of shapes assigned to an area. area_get_shape_count :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int area_get_shape_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_shape_count" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.area_get_shape_count {-# NOINLINE bindPhysics2DServer_area_get_shape_transform #-} -- | Returns the transform matrix of a shape within an area. bindPhysics2DServer_area_get_shape_transform :: MethodBind bindPhysics2DServer_area_get_shape_transform = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform matrix of a shape within an area. area_get_shape_transform :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Transform2d area_get_shape_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_shape_transform" '[Rid, Int] (IO Transform2d) where nodeMethod = Godot.Core.Physics2DServer.area_get_shape_transform {-# NOINLINE bindPhysics2DServer_area_get_space #-} -- | Returns the space assigned to the area. bindPhysics2DServer_area_get_space :: MethodBind bindPhysics2DServer_area_get_space = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the space assigned to the area. area_get_space :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Rid area_get_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_space" '[Rid] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.area_get_space {-# NOINLINE bindPhysics2DServer_area_get_space_override_mode #-} -- | Returns the space override mode for the area. bindPhysics2DServer_area_get_space_override_mode :: MethodBind bindPhysics2DServer_area_get_space_override_mode = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_space_override_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the space override mode for the area. area_get_space_override_mode :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int area_get_space_override_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_space_override_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_space_override_mode" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.area_get_space_override_mode {-# NOINLINE bindPhysics2DServer_area_get_transform #-} -- | Returns the transform matrix for an area. bindPhysics2DServer_area_get_transform :: MethodBind bindPhysics2DServer_area_get_transform = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform matrix for an area. area_get_transform :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Transform2d area_get_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_get_transform" '[Rid] (IO Transform2d) where nodeMethod = Godot.Core.Physics2DServer.area_get_transform {-# NOINLINE bindPhysics2DServer_area_remove_shape #-} -- | Removes a shape from an area. It does not delete the shape, so it can be reassigned later. bindPhysics2DServer_area_remove_shape :: MethodBind bindPhysics2DServer_area_remove_shape = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_remove_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a shape from an area. It does not delete the shape, so it can be reassigned later. area_remove_shape :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_remove_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_remove_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_remove_shape" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_remove_shape {-# NOINLINE bindPhysics2DServer_area_set_area_monitor_callback #-} bindPhysics2DServer_area_set_area_monitor_callback :: MethodBind bindPhysics2DServer_area_set_area_monitor_callback = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_area_monitor_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr area_set_area_monitor_callback :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Object -> GodotString -> IO () area_set_area_monitor_callback cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_area_monitor_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_area_monitor_callback" '[Rid, Object, GodotString] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_area_monitor_callback {-# NOINLINE bindPhysics2DServer_area_set_collision_layer #-} -- | Assigns the area to one or many physics layers. bindPhysics2DServer_area_set_collision_layer :: MethodBind bindPhysics2DServer_area_set_collision_layer = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns the area to one or many physics layers. area_set_collision_layer :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_set_collision_layer cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_collision_layer" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_collision_layer {-# NOINLINE bindPhysics2DServer_area_set_collision_mask #-} -- | Sets which physics layers the area will monitor. bindPhysics2DServer_area_set_collision_mask :: MethodBind bindPhysics2DServer_area_set_collision_mask = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets which physics layers the area will monitor. area_set_collision_mask :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_set_collision_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_collision_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_collision_mask {-# NOINLINE bindPhysics2DServer_area_set_monitor_callback #-} -- | Sets the function to call when any body/area enters or exits the area. This callback will be called for any object interacting with the area, and takes five parameters: -- 1: @AREA_BODY_ADDED@ or @AREA_BODY_REMOVED@, depending on whether the object entered or exited the area. -- 2: @RID@ of the object that entered/exited the area. -- 3: Instance ID of the object that entered/exited the area. -- 4: The shape index of the object that entered/exited the area. -- 5: The shape index of the area where the object entered/exited. bindPhysics2DServer_area_set_monitor_callback :: MethodBind bindPhysics2DServer_area_set_monitor_callback = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_monitor_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the function to call when any body/area enters or exits the area. This callback will be called for any object interacting with the area, and takes five parameters: -- 1: @AREA_BODY_ADDED@ or @AREA_BODY_REMOVED@, depending on whether the object entered or exited the area. -- 2: @RID@ of the object that entered/exited the area. -- 3: Instance ID of the object that entered/exited the area. -- 4: The shape index of the object that entered/exited the area. -- 5: The shape index of the area where the object entered/exited. area_set_monitor_callback :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Object -> GodotString -> IO () area_set_monitor_callback cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_monitor_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_monitor_callback" '[Rid, Object, GodotString] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_monitor_callback {-# NOINLINE bindPhysics2DServer_area_set_monitorable #-} bindPhysics2DServer_area_set_monitorable :: MethodBind bindPhysics2DServer_area_set_monitorable = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_monitorable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr area_set_monitorable :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () area_set_monitorable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_monitorable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_monitorable" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_monitorable {-# NOINLINE bindPhysics2DServer_area_set_param #-} -- | Sets the value for an area parameter. See @enum AreaParameter@ for a list of available parameters. bindPhysics2DServer_area_set_param :: MethodBind bindPhysics2DServer_area_set_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value for an area parameter. See @enum AreaParameter@ for a list of available parameters. area_set_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> GodotVariant -> IO () area_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_param" '[Rid, Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_param {-# NOINLINE bindPhysics2DServer_area_set_shape #-} -- | Substitutes a given area shape by another. The old shape is selected by its index, the new one by its @RID@. bindPhysics2DServer_area_set_shape :: MethodBind bindPhysics2DServer_area_set_shape = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Substitutes a given area shape by another. The old shape is selected by its index, the new one by its @RID@. area_set_shape :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Rid -> IO () area_set_shape cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_shape" '[Rid, Int, Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_shape {-# NOINLINE bindPhysics2DServer_area_set_shape_disabled #-} -- | Disables a given shape in an area. bindPhysics2DServer_area_set_shape_disabled :: MethodBind bindPhysics2DServer_area_set_shape_disabled = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_shape_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables a given shape in an area. area_set_shape_disabled :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Bool -> IO () area_set_shape_disabled cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_shape_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_shape_disabled" '[Rid, Int, Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_shape_disabled {-# NOINLINE bindPhysics2DServer_area_set_shape_transform #-} -- | Sets the transform matrix for an area shape. bindPhysics2DServer_area_set_shape_transform :: MethodBind bindPhysics2DServer_area_set_shape_transform = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform matrix for an area shape. area_set_shape_transform :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Transform2d -> IO () area_set_shape_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_shape_transform" '[Rid, Int, Transform2d] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_shape_transform {-# NOINLINE bindPhysics2DServer_area_set_space #-} -- | Assigns a space to the area. bindPhysics2DServer_area_set_space :: MethodBind bindPhysics2DServer_area_set_space = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a space to the area. area_set_space :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () area_set_space cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_space" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_space {-# NOINLINE bindPhysics2DServer_area_set_space_override_mode #-} -- | Sets the space override mode for the area. See @enum AreaSpaceOverrideMode@ for a list of available modes. bindPhysics2DServer_area_set_space_override_mode :: MethodBind bindPhysics2DServer_area_set_space_override_mode = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_space_override_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the space override mode for the area. See @enum AreaSpaceOverrideMode@ for a list of available modes. area_set_space_override_mode :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_set_space_override_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_space_override_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_space_override_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_space_override_mode {-# NOINLINE bindPhysics2DServer_area_set_transform #-} -- | Sets the transform matrix for an area. bindPhysics2DServer_area_set_transform :: MethodBind bindPhysics2DServer_area_set_transform = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "area_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform matrix for an area. area_set_transform :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Transform2d -> IO () area_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_area_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "area_set_transform" '[Rid, Transform2d] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.area_set_transform {-# NOINLINE bindPhysics2DServer_body_add_central_force #-} bindPhysics2DServer_body_add_central_force :: MethodBind bindPhysics2DServer_body_add_central_force = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_add_central_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_add_central_force :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> IO () body_add_central_force cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_add_central_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_add_central_force" '[Rid, Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_add_central_force {-# NOINLINE bindPhysics2DServer_body_add_collision_exception #-} -- | Adds a body to the list of bodies exempt from collisions. bindPhysics2DServer_body_add_collision_exception :: MethodBind bindPhysics2DServer_body_add_collision_exception = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_add_collision_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a body to the list of bodies exempt from collisions. body_add_collision_exception :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () body_add_collision_exception cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_add_collision_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_add_collision_exception" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_add_collision_exception {-# NOINLINE bindPhysics2DServer_body_add_force #-} -- | Adds a positioned force to the applied force and torque. As with @method body_apply_impulse@, both the force and the offset from the body origin are in global coordinates. A force differs from an impulse in that, while the two are forces, the impulse clears itself after being applied. bindPhysics2DServer_body_add_force :: MethodBind bindPhysics2DServer_body_add_force = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_add_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a positioned force to the applied force and torque. As with @method body_apply_impulse@, both the force and the offset from the body origin are in global coordinates. A force differs from an impulse in that, while the two are forces, the impulse clears itself after being applied. body_add_force :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> Vector2 -> IO () body_add_force cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_add_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_add_force" '[Rid, Vector2, Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_add_force {-# NOINLINE bindPhysics2DServer_body_add_shape #-} -- | Adds a shape to the body, along with a transform matrix. Shapes are usually referenced by their index, so you should track which shape has a given index. bindPhysics2DServer_body_add_shape :: MethodBind bindPhysics2DServer_body_add_shape = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_add_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a shape to the body, along with a transform matrix. Shapes are usually referenced by their index, so you should track which shape has a given index. body_add_shape :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Maybe Transform2d -> Maybe Bool -> IO () body_add_shape cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantTransform2d (TF2d (V2 1 0) (V2 0 1) (V2 0 0)) arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_add_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_add_shape" '[Rid, Rid, Maybe Transform2d, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_add_shape {-# NOINLINE bindPhysics2DServer_body_add_torque #-} bindPhysics2DServer_body_add_torque :: MethodBind bindPhysics2DServer_body_add_torque = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_add_torque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_add_torque :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () body_add_torque cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_add_torque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_add_torque" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_add_torque {-# NOINLINE bindPhysics2DServer_body_apply_central_impulse #-} bindPhysics2DServer_body_apply_central_impulse :: MethodBind bindPhysics2DServer_body_apply_central_impulse = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_apply_central_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_apply_central_impulse :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> IO () body_apply_central_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_apply_central_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_apply_central_impulse" '[Rid, Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_apply_central_impulse {-# NOINLINE bindPhysics2DServer_body_apply_impulse #-} -- | Adds a positioned impulse to the applied force and torque. Both the force and the offset from the body origin are in global coordinates. bindPhysics2DServer_body_apply_impulse :: MethodBind bindPhysics2DServer_body_apply_impulse = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_apply_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a positioned impulse to the applied force and torque. Both the force and the offset from the body origin are in global coordinates. body_apply_impulse :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> Vector2 -> IO () body_apply_impulse cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_apply_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_apply_impulse" '[Rid, Vector2, Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_apply_impulse {-# NOINLINE bindPhysics2DServer_body_apply_torque_impulse #-} bindPhysics2DServer_body_apply_torque_impulse :: MethodBind bindPhysics2DServer_body_apply_torque_impulse = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_apply_torque_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_apply_torque_impulse :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () body_apply_torque_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_apply_torque_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_apply_torque_impulse" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_apply_torque_impulse {-# NOINLINE bindPhysics2DServer_body_attach_canvas_instance_id #-} bindPhysics2DServer_body_attach_canvas_instance_id :: MethodBind bindPhysics2DServer_body_attach_canvas_instance_id = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_attach_canvas_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_attach_canvas_instance_id :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_attach_canvas_instance_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_attach_canvas_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_attach_canvas_instance_id" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_attach_canvas_instance_id {-# NOINLINE bindPhysics2DServer_body_attach_object_instance_id #-} -- | Assigns the area to a descendant of @Object@, so it can exist in the node tree. bindPhysics2DServer_body_attach_object_instance_id :: MethodBind bindPhysics2DServer_body_attach_object_instance_id = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_attach_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns the area to a descendant of @Object@, so it can exist in the node tree. body_attach_object_instance_id :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_attach_object_instance_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_attach_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_attach_object_instance_id" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_attach_object_instance_id {-# NOINLINE bindPhysics2DServer_body_clear_shapes #-} -- | Removes all shapes from a body. bindPhysics2DServer_body_clear_shapes :: MethodBind bindPhysics2DServer_body_clear_shapes = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_clear_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all shapes from a body. body_clear_shapes :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO () body_clear_shapes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_clear_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_clear_shapes" '[Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_clear_shapes {-# NOINLINE bindPhysics2DServer_body_create #-} -- | Creates a physics body. bindPhysics2DServer_body_create :: MethodBind bindPhysics2DServer_body_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a physics body. body_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid body_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.body_create {-# NOINLINE bindPhysics2DServer_body_get_canvas_instance_id #-} bindPhysics2DServer_body_get_canvas_instance_id :: MethodBind bindPhysics2DServer_body_get_canvas_instance_id = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_canvas_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_get_canvas_instance_id :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_canvas_instance_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_canvas_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_canvas_instance_id" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.body_get_canvas_instance_id {-# NOINLINE bindPhysics2DServer_body_get_collision_layer #-} -- | Returns the physics layer or layers a body belongs to. bindPhysics2DServer_body_get_collision_layer :: MethodBind bindPhysics2DServer_body_get_collision_layer = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the physics layer or layers a body belongs to. body_get_collision_layer :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_collision_layer" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.body_get_collision_layer {-# NOINLINE bindPhysics2DServer_body_get_collision_mask #-} -- | Returns the physics layer or layers a body can collide with. bindPhysics2DServer_body_get_collision_mask :: MethodBind bindPhysics2DServer_body_get_collision_mask = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the physics layer or layers a body can collide with. body_get_collision_mask :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_collision_mask" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.body_get_collision_mask {-# NOINLINE bindPhysics2DServer_body_get_continuous_collision_detection_mode #-} -- | Returns the continuous collision detection mode. bindPhysics2DServer_body_get_continuous_collision_detection_mode :: MethodBind bindPhysics2DServer_body_get_continuous_collision_detection_mode = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_continuous_collision_detection_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the continuous collision detection mode. body_get_continuous_collision_detection_mode :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_continuous_collision_detection_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_continuous_collision_detection_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_continuous_collision_detection_mode" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.body_get_continuous_collision_detection_mode {-# NOINLINE bindPhysics2DServer_body_get_direct_state #-} -- | Returns the @Physics2DDirectBodyState@ of the body. bindPhysics2DServer_body_get_direct_state :: MethodBind bindPhysics2DServer_body_get_direct_state = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_direct_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Physics2DDirectBodyState@ of the body. body_get_direct_state :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Physics2DDirectBodyState body_get_direct_state cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_direct_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_direct_state" '[Rid] (IO Physics2DDirectBodyState) where nodeMethod = Godot.Core.Physics2DServer.body_get_direct_state {-# NOINLINE bindPhysics2DServer_body_get_max_contacts_reported #-} -- | Returns the maximum contacts that can be reported. See @method body_set_max_contacts_reported@. bindPhysics2DServer_body_get_max_contacts_reported :: MethodBind bindPhysics2DServer_body_get_max_contacts_reported = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_max_contacts_reported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the maximum contacts that can be reported. See @method body_set_max_contacts_reported@. body_get_max_contacts_reported :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_max_contacts_reported cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_max_contacts_reported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_max_contacts_reported" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.body_get_max_contacts_reported {-# NOINLINE bindPhysics2DServer_body_get_mode #-} -- | Returns the body mode. bindPhysics2DServer_body_get_mode :: MethodBind bindPhysics2DServer_body_get_mode = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the body mode. body_get_mode :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_mode" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.body_get_mode {-# NOINLINE bindPhysics2DServer_body_get_object_instance_id #-} -- | Gets the instance ID of the object the area is assigned to. bindPhysics2DServer_body_get_object_instance_id :: MethodBind bindPhysics2DServer_body_get_object_instance_id = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the instance ID of the object the area is assigned to. body_get_object_instance_id :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_object_instance_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_object_instance_id" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.body_get_object_instance_id {-# NOINLINE bindPhysics2DServer_body_get_param #-} -- | Returns the value of a body parameter. See @enum BodyParameter@ for a list of available parameters. bindPhysics2DServer_body_get_param :: MethodBind bindPhysics2DServer_body_get_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a body parameter. See @enum BodyParameter@ for a list of available parameters. body_get_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float body_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.Physics2DServer.body_get_param {-# NOINLINE bindPhysics2DServer_body_get_shape #-} -- | Returns the @RID@ of the nth shape of a body. bindPhysics2DServer_body_get_shape :: MethodBind bindPhysics2DServer_body_get_shape = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the nth shape of a body. body_get_shape :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Rid body_get_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_shape" '[Rid, Int] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.body_get_shape {-# NOINLINE bindPhysics2DServer_body_get_shape_count #-} -- | Returns the number of shapes assigned to a body. bindPhysics2DServer_body_get_shape_count :: MethodBind bindPhysics2DServer_body_get_shape_count = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of shapes assigned to a body. body_get_shape_count :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_shape_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_shape_count" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.body_get_shape_count {-# NOINLINE bindPhysics2DServer_body_get_shape_metadata #-} -- | Returns the metadata of a shape of a body. bindPhysics2DServer_body_get_shape_metadata :: MethodBind bindPhysics2DServer_body_get_shape_metadata = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_shape_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the metadata of a shape of a body. body_get_shape_metadata :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO GodotVariant body_get_shape_metadata cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_shape_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_shape_metadata" '[Rid, Int] (IO GodotVariant) where nodeMethod = Godot.Core.Physics2DServer.body_get_shape_metadata {-# NOINLINE bindPhysics2DServer_body_get_shape_transform #-} -- | Returns the transform matrix of a body shape. bindPhysics2DServer_body_get_shape_transform :: MethodBind bindPhysics2DServer_body_get_shape_transform = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform matrix of a body shape. body_get_shape_transform :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Transform2d body_get_shape_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_shape_transform" '[Rid, Int] (IO Transform2d) where nodeMethod = Godot.Core.Physics2DServer.body_get_shape_transform {-# NOINLINE bindPhysics2DServer_body_get_space #-} -- | Returns the @RID@ of the space assigned to a body. bindPhysics2DServer_body_get_space :: MethodBind bindPhysics2DServer_body_get_space = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the space assigned to a body. body_get_space :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Rid body_get_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_space" '[Rid] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.body_get_space {-# NOINLINE bindPhysics2DServer_body_get_state #-} -- | Returns a body state. bindPhysics2DServer_body_get_state :: MethodBind bindPhysics2DServer_body_get_state = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_get_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a body state. body_get_state :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO GodotVariant body_get_state cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_get_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_get_state" '[Rid, Int] (IO GodotVariant) where nodeMethod = Godot.Core.Physics2DServer.body_get_state {-# NOINLINE bindPhysics2DServer_body_is_omitting_force_integration #-} -- | Returns whether a body uses a callback function to calculate its own physics (see @method body_set_force_integration_callback@). bindPhysics2DServer_body_is_omitting_force_integration :: MethodBind bindPhysics2DServer_body_is_omitting_force_integration = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_is_omitting_force_integration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a body uses a callback function to calculate its own physics (see @method body_set_force_integration_callback@). body_is_omitting_force_integration :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Bool body_is_omitting_force_integration cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_is_omitting_force_integration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_is_omitting_force_integration" '[Rid] (IO Bool) where nodeMethod = Godot.Core.Physics2DServer.body_is_omitting_force_integration {-# NOINLINE bindPhysics2DServer_body_remove_collision_exception #-} -- | Removes a body from the list of bodies exempt from collisions. bindPhysics2DServer_body_remove_collision_exception :: MethodBind bindPhysics2DServer_body_remove_collision_exception = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_remove_collision_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a body from the list of bodies exempt from collisions. body_remove_collision_exception :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () body_remove_collision_exception cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_remove_collision_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_remove_collision_exception" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_remove_collision_exception {-# NOINLINE bindPhysics2DServer_body_remove_shape #-} -- | Removes a shape from a body. The shape is not deleted, so it can be reused afterwards. bindPhysics2DServer_body_remove_shape :: MethodBind bindPhysics2DServer_body_remove_shape = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_remove_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a shape from a body. The shape is not deleted, so it can be reused afterwards. body_remove_shape :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_remove_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_remove_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_remove_shape" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_remove_shape {-# NOINLINE bindPhysics2DServer_body_set_axis_velocity #-} -- | Sets an axis velocity. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior. bindPhysics2DServer_body_set_axis_velocity :: MethodBind bindPhysics2DServer_body_set_axis_velocity = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_axis_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an axis velocity. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior. body_set_axis_velocity :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> IO () body_set_axis_velocity cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_axis_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_axis_velocity" '[Rid, Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_axis_velocity {-# NOINLINE bindPhysics2DServer_body_set_collision_layer #-} -- | Sets the physics layer or layers a body belongs to. bindPhysics2DServer_body_set_collision_layer :: MethodBind bindPhysics2DServer_body_set_collision_layer = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the physics layer or layers a body belongs to. body_set_collision_layer :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_collision_layer cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_collision_layer" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_collision_layer {-# NOINLINE bindPhysics2DServer_body_set_collision_mask #-} -- | Sets the physics layer or layers a body can collide with. bindPhysics2DServer_body_set_collision_mask :: MethodBind bindPhysics2DServer_body_set_collision_mask = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the physics layer or layers a body can collide with. body_set_collision_mask :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_collision_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_collision_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_collision_mask {-# NOINLINE bindPhysics2DServer_body_set_continuous_collision_detection_mode #-} -- | Sets the continuous collision detection mode using one of the @enum CCDMode@ constants. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. bindPhysics2DServer_body_set_continuous_collision_detection_mode :: MethodBind bindPhysics2DServer_body_set_continuous_collision_detection_mode = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_continuous_collision_detection_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the continuous collision detection mode using one of the @enum CCDMode@ constants. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. body_set_continuous_collision_detection_mode :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_continuous_collision_detection_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_continuous_collision_detection_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_continuous_collision_detection_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_continuous_collision_detection_mode {-# NOINLINE bindPhysics2DServer_body_set_force_integration_callback #-} -- | Sets the function used to calculate physics for an object, if that object allows it (see @method body_set_omit_force_integration@). bindPhysics2DServer_body_set_force_integration_callback :: MethodBind bindPhysics2DServer_body_set_force_integration_callback = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_force_integration_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the function used to calculate physics for an object, if that object allows it (see @method body_set_omit_force_integration@). body_set_force_integration_callback :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Object -> GodotString -> Maybe GodotVariant -> IO () body_set_force_integration_callback cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_force_integration_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_force_integration_callback" '[Rid, Object, GodotString, Maybe GodotVariant] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_force_integration_callback {-# NOINLINE bindPhysics2DServer_body_set_max_contacts_reported #-} -- | Sets the maximum contacts to report. Bodies can keep a log of the contacts with other bodies, this is enabled by setting the maximum amount of contacts reported to a number greater than 0. bindPhysics2DServer_body_set_max_contacts_reported :: MethodBind bindPhysics2DServer_body_set_max_contacts_reported = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_max_contacts_reported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the maximum contacts to report. Bodies can keep a log of the contacts with other bodies, this is enabled by setting the maximum amount of contacts reported to a number greater than 0. body_set_max_contacts_reported :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_max_contacts_reported cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_max_contacts_reported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_max_contacts_reported" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_max_contacts_reported {-# NOINLINE bindPhysics2DServer_body_set_mode #-} -- | Sets the body mode using one of the @enum BodyMode@ constants. bindPhysics2DServer_body_set_mode :: MethodBind bindPhysics2DServer_body_set_mode = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the body mode using one of the @enum BodyMode@ constants. body_set_mode :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_mode {-# NOINLINE bindPhysics2DServer_body_set_omit_force_integration #-} -- | Sets whether a body uses a callback function to calculate its own physics (see @method body_set_force_integration_callback@). bindPhysics2DServer_body_set_omit_force_integration :: MethodBind bindPhysics2DServer_body_set_omit_force_integration = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_omit_force_integration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether a body uses a callback function to calculate its own physics (see @method body_set_force_integration_callback@). body_set_omit_force_integration :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () body_set_omit_force_integration cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_omit_force_integration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_omit_force_integration" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_omit_force_integration {-# NOINLINE bindPhysics2DServer_body_set_param #-} -- | Sets a body parameter. See @enum BodyParameter@ for a list of available parameters. bindPhysics2DServer_body_set_param :: MethodBind bindPhysics2DServer_body_set_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a body parameter. See @enum BodyParameter@ for a list of available parameters. body_set_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () body_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_param {-# NOINLINE bindPhysics2DServer_body_set_shape #-} -- | Substitutes a given body shape by another. The old shape is selected by its index, the new one by its @RID@. bindPhysics2DServer_body_set_shape :: MethodBind bindPhysics2DServer_body_set_shape = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Substitutes a given body shape by another. The old shape is selected by its index, the new one by its @RID@. body_set_shape :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Rid -> IO () body_set_shape cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_shape" '[Rid, Int, Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_shape {-# NOINLINE bindPhysics2DServer_body_set_shape_as_one_way_collision #-} -- | Enables one way collision on body if @enable@ is @true@. bindPhysics2DServer_body_set_shape_as_one_way_collision :: MethodBind bindPhysics2DServer_body_set_shape_as_one_way_collision = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_shape_as_one_way_collision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables one way collision on body if @enable@ is @true@. body_set_shape_as_one_way_collision :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Bool -> Float -> IO () body_set_shape_as_one_way_collision cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_shape_as_one_way_collision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_shape_as_one_way_collision" '[Rid, Int, Bool, Float] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_shape_as_one_way_collision {-# NOINLINE bindPhysics2DServer_body_set_shape_disabled #-} -- | Disables shape in body if @disable@ is @true@. bindPhysics2DServer_body_set_shape_disabled :: MethodBind bindPhysics2DServer_body_set_shape_disabled = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_shape_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables shape in body if @disable@ is @true@. body_set_shape_disabled :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Bool -> IO () body_set_shape_disabled cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_shape_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_shape_disabled" '[Rid, Int, Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_shape_disabled {-# NOINLINE bindPhysics2DServer_body_set_shape_metadata #-} -- | Sets metadata of a shape within a body. This metadata is different from @method Object.set_meta@, and can be retrieved on shape queries. bindPhysics2DServer_body_set_shape_metadata :: MethodBind bindPhysics2DServer_body_set_shape_metadata = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_shape_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets metadata of a shape within a body. This metadata is different from @method Object.set_meta@, and can be retrieved on shape queries. body_set_shape_metadata :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> GodotVariant -> IO () body_set_shape_metadata cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_shape_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_shape_metadata" '[Rid, Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_shape_metadata {-# NOINLINE bindPhysics2DServer_body_set_shape_transform #-} -- | Sets the transform matrix for a body shape. bindPhysics2DServer_body_set_shape_transform :: MethodBind bindPhysics2DServer_body_set_shape_transform = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform matrix for a body shape. body_set_shape_transform :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Transform2d -> IO () body_set_shape_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_shape_transform" '[Rid, Int, Transform2d] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_shape_transform {-# NOINLINE bindPhysics2DServer_body_set_space #-} -- | Assigns a space to the body (see @method space_create@). bindPhysics2DServer_body_set_space :: MethodBind bindPhysics2DServer_body_set_space = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a space to the body (see @method space_create@). body_set_space :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () body_set_space cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_space" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_space {-# NOINLINE bindPhysics2DServer_body_set_state #-} -- | Sets a body state using one of the @enum BodyState@ constants. -- Note that the method doesn't take effect immediately. The state will change on the next physics frame. bindPhysics2DServer_body_set_state :: MethodBind bindPhysics2DServer_body_set_state = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_set_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a body state using one of the @enum BodyState@ constants. -- Note that the method doesn't take effect immediately. The state will change on the next physics frame. body_set_state :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> GodotVariant -> IO () body_set_state cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_set_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_set_state" '[Rid, Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.body_set_state {-# NOINLINE bindPhysics2DServer_body_test_motion #-} -- | Returns @true@ if a collision would result from moving in the given direction from a given point in space. Margin increases the size of the shapes involved in the collision detection. @Physics2DTestMotionResult@ can be passed to return additional information in. bindPhysics2DServer_body_test_motion :: MethodBind bindPhysics2DServer_body_test_motion = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "body_test_motion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a collision would result from moving in the given direction from a given point in space. Margin increases the size of the shapes involved in the collision detection. @Physics2DTestMotionResult@ can be passed to return additional information in. body_test_motion :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Transform2d -> Vector2 -> Bool -> Maybe Float -> Maybe Physics2DTestMotionResult -> IO Bool body_test_motion cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantReal (0.08)) toVariant arg5, maybe VariantNil toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_body_test_motion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "body_test_motion" '[Rid, Transform2d, Vector2, Bool, Maybe Float, Maybe Physics2DTestMotionResult] (IO Bool) where nodeMethod = Godot.Core.Physics2DServer.body_test_motion {-# NOINLINE bindPhysics2DServer_capsule_shape_create #-} bindPhysics2DServer_capsule_shape_create :: MethodBind bindPhysics2DServer_capsule_shape_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "capsule_shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr capsule_shape_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid capsule_shape_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_capsule_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "capsule_shape_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.capsule_shape_create {-# NOINLINE bindPhysics2DServer_circle_shape_create #-} bindPhysics2DServer_circle_shape_create :: MethodBind bindPhysics2DServer_circle_shape_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "circle_shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr circle_shape_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid circle_shape_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_circle_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "circle_shape_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.circle_shape_create {-# NOINLINE bindPhysics2DServer_concave_polygon_shape_create #-} bindPhysics2DServer_concave_polygon_shape_create :: MethodBind bindPhysics2DServer_concave_polygon_shape_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "concave_polygon_shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr concave_polygon_shape_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid concave_polygon_shape_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_concave_polygon_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "concave_polygon_shape_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.concave_polygon_shape_create {-# NOINLINE bindPhysics2DServer_convex_polygon_shape_create #-} bindPhysics2DServer_convex_polygon_shape_create :: MethodBind bindPhysics2DServer_convex_polygon_shape_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "convex_polygon_shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr convex_polygon_shape_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid convex_polygon_shape_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_convex_polygon_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "convex_polygon_shape_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.convex_polygon_shape_create {-# NOINLINE bindPhysics2DServer_damped_spring_joint_create #-} -- | Creates a damped spring joint between two bodies. If not specified, the second body is assumed to be the joint itself. bindPhysics2DServer_damped_spring_joint_create :: MethodBind bindPhysics2DServer_damped_spring_joint_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "damped_spring_joint_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a damped spring joint between two bodies. If not specified, the second body is assumed to be the joint itself. damped_spring_joint_create :: (Physics2DServer :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Rid -> Maybe Rid -> IO Rid damped_spring_joint_create cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_damped_spring_joint_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "damped_spring_joint_create" '[Vector2, Vector2, Rid, Maybe Rid] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.damped_spring_joint_create {-# NOINLINE bindPhysics2DServer_damped_string_joint_get_param #-} -- | Returns the value of a damped spring joint parameter. bindPhysics2DServer_damped_string_joint_get_param :: MethodBind bindPhysics2DServer_damped_string_joint_get_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "damped_string_joint_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a damped spring joint parameter. damped_string_joint_get_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float damped_string_joint_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_damped_string_joint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "damped_string_joint_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.Physics2DServer.damped_string_joint_get_param {-# NOINLINE bindPhysics2DServer_damped_string_joint_set_param #-} -- | Sets a damped spring joint parameter. See @enum DampedStringParam@ for a list of available parameters. bindPhysics2DServer_damped_string_joint_set_param :: MethodBind bindPhysics2DServer_damped_string_joint_set_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "damped_string_joint_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a damped spring joint parameter. See @enum DampedStringParam@ for a list of available parameters. damped_string_joint_set_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () damped_string_joint_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_damped_string_joint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "damped_string_joint_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.damped_string_joint_set_param {-# NOINLINE bindPhysics2DServer_free_rid #-} -- | Destroys any of the objects created by Physics2DServer. If the @RID@ passed is not one of the objects that can be created by Physics2DServer, an error will be sent to the console. bindPhysics2DServer_free_rid :: MethodBind bindPhysics2DServer_free_rid = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "free_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Destroys any of the objects created by Physics2DServer. If the @RID@ passed is not one of the objects that can be created by Physics2DServer, an error will be sent to the console. free_rid :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO () free_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_free_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "free_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.free_rid {-# NOINLINE bindPhysics2DServer_get_process_info #-} -- | Returns information about the current state of the 2D physics engine. See @enum ProcessInfo@ for a list of available states. bindPhysics2DServer_get_process_info :: MethodBind bindPhysics2DServer_get_process_info = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "get_process_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns information about the current state of the 2D physics engine. See @enum ProcessInfo@ for a list of available states. get_process_info :: (Physics2DServer :< cls, Object :< cls) => cls -> Int -> IO Int get_process_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_get_process_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "get_process_info" '[Int] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.get_process_info {-# NOINLINE bindPhysics2DServer_groove_joint_create #-} -- | Creates a groove joint between two bodies. If not specified, the bodies are assumed to be the joint itself. bindPhysics2DServer_groove_joint_create :: MethodBind bindPhysics2DServer_groove_joint_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "groove_joint_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a groove joint between two bodies. If not specified, the bodies are assumed to be the joint itself. groove_joint_create :: (Physics2DServer :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> Vector2 -> Maybe Rid -> Maybe Rid -> IO Rid groove_joint_create cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4, maybe VariantNil toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_groove_joint_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "groove_joint_create" '[Vector2, Vector2, Vector2, Maybe Rid, Maybe Rid] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.groove_joint_create {-# NOINLINE bindPhysics2DServer_joint_get_param #-} -- | Returns the value of a joint parameter. bindPhysics2DServer_joint_get_param :: MethodBind bindPhysics2DServer_joint_get_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "joint_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a joint parameter. joint_get_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float joint_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_joint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "joint_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.Physics2DServer.joint_get_param {-# NOINLINE bindPhysics2DServer_joint_get_type #-} -- | Returns a joint's type (see @enum JointType@). bindPhysics2DServer_joint_get_type :: MethodBind bindPhysics2DServer_joint_get_type = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "joint_get_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a joint's type (see @enum JointType@). joint_get_type :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int joint_get_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_joint_get_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "joint_get_type" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.joint_get_type {-# NOINLINE bindPhysics2DServer_joint_set_param #-} -- | Sets a joint parameter. See @enum JointParam@ for a list of available parameters. bindPhysics2DServer_joint_set_param :: MethodBind bindPhysics2DServer_joint_set_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "joint_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a joint parameter. See @enum JointParam@ for a list of available parameters. joint_set_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () joint_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_joint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "joint_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.joint_set_param {-# NOINLINE bindPhysics2DServer_line_shape_create #-} bindPhysics2DServer_line_shape_create :: MethodBind bindPhysics2DServer_line_shape_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "line_shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr line_shape_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid line_shape_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_line_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "line_shape_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.line_shape_create {-# NOINLINE bindPhysics2DServer_pin_joint_create #-} -- | Creates a pin joint between two bodies. If not specified, the second body is assumed to be the joint itself. bindPhysics2DServer_pin_joint_create :: MethodBind bindPhysics2DServer_pin_joint_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "pin_joint_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a pin joint between two bodies. If not specified, the second body is assumed to be the joint itself. pin_joint_create :: (Physics2DServer :< cls, Object :< cls) => cls -> Vector2 -> Rid -> Maybe Rid -> IO Rid pin_joint_create cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_pin_joint_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "pin_joint_create" '[Vector2, Rid, Maybe Rid] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.pin_joint_create {-# NOINLINE bindPhysics2DServer_ray_shape_create #-} bindPhysics2DServer_ray_shape_create :: MethodBind bindPhysics2DServer_ray_shape_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "ray_shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr ray_shape_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid ray_shape_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_ray_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "ray_shape_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.ray_shape_create {-# NOINLINE bindPhysics2DServer_rectangle_shape_create #-} bindPhysics2DServer_rectangle_shape_create :: MethodBind bindPhysics2DServer_rectangle_shape_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "rectangle_shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr rectangle_shape_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid rectangle_shape_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_rectangle_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "rectangle_shape_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.rectangle_shape_create {-# NOINLINE bindPhysics2DServer_segment_shape_create #-} bindPhysics2DServer_segment_shape_create :: MethodBind bindPhysics2DServer_segment_shape_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "segment_shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr segment_shape_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid segment_shape_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_segment_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "segment_shape_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.segment_shape_create {-# NOINLINE bindPhysics2DServer_set_active #-} -- | Activates or deactivates the 2D physics engine. bindPhysics2DServer_set_active :: MethodBind bindPhysics2DServer_set_active = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Activates or deactivates the 2D physics engine. set_active :: (Physics2DServer :< cls, Object :< cls) => cls -> Bool -> IO () set_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "set_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.set_active {-# NOINLINE bindPhysics2DServer_shape_get_data #-} -- | Returns the shape data. bindPhysics2DServer_shape_get_data :: MethodBind bindPhysics2DServer_shape_get_data = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "shape_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shape data. shape_get_data :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO GodotVariant shape_get_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_shape_get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "shape_get_data" '[Rid] (IO GodotVariant) where nodeMethod = Godot.Core.Physics2DServer.shape_get_data {-# NOINLINE bindPhysics2DServer_shape_get_type #-} -- | Returns a shape's type (see @enum ShapeType@). bindPhysics2DServer_shape_get_type :: MethodBind bindPhysics2DServer_shape_get_type = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "shape_get_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a shape's type (see @enum ShapeType@). shape_get_type :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Int shape_get_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_shape_get_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "shape_get_type" '[Rid] (IO Int) where nodeMethod = Godot.Core.Physics2DServer.shape_get_type {-# NOINLINE bindPhysics2DServer_shape_set_data #-} -- | Sets the shape data that defines its shape and size. The data to be passed depends on the kind of shape created @method shape_get_type@. bindPhysics2DServer_shape_set_data :: MethodBind bindPhysics2DServer_shape_set_data = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "shape_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the shape data that defines its shape and size. The data to be passed depends on the kind of shape created @method shape_get_type@. shape_set_data :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> GodotVariant -> IO () shape_set_data cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_shape_set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "shape_set_data" '[Rid, GodotVariant] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.shape_set_data {-# NOINLINE bindPhysics2DServer_space_create #-} -- | Creates a space. A space is a collection of parameters for the physics engine that can be assigned to an area or a body. It can be assigned to an area with @method area_set_space@, or to a body with @method body_set_space@. bindPhysics2DServer_space_create :: MethodBind bindPhysics2DServer_space_create = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "space_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a space. A space is a collection of parameters for the physics engine that can be assigned to an area or a body. It can be assigned to an area with @method area_set_space@, or to a body with @method body_set_space@. space_create :: (Physics2DServer :< cls, Object :< cls) => cls -> IO Rid space_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_space_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "space_create" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DServer.space_create {-# NOINLINE bindPhysics2DServer_space_get_direct_state #-} -- | Returns the state of a space, a @Physics2DDirectSpaceState@. This object can be used to make collision/intersection queries. bindPhysics2DServer_space_get_direct_state :: MethodBind bindPhysics2DServer_space_get_direct_state = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "space_get_direct_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the state of a space, a @Physics2DDirectSpaceState@. This object can be used to make collision/intersection queries. space_get_direct_state :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Physics2DDirectSpaceState space_get_direct_state cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_space_get_direct_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "space_get_direct_state" '[Rid] (IO Physics2DDirectSpaceState) where nodeMethod = Godot.Core.Physics2DServer.space_get_direct_state {-# NOINLINE bindPhysics2DServer_space_get_param #-} -- | Returns the value of a space parameter. bindPhysics2DServer_space_get_param :: MethodBind bindPhysics2DServer_space_get_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "space_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a space parameter. space_get_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float space_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_space_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "space_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.Physics2DServer.space_get_param {-# NOINLINE bindPhysics2DServer_space_is_active #-} -- | Returns whether the space is active. bindPhysics2DServer_space_is_active :: MethodBind bindPhysics2DServer_space_is_active = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "space_is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the space is active. space_is_active :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> IO Bool space_is_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_space_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "space_is_active" '[Rid] (IO Bool) where nodeMethod = Godot.Core.Physics2DServer.space_is_active {-# NOINLINE bindPhysics2DServer_space_set_active #-} -- | Marks a space as active. It will not have an effect, unless it is assigned to an area or body. bindPhysics2DServer_space_set_active :: MethodBind bindPhysics2DServer_space_set_active = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "space_set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Marks a space as active. It will not have an effect, unless it is assigned to an area or body. space_set_active :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () space_set_active cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_space_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "space_set_active" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.space_set_active {-# NOINLINE bindPhysics2DServer_space_set_param #-} -- | Sets the value for a space parameter. See @enum SpaceParameter@ for a list of available parameters. bindPhysics2DServer_space_set_param :: MethodBind bindPhysics2DServer_space_set_param = unsafePerformIO $ withCString "Physics2DServer" $ \ clsNamePtr -> withCString "space_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value for a space parameter. See @enum SpaceParameter@ for a list of available parameters. space_set_param :: (Physics2DServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () space_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DServer_space_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DServer "space_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.Physics2DServer.space_set_param ================================================ FILE: src/Godot/Core/Physics2DServerSW.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Physics2DServerSW () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Physics2DServer() ================================================ FILE: src/Godot/Core/Physics2DShapeQueryParameters.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Physics2DShapeQueryParameters (Godot.Core.Physics2DShapeQueryParameters.get_collision_layer, Godot.Core.Physics2DShapeQueryParameters.get_exclude, Godot.Core.Physics2DShapeQueryParameters.get_margin, Godot.Core.Physics2DShapeQueryParameters.get_motion, Godot.Core.Physics2DShapeQueryParameters.get_shape_rid, Godot.Core.Physics2DShapeQueryParameters.get_transform, Godot.Core.Physics2DShapeQueryParameters.is_collide_with_areas_enabled, Godot.Core.Physics2DShapeQueryParameters.is_collide_with_bodies_enabled, Godot.Core.Physics2DShapeQueryParameters.set_collide_with_areas, Godot.Core.Physics2DShapeQueryParameters.set_collide_with_bodies, Godot.Core.Physics2DShapeQueryParameters.set_collision_layer, Godot.Core.Physics2DShapeQueryParameters.set_exclude, Godot.Core.Physics2DShapeQueryParameters.set_margin, Godot.Core.Physics2DShapeQueryParameters.set_motion, Godot.Core.Physics2DShapeQueryParameters.set_shape, Godot.Core.Physics2DShapeQueryParameters.set_shape_rid, Godot.Core.Physics2DShapeQueryParameters.set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty Physics2DShapeQueryParameters "collide_with_areas" Bool 'False where nodeProperty = (is_collide_with_areas_enabled, wrapDroppingSetter set_collide_with_areas, Nothing) instance NodeProperty Physics2DShapeQueryParameters "collide_with_bodies" Bool 'False where nodeProperty = (is_collide_with_bodies_enabled, wrapDroppingSetter set_collide_with_bodies, Nothing) instance NodeProperty Physics2DShapeQueryParameters "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty Physics2DShapeQueryParameters "exclude" Array 'False where nodeProperty = (get_exclude, wrapDroppingSetter set_exclude, Nothing) instance NodeProperty Physics2DShapeQueryParameters "margin" Float 'False where nodeProperty = (get_margin, wrapDroppingSetter set_margin, Nothing) instance NodeProperty Physics2DShapeQueryParameters "motion" Vector2 'False where nodeProperty = (get_motion, wrapDroppingSetter set_motion, Nothing) instance NodeProperty Physics2DShapeQueryParameters "shape_rid" Rid 'False where nodeProperty = (get_shape_rid, wrapDroppingSetter set_shape_rid, Nothing) instance NodeProperty Physics2DShapeQueryParameters "transform" Transform2d 'False where nodeProperty = (get_transform, wrapDroppingSetter set_transform, Nothing) {-# NOINLINE bindPhysics2DShapeQueryParameters_get_collision_layer #-} -- | The physics layer(s) the query will take into account (as a bitmask). See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysics2DShapeQueryParameters_get_collision_layer :: MethodBind bindPhysics2DShapeQueryParameters_get_collision_layer = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layer(s) the query will take into account (as a bitmask). See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_layer :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.get_collision_layer {-# NOINLINE bindPhysics2DShapeQueryParameters_get_exclude #-} -- | The list of objects or object @RID@s that will be excluded from collisions. bindPhysics2DShapeQueryParameters_get_exclude :: MethodBind bindPhysics2DShapeQueryParameters_get_exclude = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "get_exclude" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The list of objects or object @RID@s that will be excluded from collisions. get_exclude :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> IO Array get_exclude cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_get_exclude (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "get_exclude" '[] (IO Array) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.get_exclude {-# NOINLINE bindPhysics2DShapeQueryParameters_get_margin #-} -- | The collision margin for the shape. bindPhysics2DShapeQueryParameters_get_margin :: MethodBind bindPhysics2DShapeQueryParameters_get_margin = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "get_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision margin for the shape. get_margin :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> IO Float get_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_get_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "get_margin" '[] (IO Float) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.get_margin {-# NOINLINE bindPhysics2DShapeQueryParameters_get_motion #-} -- | The motion of the shape being queried for. bindPhysics2DShapeQueryParameters_get_motion :: MethodBind bindPhysics2DShapeQueryParameters_get_motion = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "get_motion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The motion of the shape being queried for. get_motion :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> IO Vector2 get_motion cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_get_motion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "get_motion" '[] (IO Vector2) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.get_motion {-# NOINLINE bindPhysics2DShapeQueryParameters_get_shape_rid #-} -- | The queried shape's @RID@. See also @method set_shape@. bindPhysics2DShapeQueryParameters_get_shape_rid :: MethodBind bindPhysics2DShapeQueryParameters_get_shape_rid = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "get_shape_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The queried shape's @RID@. See also @method set_shape@. get_shape_rid :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> IO Rid get_shape_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_get_shape_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "get_shape_rid" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.get_shape_rid {-# NOINLINE bindPhysics2DShapeQueryParameters_get_transform #-} -- | The queried shape's transform matrix. bindPhysics2DShapeQueryParameters_get_transform :: MethodBind bindPhysics2DShapeQueryParameters_get_transform = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The queried shape's transform matrix. get_transform :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> IO Transform2d get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "get_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.get_transform {-# NOINLINE bindPhysics2DShapeQueryParameters_is_collide_with_areas_enabled #-} -- | If @true@, the query will take @Area2D@s into account. bindPhysics2DShapeQueryParameters_is_collide_with_areas_enabled :: MethodBind bindPhysics2DShapeQueryParameters_is_collide_with_areas_enabled = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "is_collide_with_areas_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the query will take @Area2D@s into account. is_collide_with_areas_enabled :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> IO Bool is_collide_with_areas_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_is_collide_with_areas_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "is_collide_with_areas_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.is_collide_with_areas_enabled {-# NOINLINE bindPhysics2DShapeQueryParameters_is_collide_with_bodies_enabled #-} -- | If @true@, the query will take @PhysicsBody2D@s into account. bindPhysics2DShapeQueryParameters_is_collide_with_bodies_enabled :: MethodBind bindPhysics2DShapeQueryParameters_is_collide_with_bodies_enabled = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "is_collide_with_bodies_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the query will take @PhysicsBody2D@s into account. is_collide_with_bodies_enabled :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> IO Bool is_collide_with_bodies_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_is_collide_with_bodies_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "is_collide_with_bodies_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.is_collide_with_bodies_enabled {-# NOINLINE bindPhysics2DShapeQueryParameters_set_collide_with_areas #-} -- | If @true@, the query will take @Area2D@s into account. bindPhysics2DShapeQueryParameters_set_collide_with_areas :: MethodBind bindPhysics2DShapeQueryParameters_set_collide_with_areas = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_collide_with_areas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the query will take @Area2D@s into account. set_collide_with_areas :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Bool -> IO () set_collide_with_areas cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_collide_with_areas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_collide_with_areas" '[Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_collide_with_areas {-# NOINLINE bindPhysics2DShapeQueryParameters_set_collide_with_bodies #-} -- | If @true@, the query will take @PhysicsBody2D@s into account. bindPhysics2DShapeQueryParameters_set_collide_with_bodies :: MethodBind bindPhysics2DShapeQueryParameters_set_collide_with_bodies = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_collide_with_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the query will take @PhysicsBody2D@s into account. set_collide_with_bodies :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Bool -> IO () set_collide_with_bodies cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_collide_with_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_collide_with_bodies" '[Bool] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_collide_with_bodies {-# NOINLINE bindPhysics2DShapeQueryParameters_set_collision_layer #-} -- | The physics layer(s) the query will take into account (as a bitmask). See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysics2DShapeQueryParameters_set_collision_layer :: MethodBind bindPhysics2DShapeQueryParameters_set_collision_layer = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layer(s) the query will take into account (as a bitmask). See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_layer :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_collision_layer {-# NOINLINE bindPhysics2DShapeQueryParameters_set_exclude #-} -- | The list of objects or object @RID@s that will be excluded from collisions. bindPhysics2DShapeQueryParameters_set_exclude :: MethodBind bindPhysics2DShapeQueryParameters_set_exclude = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_exclude" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The list of objects or object @RID@s that will be excluded from collisions. set_exclude :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Array -> IO () set_exclude cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_exclude (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_exclude" '[Array] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_exclude {-# NOINLINE bindPhysics2DShapeQueryParameters_set_margin #-} -- | The collision margin for the shape. bindPhysics2DShapeQueryParameters_set_margin :: MethodBind bindPhysics2DShapeQueryParameters_set_margin = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision margin for the shape. set_margin :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Float -> IO () set_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_margin {-# NOINLINE bindPhysics2DShapeQueryParameters_set_motion #-} -- | The motion of the shape being queried for. bindPhysics2DShapeQueryParameters_set_motion :: MethodBind bindPhysics2DShapeQueryParameters_set_motion = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_motion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The motion of the shape being queried for. set_motion :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Vector2 -> IO () set_motion cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_motion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_motion" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_motion {-# NOINLINE bindPhysics2DShapeQueryParameters_set_shape #-} -- | Sets the @Shape2D@ that will be used for collision/intersection queries. bindPhysics2DShapeQueryParameters_set_shape :: MethodBind bindPhysics2DShapeQueryParameters_set_shape = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Shape2D@ that will be used for collision/intersection queries. set_shape :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Resource -> IO () set_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_shape" '[Resource] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_shape {-# NOINLINE bindPhysics2DShapeQueryParameters_set_shape_rid #-} -- | The queried shape's @RID@. See also @method set_shape@. bindPhysics2DShapeQueryParameters_set_shape_rid :: MethodBind bindPhysics2DShapeQueryParameters_set_shape_rid = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_shape_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The queried shape's @RID@. See also @method set_shape@. set_shape_rid :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Rid -> IO () set_shape_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_shape_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_shape_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_shape_rid {-# NOINLINE bindPhysics2DShapeQueryParameters_set_transform #-} -- | The queried shape's transform matrix. bindPhysics2DShapeQueryParameters_set_transform :: MethodBind bindPhysics2DShapeQueryParameters_set_transform = unsafePerformIO $ withCString "Physics2DShapeQueryParameters" $ \ clsNamePtr -> withCString "set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The queried shape's transform matrix. set_transform :: (Physics2DShapeQueryParameters :< cls, Object :< cls) => cls -> Transform2d -> IO () set_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryParameters_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryParameters "set_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.Physics2DShapeQueryParameters.set_transform ================================================ FILE: src/Godot/Core/Physics2DShapeQueryResult.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Physics2DShapeQueryResult (Godot.Core.Physics2DShapeQueryResult.get_result_count, Godot.Core.Physics2DShapeQueryResult.get_result_object, Godot.Core.Physics2DShapeQueryResult.get_result_object_id, Godot.Core.Physics2DShapeQueryResult.get_result_object_shape, Godot.Core.Physics2DShapeQueryResult.get_result_rid) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindPhysics2DShapeQueryResult_get_result_count #-} -- | Returns the number of objects that intersected with the shape. bindPhysics2DShapeQueryResult_get_result_count :: MethodBind bindPhysics2DShapeQueryResult_get_result_count = unsafePerformIO $ withCString "Physics2DShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of objects that intersected with the shape. get_result_count :: (Physics2DShapeQueryResult :< cls, Object :< cls) => cls -> IO Int get_result_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryResult_get_result_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryResult "get_result_count" '[] (IO Int) where nodeMethod = Godot.Core.Physics2DShapeQueryResult.get_result_count {-# NOINLINE bindPhysics2DShapeQueryResult_get_result_object #-} -- | Returns the @Object@ that intersected with the shape at index @idx@. bindPhysics2DShapeQueryResult_get_result_object :: MethodBind bindPhysics2DShapeQueryResult_get_result_object = unsafePerformIO $ withCString "Physics2DShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Object@ that intersected with the shape at index @idx@. get_result_object :: (Physics2DShapeQueryResult :< cls, Object :< cls) => cls -> Int -> IO Object get_result_object cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryResult_get_result_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryResult "get_result_object" '[Int] (IO Object) where nodeMethod = Godot.Core.Physics2DShapeQueryResult.get_result_object {-# NOINLINE bindPhysics2DShapeQueryResult_get_result_object_id #-} -- | Returns the instance ID of the @Object@ that intersected with the shape at index @idx@. bindPhysics2DShapeQueryResult_get_result_object_id :: MethodBind bindPhysics2DShapeQueryResult_get_result_object_id = unsafePerformIO $ withCString "Physics2DShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_object_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the instance ID of the @Object@ that intersected with the shape at index @idx@. get_result_object_id :: (Physics2DShapeQueryResult :< cls, Object :< cls) => cls -> Int -> IO Int get_result_object_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryResult_get_result_object_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryResult "get_result_object_id" '[Int] (IO Int) where nodeMethod = Godot.Core.Physics2DShapeQueryResult.get_result_object_id {-# NOINLINE bindPhysics2DShapeQueryResult_get_result_object_shape #-} -- | Returns the child index of the object's @Shape@ that intersected with the shape at index @idx@. bindPhysics2DShapeQueryResult_get_result_object_shape :: MethodBind bindPhysics2DShapeQueryResult_get_result_object_shape = unsafePerformIO $ withCString "Physics2DShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_object_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the child index of the object's @Shape@ that intersected with the shape at index @idx@. get_result_object_shape :: (Physics2DShapeQueryResult :< cls, Object :< cls) => cls -> Int -> IO Int get_result_object_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryResult_get_result_object_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryResult "get_result_object_shape" '[Int] (IO Int) where nodeMethod = Godot.Core.Physics2DShapeQueryResult.get_result_object_shape {-# NOINLINE bindPhysics2DShapeQueryResult_get_result_rid #-} -- | Returns the @RID@ of the object that intersected with the shape at index @idx@. bindPhysics2DShapeQueryResult_get_result_rid :: MethodBind bindPhysics2DShapeQueryResult_get_result_rid = unsafePerformIO $ withCString "Physics2DShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the object that intersected with the shape at index @idx@. get_result_rid :: (Physics2DShapeQueryResult :< cls, Object :< cls) => cls -> Int -> IO Rid get_result_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DShapeQueryResult_get_result_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DShapeQueryResult "get_result_rid" '[Int] (IO Rid) where nodeMethod = Godot.Core.Physics2DShapeQueryResult.get_result_rid ================================================ FILE: src/Godot/Core/Physics2DTestMotionResult.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Physics2DTestMotionResult (Godot.Core.Physics2DTestMotionResult.get_collider, Godot.Core.Physics2DTestMotionResult.get_collider_id, Godot.Core.Physics2DTestMotionResult.get_collider_rid, Godot.Core.Physics2DTestMotionResult.get_collider_shape, Godot.Core.Physics2DTestMotionResult.get_collider_velocity, Godot.Core.Physics2DTestMotionResult.get_collision_normal, Godot.Core.Physics2DTestMotionResult.get_collision_point, Godot.Core.Physics2DTestMotionResult.get_motion, Godot.Core.Physics2DTestMotionResult.get_motion_remainder) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty Physics2DTestMotionResult "collider" Object 'True where nodeProperty = (get_collider, (), Nothing) instance NodeProperty Physics2DTestMotionResult "collider_id" Int 'True where nodeProperty = (get_collider_id, (), Nothing) instance NodeProperty Physics2DTestMotionResult "collider_rid" Rid 'True where nodeProperty = (get_collider_rid, (), Nothing) instance NodeProperty Physics2DTestMotionResult "collider_shape" Int 'True where nodeProperty = (get_collider_shape, (), Nothing) instance NodeProperty Physics2DTestMotionResult "collider_velocity" Vector2 'True where nodeProperty = (get_collider_velocity, (), Nothing) instance NodeProperty Physics2DTestMotionResult "collision_normal" Vector2 'True where nodeProperty = (get_collision_normal, (), Nothing) instance NodeProperty Physics2DTestMotionResult "collision_point" Vector2 'True where nodeProperty = (get_collision_point, (), Nothing) instance NodeProperty Physics2DTestMotionResult "motion" Vector2 'True where nodeProperty = (get_motion, (), Nothing) instance NodeProperty Physics2DTestMotionResult "motion_remainder" Vector2 'True where nodeProperty = (get_motion_remainder, (), Nothing) {-# NOINLINE bindPhysics2DTestMotionResult_get_collider #-} bindPhysics2DTestMotionResult_get_collider :: MethodBind bindPhysics2DTestMotionResult_get_collider = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_collider" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collider :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Object get_collider cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_collider (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_collider" '[] (IO Object) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_collider {-# NOINLINE bindPhysics2DTestMotionResult_get_collider_id #-} bindPhysics2DTestMotionResult_get_collider_id :: MethodBind bindPhysics2DTestMotionResult_get_collider_id = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_collider_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collider_id :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Int get_collider_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_collider_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_collider_id" '[] (IO Int) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_collider_id {-# NOINLINE bindPhysics2DTestMotionResult_get_collider_rid #-} bindPhysics2DTestMotionResult_get_collider_rid :: MethodBind bindPhysics2DTestMotionResult_get_collider_rid = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_collider_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collider_rid :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Rid get_collider_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_collider_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_collider_rid" '[] (IO Rid) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_collider_rid {-# NOINLINE bindPhysics2DTestMotionResult_get_collider_shape #-} bindPhysics2DTestMotionResult_get_collider_shape :: MethodBind bindPhysics2DTestMotionResult_get_collider_shape = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_collider_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collider_shape :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Int get_collider_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_collider_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_collider_shape" '[] (IO Int) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_collider_shape {-# NOINLINE bindPhysics2DTestMotionResult_get_collider_velocity #-} bindPhysics2DTestMotionResult_get_collider_velocity :: MethodBind bindPhysics2DTestMotionResult_get_collider_velocity = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_collider_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collider_velocity :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Vector2 get_collider_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_collider_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_collider_velocity" '[] (IO Vector2) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_collider_velocity {-# NOINLINE bindPhysics2DTestMotionResult_get_collision_normal #-} bindPhysics2DTestMotionResult_get_collision_normal :: MethodBind bindPhysics2DTestMotionResult_get_collision_normal = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_collision_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_normal :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Vector2 get_collision_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_collision_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_collision_normal" '[] (IO Vector2) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_collision_normal {-# NOINLINE bindPhysics2DTestMotionResult_get_collision_point #-} bindPhysics2DTestMotionResult_get_collision_point :: MethodBind bindPhysics2DTestMotionResult_get_collision_point = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_collision_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_collision_point :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Vector2 get_collision_point cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_collision_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_collision_point" '[] (IO Vector2) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_collision_point {-# NOINLINE bindPhysics2DTestMotionResult_get_motion #-} bindPhysics2DTestMotionResult_get_motion :: MethodBind bindPhysics2DTestMotionResult_get_motion = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_motion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_motion :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Vector2 get_motion cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_motion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_motion" '[] (IO Vector2) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_motion {-# NOINLINE bindPhysics2DTestMotionResult_get_motion_remainder #-} bindPhysics2DTestMotionResult_get_motion_remainder :: MethodBind bindPhysics2DTestMotionResult_get_motion_remainder = unsafePerformIO $ withCString "Physics2DTestMotionResult" $ \ clsNamePtr -> withCString "get_motion_remainder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_motion_remainder :: (Physics2DTestMotionResult :< cls, Object :< cls) => cls -> IO Vector2 get_motion_remainder cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysics2DTestMotionResult_get_motion_remainder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Physics2DTestMotionResult "get_motion_remainder" '[] (IO Vector2) where nodeMethod = Godot.Core.Physics2DTestMotionResult.get_motion_remainder ================================================ FILE: src/Godot/Core/PhysicsBody.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicsBody (Godot.Core.PhysicsBody._get_layers, Godot.Core.PhysicsBody._set_layers, Godot.Core.PhysicsBody.add_collision_exception_with, Godot.Core.PhysicsBody.get_collision_exceptions, Godot.Core.PhysicsBody.get_collision_layer, Godot.Core.PhysicsBody.get_collision_layer_bit, Godot.Core.PhysicsBody.get_collision_mask, Godot.Core.PhysicsBody.get_collision_mask_bit, Godot.Core.PhysicsBody.remove_collision_exception_with, Godot.Core.PhysicsBody.set_collision_layer, Godot.Core.PhysicsBody.set_collision_layer_bit, Godot.Core.PhysicsBody.set_collision_mask, Godot.Core.PhysicsBody.set_collision_mask_bit) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CollisionObject() instance NodeProperty PhysicsBody "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty PhysicsBody "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) {-# NOINLINE bindPhysicsBody__get_layers #-} bindPhysicsBody__get_layers :: MethodBind bindPhysicsBody__get_layers = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "_get_layers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_layers :: (PhysicsBody :< cls, Object :< cls) => cls -> IO Int _get_layers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody__get_layers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "_get_layers" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsBody._get_layers {-# NOINLINE bindPhysicsBody__set_layers #-} bindPhysicsBody__set_layers :: MethodBind bindPhysicsBody__set_layers = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "_set_layers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_layers :: (PhysicsBody :< cls, Object :< cls) => cls -> Int -> IO () _set_layers cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody__set_layers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "_set_layers" '[Int] (IO ()) where nodeMethod = Godot.Core.PhysicsBody._set_layers {-# NOINLINE bindPhysicsBody_add_collision_exception_with #-} -- | Adds a body to the list of bodies that this body can't collide with. bindPhysicsBody_add_collision_exception_with :: MethodBind bindPhysicsBody_add_collision_exception_with = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "add_collision_exception_with" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a body to the list of bodies that this body can't collide with. add_collision_exception_with :: (PhysicsBody :< cls, Object :< cls) => cls -> Node -> IO () add_collision_exception_with cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_add_collision_exception_with (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "add_collision_exception_with" '[Node] (IO ()) where nodeMethod = Godot.Core.PhysicsBody.add_collision_exception_with {-# NOINLINE bindPhysicsBody_get_collision_exceptions #-} -- | Returns an array of nodes that were added as collision exceptions for this body. bindPhysicsBody_get_collision_exceptions :: MethodBind bindPhysicsBody_get_collision_exceptions = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "get_collision_exceptions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of nodes that were added as collision exceptions for this body. get_collision_exceptions :: (PhysicsBody :< cls, Object :< cls) => cls -> IO Array get_collision_exceptions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_get_collision_exceptions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "get_collision_exceptions" '[] (IO Array) where nodeMethod = Godot.Core.PhysicsBody.get_collision_exceptions {-# NOINLINE bindPhysicsBody_get_collision_layer #-} -- | The physics layers this area is in. -- 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 @collision_mask@ property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsBody_get_collision_layer :: MethodBind bindPhysicsBody_get_collision_layer = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area is in. -- 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 @collision_mask@ property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_layer :: (PhysicsBody :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsBody.get_collision_layer {-# NOINLINE bindPhysicsBody_get_collision_layer_bit #-} -- | Returns an individual bit on the @collision_layer@. bindPhysicsBody_get_collision_layer_bit :: MethodBind bindPhysicsBody_get_collision_layer_bit = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "get_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the @collision_layer@. get_collision_layer_bit :: (PhysicsBody :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_layer_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_get_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "get_collision_layer_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.PhysicsBody.get_collision_layer_bit {-# NOINLINE bindPhysicsBody_get_collision_mask #-} -- | The physics layers this area scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsBody_get_collision_mask :: MethodBind bindPhysicsBody_get_collision_mask = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (PhysicsBody :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsBody.get_collision_mask {-# NOINLINE bindPhysicsBody_get_collision_mask_bit #-} -- | Returns an individual bit on the @collision_mask@. bindPhysicsBody_get_collision_mask_bit :: MethodBind bindPhysicsBody_get_collision_mask_bit = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the @collision_mask@. get_collision_mask_bit :: (PhysicsBody :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.PhysicsBody.get_collision_mask_bit {-# NOINLINE bindPhysicsBody_remove_collision_exception_with #-} -- | Removes a body from the list of bodies that this body can't collide with. bindPhysicsBody_remove_collision_exception_with :: MethodBind bindPhysicsBody_remove_collision_exception_with = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "remove_collision_exception_with" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a body from the list of bodies that this body can't collide with. remove_collision_exception_with :: (PhysicsBody :< cls, Object :< cls) => cls -> Node -> IO () remove_collision_exception_with cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_remove_collision_exception_with (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "remove_collision_exception_with" '[Node] (IO ()) where nodeMethod = Godot.Core.PhysicsBody.remove_collision_exception_with {-# NOINLINE bindPhysicsBody_set_collision_layer #-} -- | The physics layers this area is in. -- 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 @collision_mask@ property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsBody_set_collision_layer :: MethodBind bindPhysicsBody_set_collision_layer = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area is in. -- 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 @collision_mask@ property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_layer :: (PhysicsBody :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.PhysicsBody.set_collision_layer {-# NOINLINE bindPhysicsBody_set_collision_layer_bit #-} -- | Sets individual bits on the @collision_layer@ bitmask. Use this if you only need to change one layer's value. bindPhysicsBody_set_collision_layer_bit :: MethodBind bindPhysicsBody_set_collision_layer_bit = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "set_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets individual bits on the @collision_layer@ bitmask. Use this if you only need to change one layer's value. set_collision_layer_bit :: (PhysicsBody :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_layer_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_set_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "set_collision_layer_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsBody.set_collision_layer_bit {-# NOINLINE bindPhysicsBody_set_collision_mask #-} -- | The physics layers this area scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsBody_set_collision_mask :: MethodBind bindPhysicsBody_set_collision_mask = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (PhysicsBody :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.PhysicsBody.set_collision_mask {-# NOINLINE bindPhysicsBody_set_collision_mask_bit #-} -- | Sets individual bits on the @collision_mask@ bitmask. Use this if you only need to change one layer's value. bindPhysicsBody_set_collision_mask_bit :: MethodBind bindPhysicsBody_set_collision_mask_bit = unsafePerformIO $ withCString "PhysicsBody" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets individual bits on the @collision_mask@ bitmask. Use this if you only need to change one layer's value. set_collision_mask_bit :: (PhysicsBody :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsBody.set_collision_mask_bit ================================================ FILE: src/Godot/Core/PhysicsBody2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicsBody2D (Godot.Core.PhysicsBody2D._get_layers, Godot.Core.PhysicsBody2D._set_layers, Godot.Core.PhysicsBody2D.add_collision_exception_with, Godot.Core.PhysicsBody2D.get_collision_exceptions, Godot.Core.PhysicsBody2D.get_collision_layer, Godot.Core.PhysicsBody2D.get_collision_layer_bit, Godot.Core.PhysicsBody2D.get_collision_mask, Godot.Core.PhysicsBody2D.get_collision_mask_bit, Godot.Core.PhysicsBody2D.remove_collision_exception_with, Godot.Core.PhysicsBody2D.set_collision_layer, Godot.Core.PhysicsBody2D.set_collision_layer_bit, Godot.Core.PhysicsBody2D.set_collision_mask, Godot.Core.PhysicsBody2D.set_collision_mask_bit) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.CollisionObject2D() instance NodeProperty PhysicsBody2D "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty PhysicsBody2D "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty PhysicsBody2D "layers" Int 'False where nodeProperty = (_get_layers, wrapDroppingSetter _set_layers, Nothing) {-# NOINLINE bindPhysicsBody2D__get_layers #-} -- | Both @collision_layer@ and @collision_mask@. Returns @collision_layer@ when accessed. Updates @collision_layer@ and @collision_mask@ when modified. bindPhysicsBody2D__get_layers :: MethodBind bindPhysicsBody2D__get_layers = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "_get_layers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Both @collision_layer@ and @collision_mask@. Returns @collision_layer@ when accessed. Updates @collision_layer@ and @collision_mask@ when modified. _get_layers :: (PhysicsBody2D :< cls, Object :< cls) => cls -> IO Int _get_layers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D__get_layers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "_get_layers" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsBody2D._get_layers {-# NOINLINE bindPhysicsBody2D__set_layers #-} -- | Both @collision_layer@ and @collision_mask@. Returns @collision_layer@ when accessed. Updates @collision_layer@ and @collision_mask@ when modified. bindPhysicsBody2D__set_layers :: MethodBind bindPhysicsBody2D__set_layers = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "_set_layers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Both @collision_layer@ and @collision_mask@. Returns @collision_layer@ when accessed. Updates @collision_layer@ and @collision_mask@ when modified. _set_layers :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Int -> IO () _set_layers cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D__set_layers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "_set_layers" '[Int] (IO ()) where nodeMethod = Godot.Core.PhysicsBody2D._set_layers {-# NOINLINE bindPhysicsBody2D_add_collision_exception_with #-} -- | Adds a body to the list of bodies that this body can't collide with. bindPhysicsBody2D_add_collision_exception_with :: MethodBind bindPhysicsBody2D_add_collision_exception_with = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "add_collision_exception_with" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a body to the list of bodies that this body can't collide with. add_collision_exception_with :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Node -> IO () add_collision_exception_with cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_add_collision_exception_with (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "add_collision_exception_with" '[Node] (IO ()) where nodeMethod = Godot.Core.PhysicsBody2D.add_collision_exception_with {-# NOINLINE bindPhysicsBody2D_get_collision_exceptions #-} -- | Returns an array of nodes that were added as collision exceptions for this body. bindPhysicsBody2D_get_collision_exceptions :: MethodBind bindPhysicsBody2D_get_collision_exceptions = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "get_collision_exceptions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of nodes that were added as collision exceptions for this body. get_collision_exceptions :: (PhysicsBody2D :< cls, Object :< cls) => cls -> IO Array get_collision_exceptions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_get_collision_exceptions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "get_collision_exceptions" '[] (IO Array) where nodeMethod = Godot.Core.PhysicsBody2D.get_collision_exceptions {-# NOINLINE bindPhysicsBody2D_get_collision_layer #-} -- | The physics layers this area is in. -- 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 @collision_mask@ property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsBody2D_get_collision_layer :: MethodBind bindPhysicsBody2D_get_collision_layer = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area is in. -- 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 @collision_mask@ property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_layer :: (PhysicsBody2D :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsBody2D.get_collision_layer {-# NOINLINE bindPhysicsBody2D_get_collision_layer_bit #-} -- | Returns an individual bit on the @collision_layer@. bindPhysicsBody2D_get_collision_layer_bit :: MethodBind bindPhysicsBody2D_get_collision_layer_bit = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "get_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the @collision_layer@. get_collision_layer_bit :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_layer_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_get_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "get_collision_layer_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.PhysicsBody2D.get_collision_layer_bit {-# NOINLINE bindPhysicsBody2D_get_collision_mask #-} -- | The physics layers this area scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsBody2D_get_collision_mask :: MethodBind bindPhysicsBody2D_get_collision_mask = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (PhysicsBody2D :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsBody2D.get_collision_mask {-# NOINLINE bindPhysicsBody2D_get_collision_mask_bit #-} -- | Returns an individual bit on the @collision_mask@. bindPhysicsBody2D_get_collision_mask_bit :: MethodBind bindPhysicsBody2D_get_collision_mask_bit = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the @collision_mask@. get_collision_mask_bit :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.PhysicsBody2D.get_collision_mask_bit {-# NOINLINE bindPhysicsBody2D_remove_collision_exception_with #-} -- | Removes a body from the list of bodies that this body can't collide with. bindPhysicsBody2D_remove_collision_exception_with :: MethodBind bindPhysicsBody2D_remove_collision_exception_with = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "remove_collision_exception_with" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a body from the list of bodies that this body can't collide with. remove_collision_exception_with :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Node -> IO () remove_collision_exception_with cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_remove_collision_exception_with (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "remove_collision_exception_with" '[Node] (IO ()) where nodeMethod = Godot.Core.PhysicsBody2D.remove_collision_exception_with {-# NOINLINE bindPhysicsBody2D_set_collision_layer #-} -- | The physics layers this area is in. -- 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 @collision_mask@ property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsBody2D_set_collision_layer :: MethodBind bindPhysicsBody2D_set_collision_layer = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area is in. -- 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 @collision_mask@ property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_layer :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.PhysicsBody2D.set_collision_layer {-# NOINLINE bindPhysicsBody2D_set_collision_layer_bit #-} -- | Sets individual bits on the @collision_layer@ bitmask. Use this if you only need to change one layer's value. bindPhysicsBody2D_set_collision_layer_bit :: MethodBind bindPhysicsBody2D_set_collision_layer_bit = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "set_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets individual bits on the @collision_layer@ bitmask. Use this if you only need to change one layer's value. set_collision_layer_bit :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_layer_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_set_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "set_collision_layer_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsBody2D.set_collision_layer_bit {-# NOINLINE bindPhysicsBody2D_set_collision_mask #-} -- | The physics layers this area scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsBody2D_set_collision_mask :: MethodBind bindPhysicsBody2D_set_collision_mask = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this area scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.PhysicsBody2D.set_collision_mask {-# NOINLINE bindPhysicsBody2D_set_collision_mask_bit #-} -- | Sets individual bits on the @collision_mask@ bitmask. Use this if you only need to change one layer's value. bindPhysicsBody2D_set_collision_mask_bit :: MethodBind bindPhysicsBody2D_set_collision_mask_bit = unsafePerformIO $ withCString "PhysicsBody2D" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets individual bits on the @collision_mask@ bitmask. Use this if you only need to change one layer's value. set_collision_mask_bit :: (PhysicsBody2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsBody2D_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsBody2D "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsBody2D.set_collision_mask_bit ================================================ FILE: src/Godot/Core/PhysicsDirectBodyState.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicsDirectBodyState (Godot.Core.PhysicsDirectBodyState.add_central_force, Godot.Core.PhysicsDirectBodyState.add_force, Godot.Core.PhysicsDirectBodyState.add_torque, Godot.Core.PhysicsDirectBodyState.apply_central_impulse, Godot.Core.PhysicsDirectBodyState.apply_impulse, Godot.Core.PhysicsDirectBodyState.apply_torque_impulse, Godot.Core.PhysicsDirectBodyState.get_angular_velocity, Godot.Core.PhysicsDirectBodyState.get_center_of_mass, Godot.Core.PhysicsDirectBodyState.get_contact_collider, Godot.Core.PhysicsDirectBodyState.get_contact_collider_id, Godot.Core.PhysicsDirectBodyState.get_contact_collider_object, Godot.Core.PhysicsDirectBodyState.get_contact_collider_position, Godot.Core.PhysicsDirectBodyState.get_contact_collider_shape, Godot.Core.PhysicsDirectBodyState.get_contact_collider_velocity_at_position, Godot.Core.PhysicsDirectBodyState.get_contact_count, Godot.Core.PhysicsDirectBodyState.get_contact_impulse, Godot.Core.PhysicsDirectBodyState.get_contact_local_normal, Godot.Core.PhysicsDirectBodyState.get_contact_local_position, Godot.Core.PhysicsDirectBodyState.get_contact_local_shape, Godot.Core.PhysicsDirectBodyState.get_inverse_inertia, Godot.Core.PhysicsDirectBodyState.get_inverse_mass, Godot.Core.PhysicsDirectBodyState.get_linear_velocity, Godot.Core.PhysicsDirectBodyState.get_principal_inertia_axes, Godot.Core.PhysicsDirectBodyState.get_space_state, Godot.Core.PhysicsDirectBodyState.get_step, Godot.Core.PhysicsDirectBodyState.get_total_angular_damp, Godot.Core.PhysicsDirectBodyState.get_total_gravity, Godot.Core.PhysicsDirectBodyState.get_total_linear_damp, Godot.Core.PhysicsDirectBodyState.get_transform, Godot.Core.PhysicsDirectBodyState.integrate_forces, Godot.Core.PhysicsDirectBodyState.is_sleeping, Godot.Core.PhysicsDirectBodyState.set_angular_velocity, Godot.Core.PhysicsDirectBodyState.set_linear_velocity, Godot.Core.PhysicsDirectBodyState.set_sleep_state, Godot.Core.PhysicsDirectBodyState.set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() instance NodeProperty PhysicsDirectBodyState "angular_velocity" Vector3 'False where nodeProperty = (get_angular_velocity, wrapDroppingSetter set_angular_velocity, Nothing) instance NodeProperty PhysicsDirectBodyState "center_of_mass" Vector3 'True where nodeProperty = (get_center_of_mass, (), Nothing) instance NodeProperty PhysicsDirectBodyState "inverse_inertia" Vector3 'True where nodeProperty = (get_inverse_inertia, (), Nothing) instance NodeProperty PhysicsDirectBodyState "inverse_mass" Float 'True where nodeProperty = (get_inverse_mass, (), Nothing) instance NodeProperty PhysicsDirectBodyState "linear_velocity" Vector3 'False where nodeProperty = (get_linear_velocity, wrapDroppingSetter set_linear_velocity, Nothing) instance NodeProperty PhysicsDirectBodyState "principal_inertia_axes" Basis 'True where nodeProperty = (get_principal_inertia_axes, (), Nothing) instance NodeProperty PhysicsDirectBodyState "sleeping" Bool 'False where nodeProperty = (is_sleeping, wrapDroppingSetter set_sleep_state, Nothing) instance NodeProperty PhysicsDirectBodyState "step" Float 'True where nodeProperty = (get_step, (), Nothing) instance NodeProperty PhysicsDirectBodyState "total_angular_damp" Float 'True where nodeProperty = (get_total_angular_damp, (), Nothing) instance NodeProperty PhysicsDirectBodyState "total_gravity" Vector3 'True where nodeProperty = (get_total_gravity, (), Nothing) instance NodeProperty PhysicsDirectBodyState "total_linear_damp" Float 'True where nodeProperty = (get_total_linear_damp, (), Nothing) instance NodeProperty PhysicsDirectBodyState "transform" Transform 'False where nodeProperty = (get_transform, wrapDroppingSetter set_transform, Nothing) {-# NOINLINE bindPhysicsDirectBodyState_add_central_force #-} -- | Adds a constant directional force without affecting rotation. -- This is equivalent to @add_force(force, Vector3(0,0,0))@. bindPhysicsDirectBodyState_add_central_force :: MethodBind bindPhysicsDirectBodyState_add_central_force = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "add_central_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant directional force without affecting rotation. -- This is equivalent to @add_force(force, Vector3(0,0,0))@. add_central_force :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Vector3 -> IO () add_central_force cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_add_central_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "add_central_force" '[Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.add_central_force {-# NOINLINE bindPhysicsDirectBodyState_add_force #-} -- | Adds a positioned force to the body. Both the force and the offset from the body origin are in global coordinates. bindPhysicsDirectBodyState_add_force :: MethodBind bindPhysicsDirectBodyState_add_force = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "add_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a positioned force to the body. Both the force and the offset from the body origin are in global coordinates. add_force :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> IO () add_force cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_add_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "add_force" '[Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.add_force {-# NOINLINE bindPhysicsDirectBodyState_add_torque #-} -- | Adds a constant rotational force without affecting position. bindPhysicsDirectBodyState_add_torque :: MethodBind bindPhysicsDirectBodyState_add_torque = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "add_torque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant rotational force without affecting position. add_torque :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Vector3 -> IO () add_torque cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_add_torque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "add_torque" '[Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.add_torque {-# NOINLINE bindPhysicsDirectBodyState_apply_central_impulse #-} -- | Applies a single directional impulse without affecting rotation. -- This is equivalent to @apply_impulse(Vector3(0, 0, 0), impulse)@. bindPhysicsDirectBodyState_apply_central_impulse :: MethodBind bindPhysicsDirectBodyState_apply_central_impulse = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "apply_central_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a single directional impulse without affecting rotation. -- This is equivalent to @apply_impulse(Vector3(0, 0, 0), impulse)@. apply_central_impulse :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Vector3 -> IO () apply_central_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_apply_central_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "apply_central_impulse" '[Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.apply_central_impulse {-# NOINLINE bindPhysicsDirectBodyState_apply_impulse #-} -- | Applies a positioned impulse to the body. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason it should only be used when simulating one-time impacts. The position uses the rotation of the global coordinate system, but is centered at the object's origin. bindPhysicsDirectBodyState_apply_impulse :: MethodBind bindPhysicsDirectBodyState_apply_impulse = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "apply_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a positioned impulse to the body. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason it should only be used when simulating one-time impacts. The position uses the rotation of the global coordinate system, but is centered at the object's origin. apply_impulse :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> IO () apply_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_apply_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "apply_impulse" '[Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.apply_impulse {-# NOINLINE bindPhysicsDirectBodyState_apply_torque_impulse #-} -- | Apply a torque impulse (which will be affected by the body mass and shape). This will rotate the body around the vector @j@ passed as parameter. bindPhysicsDirectBodyState_apply_torque_impulse :: MethodBind bindPhysicsDirectBodyState_apply_torque_impulse = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "apply_torque_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Apply a torque impulse (which will be affected by the body mass and shape). This will rotate the body around the vector @j@ passed as parameter. apply_torque_impulse :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Vector3 -> IO () apply_torque_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_apply_torque_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "apply_torque_impulse" '[Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.apply_torque_impulse {-# NOINLINE bindPhysicsDirectBodyState_get_angular_velocity #-} -- | The body's rotational velocity. bindPhysicsDirectBodyState_get_angular_velocity :: MethodBind bindPhysicsDirectBodyState_get_angular_velocity = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's rotational velocity. get_angular_velocity :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Vector3 get_angular_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_angular_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_angular_velocity {-# NOINLINE bindPhysicsDirectBodyState_get_center_of_mass #-} bindPhysicsDirectBodyState_get_center_of_mass :: MethodBind bindPhysicsDirectBodyState_get_center_of_mass = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_center_of_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_center_of_mass :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Vector3 get_center_of_mass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_center_of_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_center_of_mass" '[] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_center_of_mass {-# NOINLINE bindPhysicsDirectBodyState_get_contact_collider #-} -- | Returns the collider's @RID@. bindPhysicsDirectBodyState_get_contact_collider :: MethodBind bindPhysicsDirectBodyState_get_contact_collider = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collider's @RID@. get_contact_collider :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Rid get_contact_collider cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_collider (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_collider" '[Int] (IO Rid) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_collider {-# NOINLINE bindPhysicsDirectBodyState_get_contact_collider_id #-} -- | Returns the collider's object id. bindPhysicsDirectBodyState_get_contact_collider_id :: MethodBind bindPhysicsDirectBodyState_get_contact_collider_id = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collider's object id. get_contact_collider_id :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Int get_contact_collider_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_collider_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_collider_id" '[Int] (IO Int) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_collider_id {-# NOINLINE bindPhysicsDirectBodyState_get_contact_collider_object #-} -- | Returns the collider object. bindPhysicsDirectBodyState_get_contact_collider_object :: MethodBind bindPhysicsDirectBodyState_get_contact_collider_object = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collider object. get_contact_collider_object :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Object get_contact_collider_object cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_collider_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_collider_object" '[Int] (IO Object) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_collider_object {-# NOINLINE bindPhysicsDirectBodyState_get_contact_collider_position #-} -- | Returns the contact position in the collider. bindPhysicsDirectBodyState_get_contact_collider_position :: MethodBind bindPhysicsDirectBodyState_get_contact_collider_position = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the contact position in the collider. get_contact_collider_position :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_contact_collider_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_collider_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_collider_position" '[Int] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_collider_position {-# NOINLINE bindPhysicsDirectBodyState_get_contact_collider_shape #-} -- | Returns the collider's shape index. bindPhysicsDirectBodyState_get_contact_collider_shape :: MethodBind bindPhysicsDirectBodyState_get_contact_collider_shape = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collider's shape index. get_contact_collider_shape :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Int get_contact_collider_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_collider_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_collider_shape" '[Int] (IO Int) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_collider_shape {-# NOINLINE bindPhysicsDirectBodyState_get_contact_collider_velocity_at_position #-} -- | Returns the linear velocity vector at the collider's contact point. bindPhysicsDirectBodyState_get_contact_collider_velocity_at_position :: MethodBind bindPhysicsDirectBodyState_get_contact_collider_velocity_at_position = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_collider_velocity_at_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the linear velocity vector at the collider's contact point. get_contact_collider_velocity_at_position :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_contact_collider_velocity_at_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_collider_velocity_at_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_collider_velocity_at_position" '[Int] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_collider_velocity_at_position {-# NOINLINE bindPhysicsDirectBodyState_get_contact_count #-} -- | Returns the number of contacts this body has with other bodies. -- __Note:__ By default, this returns 0 unless bodies are configured to monitor contacts. See @RigidBody.contact_monitor@. bindPhysicsDirectBodyState_get_contact_count :: MethodBind bindPhysicsDirectBodyState_get_contact_count = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of contacts this body has with other bodies. -- __Note:__ By default, this returns 0 unless bodies are configured to monitor contacts. See @RigidBody.contact_monitor@. get_contact_count :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Int get_contact_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_count" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_count {-# NOINLINE bindPhysicsDirectBodyState_get_contact_impulse #-} -- | Impulse created by the contact. Only implemented for Bullet physics. bindPhysicsDirectBodyState_get_contact_impulse :: MethodBind bindPhysicsDirectBodyState_get_contact_impulse = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Impulse created by the contact. Only implemented for Bullet physics. get_contact_impulse :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Float get_contact_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_impulse" '[Int] (IO Float) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_impulse {-# NOINLINE bindPhysicsDirectBodyState_get_contact_local_normal #-} -- | Returns the local normal at the contact point. bindPhysicsDirectBodyState_get_contact_local_normal :: MethodBind bindPhysicsDirectBodyState_get_contact_local_normal = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_local_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the local normal at the contact point. get_contact_local_normal :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_contact_local_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_local_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_local_normal" '[Int] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_local_normal {-# NOINLINE bindPhysicsDirectBodyState_get_contact_local_position #-} -- | Returns the local position of the contact point. bindPhysicsDirectBodyState_get_contact_local_position :: MethodBind bindPhysicsDirectBodyState_get_contact_local_position = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_local_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the local position of the contact point. get_contact_local_position :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Vector3 get_contact_local_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_local_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_local_position" '[Int] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_local_position {-# NOINLINE bindPhysicsDirectBodyState_get_contact_local_shape #-} -- | Returns the local shape index of the collision. bindPhysicsDirectBodyState_get_contact_local_shape :: MethodBind bindPhysicsDirectBodyState_get_contact_local_shape = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_contact_local_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the local shape index of the collision. get_contact_local_shape :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Int -> IO Int get_contact_local_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_contact_local_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_contact_local_shape" '[Int] (IO Int) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_contact_local_shape {-# NOINLINE bindPhysicsDirectBodyState_get_inverse_inertia #-} -- | The inverse of the inertia of the body. bindPhysicsDirectBodyState_get_inverse_inertia :: MethodBind bindPhysicsDirectBodyState_get_inverse_inertia = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_inverse_inertia" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The inverse of the inertia of the body. get_inverse_inertia :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Vector3 get_inverse_inertia cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_inverse_inertia (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_inverse_inertia" '[] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_inverse_inertia {-# NOINLINE bindPhysicsDirectBodyState_get_inverse_mass #-} -- | The inverse of the mass of the body. bindPhysicsDirectBodyState_get_inverse_mass :: MethodBind bindPhysicsDirectBodyState_get_inverse_mass = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_inverse_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The inverse of the mass of the body. get_inverse_mass :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_inverse_mass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_inverse_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_inverse_mass" '[] (IO Float) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_inverse_mass {-# NOINLINE bindPhysicsDirectBodyState_get_linear_velocity #-} -- | The body's linear velocity. bindPhysicsDirectBodyState_get_linear_velocity :: MethodBind bindPhysicsDirectBodyState_get_linear_velocity = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear velocity. get_linear_velocity :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Vector3 get_linear_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_linear_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_linear_velocity {-# NOINLINE bindPhysicsDirectBodyState_get_principal_inertia_axes #-} bindPhysicsDirectBodyState_get_principal_inertia_axes :: MethodBind bindPhysicsDirectBodyState_get_principal_inertia_axes = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_principal_inertia_axes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_principal_inertia_axes :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Basis get_principal_inertia_axes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_principal_inertia_axes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_principal_inertia_axes" '[] (IO Basis) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_principal_inertia_axes {-# NOINLINE bindPhysicsDirectBodyState_get_space_state #-} -- | Returns the current state of the space, useful for queries. bindPhysicsDirectBodyState_get_space_state :: MethodBind bindPhysicsDirectBodyState_get_space_state = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_space_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current state of the space, useful for queries. get_space_state :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO PhysicsDirectSpaceState get_space_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_space_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_space_state" '[] (IO PhysicsDirectSpaceState) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_space_state {-# NOINLINE bindPhysicsDirectBodyState_get_step #-} -- | The timestep (delta) used for the simulation. bindPhysicsDirectBodyState_get_step :: MethodBind bindPhysicsDirectBodyState_get_step = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The timestep (delta) used for the simulation. get_step :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_step cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_step" '[] (IO Float) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_step {-# NOINLINE bindPhysicsDirectBodyState_get_total_angular_damp #-} -- | The rate at which the body stops rotating, if there are not any other forces moving it. bindPhysicsDirectBodyState_get_total_angular_damp :: MethodBind bindPhysicsDirectBodyState_get_total_angular_damp = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_total_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which the body stops rotating, if there are not any other forces moving it. get_total_angular_damp :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_total_angular_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_total_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_total_angular_damp" '[] (IO Float) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_total_angular_damp {-# NOINLINE bindPhysicsDirectBodyState_get_total_gravity #-} -- | The total gravity vector being currently applied to this body. bindPhysicsDirectBodyState_get_total_gravity :: MethodBind bindPhysicsDirectBodyState_get_total_gravity = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_total_gravity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The total gravity vector being currently applied to this body. get_total_gravity :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Vector3 get_total_gravity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_total_gravity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_total_gravity" '[] (IO Vector3) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_total_gravity {-# NOINLINE bindPhysicsDirectBodyState_get_total_linear_damp #-} -- | The rate at which the body stops moving, if there are not any other forces moving it. bindPhysicsDirectBodyState_get_total_linear_damp :: MethodBind bindPhysicsDirectBodyState_get_total_linear_damp = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_total_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rate at which the body stops moving, if there are not any other forces moving it. get_total_linear_damp :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Float get_total_linear_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_total_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_total_linear_damp" '[] (IO Float) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_total_linear_damp {-# NOINLINE bindPhysicsDirectBodyState_get_transform #-} -- | The body's transformation matrix. bindPhysicsDirectBodyState_get_transform :: MethodBind bindPhysicsDirectBodyState_get_transform = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's transformation matrix. get_transform :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Transform get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "get_transform" '[] (IO Transform) where nodeMethod = Godot.Core.PhysicsDirectBodyState.get_transform {-# NOINLINE bindPhysicsDirectBodyState_integrate_forces #-} -- | Calls the built-in force integration code. bindPhysicsDirectBodyState_integrate_forces :: MethodBind bindPhysicsDirectBodyState_integrate_forces = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "integrate_forces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the built-in force integration code. integrate_forces :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO () integrate_forces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_integrate_forces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "integrate_forces" '[] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.integrate_forces {-# NOINLINE bindPhysicsDirectBodyState_is_sleeping #-} -- | If @true@, this body is currently sleeping (not active). bindPhysicsDirectBodyState_is_sleeping :: MethodBind bindPhysicsDirectBodyState_is_sleeping = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "is_sleeping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this body is currently sleeping (not active). is_sleeping :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> IO Bool is_sleeping cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_is_sleeping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "is_sleeping" '[] (IO Bool) where nodeMethod = Godot.Core.PhysicsDirectBodyState.is_sleeping {-# NOINLINE bindPhysicsDirectBodyState_set_angular_velocity #-} -- | The body's rotational velocity. bindPhysicsDirectBodyState_set_angular_velocity :: MethodBind bindPhysicsDirectBodyState_set_angular_velocity = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "set_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's rotational velocity. set_angular_velocity :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Vector3 -> IO () set_angular_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_set_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "set_angular_velocity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.set_angular_velocity {-# NOINLINE bindPhysicsDirectBodyState_set_linear_velocity #-} -- | The body's linear velocity. bindPhysicsDirectBodyState_set_linear_velocity :: MethodBind bindPhysicsDirectBodyState_set_linear_velocity = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "set_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear velocity. set_linear_velocity :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Vector3 -> IO () set_linear_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_set_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "set_linear_velocity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.set_linear_velocity {-# NOINLINE bindPhysicsDirectBodyState_set_sleep_state #-} -- | If @true@, this body is currently sleeping (not active). bindPhysicsDirectBodyState_set_sleep_state :: MethodBind bindPhysicsDirectBodyState_set_sleep_state = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "set_sleep_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this body is currently sleeping (not active). set_sleep_state :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Bool -> IO () set_sleep_state cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_set_sleep_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "set_sleep_state" '[Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.set_sleep_state {-# NOINLINE bindPhysicsDirectBodyState_set_transform #-} -- | The body's transformation matrix. bindPhysicsDirectBodyState_set_transform :: MethodBind bindPhysicsDirectBodyState_set_transform = unsafePerformIO $ withCString "PhysicsDirectBodyState" $ \ clsNamePtr -> withCString "set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's transformation matrix. set_transform :: (PhysicsDirectBodyState :< cls, Object :< cls) => cls -> Transform -> IO () set_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectBodyState_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectBodyState "set_transform" '[Transform] (IO ()) where nodeMethod = Godot.Core.PhysicsDirectBodyState.set_transform ================================================ FILE: src/Godot/Core/PhysicsDirectSpaceState.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicsDirectSpaceState (Godot.Core.PhysicsDirectSpaceState.cast_motion, Godot.Core.PhysicsDirectSpaceState.collide_shape, Godot.Core.PhysicsDirectSpaceState.get_rest_info, Godot.Core.PhysicsDirectSpaceState.intersect_ray, Godot.Core.PhysicsDirectSpaceState.intersect_shape) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindPhysicsDirectSpaceState_cast_motion #-} -- | Checks whether the shape can travel to a point. The method will return an array with two floats between 0 and 1, both representing a fraction of @motion@. The first is how far the shape can move without triggering a collision, and the second is the point at which a collision will occur. If no collision is detected, the returned array will be @@1, 1@@. -- If the shape can not move, the returned array will be @@0, 0@@ under Bullet, and empty under GodotPhysics. bindPhysicsDirectSpaceState_cast_motion :: MethodBind bindPhysicsDirectSpaceState_cast_motion = unsafePerformIO $ withCString "PhysicsDirectSpaceState" $ \ clsNamePtr -> withCString "cast_motion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks whether the shape can travel to a point. The method will return an array with two floats between 0 and 1, both representing a fraction of @motion@. The first is how far the shape can move without triggering a collision, and the second is the point at which a collision will occur. If no collision is detected, the returned array will be @@1, 1@@. -- If the shape can not move, the returned array will be @@0, 0@@ under Bullet, and empty under GodotPhysics. cast_motion :: (PhysicsDirectSpaceState :< cls, Object :< cls) => cls -> PhysicsShapeQueryParameters -> Vector3 -> IO Array cast_motion cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectSpaceState_cast_motion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectSpaceState "cast_motion" '[PhysicsShapeQueryParameters, Vector3] (IO Array) where nodeMethod = Godot.Core.PhysicsDirectSpaceState.cast_motion {-# NOINLINE bindPhysicsDirectSpaceState_collide_shape #-} -- | Checks the intersections of a shape, given through a @PhysicsShapeQueryParameters@ object, against the space. The resulting array contains a list of points where the shape intersects another. Like with @method intersect_shape@, the number of returned results can be limited to save processing time. bindPhysicsDirectSpaceState_collide_shape :: MethodBind bindPhysicsDirectSpaceState_collide_shape = unsafePerformIO $ withCString "PhysicsDirectSpaceState" $ \ clsNamePtr -> withCString "collide_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks the intersections of a shape, given through a @PhysicsShapeQueryParameters@ object, against the space. The resulting array contains a list of points where the shape intersects another. Like with @method intersect_shape@, the number of returned results can be limited to save processing time. collide_shape :: (PhysicsDirectSpaceState :< cls, Object :< cls) => cls -> PhysicsShapeQueryParameters -> Maybe Int -> IO Array collide_shape cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (32)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectSpaceState_collide_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectSpaceState "collide_shape" '[PhysicsShapeQueryParameters, Maybe Int] (IO Array) where nodeMethod = Godot.Core.PhysicsDirectSpaceState.collide_shape {-# NOINLINE bindPhysicsDirectSpaceState_get_rest_info #-} -- | Checks the intersections of a shape, given through a @PhysicsShapeQueryParameters@ object, against the space. If it collides with more than one shape, the nearest one is selected. The returned object is a dictionary containing the following fields: -- @collider_id@: The colliding object's ID. -- @linear_velocity@: The colliding object's velocity @Vector3@. If the object is an @Area@, the result is @(0, 0, 0)@. -- @normal@: The object's surface normal at the intersection point. -- @point@: The intersection point. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- If the shape did not intersect anything, then an empty dictionary is returned instead. bindPhysicsDirectSpaceState_get_rest_info :: MethodBind bindPhysicsDirectSpaceState_get_rest_info = unsafePerformIO $ withCString "PhysicsDirectSpaceState" $ \ clsNamePtr -> withCString "get_rest_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks the intersections of a shape, given through a @PhysicsShapeQueryParameters@ object, against the space. If it collides with more than one shape, the nearest one is selected. The returned object is a dictionary containing the following fields: -- @collider_id@: The colliding object's ID. -- @linear_velocity@: The colliding object's velocity @Vector3@. If the object is an @Area@, the result is @(0, 0, 0)@. -- @normal@: The object's surface normal at the intersection point. -- @point@: The intersection point. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- If the shape did not intersect anything, then an empty dictionary is returned instead. get_rest_info :: (PhysicsDirectSpaceState :< cls, Object :< cls) => cls -> PhysicsShapeQueryParameters -> IO Dictionary get_rest_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectSpaceState_get_rest_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectSpaceState "get_rest_info" '[PhysicsShapeQueryParameters] (IO Dictionary) where nodeMethod = Godot.Core.PhysicsDirectSpaceState.get_rest_info {-# NOINLINE bindPhysicsDirectSpaceState_intersect_ray #-} -- | Intersects a ray in a given space. The returned object is a dictionary with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @normal@: The object's surface normal at the intersection point. -- @position@: The intersection point. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- If the ray did not intersect anything, then an empty dictionary is returned instead. -- Additionally, the method can take an @exclude@ array of objects or @RID@s that are to be excluded from collisions, a @collision_mask@ bitmask representing the physics layers to check in, or booleans to determine if the ray should collide with @PhysicsBody@s or @Area@s, respectively. bindPhysicsDirectSpaceState_intersect_ray :: MethodBind bindPhysicsDirectSpaceState_intersect_ray = unsafePerformIO $ withCString "PhysicsDirectSpaceState" $ \ clsNamePtr -> withCString "intersect_ray" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Intersects a ray in a given space. The returned object is a dictionary with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @normal@: The object's surface normal at the intersection point. -- @position@: The intersection point. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- If the ray did not intersect anything, then an empty dictionary is returned instead. -- Additionally, the method can take an @exclude@ array of objects or @RID@s that are to be excluded from collisions, a @collision_mask@ bitmask representing the physics layers to check in, or booleans to determine if the ray should collide with @PhysicsBody@s or @Area@s, respectively. intersect_ray :: (PhysicsDirectSpaceState :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Maybe Array -> Maybe Int -> Maybe Bool -> Maybe Bool -> IO Dictionary intersect_ray cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantArray V.empty arg3, maybe (VariantInt (2147483647)) toVariant arg4, maybe (VariantBool True) toVariant arg5, maybe (VariantBool False) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectSpaceState_intersect_ray (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectSpaceState "intersect_ray" '[Vector3, Vector3, Maybe Array, Maybe Int, Maybe Bool, Maybe Bool] (IO Dictionary) where nodeMethod = Godot.Core.PhysicsDirectSpaceState.intersect_ray {-# NOINLINE bindPhysicsDirectSpaceState_intersect_shape #-} -- | Checks the intersections of a shape, given through a @PhysicsShapeQueryParameters@ object, against the space. The intersected shapes are returned in an array containing dictionaries with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- The number of intersections can be limited with the @max_results@ parameter, to reduce the processing time. bindPhysicsDirectSpaceState_intersect_shape :: MethodBind bindPhysicsDirectSpaceState_intersect_shape = unsafePerformIO $ withCString "PhysicsDirectSpaceState" $ \ clsNamePtr -> withCString "intersect_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Checks the intersections of a shape, given through a @PhysicsShapeQueryParameters@ object, against the space. The intersected shapes are returned in an array containing dictionaries with the following fields: -- @collider@: The colliding object. -- @collider_id@: The colliding object's ID. -- @rid@: The intersecting object's @RID@. -- @shape@: The shape index of the colliding shape. -- The number of intersections can be limited with the @max_results@ parameter, to reduce the processing time. intersect_shape :: (PhysicsDirectSpaceState :< cls, Object :< cls) => cls -> PhysicsShapeQueryParameters -> Maybe Int -> IO Array intersect_shape cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (32)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsDirectSpaceState_intersect_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsDirectSpaceState "intersect_shape" '[PhysicsShapeQueryParameters, Maybe Int] (IO Array) where nodeMethod = Godot.Core.PhysicsDirectSpaceState.intersect_shape ================================================ FILE: src/Godot/Core/PhysicsMaterial.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicsMaterial (Godot.Core.PhysicsMaterial.get_bounce, Godot.Core.PhysicsMaterial.get_friction, Godot.Core.PhysicsMaterial.is_absorbent, Godot.Core.PhysicsMaterial.is_rough, Godot.Core.PhysicsMaterial.set_absorbent, Godot.Core.PhysicsMaterial.set_bounce, Godot.Core.PhysicsMaterial.set_friction, Godot.Core.PhysicsMaterial.set_rough) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty PhysicsMaterial "absorbent" Bool 'False where nodeProperty = (is_absorbent, wrapDroppingSetter set_absorbent, Nothing) instance NodeProperty PhysicsMaterial "bounce" Float 'False where nodeProperty = (get_bounce, wrapDroppingSetter set_bounce, Nothing) instance NodeProperty PhysicsMaterial "friction" Float 'False where nodeProperty = (get_friction, wrapDroppingSetter set_friction, Nothing) instance NodeProperty PhysicsMaterial "rough" Bool 'False where nodeProperty = (is_rough, wrapDroppingSetter set_rough, Nothing) {-# NOINLINE bindPhysicsMaterial_get_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). bindPhysicsMaterial_get_bounce :: MethodBind bindPhysicsMaterial_get_bounce = unsafePerformIO $ withCString "PhysicsMaterial" $ \ clsNamePtr -> withCString "get_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). get_bounce :: (PhysicsMaterial :< cls, Object :< cls) => cls -> IO Float get_bounce cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsMaterial_get_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsMaterial "get_bounce" '[] (IO Float) where nodeMethod = Godot.Core.PhysicsMaterial.get_bounce {-# NOINLINE bindPhysicsMaterial_get_friction #-} -- | The body's friction. Values range from @0@ (frictionless) to @1@ (maximum friction). bindPhysicsMaterial_get_friction :: MethodBind bindPhysicsMaterial_get_friction = unsafePerformIO $ withCString "PhysicsMaterial" $ \ clsNamePtr -> withCString "get_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction. Values range from @0@ (frictionless) to @1@ (maximum friction). get_friction :: (PhysicsMaterial :< cls, Object :< cls) => cls -> IO Float get_friction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsMaterial_get_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsMaterial "get_friction" '[] (IO Float) where nodeMethod = Godot.Core.PhysicsMaterial.get_friction {-# NOINLINE bindPhysicsMaterial_is_absorbent #-} -- | If @true@, subtracts the bounciness from the colliding object's bounciness instead of adding it. bindPhysicsMaterial_is_absorbent :: MethodBind bindPhysicsMaterial_is_absorbent = unsafePerformIO $ withCString "PhysicsMaterial" $ \ clsNamePtr -> withCString "is_absorbent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, subtracts the bounciness from the colliding object's bounciness instead of adding it. is_absorbent :: (PhysicsMaterial :< cls, Object :< cls) => cls -> IO Bool is_absorbent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsMaterial_is_absorbent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsMaterial "is_absorbent" '[] (IO Bool) where nodeMethod = Godot.Core.PhysicsMaterial.is_absorbent {-# NOINLINE bindPhysicsMaterial_is_rough #-} -- | If @true@, the physics engine will use the friction of the object marked as "rough" when two objects collide. If @false@, the physics engine will use the lowest friction of all colliding objects instead. If @true@ for both colliding objects, the physics engine will use the highest friction. bindPhysicsMaterial_is_rough :: MethodBind bindPhysicsMaterial_is_rough = unsafePerformIO $ withCString "PhysicsMaterial" $ \ clsNamePtr -> withCString "is_rough" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the physics engine will use the friction of the object marked as "rough" when two objects collide. If @false@, the physics engine will use the lowest friction of all colliding objects instead. If @true@ for both colliding objects, the physics engine will use the highest friction. is_rough :: (PhysicsMaterial :< cls, Object :< cls) => cls -> IO Bool is_rough cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsMaterial_is_rough (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsMaterial "is_rough" '[] (IO Bool) where nodeMethod = Godot.Core.PhysicsMaterial.is_rough {-# NOINLINE bindPhysicsMaterial_set_absorbent #-} -- | If @true@, subtracts the bounciness from the colliding object's bounciness instead of adding it. bindPhysicsMaterial_set_absorbent :: MethodBind bindPhysicsMaterial_set_absorbent = unsafePerformIO $ withCString "PhysicsMaterial" $ \ clsNamePtr -> withCString "set_absorbent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, subtracts the bounciness from the colliding object's bounciness instead of adding it. set_absorbent :: (PhysicsMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_absorbent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsMaterial_set_absorbent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsMaterial "set_absorbent" '[Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsMaterial.set_absorbent {-# NOINLINE bindPhysicsMaterial_set_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). bindPhysicsMaterial_set_bounce :: MethodBind bindPhysicsMaterial_set_bounce = unsafePerformIO $ withCString "PhysicsMaterial" $ \ clsNamePtr -> withCString "set_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). set_bounce :: (PhysicsMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_bounce cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsMaterial_set_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsMaterial "set_bounce" '[Float] (IO ()) where nodeMethod = Godot.Core.PhysicsMaterial.set_bounce {-# NOINLINE bindPhysicsMaterial_set_friction #-} -- | The body's friction. Values range from @0@ (frictionless) to @1@ (maximum friction). bindPhysicsMaterial_set_friction :: MethodBind bindPhysicsMaterial_set_friction = unsafePerformIO $ withCString "PhysicsMaterial" $ \ clsNamePtr -> withCString "set_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction. Values range from @0@ (frictionless) to @1@ (maximum friction). set_friction :: (PhysicsMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_friction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsMaterial_set_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsMaterial "set_friction" '[Float] (IO ()) where nodeMethod = Godot.Core.PhysicsMaterial.set_friction {-# NOINLINE bindPhysicsMaterial_set_rough #-} -- | If @true@, the physics engine will use the friction of the object marked as "rough" when two objects collide. If @false@, the physics engine will use the lowest friction of all colliding objects instead. If @true@ for both colliding objects, the physics engine will use the highest friction. bindPhysicsMaterial_set_rough :: MethodBind bindPhysicsMaterial_set_rough = unsafePerformIO $ withCString "PhysicsMaterial" $ \ clsNamePtr -> withCString "set_rough" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the physics engine will use the friction of the object marked as "rough" when two objects collide. If @false@, the physics engine will use the lowest friction of all colliding objects instead. If @true@ for both colliding objects, the physics engine will use the highest friction. set_rough :: (PhysicsMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_rough cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsMaterial_set_rough (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsMaterial "set_rough" '[Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsMaterial.set_rough ================================================ FILE: src/Godot/Core/PhysicsServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicsServer (Godot.Core.PhysicsServer._SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS, Godot.Core.PhysicsServer._JOINT_SLIDER, Godot.Core.PhysicsServer._G6DOF_JOINT_FLAG_ENABLE_MOTOR, Godot.Core.PhysicsServer._HINGE_JOINT_LIMIT_SOFTNESS, Godot.Core.PhysicsServer._G6DOF_JOINT_LINEAR_RESTITUTION, Godot.Core.PhysicsServer._CONE_TWIST_JOINT_SWING_SPAN, Godot.Core.PhysicsServer._AREA_SPACE_OVERRIDE_REPLACE, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_MOTION_RESTITUTION, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_MOTOR_FORCE_LIMIT, Godot.Core.PhysicsServer._SPACE_PARAM_TEST_MOTION_MIN_CONTACT_DEPTH, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_ORTHOGONAL_RESTITUTION, Godot.Core.PhysicsServer._SPACE_PARAM_BODY_ANGULAR_VELOCITY_DAMP_RATIO, Godot.Core.PhysicsServer._HINGE_JOINT_MOTOR_MAX_IMPULSE, Godot.Core.PhysicsServer._G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_UPPER_LIMIT, Godot.Core.PhysicsServer._BODY_PARAM_BOUNCE, Godot.Core.PhysicsServer._BODY_AXIS_ANGULAR_Y, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_LIMIT_LOWER, Godot.Core.PhysicsServer._SHAPE_CYLINDER, Godot.Core.PhysicsServer._BODY_MODE_CHARACTER, Godot.Core.PhysicsServer._SHAPE_RAY, Godot.Core.PhysicsServer._BODY_STATE_LINEAR_VELOCITY, Godot.Core.PhysicsServer._HINGE_JOINT_BIAS, Godot.Core.PhysicsServer._AREA_PARAM_LINEAR_DAMP, Godot.Core.PhysicsServer._BODY_PARAM_ANGULAR_DAMP, Godot.Core.PhysicsServer._SPACE_PARAM_BODY_TIME_TO_SLEEP, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_MOTION_SOFTNESS, Godot.Core.PhysicsServer._BODY_PARAM_LINEAR_DAMP, Godot.Core.PhysicsServer._AREA_PARAM_GRAVITY_DISTANCE_SCALE, Godot.Core.PhysicsServer._BODY_STATE_ANGULAR_VELOCITY, Godot.Core.PhysicsServer._AREA_BODY_REMOVED, Godot.Core.PhysicsServer._BODY_STATE_SLEEPING, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS, Godot.Core.PhysicsServer._INFO_ISLAND_COUNT, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_LIMIT_RESTITUTION, Godot.Core.PhysicsServer._AREA_SPACE_OVERRIDE_DISABLED, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_ORTHOGONAL_RESTITUTION, Godot.Core.PhysicsServer._AREA_PARAM_GRAVITY_IS_POINT, Godot.Core.PhysicsServer._G6DOF_JOINT_LINEAR_UPPER_LIMIT, Godot.Core.PhysicsServer._AREA_PARAM_GRAVITY_POINT_ATTENUATION, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_FORCE_LIMIT, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_LIMIT_DAMPING, Godot.Core.PhysicsServer._BODY_STATE_TRANSFORM, Godot.Core.PhysicsServer._BODY_AXIS_LINEAR_Z, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_MOTION_RESTITUTION, Godot.Core.PhysicsServer._BODY_PARAM_MASS, Godot.Core.PhysicsServer._G6DOF_JOINT_LINEAR_MOTOR_FORCE_LIMIT, Godot.Core.PhysicsServer._BODY_MODE_STATIC, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_RESTITUTION, Godot.Core.PhysicsServer._HINGE_JOINT_LIMIT_UPPER, Godot.Core.PhysicsServer._BODY_PARAM_GRAVITY_SCALE, Godot.Core.PhysicsServer._HINGE_JOINT_MOTOR_TARGET_VELOCITY, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_ORTHOGONAL_SOFTNESS, Godot.Core.PhysicsServer._PIN_JOINT_IMPULSE_CLAMP, Godot.Core.PhysicsServer._SHAPE_PLANE, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_LIMIT_UPPER, Godot.Core.PhysicsServer._AREA_PARAM_GRAVITY, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_LOWER_LIMIT, Godot.Core.PhysicsServer._HINGE_JOINT_LIMIT_RELAXATION, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS, Godot.Core.PhysicsServer._INFO_COLLISION_PAIRS, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_LIMIT_UPPER, Godot.Core.PhysicsServer._PIN_JOINT_DAMPING, Godot.Core.PhysicsServer._HINGE_JOINT_FLAG_USE_LIMIT, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_ORTHOGONAL_SOFTNESS, Godot.Core.PhysicsServer._BODY_AXIS_ANGULAR_Z, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_LIMIT_DAMPING, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_ORTHOGONAL_DAMPING, Godot.Core.PhysicsServer._INFO_ACTIVE_OBJECTS, Godot.Core.PhysicsServer._CONE_TWIST_JOINT_RELAXATION, Godot.Core.PhysicsServer._SPACE_PARAM_CONTACT_RECYCLE_RADIUS, Godot.Core.PhysicsServer._JOINT_HINGE, Godot.Core.PhysicsServer._JOINT_CONE_TWIST, Godot.Core.PhysicsServer._SPACE_PARAM_CONTACT_MAX_SEPARATION, Godot.Core.PhysicsServer._SLIDER_JOINT_MAX, Godot.Core.PhysicsServer._G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS, Godot.Core.PhysicsServer._AREA_BODY_ADDED, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_DAMPING, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_MOTION_DAMPING, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION, Godot.Core.PhysicsServer._AREA_SPACE_OVERRIDE_COMBINE_REPLACE, Godot.Core.PhysicsServer._SLIDER_JOINT_ANGULAR_MOTION_SOFTNESS, Godot.Core.PhysicsServer._JOINT_6DOF, Godot.Core.PhysicsServer._CONE_TWIST_JOINT_BIAS, Godot.Core.PhysicsServer._SHAPE_CONVEX_POLYGON, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_MOTOR_TARGET_VELOCITY, Godot.Core.PhysicsServer._AREA_PARAM_PRIORITY, Godot.Core.PhysicsServer._AREA_SPACE_OVERRIDE_REPLACE_COMBINE, Godot.Core.PhysicsServer._BODY_MODE_RIGID, Godot.Core.PhysicsServer._HINGE_JOINT_LIMIT_LOWER, Godot.Core.PhysicsServer._SPACE_PARAM_BODY_MAX_ALLOWED_PENETRATION, Godot.Core.PhysicsServer._BODY_PARAM_FRICTION, Godot.Core.PhysicsServer._SHAPE_CAPSULE, Godot.Core.PhysicsServer._AREA_PARAM_ANGULAR_DAMP, Godot.Core.PhysicsServer._G6DOF_JOINT_LINEAR_MOTOR_TARGET_VELOCITY, Godot.Core.PhysicsServer._HINGE_JOINT_FLAG_ENABLE_MOTOR, Godot.Core.PhysicsServer._SHAPE_BOX, Godot.Core.PhysicsServer._CONE_TWIST_JOINT_TWIST_SPAN, Godot.Core.PhysicsServer._BODY_MODE_KINEMATIC, Godot.Core.PhysicsServer._SHAPE_CONCAVE_POLYGON, Godot.Core.PhysicsServer._G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT, Godot.Core.PhysicsServer._HINGE_JOINT_LIMIT_BIAS, Godot.Core.PhysicsServer._G6DOF_JOINT_ANGULAR_ERP, Godot.Core.PhysicsServer._BODY_AXIS_LINEAR_Y, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_LIMIT_LOWER, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_MOTION_DAMPING, Godot.Core.PhysicsServer._G6DOF_JOINT_LINEAR_DAMPING, Godot.Core.PhysicsServer._PIN_JOINT_BIAS, Godot.Core.PhysicsServer._AREA_PARAM_GRAVITY_VECTOR, Godot.Core.PhysicsServer._SHAPE_CUSTOM, Godot.Core.PhysicsServer._BODY_STATE_CAN_SLEEP, Godot.Core.PhysicsServer._SHAPE_HEIGHTMAP, Godot.Core.PhysicsServer._BODY_PARAM_MAX, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_ORTHOGONAL_DAMPING, Godot.Core.PhysicsServer._SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD, Godot.Core.PhysicsServer._CONE_TWIST_JOINT_SOFTNESS, Godot.Core.PhysicsServer._BODY_AXIS_ANGULAR_X, Godot.Core.PhysicsServer._JOINT_PIN, Godot.Core.PhysicsServer._SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS, Godot.Core.PhysicsServer._G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR, Godot.Core.PhysicsServer._G6DOF_JOINT_LINEAR_LOWER_LIMIT, Godot.Core.PhysicsServer._BODY_AXIS_LINEAR_X, Godot.Core.PhysicsServer._SHAPE_SPHERE, Godot.Core.PhysicsServer._AREA_SPACE_OVERRIDE_COMBINE, Godot.Core.PhysicsServer._SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD, Godot.Core.PhysicsServer.area_add_shape, Godot.Core.PhysicsServer.area_attach_object_instance_id, Godot.Core.PhysicsServer.area_clear_shapes, Godot.Core.PhysicsServer.area_create, Godot.Core.PhysicsServer.area_get_object_instance_id, Godot.Core.PhysicsServer.area_get_param, Godot.Core.PhysicsServer.area_get_shape, Godot.Core.PhysicsServer.area_get_shape_count, Godot.Core.PhysicsServer.area_get_shape_transform, Godot.Core.PhysicsServer.area_get_space, Godot.Core.PhysicsServer.area_get_space_override_mode, Godot.Core.PhysicsServer.area_get_transform, Godot.Core.PhysicsServer.area_is_ray_pickable, Godot.Core.PhysicsServer.area_remove_shape, Godot.Core.PhysicsServer.area_set_area_monitor_callback, Godot.Core.PhysicsServer.area_set_collision_layer, Godot.Core.PhysicsServer.area_set_collision_mask, Godot.Core.PhysicsServer.area_set_monitor_callback, Godot.Core.PhysicsServer.area_set_monitorable, Godot.Core.PhysicsServer.area_set_param, Godot.Core.PhysicsServer.area_set_ray_pickable, Godot.Core.PhysicsServer.area_set_shape, Godot.Core.PhysicsServer.area_set_shape_disabled, Godot.Core.PhysicsServer.area_set_shape_transform, Godot.Core.PhysicsServer.area_set_space, Godot.Core.PhysicsServer.area_set_space_override_mode, Godot.Core.PhysicsServer.area_set_transform, Godot.Core.PhysicsServer.body_add_central_force, Godot.Core.PhysicsServer.body_add_collision_exception, Godot.Core.PhysicsServer.body_add_force, Godot.Core.PhysicsServer.body_add_shape, Godot.Core.PhysicsServer.body_add_torque, Godot.Core.PhysicsServer.body_apply_central_impulse, Godot.Core.PhysicsServer.body_apply_impulse, Godot.Core.PhysicsServer.body_apply_torque_impulse, Godot.Core.PhysicsServer.body_attach_object_instance_id, Godot.Core.PhysicsServer.body_clear_shapes, Godot.Core.PhysicsServer.body_create, Godot.Core.PhysicsServer.body_get_collision_layer, Godot.Core.PhysicsServer.body_get_collision_mask, Godot.Core.PhysicsServer.body_get_direct_state, Godot.Core.PhysicsServer.body_get_kinematic_safe_margin, Godot.Core.PhysicsServer.body_get_max_contacts_reported, Godot.Core.PhysicsServer.body_get_mode, Godot.Core.PhysicsServer.body_get_object_instance_id, Godot.Core.PhysicsServer.body_get_param, Godot.Core.PhysicsServer.body_get_shape, Godot.Core.PhysicsServer.body_get_shape_count, Godot.Core.PhysicsServer.body_get_shape_transform, Godot.Core.PhysicsServer.body_get_space, Godot.Core.PhysicsServer.body_get_state, Godot.Core.PhysicsServer.body_is_axis_locked, Godot.Core.PhysicsServer.body_is_continuous_collision_detection_enabled, Godot.Core.PhysicsServer.body_is_omitting_force_integration, Godot.Core.PhysicsServer.body_is_ray_pickable, Godot.Core.PhysicsServer.body_remove_collision_exception, Godot.Core.PhysicsServer.body_remove_shape, Godot.Core.PhysicsServer.body_set_axis_lock, Godot.Core.PhysicsServer.body_set_axis_velocity, Godot.Core.PhysicsServer.body_set_collision_layer, Godot.Core.PhysicsServer.body_set_collision_mask, Godot.Core.PhysicsServer.body_set_enable_continuous_collision_detection, Godot.Core.PhysicsServer.body_set_force_integration_callback, Godot.Core.PhysicsServer.body_set_kinematic_safe_margin, Godot.Core.PhysicsServer.body_set_max_contacts_reported, Godot.Core.PhysicsServer.body_set_mode, Godot.Core.PhysicsServer.body_set_omit_force_integration, Godot.Core.PhysicsServer.body_set_param, Godot.Core.PhysicsServer.body_set_ray_pickable, Godot.Core.PhysicsServer.body_set_shape, Godot.Core.PhysicsServer.body_set_shape_disabled, Godot.Core.PhysicsServer.body_set_shape_transform, Godot.Core.PhysicsServer.body_set_space, Godot.Core.PhysicsServer.body_set_state, Godot.Core.PhysicsServer.cone_twist_joint_get_param, Godot.Core.PhysicsServer.cone_twist_joint_set_param, Godot.Core.PhysicsServer.free_rid, Godot.Core.PhysicsServer.generic_6dof_joint_get_flag, Godot.Core.PhysicsServer.generic_6dof_joint_get_param, Godot.Core.PhysicsServer.generic_6dof_joint_set_flag, Godot.Core.PhysicsServer.generic_6dof_joint_set_param, Godot.Core.PhysicsServer.get_process_info, Godot.Core.PhysicsServer.hinge_joint_get_flag, Godot.Core.PhysicsServer.hinge_joint_get_param, Godot.Core.PhysicsServer.hinge_joint_set_flag, Godot.Core.PhysicsServer.hinge_joint_set_param, Godot.Core.PhysicsServer.joint_create_cone_twist, Godot.Core.PhysicsServer.joint_create_generic_6dof, Godot.Core.PhysicsServer.joint_create_hinge, Godot.Core.PhysicsServer.joint_create_pin, Godot.Core.PhysicsServer.joint_create_slider, Godot.Core.PhysicsServer.joint_get_solver_priority, Godot.Core.PhysicsServer.joint_get_type, Godot.Core.PhysicsServer.joint_set_solver_priority, Godot.Core.PhysicsServer.pin_joint_get_local_a, Godot.Core.PhysicsServer.pin_joint_get_local_b, Godot.Core.PhysicsServer.pin_joint_get_param, Godot.Core.PhysicsServer.pin_joint_set_local_a, Godot.Core.PhysicsServer.pin_joint_set_local_b, Godot.Core.PhysicsServer.pin_joint_set_param, Godot.Core.PhysicsServer.set_active, Godot.Core.PhysicsServer.shape_create, Godot.Core.PhysicsServer.shape_get_data, Godot.Core.PhysicsServer.shape_get_type, Godot.Core.PhysicsServer.shape_set_data, Godot.Core.PhysicsServer.slider_joint_get_param, Godot.Core.PhysicsServer.slider_joint_set_param, Godot.Core.PhysicsServer.space_create, Godot.Core.PhysicsServer.space_get_direct_state, Godot.Core.PhysicsServer.space_get_param, Godot.Core.PhysicsServer.space_is_active, Godot.Core.PhysicsServer.space_set_active, Godot.Core.PhysicsServer.space_set_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS :: Int _SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS = 7 _JOINT_SLIDER :: Int _JOINT_SLIDER = 2 _G6DOF_JOINT_FLAG_ENABLE_MOTOR :: Int _G6DOF_JOINT_FLAG_ENABLE_MOTOR = 4 _HINGE_JOINT_LIMIT_SOFTNESS :: Int _HINGE_JOINT_LIMIT_SOFTNESS = 4 _G6DOF_JOINT_LINEAR_RESTITUTION :: Int _G6DOF_JOINT_LINEAR_RESTITUTION = 3 _CONE_TWIST_JOINT_SWING_SPAN :: Int _CONE_TWIST_JOINT_SWING_SPAN = 0 _AREA_SPACE_OVERRIDE_REPLACE :: Int _AREA_SPACE_OVERRIDE_REPLACE = 3 _SLIDER_JOINT_LINEAR_MOTION_RESTITUTION :: Int _SLIDER_JOINT_LINEAR_MOTION_RESTITUTION = 6 _G6DOF_JOINT_ANGULAR_MOTOR_FORCE_LIMIT :: Int _G6DOF_JOINT_ANGULAR_MOTOR_FORCE_LIMIT = 18 _SPACE_PARAM_TEST_MOTION_MIN_CONTACT_DEPTH :: Int _SPACE_PARAM_TEST_MOTION_MIN_CONTACT_DEPTH = 8 _SLIDER_JOINT_LINEAR_ORTHOGONAL_RESTITUTION :: Int _SLIDER_JOINT_LINEAR_ORTHOGONAL_RESTITUTION = 9 _SPACE_PARAM_BODY_ANGULAR_VELOCITY_DAMP_RATIO :: Int _SPACE_PARAM_BODY_ANGULAR_VELOCITY_DAMP_RATIO = 6 _HINGE_JOINT_MOTOR_MAX_IMPULSE :: Int _HINGE_JOINT_MOTOR_MAX_IMPULSE = 7 _G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT :: Int _G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT = 1 _G6DOF_JOINT_ANGULAR_UPPER_LIMIT :: Int _G6DOF_JOINT_ANGULAR_UPPER_LIMIT = 11 _BODY_PARAM_BOUNCE :: Int _BODY_PARAM_BOUNCE = 0 _BODY_AXIS_ANGULAR_Y :: Int _BODY_AXIS_ANGULAR_Y = 16 _SLIDER_JOINT_ANGULAR_LIMIT_LOWER :: Int _SLIDER_JOINT_ANGULAR_LIMIT_LOWER = 12 _SHAPE_CYLINDER :: Int _SHAPE_CYLINDER = 5 _BODY_MODE_CHARACTER :: Int _BODY_MODE_CHARACTER = 3 _SHAPE_RAY :: Int _SHAPE_RAY = 1 _BODY_STATE_LINEAR_VELOCITY :: Int _BODY_STATE_LINEAR_VELOCITY = 1 _HINGE_JOINT_BIAS :: Int _HINGE_JOINT_BIAS = 0 _AREA_PARAM_LINEAR_DAMP :: Int _AREA_PARAM_LINEAR_DAMP = 5 _BODY_PARAM_ANGULAR_DAMP :: Int _BODY_PARAM_ANGULAR_DAMP = 5 _SPACE_PARAM_BODY_TIME_TO_SLEEP :: Int _SPACE_PARAM_BODY_TIME_TO_SLEEP = 5 _SLIDER_JOINT_LINEAR_MOTION_SOFTNESS :: Int _SLIDER_JOINT_LINEAR_MOTION_SOFTNESS = 5 _BODY_PARAM_LINEAR_DAMP :: Int _BODY_PARAM_LINEAR_DAMP = 4 _AREA_PARAM_GRAVITY_DISTANCE_SCALE :: Int _AREA_PARAM_GRAVITY_DISTANCE_SCALE = 3 _BODY_STATE_ANGULAR_VELOCITY :: Int _BODY_STATE_ANGULAR_VELOCITY = 2 _AREA_BODY_REMOVED :: Int _AREA_BODY_REMOVED = 1 _BODY_STATE_SLEEPING :: Int _BODY_STATE_SLEEPING = 3 _G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS :: Int _G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS = 12 _INFO_ISLAND_COUNT :: Int _INFO_ISLAND_COUNT = 2 _SLIDER_JOINT_ANGULAR_LIMIT_RESTITUTION :: Int _SLIDER_JOINT_ANGULAR_LIMIT_RESTITUTION = 14 _AREA_SPACE_OVERRIDE_DISABLED :: Int _AREA_SPACE_OVERRIDE_DISABLED = 0 _SLIDER_JOINT_ANGULAR_ORTHOGONAL_RESTITUTION :: Int _SLIDER_JOINT_ANGULAR_ORTHOGONAL_RESTITUTION = 20 _AREA_PARAM_GRAVITY_IS_POINT :: Int _AREA_PARAM_GRAVITY_IS_POINT = 2 _G6DOF_JOINT_LINEAR_UPPER_LIMIT :: Int _G6DOF_JOINT_LINEAR_UPPER_LIMIT = 1 _AREA_PARAM_GRAVITY_POINT_ATTENUATION :: Int _AREA_PARAM_GRAVITY_POINT_ATTENUATION = 4 _G6DOF_JOINT_ANGULAR_FORCE_LIMIT :: Int _G6DOF_JOINT_ANGULAR_FORCE_LIMIT = 15 _SLIDER_JOINT_LINEAR_LIMIT_DAMPING :: Int _SLIDER_JOINT_LINEAR_LIMIT_DAMPING = 4 _BODY_STATE_TRANSFORM :: Int _BODY_STATE_TRANSFORM = 0 _BODY_AXIS_LINEAR_Z :: Int _BODY_AXIS_LINEAR_Z = 4 _SLIDER_JOINT_ANGULAR_MOTION_RESTITUTION :: Int _SLIDER_JOINT_ANGULAR_MOTION_RESTITUTION = 17 _BODY_PARAM_MASS :: Int _BODY_PARAM_MASS = 2 _G6DOF_JOINT_LINEAR_MOTOR_FORCE_LIMIT :: Int _G6DOF_JOINT_LINEAR_MOTOR_FORCE_LIMIT = 6 _BODY_MODE_STATIC :: Int _BODY_MODE_STATIC = 0 _G6DOF_JOINT_ANGULAR_RESTITUTION :: Int _G6DOF_JOINT_ANGULAR_RESTITUTION = 14 _HINGE_JOINT_LIMIT_UPPER :: Int _HINGE_JOINT_LIMIT_UPPER = 1 _BODY_PARAM_GRAVITY_SCALE :: Int _BODY_PARAM_GRAVITY_SCALE = 3 _HINGE_JOINT_MOTOR_TARGET_VELOCITY :: Int _HINGE_JOINT_MOTOR_TARGET_VELOCITY = 6 _SLIDER_JOINT_LINEAR_ORTHOGONAL_SOFTNESS :: Int _SLIDER_JOINT_LINEAR_ORTHOGONAL_SOFTNESS = 8 _PIN_JOINT_IMPULSE_CLAMP :: Int _PIN_JOINT_IMPULSE_CLAMP = 2 _SHAPE_PLANE :: Int _SHAPE_PLANE = 0 _SLIDER_JOINT_ANGULAR_LIMIT_UPPER :: Int _SLIDER_JOINT_ANGULAR_LIMIT_UPPER = 11 _AREA_PARAM_GRAVITY :: Int _AREA_PARAM_GRAVITY = 0 _G6DOF_JOINT_ANGULAR_LOWER_LIMIT :: Int _G6DOF_JOINT_ANGULAR_LOWER_LIMIT = 10 _HINGE_JOINT_LIMIT_RELAXATION :: Int _HINGE_JOINT_LIMIT_RELAXATION = 5 _SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS :: Int _SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS = 13 _INFO_COLLISION_PAIRS :: Int _INFO_COLLISION_PAIRS = 1 _SLIDER_JOINT_LINEAR_LIMIT_UPPER :: Int _SLIDER_JOINT_LINEAR_LIMIT_UPPER = 0 _PIN_JOINT_DAMPING :: Int _PIN_JOINT_DAMPING = 1 _HINGE_JOINT_FLAG_USE_LIMIT :: Int _HINGE_JOINT_FLAG_USE_LIMIT = 0 _SLIDER_JOINT_ANGULAR_ORTHOGONAL_SOFTNESS :: Int _SLIDER_JOINT_ANGULAR_ORTHOGONAL_SOFTNESS = 19 _BODY_AXIS_ANGULAR_Z :: Int _BODY_AXIS_ANGULAR_Z = 32 _SLIDER_JOINT_ANGULAR_LIMIT_DAMPING :: Int _SLIDER_JOINT_ANGULAR_LIMIT_DAMPING = 15 _SLIDER_JOINT_ANGULAR_ORTHOGONAL_DAMPING :: Int _SLIDER_JOINT_ANGULAR_ORTHOGONAL_DAMPING = 21 _INFO_ACTIVE_OBJECTS :: Int _INFO_ACTIVE_OBJECTS = 0 _CONE_TWIST_JOINT_RELAXATION :: Int _CONE_TWIST_JOINT_RELAXATION = 4 _SPACE_PARAM_CONTACT_RECYCLE_RADIUS :: Int _SPACE_PARAM_CONTACT_RECYCLE_RADIUS = 0 _JOINT_HINGE :: Int _JOINT_HINGE = 1 _JOINT_CONE_TWIST :: Int _JOINT_CONE_TWIST = 3 _SPACE_PARAM_CONTACT_MAX_SEPARATION :: Int _SPACE_PARAM_CONTACT_MAX_SEPARATION = 1 _SLIDER_JOINT_MAX :: Int _SLIDER_JOINT_MAX = 22 _G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS :: Int _G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS = 2 _AREA_BODY_ADDED :: Int _AREA_BODY_ADDED = 0 _G6DOF_JOINT_ANGULAR_DAMPING :: Int _G6DOF_JOINT_ANGULAR_DAMPING = 13 _SLIDER_JOINT_ANGULAR_MOTION_DAMPING :: Int _SLIDER_JOINT_ANGULAR_MOTION_DAMPING = 18 _SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION :: Int _SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION = 3 _AREA_SPACE_OVERRIDE_COMBINE_REPLACE :: Int _AREA_SPACE_OVERRIDE_COMBINE_REPLACE = 2 _SLIDER_JOINT_ANGULAR_MOTION_SOFTNESS :: Int _SLIDER_JOINT_ANGULAR_MOTION_SOFTNESS = 16 _JOINT_6DOF :: Int _JOINT_6DOF = 4 _CONE_TWIST_JOINT_BIAS :: Int _CONE_TWIST_JOINT_BIAS = 2 _SHAPE_CONVEX_POLYGON :: Int _SHAPE_CONVEX_POLYGON = 6 _G6DOF_JOINT_ANGULAR_MOTOR_TARGET_VELOCITY :: Int _G6DOF_JOINT_ANGULAR_MOTOR_TARGET_VELOCITY = 17 _AREA_PARAM_PRIORITY :: Int _AREA_PARAM_PRIORITY = 7 _AREA_SPACE_OVERRIDE_REPLACE_COMBINE :: Int _AREA_SPACE_OVERRIDE_REPLACE_COMBINE = 4 _BODY_MODE_RIGID :: Int _BODY_MODE_RIGID = 2 _HINGE_JOINT_LIMIT_LOWER :: Int _HINGE_JOINT_LIMIT_LOWER = 2 _SPACE_PARAM_BODY_MAX_ALLOWED_PENETRATION :: Int _SPACE_PARAM_BODY_MAX_ALLOWED_PENETRATION = 2 _BODY_PARAM_FRICTION :: Int _BODY_PARAM_FRICTION = 1 _SHAPE_CAPSULE :: Int _SHAPE_CAPSULE = 4 _AREA_PARAM_ANGULAR_DAMP :: Int _AREA_PARAM_ANGULAR_DAMP = 6 _G6DOF_JOINT_LINEAR_MOTOR_TARGET_VELOCITY :: Int _G6DOF_JOINT_LINEAR_MOTOR_TARGET_VELOCITY = 5 _HINGE_JOINT_FLAG_ENABLE_MOTOR :: Int _HINGE_JOINT_FLAG_ENABLE_MOTOR = 1 _SHAPE_BOX :: Int _SHAPE_BOX = 3 _CONE_TWIST_JOINT_TWIST_SPAN :: Int _CONE_TWIST_JOINT_TWIST_SPAN = 1 _BODY_MODE_KINEMATIC :: Int _BODY_MODE_KINEMATIC = 1 _SHAPE_CONCAVE_POLYGON :: Int _SHAPE_CONCAVE_POLYGON = 7 _G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT :: Int _G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT = 0 _HINGE_JOINT_LIMIT_BIAS :: Int _HINGE_JOINT_LIMIT_BIAS = 3 _G6DOF_JOINT_ANGULAR_ERP :: Int _G6DOF_JOINT_ANGULAR_ERP = 16 _BODY_AXIS_LINEAR_Y :: Int _BODY_AXIS_LINEAR_Y = 2 _SLIDER_JOINT_LINEAR_LIMIT_LOWER :: Int _SLIDER_JOINT_LINEAR_LIMIT_LOWER = 1 _SLIDER_JOINT_LINEAR_MOTION_DAMPING :: Int _SLIDER_JOINT_LINEAR_MOTION_DAMPING = 7 _G6DOF_JOINT_LINEAR_DAMPING :: Int _G6DOF_JOINT_LINEAR_DAMPING = 4 _PIN_JOINT_BIAS :: Int _PIN_JOINT_BIAS = 0 _AREA_PARAM_GRAVITY_VECTOR :: Int _AREA_PARAM_GRAVITY_VECTOR = 1 _SHAPE_CUSTOM :: Int _SHAPE_CUSTOM = 9 _BODY_STATE_CAN_SLEEP :: Int _BODY_STATE_CAN_SLEEP = 4 _SHAPE_HEIGHTMAP :: Int _SHAPE_HEIGHTMAP = 8 _BODY_PARAM_MAX :: Int _BODY_PARAM_MAX = 6 _SLIDER_JOINT_LINEAR_ORTHOGONAL_DAMPING :: Int _SLIDER_JOINT_LINEAR_ORTHOGONAL_DAMPING = 10 _SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD :: Int _SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD = 4 _CONE_TWIST_JOINT_SOFTNESS :: Int _CONE_TWIST_JOINT_SOFTNESS = 3 _BODY_AXIS_ANGULAR_X :: Int _BODY_AXIS_ANGULAR_X = 8 _JOINT_PIN :: Int _JOINT_PIN = 0 _SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS :: Int _SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS = 2 _G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR :: Int _G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR = 5 _G6DOF_JOINT_LINEAR_LOWER_LIMIT :: Int _G6DOF_JOINT_LINEAR_LOWER_LIMIT = 0 _BODY_AXIS_LINEAR_X :: Int _BODY_AXIS_LINEAR_X = 1 _SHAPE_SPHERE :: Int _SHAPE_SPHERE = 2 _AREA_SPACE_OVERRIDE_COMBINE :: Int _AREA_SPACE_OVERRIDE_COMBINE = 1 _SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD :: Int _SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD = 3 {-# NOINLINE bindPhysicsServer_area_add_shape #-} -- | Adds a shape to the area, along with a transform matrix. Shapes are usually referenced by their index, so you should track which shape has a given index. bindPhysicsServer_area_add_shape :: MethodBind bindPhysicsServer_area_add_shape = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_add_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a shape to the area, along with a transform matrix. Shapes are usually referenced by their index, so you should track which shape has a given index. area_add_shape :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Maybe Transform -> Maybe Bool -> IO () area_add_shape cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantTransform (TF (V3 (V3 1 0 0) (V3 0 1 0) (V3 0 0 1)) (V3 0 0 0)) arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_add_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_add_shape" '[Rid, Rid, Maybe Transform, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_add_shape {-# NOINLINE bindPhysicsServer_area_attach_object_instance_id #-} -- | Assigns the area to a descendant of @Object@, so it can exist in the node tree. bindPhysicsServer_area_attach_object_instance_id :: MethodBind bindPhysicsServer_area_attach_object_instance_id = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_attach_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns the area to a descendant of @Object@, so it can exist in the node tree. area_attach_object_instance_id :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_attach_object_instance_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_attach_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_attach_object_instance_id" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_attach_object_instance_id {-# NOINLINE bindPhysicsServer_area_clear_shapes #-} -- | Removes all shapes from an area. It does not delete the shapes, so they can be reassigned later. bindPhysicsServer_area_clear_shapes :: MethodBind bindPhysicsServer_area_clear_shapes = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_clear_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all shapes from an area. It does not delete the shapes, so they can be reassigned later. area_clear_shapes :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO () area_clear_shapes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_clear_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_clear_shapes" '[Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_clear_shapes {-# NOINLINE bindPhysicsServer_area_create #-} -- | Creates an @Area@. bindPhysicsServer_area_create :: MethodBind bindPhysicsServer_area_create = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an @Area@. area_create :: (PhysicsServer :< cls, Object :< cls) => cls -> IO Rid area_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_create" '[] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.area_create {-# NOINLINE bindPhysicsServer_area_get_object_instance_id #-} -- | Gets the instance ID of the object the area is assigned to. bindPhysicsServer_area_get_object_instance_id :: MethodBind bindPhysicsServer_area_get_object_instance_id = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_get_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the instance ID of the object the area is assigned to. area_get_object_instance_id :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int area_get_object_instance_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_get_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_get_object_instance_id" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.area_get_object_instance_id {-# NOINLINE bindPhysicsServer_area_get_param #-} -- | Returns an area parameter value. A list of available parameters is on the @enum AreaParameter@ constants. bindPhysicsServer_area_get_param :: MethodBind bindPhysicsServer_area_get_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an area parameter value. A list of available parameters is on the @enum AreaParameter@ constants. area_get_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO GodotVariant area_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_get_param" '[Rid, Int] (IO GodotVariant) where nodeMethod = Godot.Core.PhysicsServer.area_get_param {-# NOINLINE bindPhysicsServer_area_get_shape #-} -- | Returns the @RID@ of the nth shape of an area. bindPhysicsServer_area_get_shape :: MethodBind bindPhysicsServer_area_get_shape = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the nth shape of an area. area_get_shape :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Rid area_get_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_get_shape" '[Rid, Int] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.area_get_shape {-# NOINLINE bindPhysicsServer_area_get_shape_count #-} -- | Returns the number of shapes assigned to an area. bindPhysicsServer_area_get_shape_count :: MethodBind bindPhysicsServer_area_get_shape_count = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_get_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of shapes assigned to an area. area_get_shape_count :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int area_get_shape_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_get_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_get_shape_count" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.area_get_shape_count {-# NOINLINE bindPhysicsServer_area_get_shape_transform #-} -- | Returns the transform matrix of a shape within an area. bindPhysicsServer_area_get_shape_transform :: MethodBind bindPhysicsServer_area_get_shape_transform = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_get_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform matrix of a shape within an area. area_get_shape_transform :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Transform area_get_shape_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_get_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_get_shape_transform" '[Rid, Int] (IO Transform) where nodeMethod = Godot.Core.PhysicsServer.area_get_shape_transform {-# NOINLINE bindPhysicsServer_area_get_space #-} -- | Returns the space assigned to the area. bindPhysicsServer_area_get_space :: MethodBind bindPhysicsServer_area_get_space = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_get_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the space assigned to the area. area_get_space :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Rid area_get_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_get_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_get_space" '[Rid] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.area_get_space {-# NOINLINE bindPhysicsServer_area_get_space_override_mode #-} -- | Returns the space override mode for the area. bindPhysicsServer_area_get_space_override_mode :: MethodBind bindPhysicsServer_area_get_space_override_mode = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_get_space_override_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the space override mode for the area. area_get_space_override_mode :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int area_get_space_override_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_get_space_override_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_get_space_override_mode" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.area_get_space_override_mode {-# NOINLINE bindPhysicsServer_area_get_transform #-} -- | Returns the transform matrix for an area. bindPhysicsServer_area_get_transform :: MethodBind bindPhysicsServer_area_get_transform = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform matrix for an area. area_get_transform :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Transform area_get_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_get_transform" '[Rid] (IO Transform) where nodeMethod = Godot.Core.PhysicsServer.area_get_transform {-# NOINLINE bindPhysicsServer_area_is_ray_pickable #-} -- | If @true@, area collides with rays. bindPhysicsServer_area_is_ray_pickable :: MethodBind bindPhysicsServer_area_is_ray_pickable = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_is_ray_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, area collides with rays. area_is_ray_pickable :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Bool area_is_ray_pickable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_is_ray_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_is_ray_pickable" '[Rid] (IO Bool) where nodeMethod = Godot.Core.PhysicsServer.area_is_ray_pickable {-# NOINLINE bindPhysicsServer_area_remove_shape #-} -- | Removes a shape from an area. It does not delete the shape, so it can be reassigned later. bindPhysicsServer_area_remove_shape :: MethodBind bindPhysicsServer_area_remove_shape = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_remove_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a shape from an area. It does not delete the shape, so it can be reassigned later. area_remove_shape :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_remove_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_remove_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_remove_shape" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_remove_shape {-# NOINLINE bindPhysicsServer_area_set_area_monitor_callback #-} bindPhysicsServer_area_set_area_monitor_callback :: MethodBind bindPhysicsServer_area_set_area_monitor_callback = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_area_monitor_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr area_set_area_monitor_callback :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Object -> GodotString -> IO () area_set_area_monitor_callback cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_area_monitor_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_area_monitor_callback" '[Rid, Object, GodotString] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_area_monitor_callback {-# NOINLINE bindPhysicsServer_area_set_collision_layer #-} -- | Assigns the area to one or many physics layers. bindPhysicsServer_area_set_collision_layer :: MethodBind bindPhysicsServer_area_set_collision_layer = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns the area to one or many physics layers. area_set_collision_layer :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_set_collision_layer cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_collision_layer" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_collision_layer {-# NOINLINE bindPhysicsServer_area_set_collision_mask #-} -- | Sets which physics layers the area will monitor. bindPhysicsServer_area_set_collision_mask :: MethodBind bindPhysicsServer_area_set_collision_mask = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets which physics layers the area will monitor. area_set_collision_mask :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_set_collision_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_collision_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_collision_mask {-# NOINLINE bindPhysicsServer_area_set_monitor_callback #-} -- | Sets the function to call when any body/area enters or exits the area. This callback will be called for any object interacting with the area, and takes five parameters: -- 1: @AREA_BODY_ADDED@ or @AREA_BODY_REMOVED@, depending on whether the object entered or exited the area. -- 2: @RID@ of the object that entered/exited the area. -- 3: Instance ID of the object that entered/exited the area. -- 4: The shape index of the object that entered/exited the area. -- 5: The shape index of the area where the object entered/exited. bindPhysicsServer_area_set_monitor_callback :: MethodBind bindPhysicsServer_area_set_monitor_callback = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_monitor_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the function to call when any body/area enters or exits the area. This callback will be called for any object interacting with the area, and takes five parameters: -- 1: @AREA_BODY_ADDED@ or @AREA_BODY_REMOVED@, depending on whether the object entered or exited the area. -- 2: @RID@ of the object that entered/exited the area. -- 3: Instance ID of the object that entered/exited the area. -- 4: The shape index of the object that entered/exited the area. -- 5: The shape index of the area where the object entered/exited. area_set_monitor_callback :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Object -> GodotString -> IO () area_set_monitor_callback cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_monitor_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_monitor_callback" '[Rid, Object, GodotString] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_monitor_callback {-# NOINLINE bindPhysicsServer_area_set_monitorable #-} bindPhysicsServer_area_set_monitorable :: MethodBind bindPhysicsServer_area_set_monitorable = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_monitorable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr area_set_monitorable :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () area_set_monitorable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_monitorable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_monitorable" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_monitorable {-# NOINLINE bindPhysicsServer_area_set_param #-} -- | Sets the value for an area parameter. A list of available parameters is on the @enum AreaParameter@ constants. bindPhysicsServer_area_set_param :: MethodBind bindPhysicsServer_area_set_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value for an area parameter. A list of available parameters is on the @enum AreaParameter@ constants. area_set_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> GodotVariant -> IO () area_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_param" '[Rid, Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_param {-# NOINLINE bindPhysicsServer_area_set_ray_pickable #-} -- | Sets object pickable with rays. bindPhysicsServer_area_set_ray_pickable :: MethodBind bindPhysicsServer_area_set_ray_pickable = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_ray_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets object pickable with rays. area_set_ray_pickable :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () area_set_ray_pickable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_ray_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_ray_pickable" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_ray_pickable {-# NOINLINE bindPhysicsServer_area_set_shape #-} -- | Substitutes a given area shape by another. The old shape is selected by its index, the new one by its @RID@. bindPhysicsServer_area_set_shape :: MethodBind bindPhysicsServer_area_set_shape = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Substitutes a given area shape by another. The old shape is selected by its index, the new one by its @RID@. area_set_shape :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Rid -> IO () area_set_shape cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_shape" '[Rid, Int, Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_shape {-# NOINLINE bindPhysicsServer_area_set_shape_disabled #-} bindPhysicsServer_area_set_shape_disabled :: MethodBind bindPhysicsServer_area_set_shape_disabled = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_shape_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr area_set_shape_disabled :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Bool -> IO () area_set_shape_disabled cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_shape_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_shape_disabled" '[Rid, Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_shape_disabled {-# NOINLINE bindPhysicsServer_area_set_shape_transform #-} -- | Sets the transform matrix for an area shape. bindPhysicsServer_area_set_shape_transform :: MethodBind bindPhysicsServer_area_set_shape_transform = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform matrix for an area shape. area_set_shape_transform :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Transform -> IO () area_set_shape_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_shape_transform" '[Rid, Int, Transform] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_shape_transform {-# NOINLINE bindPhysicsServer_area_set_space #-} -- | Assigns a space to the area. bindPhysicsServer_area_set_space :: MethodBind bindPhysicsServer_area_set_space = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a space to the area. area_set_space :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () area_set_space cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_space" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_space {-# NOINLINE bindPhysicsServer_area_set_space_override_mode #-} -- | Sets the space override mode for the area. The modes are described in the @enum AreaSpaceOverrideMode@ constants. bindPhysicsServer_area_set_space_override_mode :: MethodBind bindPhysicsServer_area_set_space_override_mode = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_space_override_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the space override mode for the area. The modes are described in the @enum AreaSpaceOverrideMode@ constants. area_set_space_override_mode :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () area_set_space_override_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_space_override_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_space_override_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_space_override_mode {-# NOINLINE bindPhysicsServer_area_set_transform #-} -- | Sets the transform matrix for an area. bindPhysicsServer_area_set_transform :: MethodBind bindPhysicsServer_area_set_transform = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "area_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform matrix for an area. area_set_transform :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Transform -> IO () area_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_area_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "area_set_transform" '[Rid, Transform] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.area_set_transform {-# NOINLINE bindPhysicsServer_body_add_central_force #-} bindPhysicsServer_body_add_central_force :: MethodBind bindPhysicsServer_body_add_central_force = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_add_central_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_add_central_force :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () body_add_central_force cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_add_central_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_add_central_force" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_add_central_force {-# NOINLINE bindPhysicsServer_body_add_collision_exception #-} -- | Adds a body to the list of bodies exempt from collisions. bindPhysicsServer_body_add_collision_exception :: MethodBind bindPhysicsServer_body_add_collision_exception = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_add_collision_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a body to the list of bodies exempt from collisions. body_add_collision_exception :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () body_add_collision_exception cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_add_collision_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_add_collision_exception" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_add_collision_exception {-# NOINLINE bindPhysicsServer_body_add_force #-} bindPhysicsServer_body_add_force :: MethodBind bindPhysicsServer_body_add_force = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_add_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_add_force :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> Vector3 -> IO () body_add_force cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_add_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_add_force" '[Rid, Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_add_force {-# NOINLINE bindPhysicsServer_body_add_shape #-} -- | Adds a shape to the body, along with a transform matrix. Shapes are usually referenced by their index, so you should track which shape has a given index. bindPhysicsServer_body_add_shape :: MethodBind bindPhysicsServer_body_add_shape = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_add_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a shape to the body, along with a transform matrix. Shapes are usually referenced by their index, so you should track which shape has a given index. body_add_shape :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Maybe Transform -> Maybe Bool -> IO () body_add_shape cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantTransform (TF (V3 (V3 1 0 0) (V3 0 1 0) (V3 0 0 1)) (V3 0 0 0)) arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_add_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_add_shape" '[Rid, Rid, Maybe Transform, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_add_shape {-# NOINLINE bindPhysicsServer_body_add_torque #-} bindPhysicsServer_body_add_torque :: MethodBind bindPhysicsServer_body_add_torque = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_add_torque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_add_torque :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () body_add_torque cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_add_torque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_add_torque" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_add_torque {-# NOINLINE bindPhysicsServer_body_apply_central_impulse #-} bindPhysicsServer_body_apply_central_impulse :: MethodBind bindPhysicsServer_body_apply_central_impulse = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_apply_central_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_apply_central_impulse :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () body_apply_central_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_apply_central_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_apply_central_impulse" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_apply_central_impulse {-# NOINLINE bindPhysicsServer_body_apply_impulse #-} -- | Gives the body a push at a @position@ in the direction of the @impulse@. bindPhysicsServer_body_apply_impulse :: MethodBind bindPhysicsServer_body_apply_impulse = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_apply_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gives the body a push at a @position@ in the direction of the @impulse@. body_apply_impulse :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> Vector3 -> IO () body_apply_impulse cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_apply_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_apply_impulse" '[Rid, Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_apply_impulse {-# NOINLINE bindPhysicsServer_body_apply_torque_impulse #-} -- | Gives the body a push to rotate it. bindPhysicsServer_body_apply_torque_impulse :: MethodBind bindPhysicsServer_body_apply_torque_impulse = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_apply_torque_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gives the body a push to rotate it. body_apply_torque_impulse :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () body_apply_torque_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_apply_torque_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_apply_torque_impulse" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_apply_torque_impulse {-# NOINLINE bindPhysicsServer_body_attach_object_instance_id #-} -- | Assigns the area to a descendant of @Object@, so it can exist in the node tree. bindPhysicsServer_body_attach_object_instance_id :: MethodBind bindPhysicsServer_body_attach_object_instance_id = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_attach_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns the area to a descendant of @Object@, so it can exist in the node tree. body_attach_object_instance_id :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_attach_object_instance_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_attach_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_attach_object_instance_id" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_attach_object_instance_id {-# NOINLINE bindPhysicsServer_body_clear_shapes #-} -- | Removes all shapes from a body. bindPhysicsServer_body_clear_shapes :: MethodBind bindPhysicsServer_body_clear_shapes = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_clear_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all shapes from a body. body_clear_shapes :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO () body_clear_shapes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_clear_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_clear_shapes" '[Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_clear_shapes {-# NOINLINE bindPhysicsServer_body_create #-} -- | Creates a physics body. The first parameter can be any value from @enum BodyMode@ constants, for the type of body created. Additionally, the body can be created in sleeping state to save processing time. bindPhysicsServer_body_create :: MethodBind bindPhysicsServer_body_create = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a physics body. The first parameter can be any value from @enum BodyMode@ constants, for the type of body created. Additionally, the body can be created in sleeping state to save processing time. body_create :: (PhysicsServer :< cls, Object :< cls) => cls -> Maybe Int -> Maybe Bool -> IO Rid body_create cls arg1 arg2 = withVariantArray [maybe (VariantInt (2)) toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_create" '[Maybe Int, Maybe Bool] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.body_create {-# NOINLINE bindPhysicsServer_body_get_collision_layer #-} -- | Returns the physics layer or layers a body belongs to. bindPhysicsServer_body_get_collision_layer :: MethodBind bindPhysicsServer_body_get_collision_layer = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the physics layer or layers a body belongs to. body_get_collision_layer :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_collision_layer" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.body_get_collision_layer {-# NOINLINE bindPhysicsServer_body_get_collision_mask #-} -- | Returns the physics layer or layers a body can collide with. -- - bindPhysicsServer_body_get_collision_mask :: MethodBind bindPhysicsServer_body_get_collision_mask = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the physics layer or layers a body can collide with. -- - body_get_collision_mask :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_collision_mask" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.body_get_collision_mask {-# NOINLINE bindPhysicsServer_body_get_direct_state #-} -- | Returns the @PhysicsDirectBodyState@ of the body. bindPhysicsServer_body_get_direct_state :: MethodBind bindPhysicsServer_body_get_direct_state = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_direct_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @PhysicsDirectBodyState@ of the body. body_get_direct_state :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO PhysicsDirectBodyState body_get_direct_state cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_direct_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_direct_state" '[Rid] (IO PhysicsDirectBodyState) where nodeMethod = Godot.Core.PhysicsServer.body_get_direct_state {-# NOINLINE bindPhysicsServer_body_get_kinematic_safe_margin #-} bindPhysicsServer_body_get_kinematic_safe_margin :: MethodBind bindPhysicsServer_body_get_kinematic_safe_margin = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_kinematic_safe_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_get_kinematic_safe_margin :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Float body_get_kinematic_safe_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_kinematic_safe_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_kinematic_safe_margin" '[Rid] (IO Float) where nodeMethod = Godot.Core.PhysicsServer.body_get_kinematic_safe_margin {-# NOINLINE bindPhysicsServer_body_get_max_contacts_reported #-} -- | Returns the maximum contacts that can be reported. See @method body_set_max_contacts_reported@. bindPhysicsServer_body_get_max_contacts_reported :: MethodBind bindPhysicsServer_body_get_max_contacts_reported = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_max_contacts_reported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the maximum contacts that can be reported. See @method body_set_max_contacts_reported@. body_get_max_contacts_reported :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_max_contacts_reported cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_max_contacts_reported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_max_contacts_reported" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.body_get_max_contacts_reported {-# NOINLINE bindPhysicsServer_body_get_mode #-} -- | Returns the body mode. bindPhysicsServer_body_get_mode :: MethodBind bindPhysicsServer_body_get_mode = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the body mode. body_get_mode :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_mode" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.body_get_mode {-# NOINLINE bindPhysicsServer_body_get_object_instance_id #-} -- | Gets the instance ID of the object the area is assigned to. bindPhysicsServer_body_get_object_instance_id :: MethodBind bindPhysicsServer_body_get_object_instance_id = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the instance ID of the object the area is assigned to. body_get_object_instance_id :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_object_instance_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_object_instance_id" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.body_get_object_instance_id {-# NOINLINE bindPhysicsServer_body_get_param #-} -- | Returns the value of a body parameter. A list of available parameters is on the @enum BodyParameter@ constants. bindPhysicsServer_body_get_param :: MethodBind bindPhysicsServer_body_get_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a body parameter. A list of available parameters is on the @enum BodyParameter@ constants. body_get_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float body_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.PhysicsServer.body_get_param {-# NOINLINE bindPhysicsServer_body_get_shape #-} -- | Returns the @RID@ of the nth shape of a body. bindPhysicsServer_body_get_shape :: MethodBind bindPhysicsServer_body_get_shape = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the nth shape of a body. body_get_shape :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Rid body_get_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_shape" '[Rid, Int] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.body_get_shape {-# NOINLINE bindPhysicsServer_body_get_shape_count #-} -- | Returns the number of shapes assigned to a body. bindPhysicsServer_body_get_shape_count :: MethodBind bindPhysicsServer_body_get_shape_count = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of shapes assigned to a body. body_get_shape_count :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int body_get_shape_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_shape_count" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.body_get_shape_count {-# NOINLINE bindPhysicsServer_body_get_shape_transform #-} -- | Returns the transform matrix of a body shape. bindPhysicsServer_body_get_shape_transform :: MethodBind bindPhysicsServer_body_get_shape_transform = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transform matrix of a body shape. body_get_shape_transform :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Transform body_get_shape_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_shape_transform" '[Rid, Int] (IO Transform) where nodeMethod = Godot.Core.PhysicsServer.body_get_shape_transform {-# NOINLINE bindPhysicsServer_body_get_space #-} -- | Returns the @RID@ of the space assigned to a body. bindPhysicsServer_body_get_space :: MethodBind bindPhysicsServer_body_get_space = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the space assigned to a body. body_get_space :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Rid body_get_space cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_space" '[Rid] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.body_get_space {-# NOINLINE bindPhysicsServer_body_get_state #-} -- | Returns a body state. bindPhysicsServer_body_get_state :: MethodBind bindPhysicsServer_body_get_state = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_get_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a body state. body_get_state :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO GodotVariant body_get_state cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_get_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_get_state" '[Rid, Int] (IO GodotVariant) where nodeMethod = Godot.Core.PhysicsServer.body_get_state {-# NOINLINE bindPhysicsServer_body_is_axis_locked #-} bindPhysicsServer_body_is_axis_locked :: MethodBind bindPhysicsServer_body_is_axis_locked = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_is_axis_locked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_is_axis_locked :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Bool body_is_axis_locked cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_is_axis_locked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_is_axis_locked" '[Rid, Int] (IO Bool) where nodeMethod = Godot.Core.PhysicsServer.body_is_axis_locked {-# NOINLINE bindPhysicsServer_body_is_continuous_collision_detection_enabled #-} -- | If @true@, the continuous collision detection mode is enabled. bindPhysicsServer_body_is_continuous_collision_detection_enabled :: MethodBind bindPhysicsServer_body_is_continuous_collision_detection_enabled = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_is_continuous_collision_detection_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the continuous collision detection mode is enabled. body_is_continuous_collision_detection_enabled :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Bool body_is_continuous_collision_detection_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_is_continuous_collision_detection_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_is_continuous_collision_detection_enabled" '[Rid] (IO Bool) where nodeMethod = Godot.Core.PhysicsServer.body_is_continuous_collision_detection_enabled {-# NOINLINE bindPhysicsServer_body_is_omitting_force_integration #-} -- | Returns whether a body uses a callback function to calculate its own physics (see @method body_set_force_integration_callback@). bindPhysicsServer_body_is_omitting_force_integration :: MethodBind bindPhysicsServer_body_is_omitting_force_integration = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_is_omitting_force_integration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a body uses a callback function to calculate its own physics (see @method body_set_force_integration_callback@). body_is_omitting_force_integration :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Bool body_is_omitting_force_integration cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_is_omitting_force_integration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_is_omitting_force_integration" '[Rid] (IO Bool) where nodeMethod = Godot.Core.PhysicsServer.body_is_omitting_force_integration {-# NOINLINE bindPhysicsServer_body_is_ray_pickable #-} -- | If @true@, the body can be detected by rays. bindPhysicsServer_body_is_ray_pickable :: MethodBind bindPhysicsServer_body_is_ray_pickable = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_is_ray_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body can be detected by rays. body_is_ray_pickable :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Bool body_is_ray_pickable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_is_ray_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_is_ray_pickable" '[Rid] (IO Bool) where nodeMethod = Godot.Core.PhysicsServer.body_is_ray_pickable {-# NOINLINE bindPhysicsServer_body_remove_collision_exception #-} -- | Removes a body from the list of bodies exempt from collisions. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. bindPhysicsServer_body_remove_collision_exception :: MethodBind bindPhysicsServer_body_remove_collision_exception = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_remove_collision_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a body from the list of bodies exempt from collisions. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. body_remove_collision_exception :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () body_remove_collision_exception cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_remove_collision_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_remove_collision_exception" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_remove_collision_exception {-# NOINLINE bindPhysicsServer_body_remove_shape #-} -- | Removes a shape from a body. The shape is not deleted, so it can be reused afterwards. bindPhysicsServer_body_remove_shape :: MethodBind bindPhysicsServer_body_remove_shape = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_remove_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a shape from a body. The shape is not deleted, so it can be reused afterwards. body_remove_shape :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_remove_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_remove_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_remove_shape" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_remove_shape {-# NOINLINE bindPhysicsServer_body_set_axis_lock #-} bindPhysicsServer_body_set_axis_lock :: MethodBind bindPhysicsServer_body_set_axis_lock = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_axis_lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_set_axis_lock :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Bool -> IO () body_set_axis_lock cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_axis_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_axis_lock" '[Rid, Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_axis_lock {-# NOINLINE bindPhysicsServer_body_set_axis_velocity #-} -- | Sets an axis velocity. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior. bindPhysicsServer_body_set_axis_velocity :: MethodBind bindPhysicsServer_body_set_axis_velocity = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_axis_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an axis velocity. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior. body_set_axis_velocity :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () body_set_axis_velocity cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_axis_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_axis_velocity" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_axis_velocity {-# NOINLINE bindPhysicsServer_body_set_collision_layer #-} -- | Sets the physics layer or layers a body belongs to. bindPhysicsServer_body_set_collision_layer :: MethodBind bindPhysicsServer_body_set_collision_layer = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the physics layer or layers a body belongs to. body_set_collision_layer :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_collision_layer cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_collision_layer" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_collision_layer {-# NOINLINE bindPhysicsServer_body_set_collision_mask #-} -- | Sets the physics layer or layers a body can collide with. bindPhysicsServer_body_set_collision_mask :: MethodBind bindPhysicsServer_body_set_collision_mask = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the physics layer or layers a body can collide with. body_set_collision_mask :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_collision_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_collision_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_collision_mask {-# NOINLINE bindPhysicsServer_body_set_enable_continuous_collision_detection #-} -- | If @true@, the continuous collision detection mode is enabled. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. bindPhysicsServer_body_set_enable_continuous_collision_detection :: MethodBind bindPhysicsServer_body_set_enable_continuous_collision_detection = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_enable_continuous_collision_detection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the continuous collision detection mode is enabled. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. body_set_enable_continuous_collision_detection :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () body_set_enable_continuous_collision_detection cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_enable_continuous_collision_detection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_enable_continuous_collision_detection" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_enable_continuous_collision_detection {-# NOINLINE bindPhysicsServer_body_set_force_integration_callback #-} -- | Sets the function used to calculate physics for an object, if that object allows it (see @method body_set_omit_force_integration@). bindPhysicsServer_body_set_force_integration_callback :: MethodBind bindPhysicsServer_body_set_force_integration_callback = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_force_integration_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the function used to calculate physics for an object, if that object allows it (see @method body_set_omit_force_integration@). body_set_force_integration_callback :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Object -> GodotString -> Maybe GodotVariant -> IO () body_set_force_integration_callback cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_force_integration_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_force_integration_callback" '[Rid, Object, GodotString, Maybe GodotVariant] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_force_integration_callback {-# NOINLINE bindPhysicsServer_body_set_kinematic_safe_margin #-} bindPhysicsServer_body_set_kinematic_safe_margin :: MethodBind bindPhysicsServer_body_set_kinematic_safe_margin = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_kinematic_safe_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_set_kinematic_safe_margin :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () body_set_kinematic_safe_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_kinematic_safe_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_kinematic_safe_margin" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_kinematic_safe_margin {-# NOINLINE bindPhysicsServer_body_set_max_contacts_reported #-} -- | Sets the maximum contacts to report. Bodies can keep a log of the contacts with other bodies, this is enabled by setting the maximum amount of contacts reported to a number greater than 0. bindPhysicsServer_body_set_max_contacts_reported :: MethodBind bindPhysicsServer_body_set_max_contacts_reported = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_max_contacts_reported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the maximum contacts to report. Bodies can keep a log of the contacts with other bodies, this is enabled by setting the maximum amount of contacts reported to a number greater than 0. body_set_max_contacts_reported :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_max_contacts_reported cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_max_contacts_reported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_max_contacts_reported" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_max_contacts_reported {-# NOINLINE bindPhysicsServer_body_set_mode #-} -- | Sets the body mode, from one of the @enum BodyMode@ constants. bindPhysicsServer_body_set_mode :: MethodBind bindPhysicsServer_body_set_mode = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the body mode, from one of the @enum BodyMode@ constants. body_set_mode :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () body_set_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_mode {-# NOINLINE bindPhysicsServer_body_set_omit_force_integration #-} -- | Sets whether a body uses a callback function to calculate its own physics (see @method body_set_force_integration_callback@). bindPhysicsServer_body_set_omit_force_integration :: MethodBind bindPhysicsServer_body_set_omit_force_integration = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_omit_force_integration" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether a body uses a callback function to calculate its own physics (see @method body_set_force_integration_callback@). body_set_omit_force_integration :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () body_set_omit_force_integration cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_omit_force_integration (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_omit_force_integration" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_omit_force_integration {-# NOINLINE bindPhysicsServer_body_set_param #-} -- | Sets a body parameter. A list of available parameters is on the @enum BodyParameter@ constants. bindPhysicsServer_body_set_param :: MethodBind bindPhysicsServer_body_set_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a body parameter. A list of available parameters is on the @enum BodyParameter@ constants. body_set_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () body_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_param {-# NOINLINE bindPhysicsServer_body_set_ray_pickable #-} -- | Sets the body pickable with rays if @enabled@ is set. bindPhysicsServer_body_set_ray_pickable :: MethodBind bindPhysicsServer_body_set_ray_pickable = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_ray_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the body pickable with rays if @enabled@ is set. body_set_ray_pickable :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () body_set_ray_pickable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_ray_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_ray_pickable" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_ray_pickable {-# NOINLINE bindPhysicsServer_body_set_shape #-} -- | Substitutes a given body shape by another. The old shape is selected by its index, the new one by its @RID@. bindPhysicsServer_body_set_shape :: MethodBind bindPhysicsServer_body_set_shape = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Substitutes a given body shape by another. The old shape is selected by its index, the new one by its @RID@. body_set_shape :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Rid -> IO () body_set_shape cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_shape" '[Rid, Int, Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_shape {-# NOINLINE bindPhysicsServer_body_set_shape_disabled #-} bindPhysicsServer_body_set_shape_disabled :: MethodBind bindPhysicsServer_body_set_shape_disabled = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_shape_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr body_set_shape_disabled :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Bool -> IO () body_set_shape_disabled cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_shape_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_shape_disabled" '[Rid, Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_shape_disabled {-# NOINLINE bindPhysicsServer_body_set_shape_transform #-} -- | Sets the transform matrix for a body shape. bindPhysicsServer_body_set_shape_transform :: MethodBind bindPhysicsServer_body_set_shape_transform = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transform matrix for a body shape. body_set_shape_transform :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Transform -> IO () body_set_shape_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_shape_transform" '[Rid, Int, Transform] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_shape_transform {-# NOINLINE bindPhysicsServer_body_set_space #-} -- | Assigns a space to the body (see @method space_create@). bindPhysicsServer_body_set_space :: MethodBind bindPhysicsServer_body_set_space = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Assigns a space to the body (see @method space_create@). body_set_space :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () body_set_space cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_space" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_space {-# NOINLINE bindPhysicsServer_body_set_state #-} -- | Sets a body state (see @enum BodyState@ constants). bindPhysicsServer_body_set_state :: MethodBind bindPhysicsServer_body_set_state = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "body_set_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a body state (see @enum BodyState@ constants). body_set_state :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> GodotVariant -> IO () body_set_state cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_body_set_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "body_set_state" '[Rid, Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.body_set_state {-# NOINLINE bindPhysicsServer_cone_twist_joint_get_param #-} -- | Gets a cone_twist_joint parameter (see @enum ConeTwistJointParam@ constants). bindPhysicsServer_cone_twist_joint_get_param :: MethodBind bindPhysicsServer_cone_twist_joint_get_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "cone_twist_joint_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a cone_twist_joint parameter (see @enum ConeTwistJointParam@ constants). cone_twist_joint_get_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float cone_twist_joint_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_cone_twist_joint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "cone_twist_joint_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.PhysicsServer.cone_twist_joint_get_param {-# NOINLINE bindPhysicsServer_cone_twist_joint_set_param #-} -- | Sets a cone_twist_joint parameter (see @enum ConeTwistJointParam@ constants). bindPhysicsServer_cone_twist_joint_set_param :: MethodBind bindPhysicsServer_cone_twist_joint_set_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "cone_twist_joint_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a cone_twist_joint parameter (see @enum ConeTwistJointParam@ constants). cone_twist_joint_set_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () cone_twist_joint_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_cone_twist_joint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "cone_twist_joint_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.cone_twist_joint_set_param {-# NOINLINE bindPhysicsServer_free_rid #-} -- | Destroys any of the objects created by PhysicsServer. If the @RID@ passed is not one of the objects that can be created by PhysicsServer, an error will be sent to the console. bindPhysicsServer_free_rid :: MethodBind bindPhysicsServer_free_rid = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "free_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Destroys any of the objects created by PhysicsServer. If the @RID@ passed is not one of the objects that can be created by PhysicsServer, an error will be sent to the console. free_rid :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO () free_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_free_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "free_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.free_rid {-# NOINLINE bindPhysicsServer_generic_6dof_joint_get_flag #-} -- | Gets a generic_6_DOF_joint flag (see @enum G6DOFJointAxisFlag@ constants). bindPhysicsServer_generic_6dof_joint_get_flag :: MethodBind bindPhysicsServer_generic_6dof_joint_get_flag = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "generic_6dof_joint_get_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a generic_6_DOF_joint flag (see @enum G6DOFJointAxisFlag@ constants). generic_6dof_joint_get_flag :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> IO Bool generic_6dof_joint_get_flag cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_generic_6dof_joint_get_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "generic_6dof_joint_get_flag" '[Rid, Int, Int] (IO Bool) where nodeMethod = Godot.Core.PhysicsServer.generic_6dof_joint_get_flag {-# NOINLINE bindPhysicsServer_generic_6dof_joint_get_param #-} -- | Gets a generic_6_DOF_joint parameter (see @enum G6DOFJointAxisParam@ constants). bindPhysicsServer_generic_6dof_joint_get_param :: MethodBind bindPhysicsServer_generic_6dof_joint_get_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "generic_6dof_joint_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a generic_6_DOF_joint parameter (see @enum G6DOFJointAxisParam@ constants). generic_6dof_joint_get_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> IO Float generic_6dof_joint_get_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_generic_6dof_joint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "generic_6dof_joint_get_param" '[Rid, Int, Int] (IO Float) where nodeMethod = Godot.Core.PhysicsServer.generic_6dof_joint_get_param {-# NOINLINE bindPhysicsServer_generic_6dof_joint_set_flag #-} -- | Sets a generic_6_DOF_joint flag (see @enum G6DOFJointAxisFlag@ constants). bindPhysicsServer_generic_6dof_joint_set_flag :: MethodBind bindPhysicsServer_generic_6dof_joint_set_flag = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "generic_6dof_joint_set_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a generic_6_DOF_joint flag (see @enum G6DOFJointAxisFlag@ constants). generic_6dof_joint_set_flag :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> Bool -> IO () generic_6dof_joint_set_flag cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_generic_6dof_joint_set_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "generic_6dof_joint_set_flag" '[Rid, Int, Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.generic_6dof_joint_set_flag {-# NOINLINE bindPhysicsServer_generic_6dof_joint_set_param #-} -- | Sets a generic_6_DOF_joint parameter (see @enum G6DOFJointAxisParam@ constants). bindPhysicsServer_generic_6dof_joint_set_param :: MethodBind bindPhysicsServer_generic_6dof_joint_set_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "generic_6dof_joint_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a generic_6_DOF_joint parameter (see @enum G6DOFJointAxisParam@ constants). generic_6dof_joint_set_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> Float -> IO () generic_6dof_joint_set_param cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_generic_6dof_joint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "generic_6dof_joint_set_param" '[Rid, Int, Int, Float] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.generic_6dof_joint_set_param {-# NOINLINE bindPhysicsServer_get_process_info #-} -- | Returns an Info defined by the @enum ProcessInfo@ input given. bindPhysicsServer_get_process_info :: MethodBind bindPhysicsServer_get_process_info = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "get_process_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an Info defined by the @enum ProcessInfo@ input given. get_process_info :: (PhysicsServer :< cls, Object :< cls) => cls -> Int -> IO Int get_process_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_get_process_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "get_process_info" '[Int] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.get_process_info {-# NOINLINE bindPhysicsServer_hinge_joint_get_flag #-} -- | Gets a hinge_joint flag (see @enum HingeJointFlag@ constants). bindPhysicsServer_hinge_joint_get_flag :: MethodBind bindPhysicsServer_hinge_joint_get_flag = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "hinge_joint_get_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a hinge_joint flag (see @enum HingeJointFlag@ constants). hinge_joint_get_flag :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Bool hinge_joint_get_flag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_hinge_joint_get_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "hinge_joint_get_flag" '[Rid, Int] (IO Bool) where nodeMethod = Godot.Core.PhysicsServer.hinge_joint_get_flag {-# NOINLINE bindPhysicsServer_hinge_joint_get_param #-} -- | Gets a hinge_joint parameter (see @enum HingeJointParam@). bindPhysicsServer_hinge_joint_get_param :: MethodBind bindPhysicsServer_hinge_joint_get_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "hinge_joint_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a hinge_joint parameter (see @enum HingeJointParam@). hinge_joint_get_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float hinge_joint_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_hinge_joint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "hinge_joint_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.PhysicsServer.hinge_joint_get_param {-# NOINLINE bindPhysicsServer_hinge_joint_set_flag #-} -- | Sets a hinge_joint flag (see @enum HingeJointFlag@ constants). bindPhysicsServer_hinge_joint_set_flag :: MethodBind bindPhysicsServer_hinge_joint_set_flag = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "hinge_joint_set_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a hinge_joint flag (see @enum HingeJointFlag@ constants). hinge_joint_set_flag :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Bool -> IO () hinge_joint_set_flag cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_hinge_joint_set_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "hinge_joint_set_flag" '[Rid, Int, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.hinge_joint_set_flag {-# NOINLINE bindPhysicsServer_hinge_joint_set_param #-} -- | Sets a hinge_joint parameter (see @enum HingeJointParam@ constants). bindPhysicsServer_hinge_joint_set_param :: MethodBind bindPhysicsServer_hinge_joint_set_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "hinge_joint_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a hinge_joint parameter (see @enum HingeJointParam@ constants). hinge_joint_set_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () hinge_joint_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_hinge_joint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "hinge_joint_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.hinge_joint_set_param {-# NOINLINE bindPhysicsServer_joint_create_cone_twist #-} -- | Creates a @ConeTwistJoint@. bindPhysicsServer_joint_create_cone_twist :: MethodBind bindPhysicsServer_joint_create_cone_twist = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "joint_create_cone_twist" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a @ConeTwistJoint@. joint_create_cone_twist :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Transform -> Rid -> Transform -> IO Rid joint_create_cone_twist cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_joint_create_cone_twist (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "joint_create_cone_twist" '[Rid, Transform, Rid, Transform] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.joint_create_cone_twist {-# NOINLINE bindPhysicsServer_joint_create_generic_6dof #-} -- | Creates a @Generic6DOFJoint@. bindPhysicsServer_joint_create_generic_6dof :: MethodBind bindPhysicsServer_joint_create_generic_6dof = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "joint_create_generic_6dof" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a @Generic6DOFJoint@. joint_create_generic_6dof :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Transform -> Rid -> Transform -> IO Rid joint_create_generic_6dof cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_joint_create_generic_6dof (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "joint_create_generic_6dof" '[Rid, Transform, Rid, Transform] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.joint_create_generic_6dof {-# NOINLINE bindPhysicsServer_joint_create_hinge #-} -- | Creates a @HingeJoint@. bindPhysicsServer_joint_create_hinge :: MethodBind bindPhysicsServer_joint_create_hinge = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "joint_create_hinge" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a @HingeJoint@. joint_create_hinge :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Transform -> Rid -> Transform -> IO Rid joint_create_hinge cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_joint_create_hinge (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "joint_create_hinge" '[Rid, Transform, Rid, Transform] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.joint_create_hinge {-# NOINLINE bindPhysicsServer_joint_create_pin #-} -- | Creates a @PinJoint@. bindPhysicsServer_joint_create_pin :: MethodBind bindPhysicsServer_joint_create_pin = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "joint_create_pin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a @PinJoint@. joint_create_pin :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> Rid -> Vector3 -> IO Rid joint_create_pin cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_joint_create_pin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "joint_create_pin" '[Rid, Vector3, Rid, Vector3] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.joint_create_pin {-# NOINLINE bindPhysicsServer_joint_create_slider #-} -- | Creates a @SliderJoint@. bindPhysicsServer_joint_create_slider :: MethodBind bindPhysicsServer_joint_create_slider = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "joint_create_slider" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a @SliderJoint@. joint_create_slider :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Transform -> Rid -> Transform -> IO Rid joint_create_slider cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_joint_create_slider (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "joint_create_slider" '[Rid, Transform, Rid, Transform] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.joint_create_slider {-# NOINLINE bindPhysicsServer_joint_get_solver_priority #-} -- | Gets the priority value of the Joint. bindPhysicsServer_joint_get_solver_priority :: MethodBind bindPhysicsServer_joint_get_solver_priority = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "joint_get_solver_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the priority value of the Joint. joint_get_solver_priority :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int joint_get_solver_priority cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_joint_get_solver_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "joint_get_solver_priority" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.joint_get_solver_priority {-# NOINLINE bindPhysicsServer_joint_get_type #-} -- | Returns the type of the Joint. bindPhysicsServer_joint_get_type :: MethodBind bindPhysicsServer_joint_get_type = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "joint_get_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the type of the Joint. joint_get_type :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int joint_get_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_joint_get_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "joint_get_type" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.joint_get_type {-# NOINLINE bindPhysicsServer_joint_set_solver_priority #-} -- | Sets the priority value of the Joint. bindPhysicsServer_joint_set_solver_priority :: MethodBind bindPhysicsServer_joint_set_solver_priority = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "joint_set_solver_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the priority value of the Joint. joint_set_solver_priority :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () joint_set_solver_priority cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_joint_set_solver_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "joint_set_solver_priority" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.joint_set_solver_priority {-# NOINLINE bindPhysicsServer_pin_joint_get_local_a #-} -- | Returns position of the joint in the local space of body a of the joint. bindPhysicsServer_pin_joint_get_local_a :: MethodBind bindPhysicsServer_pin_joint_get_local_a = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "pin_joint_get_local_a" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns position of the joint in the local space of body a of the joint. pin_joint_get_local_a :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Vector3 pin_joint_get_local_a cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_pin_joint_get_local_a (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "pin_joint_get_local_a" '[Rid] (IO Vector3) where nodeMethod = Godot.Core.PhysicsServer.pin_joint_get_local_a {-# NOINLINE bindPhysicsServer_pin_joint_get_local_b #-} -- | Returns position of the joint in the local space of body b of the joint. bindPhysicsServer_pin_joint_get_local_b :: MethodBind bindPhysicsServer_pin_joint_get_local_b = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "pin_joint_get_local_b" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns position of the joint in the local space of body b of the joint. pin_joint_get_local_b :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Vector3 pin_joint_get_local_b cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_pin_joint_get_local_b (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "pin_joint_get_local_b" '[Rid] (IO Vector3) where nodeMethod = Godot.Core.PhysicsServer.pin_joint_get_local_b {-# NOINLINE bindPhysicsServer_pin_joint_get_param #-} -- | Gets a pin_joint parameter (see @enum PinJointParam@ constants). bindPhysicsServer_pin_joint_get_param :: MethodBind bindPhysicsServer_pin_joint_get_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "pin_joint_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a pin_joint parameter (see @enum PinJointParam@ constants). pin_joint_get_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float pin_joint_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_pin_joint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "pin_joint_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.PhysicsServer.pin_joint_get_param {-# NOINLINE bindPhysicsServer_pin_joint_set_local_a #-} -- | Sets position of the joint in the local space of body a of the joint. bindPhysicsServer_pin_joint_set_local_a :: MethodBind bindPhysicsServer_pin_joint_set_local_a = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "pin_joint_set_local_a" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets position of the joint in the local space of body a of the joint. pin_joint_set_local_a :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () pin_joint_set_local_a cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_pin_joint_set_local_a (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "pin_joint_set_local_a" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.pin_joint_set_local_a {-# NOINLINE bindPhysicsServer_pin_joint_set_local_b #-} -- | Sets position of the joint in the local space of body b of the joint. bindPhysicsServer_pin_joint_set_local_b :: MethodBind bindPhysicsServer_pin_joint_set_local_b = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "pin_joint_set_local_b" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets position of the joint in the local space of body b of the joint. pin_joint_set_local_b :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () pin_joint_set_local_b cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_pin_joint_set_local_b (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "pin_joint_set_local_b" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.pin_joint_set_local_b {-# NOINLINE bindPhysicsServer_pin_joint_set_param #-} -- | Sets a pin_joint parameter (see @enum PinJointParam@ constants). bindPhysicsServer_pin_joint_set_param :: MethodBind bindPhysicsServer_pin_joint_set_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "pin_joint_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a pin_joint parameter (see @enum PinJointParam@ constants). pin_joint_set_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () pin_joint_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_pin_joint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "pin_joint_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.pin_joint_set_param {-# NOINLINE bindPhysicsServer_set_active #-} -- | Activates or deactivates the 3D physics engine. bindPhysicsServer_set_active :: MethodBind bindPhysicsServer_set_active = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Activates or deactivates the 3D physics engine. set_active :: (PhysicsServer :< cls, Object :< cls) => cls -> Bool -> IO () set_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "set_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.set_active {-# NOINLINE bindPhysicsServer_shape_create #-} -- | Creates a shape of a type from @enum ShapeType@. Does not assign it to a body or an area. To do so, you must use @method area_set_shape@ or @method body_set_shape@. bindPhysicsServer_shape_create :: MethodBind bindPhysicsServer_shape_create = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "shape_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a shape of a type from @enum ShapeType@. Does not assign it to a body or an area. To do so, you must use @method area_set_shape@ or @method body_set_shape@. shape_create :: (PhysicsServer :< cls, Object :< cls) => cls -> Int -> IO Rid shape_create cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_shape_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "shape_create" '[Int] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.shape_create {-# NOINLINE bindPhysicsServer_shape_get_data #-} -- | Returns the shape data. bindPhysicsServer_shape_get_data :: MethodBind bindPhysicsServer_shape_get_data = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "shape_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shape data. shape_get_data :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO GodotVariant shape_get_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_shape_get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "shape_get_data" '[Rid] (IO GodotVariant) where nodeMethod = Godot.Core.PhysicsServer.shape_get_data {-# NOINLINE bindPhysicsServer_shape_get_type #-} -- | Returns the type of shape (see @enum ShapeType@ constants). bindPhysicsServer_shape_get_type :: MethodBind bindPhysicsServer_shape_get_type = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "shape_get_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the type of shape (see @enum ShapeType@ constants). shape_get_type :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Int shape_get_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_shape_get_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "shape_get_type" '[Rid] (IO Int) where nodeMethod = Godot.Core.PhysicsServer.shape_get_type {-# NOINLINE bindPhysicsServer_shape_set_data #-} -- | Sets the shape data that defines its shape and size. The data to be passed depends on the kind of shape created @method shape_get_type@. bindPhysicsServer_shape_set_data :: MethodBind bindPhysicsServer_shape_set_data = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "shape_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the shape data that defines its shape and size. The data to be passed depends on the kind of shape created @method shape_get_type@. shape_set_data :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> GodotVariant -> IO () shape_set_data cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_shape_set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "shape_set_data" '[Rid, GodotVariant] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.shape_set_data {-# NOINLINE bindPhysicsServer_slider_joint_get_param #-} -- | Gets a slider_joint parameter (see @enum SliderJointParam@ constants). bindPhysicsServer_slider_joint_get_param :: MethodBind bindPhysicsServer_slider_joint_get_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "slider_joint_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a slider_joint parameter (see @enum SliderJointParam@ constants). slider_joint_get_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float slider_joint_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_slider_joint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "slider_joint_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.PhysicsServer.slider_joint_get_param {-# NOINLINE bindPhysicsServer_slider_joint_set_param #-} -- | Gets a slider_joint parameter (see @enum SliderJointParam@ constants). bindPhysicsServer_slider_joint_set_param :: MethodBind bindPhysicsServer_slider_joint_set_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "slider_joint_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a slider_joint parameter (see @enum SliderJointParam@ constants). slider_joint_set_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () slider_joint_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_slider_joint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "slider_joint_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.slider_joint_set_param {-# NOINLINE bindPhysicsServer_space_create #-} -- | Creates a space. A space is a collection of parameters for the physics engine that can be assigned to an area or a body. It can be assigned to an area with @method area_set_space@, or to a body with @method body_set_space@. bindPhysicsServer_space_create :: MethodBind bindPhysicsServer_space_create = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "space_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a space. A space is a collection of parameters for the physics engine that can be assigned to an area or a body. It can be assigned to an area with @method area_set_space@, or to a body with @method body_set_space@. space_create :: (PhysicsServer :< cls, Object :< cls) => cls -> IO Rid space_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_space_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "space_create" '[] (IO Rid) where nodeMethod = Godot.Core.PhysicsServer.space_create {-# NOINLINE bindPhysicsServer_space_get_direct_state #-} -- | Returns the state of a space, a @PhysicsDirectSpaceState@. This object can be used to make collision/intersection queries. bindPhysicsServer_space_get_direct_state :: MethodBind bindPhysicsServer_space_get_direct_state = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "space_get_direct_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the state of a space, a @PhysicsDirectSpaceState@. This object can be used to make collision/intersection queries. space_get_direct_state :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO PhysicsDirectSpaceState space_get_direct_state cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_space_get_direct_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "space_get_direct_state" '[Rid] (IO PhysicsDirectSpaceState) where nodeMethod = Godot.Core.PhysicsServer.space_get_direct_state {-# NOINLINE bindPhysicsServer_space_get_param #-} -- | Returns the value of a space parameter. bindPhysicsServer_space_get_param :: MethodBind bindPhysicsServer_space_get_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "space_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a space parameter. space_get_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Float space_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_space_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "space_get_param" '[Rid, Int] (IO Float) where nodeMethod = Godot.Core.PhysicsServer.space_get_param {-# NOINLINE bindPhysicsServer_space_is_active #-} -- | Returns whether the space is active. bindPhysicsServer_space_is_active :: MethodBind bindPhysicsServer_space_is_active = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "space_is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the space is active. space_is_active :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> IO Bool space_is_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_space_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "space_is_active" '[Rid] (IO Bool) where nodeMethod = Godot.Core.PhysicsServer.space_is_active {-# NOINLINE bindPhysicsServer_space_set_active #-} -- | Marks a space as active. It will not have an effect, unless it is assigned to an area or body. bindPhysicsServer_space_set_active :: MethodBind bindPhysicsServer_space_set_active = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "space_set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Marks a space as active. It will not have an effect, unless it is assigned to an area or body. space_set_active :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () space_set_active cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_space_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "space_set_active" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.space_set_active {-# NOINLINE bindPhysicsServer_space_set_param #-} -- | Sets the value for a space parameter. A list of available parameters is on the @enum SpaceParameter@ constants. bindPhysicsServer_space_set_param :: MethodBind bindPhysicsServer_space_set_param = unsafePerformIO $ withCString "PhysicsServer" $ \ clsNamePtr -> withCString "space_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value for a space parameter. A list of available parameters is on the @enum SpaceParameter@ constants. space_set_param :: (PhysicsServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () space_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsServer_space_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsServer "space_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.PhysicsServer.space_set_param ================================================ FILE: src/Godot/Core/PhysicsShapeQueryParameters.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicsShapeQueryParameters (Godot.Core.PhysicsShapeQueryParameters.get_collision_mask, Godot.Core.PhysicsShapeQueryParameters.get_exclude, Godot.Core.PhysicsShapeQueryParameters.get_margin, Godot.Core.PhysicsShapeQueryParameters.get_shape_rid, Godot.Core.PhysicsShapeQueryParameters.get_transform, Godot.Core.PhysicsShapeQueryParameters.is_collide_with_areas_enabled, Godot.Core.PhysicsShapeQueryParameters.is_collide_with_bodies_enabled, Godot.Core.PhysicsShapeQueryParameters.set_collide_with_areas, Godot.Core.PhysicsShapeQueryParameters.set_collide_with_bodies, Godot.Core.PhysicsShapeQueryParameters.set_collision_mask, Godot.Core.PhysicsShapeQueryParameters.set_exclude, Godot.Core.PhysicsShapeQueryParameters.set_margin, Godot.Core.PhysicsShapeQueryParameters.set_shape, Godot.Core.PhysicsShapeQueryParameters.set_shape_rid, Godot.Core.PhysicsShapeQueryParameters.set_transform) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty PhysicsShapeQueryParameters "collide_with_areas" Bool 'False where nodeProperty = (is_collide_with_areas_enabled, wrapDroppingSetter set_collide_with_areas, Nothing) instance NodeProperty PhysicsShapeQueryParameters "collide_with_bodies" Bool 'False where nodeProperty = (is_collide_with_bodies_enabled, wrapDroppingSetter set_collide_with_bodies, Nothing) instance NodeProperty PhysicsShapeQueryParameters "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty PhysicsShapeQueryParameters "exclude" Array 'False where nodeProperty = (get_exclude, wrapDroppingSetter set_exclude, Nothing) instance NodeProperty PhysicsShapeQueryParameters "margin" Float 'False where nodeProperty = (get_margin, wrapDroppingSetter set_margin, Nothing) instance NodeProperty PhysicsShapeQueryParameters "shape_rid" Rid 'False where nodeProperty = (get_shape_rid, wrapDroppingSetter set_shape_rid, Nothing) instance NodeProperty PhysicsShapeQueryParameters "transform" Transform 'False where nodeProperty = (get_transform, wrapDroppingSetter set_transform, Nothing) {-# NOINLINE bindPhysicsShapeQueryParameters_get_collision_mask #-} -- | The physics layer(s) the query will take into account (as a bitmask). See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsShapeQueryParameters_get_collision_mask :: MethodBind bindPhysicsShapeQueryParameters_get_collision_mask = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layer(s) the query will take into account (as a bitmask). See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.get_collision_mask {-# NOINLINE bindPhysicsShapeQueryParameters_get_exclude #-} -- | The list of objects or object @RID@s that will be excluded from collisions. bindPhysicsShapeQueryParameters_get_exclude :: MethodBind bindPhysicsShapeQueryParameters_get_exclude = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "get_exclude" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The list of objects or object @RID@s that will be excluded from collisions. get_exclude :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> IO Array get_exclude cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_get_exclude (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "get_exclude" '[] (IO Array) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.get_exclude {-# NOINLINE bindPhysicsShapeQueryParameters_get_margin #-} -- | The collision margin for the shape. bindPhysicsShapeQueryParameters_get_margin :: MethodBind bindPhysicsShapeQueryParameters_get_margin = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "get_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision margin for the shape. get_margin :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> IO Float get_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_get_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "get_margin" '[] (IO Float) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.get_margin {-# NOINLINE bindPhysicsShapeQueryParameters_get_shape_rid #-} -- | The queried shape's @RID@. See also @method set_shape@. bindPhysicsShapeQueryParameters_get_shape_rid :: MethodBind bindPhysicsShapeQueryParameters_get_shape_rid = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "get_shape_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The queried shape's @RID@. See also @method set_shape@. get_shape_rid :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> IO Rid get_shape_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_get_shape_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "get_shape_rid" '[] (IO Rid) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.get_shape_rid {-# NOINLINE bindPhysicsShapeQueryParameters_get_transform #-} -- | The queried shape's transform matrix. bindPhysicsShapeQueryParameters_get_transform :: MethodBind bindPhysicsShapeQueryParameters_get_transform = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The queried shape's transform matrix. get_transform :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> IO Transform get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "get_transform" '[] (IO Transform) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.get_transform {-# NOINLINE bindPhysicsShapeQueryParameters_is_collide_with_areas_enabled #-} -- | If @true@, the query will take @Area@s into account. bindPhysicsShapeQueryParameters_is_collide_with_areas_enabled :: MethodBind bindPhysicsShapeQueryParameters_is_collide_with_areas_enabled = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "is_collide_with_areas_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the query will take @Area@s into account. is_collide_with_areas_enabled :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> IO Bool is_collide_with_areas_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_is_collide_with_areas_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "is_collide_with_areas_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.is_collide_with_areas_enabled {-# NOINLINE bindPhysicsShapeQueryParameters_is_collide_with_bodies_enabled #-} -- | If @true@, the query will take @PhysicsBody@s into account. bindPhysicsShapeQueryParameters_is_collide_with_bodies_enabled :: MethodBind bindPhysicsShapeQueryParameters_is_collide_with_bodies_enabled = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "is_collide_with_bodies_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the query will take @PhysicsBody@s into account. is_collide_with_bodies_enabled :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> IO Bool is_collide_with_bodies_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_is_collide_with_bodies_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "is_collide_with_bodies_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.is_collide_with_bodies_enabled {-# NOINLINE bindPhysicsShapeQueryParameters_set_collide_with_areas #-} -- | If @true@, the query will take @Area@s into account. bindPhysicsShapeQueryParameters_set_collide_with_areas :: MethodBind bindPhysicsShapeQueryParameters_set_collide_with_areas = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "set_collide_with_areas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the query will take @Area@s into account. set_collide_with_areas :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> Bool -> IO () set_collide_with_areas cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_set_collide_with_areas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "set_collide_with_areas" '[Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.set_collide_with_areas {-# NOINLINE bindPhysicsShapeQueryParameters_set_collide_with_bodies #-} -- | If @true@, the query will take @PhysicsBody@s into account. bindPhysicsShapeQueryParameters_set_collide_with_bodies :: MethodBind bindPhysicsShapeQueryParameters_set_collide_with_bodies = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "set_collide_with_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the query will take @PhysicsBody@s into account. set_collide_with_bodies :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> Bool -> IO () set_collide_with_bodies cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_set_collide_with_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "set_collide_with_bodies" '[Bool] (IO ()) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.set_collide_with_bodies {-# NOINLINE bindPhysicsShapeQueryParameters_set_collision_mask #-} -- | The physics layer(s) the query will take into account (as a bitmask). See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindPhysicsShapeQueryParameters_set_collision_mask :: MethodBind bindPhysicsShapeQueryParameters_set_collision_mask = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layer(s) the query will take into account (as a bitmask). See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.set_collision_mask {-# NOINLINE bindPhysicsShapeQueryParameters_set_exclude #-} -- | The list of objects or object @RID@s that will be excluded from collisions. bindPhysicsShapeQueryParameters_set_exclude :: MethodBind bindPhysicsShapeQueryParameters_set_exclude = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "set_exclude" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The list of objects or object @RID@s that will be excluded from collisions. set_exclude :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> Array -> IO () set_exclude cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_set_exclude (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "set_exclude" '[Array] (IO ()) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.set_exclude {-# NOINLINE bindPhysicsShapeQueryParameters_set_margin #-} -- | The collision margin for the shape. bindPhysicsShapeQueryParameters_set_margin :: MethodBind bindPhysicsShapeQueryParameters_set_margin = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "set_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision margin for the shape. set_margin :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> Float -> IO () set_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_set_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "set_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.set_margin {-# NOINLINE bindPhysicsShapeQueryParameters_set_shape #-} -- | Sets the @Shape@ that will be used for collision/intersection queries. bindPhysicsShapeQueryParameters_set_shape :: MethodBind bindPhysicsShapeQueryParameters_set_shape = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Shape@ that will be used for collision/intersection queries. set_shape :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> Resource -> IO () set_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "set_shape" '[Resource] (IO ()) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.set_shape {-# NOINLINE bindPhysicsShapeQueryParameters_set_shape_rid #-} -- | The queried shape's @RID@. See also @method set_shape@. bindPhysicsShapeQueryParameters_set_shape_rid :: MethodBind bindPhysicsShapeQueryParameters_set_shape_rid = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "set_shape_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The queried shape's @RID@. See also @method set_shape@. set_shape_rid :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> Rid -> IO () set_shape_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_set_shape_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "set_shape_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.set_shape_rid {-# NOINLINE bindPhysicsShapeQueryParameters_set_transform #-} -- | The queried shape's transform matrix. bindPhysicsShapeQueryParameters_set_transform :: MethodBind bindPhysicsShapeQueryParameters_set_transform = unsafePerformIO $ withCString "PhysicsShapeQueryParameters" $ \ clsNamePtr -> withCString "set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The queried shape's transform matrix. set_transform :: (PhysicsShapeQueryParameters :< cls, Object :< cls) => cls -> Transform -> IO () set_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryParameters_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryParameters "set_transform" '[Transform] (IO ()) where nodeMethod = Godot.Core.PhysicsShapeQueryParameters.set_transform ================================================ FILE: src/Godot/Core/PhysicsShapeQueryResult.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PhysicsShapeQueryResult (Godot.Core.PhysicsShapeQueryResult.get_result_count, Godot.Core.PhysicsShapeQueryResult.get_result_object, Godot.Core.PhysicsShapeQueryResult.get_result_object_id, Godot.Core.PhysicsShapeQueryResult.get_result_object_shape, Godot.Core.PhysicsShapeQueryResult.get_result_rid) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindPhysicsShapeQueryResult_get_result_count #-} -- | Returns the number of objects that intersected with the shape. bindPhysicsShapeQueryResult_get_result_count :: MethodBind bindPhysicsShapeQueryResult_get_result_count = unsafePerformIO $ withCString "PhysicsShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of objects that intersected with the shape. get_result_count :: (PhysicsShapeQueryResult :< cls, Object :< cls) => cls -> IO Int get_result_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryResult_get_result_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryResult "get_result_count" '[] (IO Int) where nodeMethod = Godot.Core.PhysicsShapeQueryResult.get_result_count {-# NOINLINE bindPhysicsShapeQueryResult_get_result_object #-} -- | Returns the @Object@ that intersected with the shape at index @idx@. bindPhysicsShapeQueryResult_get_result_object :: MethodBind bindPhysicsShapeQueryResult_get_result_object = unsafePerformIO $ withCString "PhysicsShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Object@ that intersected with the shape at index @idx@. get_result_object :: (PhysicsShapeQueryResult :< cls, Object :< cls) => cls -> Int -> IO Object get_result_object cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryResult_get_result_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryResult "get_result_object" '[Int] (IO Object) where nodeMethod = Godot.Core.PhysicsShapeQueryResult.get_result_object {-# NOINLINE bindPhysicsShapeQueryResult_get_result_object_id #-} -- | Returns the instance ID of the @Object@ that intersected with the shape at index @idx@. bindPhysicsShapeQueryResult_get_result_object_id :: MethodBind bindPhysicsShapeQueryResult_get_result_object_id = unsafePerformIO $ withCString "PhysicsShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_object_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the instance ID of the @Object@ that intersected with the shape at index @idx@. get_result_object_id :: (PhysicsShapeQueryResult :< cls, Object :< cls) => cls -> Int -> IO Int get_result_object_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryResult_get_result_object_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryResult "get_result_object_id" '[Int] (IO Int) where nodeMethod = Godot.Core.PhysicsShapeQueryResult.get_result_object_id {-# NOINLINE bindPhysicsShapeQueryResult_get_result_object_shape #-} -- | Returns the child index of the object's @Shape@ that intersected with the shape at index @idx@. bindPhysicsShapeQueryResult_get_result_object_shape :: MethodBind bindPhysicsShapeQueryResult_get_result_object_shape = unsafePerformIO $ withCString "PhysicsShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_object_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the child index of the object's @Shape@ that intersected with the shape at index @idx@. get_result_object_shape :: (PhysicsShapeQueryResult :< cls, Object :< cls) => cls -> Int -> IO Int get_result_object_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryResult_get_result_object_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryResult "get_result_object_shape" '[Int] (IO Int) where nodeMethod = Godot.Core.PhysicsShapeQueryResult.get_result_object_shape {-# NOINLINE bindPhysicsShapeQueryResult_get_result_rid #-} -- | Returns the @RID@ of the object that intersected with the shape at index @idx@. bindPhysicsShapeQueryResult_get_result_rid :: MethodBind bindPhysicsShapeQueryResult_get_result_rid = unsafePerformIO $ withCString "PhysicsShapeQueryResult" $ \ clsNamePtr -> withCString "get_result_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of the object that intersected with the shape at index @idx@. get_result_rid :: (PhysicsShapeQueryResult :< cls, Object :< cls) => cls -> Int -> IO Rid get_result_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPhysicsShapeQueryResult_get_result_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PhysicsShapeQueryResult "get_result_rid" '[Int] (IO Rid) where nodeMethod = Godot.Core.PhysicsShapeQueryResult.get_result_rid ================================================ FILE: src/Godot/Core/PinJoint.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PinJoint (Godot.Core.PinJoint._PARAM_IMPULSE_CLAMP, Godot.Core.PinJoint._PARAM_DAMPING, Godot.Core.PinJoint._PARAM_BIAS, Godot.Core.PinJoint.get_param, Godot.Core.PinJoint.set_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Joint() _PARAM_IMPULSE_CLAMP :: Int _PARAM_IMPULSE_CLAMP = 2 _PARAM_DAMPING :: Int _PARAM_DAMPING = 1 _PARAM_BIAS :: Int _PARAM_BIAS = 0 instance NodeProperty PinJoint "params/bias" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param, wrapIndexedSetter 0 set_param, Nothing) instance NodeProperty PinJoint "params/damping" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param, wrapIndexedSetter 1 set_param, Nothing) instance NodeProperty PinJoint "params/impulse_clamp" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param, wrapIndexedSetter 2 set_param, Nothing) {-# NOINLINE bindPinJoint_get_param #-} -- | Returns the value of the specified parameter. bindPinJoint_get_param :: MethodBind bindPinJoint_get_param = unsafePerformIO $ withCString "PinJoint" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the specified parameter. get_param :: (PinJoint :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPinJoint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PinJoint "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.PinJoint.get_param {-# NOINLINE bindPinJoint_set_param #-} -- | Sets the value of the specified parameter. bindPinJoint_set_param :: MethodBind bindPinJoint_set_param = unsafePerformIO $ withCString "PinJoint" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value of the specified parameter. set_param :: (PinJoint :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPinJoint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PinJoint "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.PinJoint.set_param ================================================ FILE: src/Godot/Core/PinJoint2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PinJoint2D (Godot.Core.PinJoint2D.get_softness, Godot.Core.PinJoint2D.set_softness) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Joint2D() instance NodeProperty PinJoint2D "softness" Float 'False where nodeProperty = (get_softness, wrapDroppingSetter set_softness, Nothing) {-# NOINLINE bindPinJoint2D_get_softness #-} -- | The higher this value, the more the bond to the pinned partner can flex. bindPinJoint2D_get_softness :: MethodBind bindPinJoint2D_get_softness = unsafePerformIO $ withCString "PinJoint2D" $ \ clsNamePtr -> withCString "get_softness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The higher this value, the more the bond to the pinned partner can flex. get_softness :: (PinJoint2D :< cls, Object :< cls) => cls -> IO Float get_softness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPinJoint2D_get_softness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PinJoint2D "get_softness" '[] (IO Float) where nodeMethod = Godot.Core.PinJoint2D.get_softness {-# NOINLINE bindPinJoint2D_set_softness #-} -- | The higher this value, the more the bond to the pinned partner can flex. bindPinJoint2D_set_softness :: MethodBind bindPinJoint2D_set_softness = unsafePerformIO $ withCString "PinJoint2D" $ \ clsNamePtr -> withCString "set_softness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The higher this value, the more the bond to the pinned partner can flex. set_softness :: (PinJoint2D :< cls, Object :< cls) => cls -> Float -> IO () set_softness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPinJoint2D_set_softness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PinJoint2D "set_softness" '[Float] (IO ()) where nodeMethod = Godot.Core.PinJoint2D.set_softness ================================================ FILE: src/Godot/Core/PlaneMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PlaneMesh (Godot.Core.PlaneMesh.get_size, Godot.Core.PlaneMesh.get_subdivide_depth, Godot.Core.PlaneMesh.get_subdivide_width, Godot.Core.PlaneMesh.set_size, Godot.Core.PlaneMesh.set_subdivide_depth, Godot.Core.PlaneMesh.set_subdivide_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PrimitiveMesh() instance NodeProperty PlaneMesh "size" Vector2 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) instance NodeProperty PlaneMesh "subdivide_depth" Int 'False where nodeProperty = (get_subdivide_depth, wrapDroppingSetter set_subdivide_depth, Nothing) instance NodeProperty PlaneMesh "subdivide_width" Int 'False where nodeProperty = (get_subdivide_width, wrapDroppingSetter set_subdivide_width, Nothing) {-# NOINLINE bindPlaneMesh_get_size #-} -- | Size of the generated plane. bindPlaneMesh_get_size :: MethodBind bindPlaneMesh_get_size = unsafePerformIO $ withCString "PlaneMesh" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size of the generated plane. get_size :: (PlaneMesh :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPlaneMesh_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PlaneMesh "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.PlaneMesh.get_size {-# NOINLINE bindPlaneMesh_get_subdivide_depth #-} -- | Number of subdivision along the Z axis. bindPlaneMesh_get_subdivide_depth :: MethodBind bindPlaneMesh_get_subdivide_depth = unsafePerformIO $ withCString "PlaneMesh" $ \ clsNamePtr -> withCString "get_subdivide_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of subdivision along the Z axis. get_subdivide_depth :: (PlaneMesh :< cls, Object :< cls) => cls -> IO Int get_subdivide_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPlaneMesh_get_subdivide_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PlaneMesh "get_subdivide_depth" '[] (IO Int) where nodeMethod = Godot.Core.PlaneMesh.get_subdivide_depth {-# NOINLINE bindPlaneMesh_get_subdivide_width #-} -- | Number of subdivision along the X axis. bindPlaneMesh_get_subdivide_width :: MethodBind bindPlaneMesh_get_subdivide_width = unsafePerformIO $ withCString "PlaneMesh" $ \ clsNamePtr -> withCString "get_subdivide_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of subdivision along the X axis. get_subdivide_width :: (PlaneMesh :< cls, Object :< cls) => cls -> IO Int get_subdivide_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPlaneMesh_get_subdivide_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PlaneMesh "get_subdivide_width" '[] (IO Int) where nodeMethod = Godot.Core.PlaneMesh.get_subdivide_width {-# NOINLINE bindPlaneMesh_set_size #-} -- | Size of the generated plane. bindPlaneMesh_set_size :: MethodBind bindPlaneMesh_set_size = unsafePerformIO $ withCString "PlaneMesh" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size of the generated plane. set_size :: (PlaneMesh :< cls, Object :< cls) => cls -> Vector2 -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPlaneMesh_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PlaneMesh "set_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.PlaneMesh.set_size {-# NOINLINE bindPlaneMesh_set_subdivide_depth #-} -- | Number of subdivision along the Z axis. bindPlaneMesh_set_subdivide_depth :: MethodBind bindPlaneMesh_set_subdivide_depth = unsafePerformIO $ withCString "PlaneMesh" $ \ clsNamePtr -> withCString "set_subdivide_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of subdivision along the Z axis. set_subdivide_depth :: (PlaneMesh :< cls, Object :< cls) => cls -> Int -> IO () set_subdivide_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPlaneMesh_set_subdivide_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PlaneMesh "set_subdivide_depth" '[Int] (IO ()) where nodeMethod = Godot.Core.PlaneMesh.set_subdivide_depth {-# NOINLINE bindPlaneMesh_set_subdivide_width #-} -- | Number of subdivision along the X axis. bindPlaneMesh_set_subdivide_width :: MethodBind bindPlaneMesh_set_subdivide_width = unsafePerformIO $ withCString "PlaneMesh" $ \ clsNamePtr -> withCString "set_subdivide_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of subdivision along the X axis. set_subdivide_width :: (PlaneMesh :< cls, Object :< cls) => cls -> Int -> IO () set_subdivide_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPlaneMesh_set_subdivide_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PlaneMesh "set_subdivide_width" '[Int] (IO ()) where nodeMethod = Godot.Core.PlaneMesh.set_subdivide_width ================================================ FILE: src/Godot/Core/PlaneShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PlaneShape (Godot.Core.PlaneShape.get_plane, Godot.Core.PlaneShape.set_plane) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty PlaneShape "plane" Plane 'False where nodeProperty = (get_plane, wrapDroppingSetter set_plane, Nothing) {-# NOINLINE bindPlaneShape_get_plane #-} -- | The @Plane@ used by the @PlaneShape@ for collision. bindPlaneShape_get_plane :: MethodBind bindPlaneShape_get_plane = unsafePerformIO $ withCString "PlaneShape" $ \ clsNamePtr -> withCString "get_plane" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Plane@ used by the @PlaneShape@ for collision. get_plane :: (PlaneShape :< cls, Object :< cls) => cls -> IO Plane get_plane cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPlaneShape_get_plane (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PlaneShape "get_plane" '[] (IO Plane) where nodeMethod = Godot.Core.PlaneShape.get_plane {-# NOINLINE bindPlaneShape_set_plane #-} -- | The @Plane@ used by the @PlaneShape@ for collision. bindPlaneShape_set_plane :: MethodBind bindPlaneShape_set_plane = unsafePerformIO $ withCString "PlaneShape" $ \ clsNamePtr -> withCString "set_plane" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Plane@ used by the @PlaneShape@ for collision. set_plane :: (PlaneShape :< cls, Object :< cls) => cls -> Plane -> IO () set_plane cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPlaneShape_set_plane (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PlaneShape "set_plane" '[Plane] (IO ()) where nodeMethod = Godot.Core.PlaneShape.set_plane ================================================ FILE: src/Godot/Core/PluginScript.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PluginScript (Godot.Core.PluginScript.new) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Script() {-# NOINLINE bindPluginScript_new #-} bindPluginScript_new :: MethodBind bindPluginScript_new = unsafePerformIO $ withCString "PluginScript" $ \ clsNamePtr -> withCString "new" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr new :: (PluginScript :< cls, Object :< cls) => cls -> [Variant 'GodotTy] -> IO GodotVariant new cls varargs = withVariantArray ([] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindPluginScript_new (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PluginScript "new" '[[Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.PluginScript.new ================================================ FILE: src/Godot/Core/PointMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PointMesh () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PrimitiveMesh() ================================================ FILE: src/Godot/Core/Polygon2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Polygon2D (Godot.Core.Polygon2D._get_bones, Godot.Core.Polygon2D._set_bones, Godot.Core.Polygon2D._skeleton_bone_setup_changed, Godot.Core.Polygon2D.add_bone, Godot.Core.Polygon2D.clear_bones, Godot.Core.Polygon2D.erase_bone, Godot.Core.Polygon2D.get_antialiased, Godot.Core.Polygon2D.get_bone_count, Godot.Core.Polygon2D.get_bone_path, Godot.Core.Polygon2D.get_bone_weights, Godot.Core.Polygon2D.get_color, Godot.Core.Polygon2D.get_internal_vertex_count, Godot.Core.Polygon2D.get_invert, Godot.Core.Polygon2D.get_invert_border, Godot.Core.Polygon2D.get_offset, Godot.Core.Polygon2D.get_polygon, Godot.Core.Polygon2D.get_polygons, Godot.Core.Polygon2D.get_skeleton, Godot.Core.Polygon2D.get_texture, Godot.Core.Polygon2D.get_texture_offset, Godot.Core.Polygon2D.get_texture_rotation, Godot.Core.Polygon2D.get_texture_rotation_degrees, Godot.Core.Polygon2D.get_texture_scale, Godot.Core.Polygon2D.get_uv, Godot.Core.Polygon2D.get_vertex_colors, Godot.Core.Polygon2D.set_antialiased, Godot.Core.Polygon2D.set_bone_path, Godot.Core.Polygon2D.set_bone_weights, Godot.Core.Polygon2D.set_color, Godot.Core.Polygon2D.set_internal_vertex_count, Godot.Core.Polygon2D.set_invert, Godot.Core.Polygon2D.set_invert_border, Godot.Core.Polygon2D.set_offset, Godot.Core.Polygon2D.set_polygon, Godot.Core.Polygon2D.set_polygons, Godot.Core.Polygon2D.set_skeleton, Godot.Core.Polygon2D.set_texture, Godot.Core.Polygon2D.set_texture_offset, Godot.Core.Polygon2D.set_texture_rotation, Godot.Core.Polygon2D.set_texture_rotation_degrees, Godot.Core.Polygon2D.set_texture_scale, Godot.Core.Polygon2D.set_uv, Godot.Core.Polygon2D.set_vertex_colors) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty Polygon2D "antialiased" Bool 'False where nodeProperty = (get_antialiased, wrapDroppingSetter set_antialiased, Nothing) instance NodeProperty Polygon2D "bones" Array 'False where nodeProperty = (_get_bones, wrapDroppingSetter _set_bones, Nothing) instance NodeProperty Polygon2D "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) instance NodeProperty Polygon2D "internal_vertex_count" Int 'False where nodeProperty = (get_internal_vertex_count, wrapDroppingSetter set_internal_vertex_count, Nothing) instance NodeProperty Polygon2D "invert_border" Float 'False where nodeProperty = (get_invert_border, wrapDroppingSetter set_invert_border, Nothing) instance NodeProperty Polygon2D "invert_enable" Bool 'False where nodeProperty = (get_invert, wrapDroppingSetter set_invert, Nothing) instance NodeProperty Polygon2D "offset" Vector2 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty Polygon2D "polygon" PoolVector2Array 'False where nodeProperty = (get_polygon, wrapDroppingSetter set_polygon, Nothing) instance NodeProperty Polygon2D "polygons" Array 'False where nodeProperty = (get_polygons, wrapDroppingSetter set_polygons, Nothing) instance NodeProperty Polygon2D "skeleton" NodePath 'False where nodeProperty = (get_skeleton, wrapDroppingSetter set_skeleton, Nothing) instance NodeProperty Polygon2D "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) instance NodeProperty Polygon2D "texture_offset" Vector2 'False where nodeProperty = (get_texture_offset, wrapDroppingSetter set_texture_offset, Nothing) instance NodeProperty Polygon2D "texture_rotation" Float 'False where nodeProperty = (get_texture_rotation, wrapDroppingSetter set_texture_rotation, Nothing) instance NodeProperty Polygon2D "texture_rotation_degrees" Float 'False where nodeProperty = (get_texture_rotation_degrees, wrapDroppingSetter set_texture_rotation_degrees, Nothing) instance NodeProperty Polygon2D "texture_scale" Vector2 'False where nodeProperty = (get_texture_scale, wrapDroppingSetter set_texture_scale, Nothing) instance NodeProperty Polygon2D "uv" PoolVector2Array 'False where nodeProperty = (get_uv, wrapDroppingSetter set_uv, Nothing) instance NodeProperty Polygon2D "vertex_colors" PoolColorArray 'False where nodeProperty = (get_vertex_colors, wrapDroppingSetter set_vertex_colors, Nothing) {-# NOINLINE bindPolygon2D__get_bones #-} bindPolygon2D__get_bones :: MethodBind bindPolygon2D__get_bones = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "_get_bones" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_bones :: (Polygon2D :< cls, Object :< cls) => cls -> IO Array _get_bones cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D__get_bones (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "_get_bones" '[] (IO Array) where nodeMethod = Godot.Core.Polygon2D._get_bones {-# NOINLINE bindPolygon2D__set_bones #-} bindPolygon2D__set_bones :: MethodBind bindPolygon2D__set_bones = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "_set_bones" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_bones :: (Polygon2D :< cls, Object :< cls) => cls -> Array -> IO () _set_bones cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D__set_bones (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "_set_bones" '[Array] (IO ()) where nodeMethod = Godot.Core.Polygon2D._set_bones {-# NOINLINE bindPolygon2D__skeleton_bone_setup_changed #-} bindPolygon2D__skeleton_bone_setup_changed :: MethodBind bindPolygon2D__skeleton_bone_setup_changed = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "_skeleton_bone_setup_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _skeleton_bone_setup_changed :: (Polygon2D :< cls, Object :< cls) => cls -> IO () _skeleton_bone_setup_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D__skeleton_bone_setup_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "_skeleton_bone_setup_changed" '[] (IO ()) where nodeMethod = Godot.Core.Polygon2D._skeleton_bone_setup_changed {-# NOINLINE bindPolygon2D_add_bone #-} -- | Adds a bone with the specified @path@ and @weights@. bindPolygon2D_add_bone :: MethodBind bindPolygon2D_add_bone = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "add_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a bone with the specified @path@ and @weights@. add_bone :: (Polygon2D :< cls, Object :< cls) => cls -> NodePath -> PoolRealArray -> IO () add_bone cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_add_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "add_bone" '[NodePath, PoolRealArray] (IO ()) where nodeMethod = Godot.Core.Polygon2D.add_bone {-# NOINLINE bindPolygon2D_clear_bones #-} -- | Removes all bones from this @Polygon2D@. bindPolygon2D_clear_bones :: MethodBind bindPolygon2D_clear_bones = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "clear_bones" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all bones from this @Polygon2D@. clear_bones :: (Polygon2D :< cls, Object :< cls) => cls -> IO () clear_bones cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_clear_bones (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "clear_bones" '[] (IO ()) where nodeMethod = Godot.Core.Polygon2D.clear_bones {-# NOINLINE bindPolygon2D_erase_bone #-} -- | Removes the specified bone from this @Polygon2D@. bindPolygon2D_erase_bone :: MethodBind bindPolygon2D_erase_bone = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "erase_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the specified bone from this @Polygon2D@. erase_bone :: (Polygon2D :< cls, Object :< cls) => cls -> Int -> IO () erase_bone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_erase_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "erase_bone" '[Int] (IO ()) where nodeMethod = Godot.Core.Polygon2D.erase_bone {-# NOINLINE bindPolygon2D_get_antialiased #-} -- | If @true@, polygon edges will be anti-aliased. bindPolygon2D_get_antialiased :: MethodBind bindPolygon2D_get_antialiased = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_antialiased" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, polygon edges will be anti-aliased. get_antialiased :: (Polygon2D :< cls, Object :< cls) => cls -> IO Bool get_antialiased cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_antialiased (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_antialiased" '[] (IO Bool) where nodeMethod = Godot.Core.Polygon2D.get_antialiased {-# NOINLINE bindPolygon2D_get_bone_count #-} -- | Returns the number of bones in this @Polygon2D@. bindPolygon2D_get_bone_count :: MethodBind bindPolygon2D_get_bone_count = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_bone_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of bones in this @Polygon2D@. get_bone_count :: (Polygon2D :< cls, Object :< cls) => cls -> IO Int get_bone_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_bone_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_bone_count" '[] (IO Int) where nodeMethod = Godot.Core.Polygon2D.get_bone_count {-# NOINLINE bindPolygon2D_get_bone_path #-} -- | Returns the path to the node associated with the specified bone. bindPolygon2D_get_bone_path :: MethodBind bindPolygon2D_get_bone_path = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_bone_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to the node associated with the specified bone. get_bone_path :: (Polygon2D :< cls, Object :< cls) => cls -> Int -> IO NodePath get_bone_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_bone_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_bone_path" '[Int] (IO NodePath) where nodeMethod = Godot.Core.Polygon2D.get_bone_path {-# NOINLINE bindPolygon2D_get_bone_weights #-} -- | Returns the height values of the specified bone. bindPolygon2D_get_bone_weights :: MethodBind bindPolygon2D_get_bone_weights = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_bone_weights" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the height values of the specified bone. get_bone_weights :: (Polygon2D :< cls, Object :< cls) => cls -> Int -> IO PoolRealArray get_bone_weights cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_bone_weights (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_bone_weights" '[Int] (IO PoolRealArray) where nodeMethod = Godot.Core.Polygon2D.get_bone_weights {-# NOINLINE bindPolygon2D_get_color #-} -- | The polygon's fill color. If @texture@ is defined, it will be multiplied by this color. It will also be the default color for vertices not set in @vertex_colors@. bindPolygon2D_get_color :: MethodBind bindPolygon2D_get_color = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's fill color. If @texture@ is defined, it will be multiplied by this color. It will also be the default color for vertices not set in @vertex_colors@. get_color :: (Polygon2D :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_color" '[] (IO Color) where nodeMethod = Godot.Core.Polygon2D.get_color {-# NOINLINE bindPolygon2D_get_internal_vertex_count #-} bindPolygon2D_get_internal_vertex_count :: MethodBind bindPolygon2D_get_internal_vertex_count = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_internal_vertex_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_internal_vertex_count :: (Polygon2D :< cls, Object :< cls) => cls -> IO Int get_internal_vertex_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_internal_vertex_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_internal_vertex_count" '[] (IO Int) where nodeMethod = Godot.Core.Polygon2D.get_internal_vertex_count {-# NOINLINE bindPolygon2D_get_invert #-} -- | If @true@, polygon will be inverted, containing the area outside the defined points and extending to the @invert_border@. bindPolygon2D_get_invert :: MethodBind bindPolygon2D_get_invert = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_invert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, polygon will be inverted, containing the area outside the defined points and extending to the @invert_border@. get_invert :: (Polygon2D :< cls, Object :< cls) => cls -> IO Bool get_invert cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_invert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_invert" '[] (IO Bool) where nodeMethod = Godot.Core.Polygon2D.get_invert {-# NOINLINE bindPolygon2D_get_invert_border #-} -- | Added padding applied to the bounding box when using @invert@. Setting this value too small may result in a "Bad Polygon" error. bindPolygon2D_get_invert_border :: MethodBind bindPolygon2D_get_invert_border = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_invert_border" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Added padding applied to the bounding box when using @invert@. Setting this value too small may result in a "Bad Polygon" error. get_invert_border :: (Polygon2D :< cls, Object :< cls) => cls -> IO Float get_invert_border cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_invert_border (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_invert_border" '[] (IO Float) where nodeMethod = Godot.Core.Polygon2D.get_invert_border {-# NOINLINE bindPolygon2D_get_offset #-} -- | The offset applied to each vertex. bindPolygon2D_get_offset :: MethodBind bindPolygon2D_get_offset = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The offset applied to each vertex. get_offset :: (Polygon2D :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.Polygon2D.get_offset {-# NOINLINE bindPolygon2D_get_polygon #-} -- | The polygon's list of vertices. The final point will be connected to the first. -- __Note:__ This returns a copy of the @PoolVector2Array@ rather than a reference. bindPolygon2D_get_polygon :: MethodBind bindPolygon2D_get_polygon = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's list of vertices. The final point will be connected to the first. -- __Note:__ This returns a copy of the @PoolVector2Array@ rather than a reference. get_polygon :: (Polygon2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_polygon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_polygon" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.Polygon2D.get_polygon {-# NOINLINE bindPolygon2D_get_polygons #-} bindPolygon2D_get_polygons :: MethodBind bindPolygon2D_get_polygons = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_polygons :: (Polygon2D :< cls, Object :< cls) => cls -> IO Array get_polygons cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_polygons" '[] (IO Array) where nodeMethod = Godot.Core.Polygon2D.get_polygons {-# NOINLINE bindPolygon2D_get_skeleton #-} bindPolygon2D_get_skeleton :: MethodBind bindPolygon2D_get_skeleton = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_skeleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_skeleton :: (Polygon2D :< cls, Object :< cls) => cls -> IO NodePath get_skeleton cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_skeleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_skeleton" '[] (IO NodePath) where nodeMethod = Godot.Core.Polygon2D.get_skeleton {-# NOINLINE bindPolygon2D_get_texture #-} -- | The polygon's fill texture. Use @uv@ to set texture coordinates. bindPolygon2D_get_texture :: MethodBind bindPolygon2D_get_texture = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's fill texture. Use @uv@ to set texture coordinates. get_texture :: (Polygon2D :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.Polygon2D.get_texture {-# NOINLINE bindPolygon2D_get_texture_offset #-} -- | Amount to offset the polygon's @texture@. If @(0, 0)@ the texture's origin (its top-left corner) will be placed at the polygon's @position@. bindPolygon2D_get_texture_offset :: MethodBind bindPolygon2D_get_texture_offset = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_texture_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount to offset the polygon's @texture@. If @(0, 0)@ the texture's origin (its top-left corner) will be placed at the polygon's @position@. get_texture_offset :: (Polygon2D :< cls, Object :< cls) => cls -> IO Vector2 get_texture_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_texture_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_texture_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.Polygon2D.get_texture_offset {-# NOINLINE bindPolygon2D_get_texture_rotation #-} -- | The texture's rotation in radians. bindPolygon2D_get_texture_rotation :: MethodBind bindPolygon2D_get_texture_rotation = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_texture_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's rotation in radians. get_texture_rotation :: (Polygon2D :< cls, Object :< cls) => cls -> IO Float get_texture_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_texture_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_texture_rotation" '[] (IO Float) where nodeMethod = Godot.Core.Polygon2D.get_texture_rotation {-# NOINLINE bindPolygon2D_get_texture_rotation_degrees #-} -- | The texture's rotation in degrees. bindPolygon2D_get_texture_rotation_degrees :: MethodBind bindPolygon2D_get_texture_rotation_degrees = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_texture_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's rotation in degrees. get_texture_rotation_degrees :: (Polygon2D :< cls, Object :< cls) => cls -> IO Float get_texture_rotation_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_texture_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_texture_rotation_degrees" '[] (IO Float) where nodeMethod = Godot.Core.Polygon2D.get_texture_rotation_degrees {-# NOINLINE bindPolygon2D_get_texture_scale #-} -- | Amount to multiply the @uv@ coordinates when using a @texture@. Larger values make the texture smaller, and vice versa. bindPolygon2D_get_texture_scale :: MethodBind bindPolygon2D_get_texture_scale = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_texture_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount to multiply the @uv@ coordinates when using a @texture@. Larger values make the texture smaller, and vice versa. get_texture_scale :: (Polygon2D :< cls, Object :< cls) => cls -> IO Vector2 get_texture_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_texture_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_texture_scale" '[] (IO Vector2) where nodeMethod = Godot.Core.Polygon2D.get_texture_scale {-# NOINLINE bindPolygon2D_get_uv #-} -- | Texture coordinates for each vertex of the polygon. There should be one @uv@ per polygon vertex. If there are fewer, undefined vertices will use @(0, 0)@. bindPolygon2D_get_uv :: MethodBind bindPolygon2D_get_uv = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture coordinates for each vertex of the polygon. There should be one @uv@ per polygon vertex. If there are fewer, undefined vertices will use @(0, 0)@. get_uv :: (Polygon2D :< cls, Object :< cls) => cls -> IO PoolVector2Array get_uv cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_uv" '[] (IO PoolVector2Array) where nodeMethod = Godot.Core.Polygon2D.get_uv {-# NOINLINE bindPolygon2D_get_vertex_colors #-} -- | Color for each vertex. Colors are interpolated between vertices, resulting in smooth gradients. There should be one per polygon vertex. If there are fewer, undefined vertices will use @color@. bindPolygon2D_get_vertex_colors :: MethodBind bindPolygon2D_get_vertex_colors = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "get_vertex_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color for each vertex. Colors are interpolated between vertices, resulting in smooth gradients. There should be one per polygon vertex. If there are fewer, undefined vertices will use @color@. get_vertex_colors :: (Polygon2D :< cls, Object :< cls) => cls -> IO PoolColorArray get_vertex_colors cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_get_vertex_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "get_vertex_colors" '[] (IO PoolColorArray) where nodeMethod = Godot.Core.Polygon2D.get_vertex_colors {-# NOINLINE bindPolygon2D_set_antialiased #-} -- | If @true@, polygon edges will be anti-aliased. bindPolygon2D_set_antialiased :: MethodBind bindPolygon2D_set_antialiased = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_antialiased" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, polygon edges will be anti-aliased. set_antialiased :: (Polygon2D :< cls, Object :< cls) => cls -> Bool -> IO () set_antialiased cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_antialiased (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_antialiased" '[Bool] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_antialiased {-# NOINLINE bindPolygon2D_set_bone_path #-} -- | Sets the path to the node associated with the specified bone. bindPolygon2D_set_bone_path :: MethodBind bindPolygon2D_set_bone_path = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_bone_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the path to the node associated with the specified bone. set_bone_path :: (Polygon2D :< cls, Object :< cls) => cls -> Int -> NodePath -> IO () set_bone_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_bone_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_bone_path" '[Int, NodePath] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_bone_path {-# NOINLINE bindPolygon2D_set_bone_weights #-} -- | Sets the weight values for the specified bone. bindPolygon2D_set_bone_weights :: MethodBind bindPolygon2D_set_bone_weights = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_bone_weights" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the weight values for the specified bone. set_bone_weights :: (Polygon2D :< cls, Object :< cls) => cls -> Int -> PoolRealArray -> IO () set_bone_weights cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_bone_weights (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_bone_weights" '[Int, PoolRealArray] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_bone_weights {-# NOINLINE bindPolygon2D_set_color #-} -- | The polygon's fill color. If @texture@ is defined, it will be multiplied by this color. It will also be the default color for vertices not set in @vertex_colors@. bindPolygon2D_set_color :: MethodBind bindPolygon2D_set_color = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's fill color. If @texture@ is defined, it will be multiplied by this color. It will also be the default color for vertices not set in @vertex_colors@. set_color :: (Polygon2D :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_color {-# NOINLINE bindPolygon2D_set_internal_vertex_count #-} bindPolygon2D_set_internal_vertex_count :: MethodBind bindPolygon2D_set_internal_vertex_count = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_internal_vertex_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_internal_vertex_count :: (Polygon2D :< cls, Object :< cls) => cls -> Int -> IO () set_internal_vertex_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_internal_vertex_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_internal_vertex_count" '[Int] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_internal_vertex_count {-# NOINLINE bindPolygon2D_set_invert #-} -- | If @true@, polygon will be inverted, containing the area outside the defined points and extending to the @invert_border@. bindPolygon2D_set_invert :: MethodBind bindPolygon2D_set_invert = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_invert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, polygon will be inverted, containing the area outside the defined points and extending to the @invert_border@. set_invert :: (Polygon2D :< cls, Object :< cls) => cls -> Bool -> IO () set_invert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_invert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_invert" '[Bool] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_invert {-# NOINLINE bindPolygon2D_set_invert_border #-} -- | Added padding applied to the bounding box when using @invert@. Setting this value too small may result in a "Bad Polygon" error. bindPolygon2D_set_invert_border :: MethodBind bindPolygon2D_set_invert_border = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_invert_border" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Added padding applied to the bounding box when using @invert@. Setting this value too small may result in a "Bad Polygon" error. set_invert_border :: (Polygon2D :< cls, Object :< cls) => cls -> Float -> IO () set_invert_border cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_invert_border (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_invert_border" '[Float] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_invert_border {-# NOINLINE bindPolygon2D_set_offset #-} -- | The offset applied to each vertex. bindPolygon2D_set_offset :: MethodBind bindPolygon2D_set_offset = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The offset applied to each vertex. set_offset :: (Polygon2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_offset {-# NOINLINE bindPolygon2D_set_polygon #-} -- | The polygon's list of vertices. The final point will be connected to the first. -- __Note:__ This returns a copy of the @PoolVector2Array@ rather than a reference. bindPolygon2D_set_polygon :: MethodBind bindPolygon2D_set_polygon = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's list of vertices. The final point will be connected to the first. -- __Note:__ This returns a copy of the @PoolVector2Array@ rather than a reference. set_polygon :: (Polygon2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_polygon" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_polygon {-# NOINLINE bindPolygon2D_set_polygons #-} bindPolygon2D_set_polygons :: MethodBind bindPolygon2D_set_polygons = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_polygons" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_polygons :: (Polygon2D :< cls, Object :< cls) => cls -> Array -> IO () set_polygons cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_polygons (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_polygons" '[Array] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_polygons {-# NOINLINE bindPolygon2D_set_skeleton #-} bindPolygon2D_set_skeleton :: MethodBind bindPolygon2D_set_skeleton = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_skeleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_skeleton :: (Polygon2D :< cls, Object :< cls) => cls -> NodePath -> IO () set_skeleton cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_skeleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_skeleton" '[NodePath] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_skeleton {-# NOINLINE bindPolygon2D_set_texture #-} -- | The polygon's fill texture. Use @uv@ to set texture coordinates. bindPolygon2D_set_texture :: MethodBind bindPolygon2D_set_texture = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The polygon's fill texture. Use @uv@ to set texture coordinates. set_texture :: (Polygon2D :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_texture {-# NOINLINE bindPolygon2D_set_texture_offset #-} -- | Amount to offset the polygon's @texture@. If @(0, 0)@ the texture's origin (its top-left corner) will be placed at the polygon's @position@. bindPolygon2D_set_texture_offset :: MethodBind bindPolygon2D_set_texture_offset = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_texture_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount to offset the polygon's @texture@. If @(0, 0)@ the texture's origin (its top-left corner) will be placed at the polygon's @position@. set_texture_offset :: (Polygon2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_texture_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_texture_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_texture_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_texture_offset {-# NOINLINE bindPolygon2D_set_texture_rotation #-} -- | The texture's rotation in radians. bindPolygon2D_set_texture_rotation :: MethodBind bindPolygon2D_set_texture_rotation = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_texture_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's rotation in radians. set_texture_rotation :: (Polygon2D :< cls, Object :< cls) => cls -> Float -> IO () set_texture_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_texture_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_texture_rotation" '[Float] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_texture_rotation {-# NOINLINE bindPolygon2D_set_texture_rotation_degrees #-} -- | The texture's rotation in degrees. bindPolygon2D_set_texture_rotation_degrees :: MethodBind bindPolygon2D_set_texture_rotation_degrees = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_texture_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's rotation in degrees. set_texture_rotation_degrees :: (Polygon2D :< cls, Object :< cls) => cls -> Float -> IO () set_texture_rotation_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_texture_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_texture_rotation_degrees" '[Float] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_texture_rotation_degrees {-# NOINLINE bindPolygon2D_set_texture_scale #-} -- | Amount to multiply the @uv@ coordinates when using a @texture@. Larger values make the texture smaller, and vice versa. bindPolygon2D_set_texture_scale :: MethodBind bindPolygon2D_set_texture_scale = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_texture_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount to multiply the @uv@ coordinates when using a @texture@. Larger values make the texture smaller, and vice versa. set_texture_scale :: (Polygon2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_texture_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_texture_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_texture_scale" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_texture_scale {-# NOINLINE bindPolygon2D_set_uv #-} -- | Texture coordinates for each vertex of the polygon. There should be one @uv@ per polygon vertex. If there are fewer, undefined vertices will use @(0, 0)@. bindPolygon2D_set_uv :: MethodBind bindPolygon2D_set_uv = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture coordinates for each vertex of the polygon. There should be one @uv@ per polygon vertex. If there are fewer, undefined vertices will use @(0, 0)@. set_uv :: (Polygon2D :< cls, Object :< cls) => cls -> PoolVector2Array -> IO () set_uv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_uv" '[PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_uv {-# NOINLINE bindPolygon2D_set_vertex_colors #-} -- | Color for each vertex. Colors are interpolated between vertices, resulting in smooth gradients. There should be one per polygon vertex. If there are fewer, undefined vertices will use @color@. bindPolygon2D_set_vertex_colors :: MethodBind bindPolygon2D_set_vertex_colors = unsafePerformIO $ withCString "Polygon2D" $ \ clsNamePtr -> withCString "set_vertex_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color for each vertex. Colors are interpolated between vertices, resulting in smooth gradients. There should be one per polygon vertex. If there are fewer, undefined vertices will use @color@. set_vertex_colors :: (Polygon2D :< cls, Object :< cls) => cls -> PoolColorArray -> IO () set_vertex_colors cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygon2D_set_vertex_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Polygon2D "set_vertex_colors" '[PoolColorArray] (IO ()) where nodeMethod = Godot.Core.Polygon2D.set_vertex_colors ================================================ FILE: src/Godot/Core/PolygonPathFinder.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PolygonPathFinder (Godot.Core.PolygonPathFinder._get_data, Godot.Core.PolygonPathFinder._set_data, Godot.Core.PolygonPathFinder.find_path, Godot.Core.PolygonPathFinder.get_bounds, Godot.Core.PolygonPathFinder.get_closest_point, Godot.Core.PolygonPathFinder.get_intersections, Godot.Core.PolygonPathFinder.get_point_penalty, Godot.Core.PolygonPathFinder.is_point_inside, Godot.Core.PolygonPathFinder.set_point_penalty, Godot.Core.PolygonPathFinder.setup) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty PolygonPathFinder "data" Dictionary 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) {-# NOINLINE bindPolygonPathFinder__get_data #-} bindPolygonPathFinder__get_data :: MethodBind bindPolygonPathFinder__get_data = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_data :: (PolygonPathFinder :< cls, Object :< cls) => cls -> IO Dictionary _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "_get_data" '[] (IO Dictionary) where nodeMethod = Godot.Core.PolygonPathFinder._get_data {-# NOINLINE bindPolygonPathFinder__set_data #-} bindPolygonPathFinder__set_data :: MethodBind bindPolygonPathFinder__set_data = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_data :: (PolygonPathFinder :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "_set_data" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.PolygonPathFinder._set_data {-# NOINLINE bindPolygonPathFinder_find_path #-} bindPolygonPathFinder_find_path :: MethodBind bindPolygonPathFinder_find_path = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "find_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr find_path :: (PolygonPathFinder :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> IO PoolVector2Array find_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder_find_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "find_path" '[Vector2, Vector2] (IO PoolVector2Array) where nodeMethod = Godot.Core.PolygonPathFinder.find_path {-# NOINLINE bindPolygonPathFinder_get_bounds #-} bindPolygonPathFinder_get_bounds :: MethodBind bindPolygonPathFinder_get_bounds = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "get_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bounds :: (PolygonPathFinder :< cls, Object :< cls) => cls -> IO Rect2 get_bounds cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder_get_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "get_bounds" '[] (IO Rect2) where nodeMethod = Godot.Core.PolygonPathFinder.get_bounds {-# NOINLINE bindPolygonPathFinder_get_closest_point #-} bindPolygonPathFinder_get_closest_point :: MethodBind bindPolygonPathFinder_get_closest_point = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "get_closest_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_closest_point :: (PolygonPathFinder :< cls, Object :< cls) => cls -> Vector2 -> IO Vector2 get_closest_point cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder_get_closest_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "get_closest_point" '[Vector2] (IO Vector2) where nodeMethod = Godot.Core.PolygonPathFinder.get_closest_point {-# NOINLINE bindPolygonPathFinder_get_intersections #-} bindPolygonPathFinder_get_intersections :: MethodBind bindPolygonPathFinder_get_intersections = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "get_intersections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_intersections :: (PolygonPathFinder :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> IO PoolVector2Array get_intersections cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder_get_intersections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "get_intersections" '[Vector2, Vector2] (IO PoolVector2Array) where nodeMethod = Godot.Core.PolygonPathFinder.get_intersections {-# NOINLINE bindPolygonPathFinder_get_point_penalty #-} bindPolygonPathFinder_get_point_penalty :: MethodBind bindPolygonPathFinder_get_point_penalty = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "get_point_penalty" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_point_penalty :: (PolygonPathFinder :< cls, Object :< cls) => cls -> Int -> IO Float get_point_penalty cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder_get_point_penalty (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "get_point_penalty" '[Int] (IO Float) where nodeMethod = Godot.Core.PolygonPathFinder.get_point_penalty {-# NOINLINE bindPolygonPathFinder_is_point_inside #-} bindPolygonPathFinder_is_point_inside :: MethodBind bindPolygonPathFinder_is_point_inside = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "is_point_inside" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_point_inside :: (PolygonPathFinder :< cls, Object :< cls) => cls -> Vector2 -> IO Bool is_point_inside cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder_is_point_inside (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "is_point_inside" '[Vector2] (IO Bool) where nodeMethod = Godot.Core.PolygonPathFinder.is_point_inside {-# NOINLINE bindPolygonPathFinder_set_point_penalty #-} bindPolygonPathFinder_set_point_penalty :: MethodBind bindPolygonPathFinder_set_point_penalty = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "set_point_penalty" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_point_penalty :: (PolygonPathFinder :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_point_penalty cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder_set_point_penalty (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "set_point_penalty" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.PolygonPathFinder.set_point_penalty {-# NOINLINE bindPolygonPathFinder_setup #-} bindPolygonPathFinder_setup :: MethodBind bindPolygonPathFinder_setup = unsafePerformIO $ withCString "PolygonPathFinder" $ \ clsNamePtr -> withCString "setup" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr setup :: (PolygonPathFinder :< cls, Object :< cls) => cls -> PoolVector2Array -> PoolIntArray -> IO () setup cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPolygonPathFinder_setup (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PolygonPathFinder "setup" '[PoolVector2Array, PoolIntArray] (IO ()) where nodeMethod = Godot.Core.PolygonPathFinder.setup ================================================ FILE: src/Godot/Core/Popup.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Popup (Godot.Core.Popup._NOTIFICATION_POST_POPUP, Godot.Core.Popup._NOTIFICATION_POPUP_HIDE, Godot.Core.Popup.sig_about_to_show, Godot.Core.Popup.sig_popup_hide, Godot.Core.Popup.is_exclusive, Godot.Core.Popup.popup, Godot.Core.Popup.popup_centered, Godot.Core.Popup.popup_centered_clamped, Godot.Core.Popup.popup_centered_minsize, Godot.Core.Popup.popup_centered_ratio, Godot.Core.Popup.set_as_minsize, Godot.Core.Popup.set_exclusive) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _NOTIFICATION_POST_POPUP :: Int _NOTIFICATION_POST_POPUP = 80 _NOTIFICATION_POPUP_HIDE :: Int _NOTIFICATION_POPUP_HIDE = 81 -- | Emitted when a popup is about to be shown. This is often used in @PopupMenu@ to clear the list of options then create a new one according to the current context. sig_about_to_show :: Godot.Internal.Dispatch.Signal Popup sig_about_to_show = Godot.Internal.Dispatch.Signal "about_to_show" instance NodeSignal Popup "about_to_show" '[] -- | Emitted when a popup is hidden. sig_popup_hide :: Godot.Internal.Dispatch.Signal Popup sig_popup_hide = Godot.Internal.Dispatch.Signal "popup_hide" instance NodeSignal Popup "popup_hide" '[] instance NodeProperty Popup "popup_exclusive" Bool 'False where nodeProperty = (is_exclusive, wrapDroppingSetter set_exclusive, Nothing) {-# NOINLINE bindPopup_is_exclusive #-} -- | If @true@, the popup will not be hidden when a click event occurs outside of it, or when it receives the @ui_cancel@ action event. -- __Note:__ Enabling this property doesn't affect the Close or Cancel buttons' behavior in dialogs that inherit from this class. As a workaround, you can use @method WindowDialog.get_close_button@ or @method ConfirmationDialog.get_cancel@ and hide the buttons in question by setting their @CanvasItem.visible@ property to @false@. bindPopup_is_exclusive :: MethodBind bindPopup_is_exclusive = unsafePerformIO $ withCString "Popup" $ \ clsNamePtr -> withCString "is_exclusive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the popup will not be hidden when a click event occurs outside of it, or when it receives the @ui_cancel@ action event. -- __Note:__ Enabling this property doesn't affect the Close or Cancel buttons' behavior in dialogs that inherit from this class. As a workaround, you can use @method WindowDialog.get_close_button@ or @method ConfirmationDialog.get_cancel@ and hide the buttons in question by setting their @CanvasItem.visible@ property to @false@. is_exclusive :: (Popup :< cls, Object :< cls) => cls -> IO Bool is_exclusive cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopup_is_exclusive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Popup "is_exclusive" '[] (IO Bool) where nodeMethod = Godot.Core.Popup.is_exclusive {-# NOINLINE bindPopup_popup #-} -- | Popup (show the control in modal form). bindPopup_popup :: MethodBind bindPopup_popup = unsafePerformIO $ withCString "Popup" $ \ clsNamePtr -> withCString "popup" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Popup (show the control in modal form). popup :: (Popup :< cls, Object :< cls) => cls -> Maybe Rect2 -> IO () popup cls arg1 = withVariantArray [defaultedVariant VariantRect2 (V2 (V2 0 0) (V2 0 0)) arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopup_popup (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Popup "popup" '[Maybe Rect2] (IO ()) where nodeMethod = Godot.Core.Popup.popup {-# NOINLINE bindPopup_popup_centered #-} -- | Popup (show the control in modal form) in the center of the screen relative to its current canvas transform, at the current size, or at a size determined by @size@. bindPopup_popup_centered :: MethodBind bindPopup_popup_centered = unsafePerformIO $ withCString "Popup" $ \ clsNamePtr -> withCString "popup_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Popup (show the control in modal form) in the center of the screen relative to its current canvas transform, at the current size, or at a size determined by @size@. popup_centered :: (Popup :< cls, Object :< cls) => cls -> Maybe Vector2 -> IO () popup_centered cls arg1 = withVariantArray [defaultedVariant VariantVector2 (V2 0 0) arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopup_popup_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Popup "popup_centered" '[Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.Popup.popup_centered {-# NOINLINE bindPopup_popup_centered_clamped #-} -- | Popup (show the control in modal form) in the center of the screen relative to the current canvas transform, clamping the size to @size@, then ensuring the popup is no larger than the viewport size multiplied by @fallback_ratio@. bindPopup_popup_centered_clamped :: MethodBind bindPopup_popup_centered_clamped = unsafePerformIO $ withCString "Popup" $ \ clsNamePtr -> withCString "popup_centered_clamped" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Popup (show the control in modal form) in the center of the screen relative to the current canvas transform, clamping the size to @size@, then ensuring the popup is no larger than the viewport size multiplied by @fallback_ratio@. popup_centered_clamped :: (Popup :< cls, Object :< cls) => cls -> Maybe Vector2 -> Maybe Float -> IO () popup_centered_clamped cls arg1 arg2 = withVariantArray [defaultedVariant VariantVector2 (V2 0 0) arg1, maybe (VariantReal (0.75)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopup_popup_centered_clamped (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Popup "popup_centered_clamped" '[Maybe Vector2, Maybe Float] (IO ()) where nodeMethod = Godot.Core.Popup.popup_centered_clamped {-# NOINLINE bindPopup_popup_centered_minsize #-} -- | Popup (show the control in modal form) in the center of the screen relative to the current canvas transform, ensuring the size is never smaller than @minsize@. bindPopup_popup_centered_minsize :: MethodBind bindPopup_popup_centered_minsize = unsafePerformIO $ withCString "Popup" $ \ clsNamePtr -> withCString "popup_centered_minsize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Popup (show the control in modal form) in the center of the screen relative to the current canvas transform, ensuring the size is never smaller than @minsize@. popup_centered_minsize :: (Popup :< cls, Object :< cls) => cls -> Maybe Vector2 -> IO () popup_centered_minsize cls arg1 = withVariantArray [defaultedVariant VariantVector2 (V2 0 0) arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopup_popup_centered_minsize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Popup "popup_centered_minsize" '[Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.Popup.popup_centered_minsize {-# NOINLINE bindPopup_popup_centered_ratio #-} -- | Popup (show the control in modal form) in the center of the screen relative to the current canvas transform, scaled at a ratio of size of the screen. bindPopup_popup_centered_ratio :: MethodBind bindPopup_popup_centered_ratio = unsafePerformIO $ withCString "Popup" $ \ clsNamePtr -> withCString "popup_centered_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Popup (show the control in modal form) in the center of the screen relative to the current canvas transform, scaled at a ratio of size of the screen. popup_centered_ratio :: (Popup :< cls, Object :< cls) => cls -> Maybe Float -> IO () popup_centered_ratio cls arg1 = withVariantArray [maybe (VariantReal (0.75)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopup_popup_centered_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Popup "popup_centered_ratio" '[Maybe Float] (IO ()) where nodeMethod = Godot.Core.Popup.popup_centered_ratio {-# NOINLINE bindPopup_set_as_minsize #-} -- | Shrink popup to keep to the minimum size of content. bindPopup_set_as_minsize :: MethodBind bindPopup_set_as_minsize = unsafePerformIO $ withCString "Popup" $ \ clsNamePtr -> withCString "set_as_minsize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shrink popup to keep to the minimum size of content. set_as_minsize :: (Popup :< cls, Object :< cls) => cls -> IO () set_as_minsize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopup_set_as_minsize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Popup "set_as_minsize" '[] (IO ()) where nodeMethod = Godot.Core.Popup.set_as_minsize {-# NOINLINE bindPopup_set_exclusive #-} -- | If @true@, the popup will not be hidden when a click event occurs outside of it, or when it receives the @ui_cancel@ action event. -- __Note:__ Enabling this property doesn't affect the Close or Cancel buttons' behavior in dialogs that inherit from this class. As a workaround, you can use @method WindowDialog.get_close_button@ or @method ConfirmationDialog.get_cancel@ and hide the buttons in question by setting their @CanvasItem.visible@ property to @false@. bindPopup_set_exclusive :: MethodBind bindPopup_set_exclusive = unsafePerformIO $ withCString "Popup" $ \ clsNamePtr -> withCString "set_exclusive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the popup will not be hidden when a click event occurs outside of it, or when it receives the @ui_cancel@ action event. -- __Note:__ Enabling this property doesn't affect the Close or Cancel buttons' behavior in dialogs that inherit from this class. As a workaround, you can use @method WindowDialog.get_close_button@ or @method ConfirmationDialog.get_cancel@ and hide the buttons in question by setting their @CanvasItem.visible@ property to @false@. set_exclusive :: (Popup :< cls, Object :< cls) => cls -> Bool -> IO () set_exclusive cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopup_set_exclusive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Popup "set_exclusive" '[Bool] (IO ()) where nodeMethod = Godot.Core.Popup.set_exclusive ================================================ FILE: src/Godot/Core/PopupDialog.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PopupDialog () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Popup() ================================================ FILE: src/Godot/Core/PopupMenu.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PopupMenu (Godot.Core.PopupMenu.sig_id_focused, Godot.Core.PopupMenu.sig_id_pressed, Godot.Core.PopupMenu.sig_index_pressed, Godot.Core.PopupMenu._get_items, Godot.Core.PopupMenu._gui_input, Godot.Core.PopupMenu._set_items, Godot.Core.PopupMenu._submenu_timeout, Godot.Core.PopupMenu.add_check_item, Godot.Core.PopupMenu.add_check_shortcut, Godot.Core.PopupMenu.add_icon_check_item, Godot.Core.PopupMenu.add_icon_check_shortcut, Godot.Core.PopupMenu.add_icon_item, Godot.Core.PopupMenu.add_icon_radio_check_item, Godot.Core.PopupMenu.add_icon_radio_check_shortcut, Godot.Core.PopupMenu.add_icon_shortcut, Godot.Core.PopupMenu.add_item, Godot.Core.PopupMenu.add_multistate_item, Godot.Core.PopupMenu.add_radio_check_item, Godot.Core.PopupMenu.add_radio_check_shortcut, Godot.Core.PopupMenu.add_separator, Godot.Core.PopupMenu.add_shortcut, Godot.Core.PopupMenu.add_submenu_item, Godot.Core.PopupMenu.clear, Godot.Core.PopupMenu.get_allow_search, Godot.Core.PopupMenu.get_item_accelerator, Godot.Core.PopupMenu.get_item_count, Godot.Core.PopupMenu.get_item_icon, Godot.Core.PopupMenu.get_item_id, Godot.Core.PopupMenu.get_item_index, Godot.Core.PopupMenu.get_item_metadata, Godot.Core.PopupMenu.get_item_shortcut, Godot.Core.PopupMenu.get_item_submenu, Godot.Core.PopupMenu.get_item_text, Godot.Core.PopupMenu.get_item_tooltip, Godot.Core.PopupMenu.get_submenu_popup_delay, Godot.Core.PopupMenu.is_hide_on_checkable_item_selection, Godot.Core.PopupMenu.is_hide_on_item_selection, Godot.Core.PopupMenu.is_hide_on_state_item_selection, Godot.Core.PopupMenu.is_hide_on_window_lose_focus, Godot.Core.PopupMenu.is_item_checkable, Godot.Core.PopupMenu.is_item_checked, Godot.Core.PopupMenu.is_item_disabled, Godot.Core.PopupMenu.is_item_radio_checkable, Godot.Core.PopupMenu.is_item_separator, Godot.Core.PopupMenu.is_item_shortcut_disabled, Godot.Core.PopupMenu.remove_item, Godot.Core.PopupMenu.set_allow_search, Godot.Core.PopupMenu.set_hide_on_checkable_item_selection, Godot.Core.PopupMenu.set_hide_on_item_selection, Godot.Core.PopupMenu.set_hide_on_state_item_selection, Godot.Core.PopupMenu.set_hide_on_window_lose_focus, Godot.Core.PopupMenu.set_item_accelerator, Godot.Core.PopupMenu.set_item_as_checkable, Godot.Core.PopupMenu.set_item_as_radio_checkable, Godot.Core.PopupMenu.set_item_as_separator, Godot.Core.PopupMenu.set_item_checked, Godot.Core.PopupMenu.set_item_disabled, Godot.Core.PopupMenu.set_item_icon, Godot.Core.PopupMenu.set_item_id, Godot.Core.PopupMenu.set_item_metadata, Godot.Core.PopupMenu.set_item_multistate, Godot.Core.PopupMenu.set_item_shortcut, Godot.Core.PopupMenu.set_item_shortcut_disabled, Godot.Core.PopupMenu.set_item_submenu, Godot.Core.PopupMenu.set_item_text, Godot.Core.PopupMenu.set_item_tooltip, Godot.Core.PopupMenu.set_submenu_popup_delay, Godot.Core.PopupMenu.toggle_item_checked, Godot.Core.PopupMenu.toggle_item_multistate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Popup() -- | Emitted when user navigated to an item of some @id@ using @ui_up@ or @ui_down@ action. sig_id_focused :: Godot.Internal.Dispatch.Signal PopupMenu sig_id_focused = Godot.Internal.Dispatch.Signal "id_focused" instance NodeSignal PopupMenu "id_focused" '[Int] -- | Emitted when an item of some @id@ is pressed or its accelerator is activated. sig_id_pressed :: Godot.Internal.Dispatch.Signal PopupMenu sig_id_pressed = Godot.Internal.Dispatch.Signal "id_pressed" instance NodeSignal PopupMenu "id_pressed" '[Int] -- | Emitted when an item of some @index@ is pressed or its accelerator is activated. sig_index_pressed :: Godot.Internal.Dispatch.Signal PopupMenu sig_index_pressed = Godot.Internal.Dispatch.Signal "index_pressed" instance NodeSignal PopupMenu "index_pressed" '[Int] instance NodeProperty PopupMenu "allow_search" Bool 'False where nodeProperty = (get_allow_search, wrapDroppingSetter set_allow_search, Nothing) instance NodeProperty PopupMenu "hide_on_checkable_item_selection" Bool 'False where nodeProperty = (is_hide_on_checkable_item_selection, wrapDroppingSetter set_hide_on_checkable_item_selection, Nothing) instance NodeProperty PopupMenu "hide_on_item_selection" Bool 'False where nodeProperty = (is_hide_on_item_selection, wrapDroppingSetter set_hide_on_item_selection, Nothing) instance NodeProperty PopupMenu "hide_on_state_item_selection" Bool 'False where nodeProperty = (is_hide_on_state_item_selection, wrapDroppingSetter set_hide_on_state_item_selection, Nothing) instance NodeProperty PopupMenu "items" Array 'False where nodeProperty = (_get_items, wrapDroppingSetter _set_items, Nothing) instance NodeProperty PopupMenu "submenu_popup_delay" Float 'False where nodeProperty = (get_submenu_popup_delay, wrapDroppingSetter set_submenu_popup_delay, Nothing) {-# NOINLINE bindPopupMenu__get_items #-} bindPopupMenu__get_items :: MethodBind bindPopupMenu__get_items = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "_get_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_items :: (PopupMenu :< cls, Object :< cls) => cls -> IO Array _get_items cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu__get_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "_get_items" '[] (IO Array) where nodeMethod = Godot.Core.PopupMenu._get_items {-# NOINLINE bindPopupMenu__gui_input #-} bindPopupMenu__gui_input :: MethodBind bindPopupMenu__gui_input = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (PopupMenu :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.PopupMenu._gui_input {-# NOINLINE bindPopupMenu__set_items #-} bindPopupMenu__set_items :: MethodBind bindPopupMenu__set_items = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "_set_items" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_items :: (PopupMenu :< cls, Object :< cls) => cls -> Array -> IO () _set_items cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu__set_items (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "_set_items" '[Array] (IO ()) where nodeMethod = Godot.Core.PopupMenu._set_items {-# NOINLINE bindPopupMenu__submenu_timeout #-} bindPopupMenu__submenu_timeout :: MethodBind bindPopupMenu__submenu_timeout = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "_submenu_timeout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _submenu_timeout :: (PopupMenu :< cls, Object :< cls) => cls -> IO () _submenu_timeout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu__submenu_timeout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "_submenu_timeout" '[] (IO ()) where nodeMethod = Godot.Core.PopupMenu._submenu_timeout {-# NOINLINE bindPopupMenu_add_check_item #-} -- | Adds a new checkable item with text @label@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. bindPopupMenu_add_check_item :: MethodBind bindPopupMenu_add_check_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_check_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new checkable item with text @label@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. add_check_item :: (PopupMenu :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> Maybe Int -> IO () add_check_item cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_check_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_check_item" '[GodotString, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_check_item {-# NOINLINE bindPopupMenu_add_check_shortcut #-} -- | Adds a new checkable item and assigns the specified @ShortCut@ to it. Sets the label of the checkbox to the @ShortCut@'s name. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. bindPopupMenu_add_check_shortcut :: MethodBind bindPopupMenu_add_check_shortcut = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_check_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new checkable item and assigns the specified @ShortCut@ to it. Sets the label of the checkbox to the @ShortCut@'s name. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. add_check_shortcut :: (PopupMenu :< cls, Object :< cls) => cls -> ShortCut -> Maybe Int -> Maybe Bool -> IO () add_check_shortcut cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_check_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_check_shortcut" '[ShortCut, Maybe Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_check_shortcut {-# NOINLINE bindPopupMenu_add_icon_check_item #-} -- | Adds a new checkable item with text @label@ and icon @texture@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. bindPopupMenu_add_icon_check_item :: MethodBind bindPopupMenu_add_icon_check_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_icon_check_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new checkable item with text @label@ and icon @texture@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. add_icon_check_item :: (PopupMenu :< cls, Object :< cls) => cls -> Texture -> GodotString -> Maybe Int -> Maybe Int -> IO () add_icon_check_item cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3, maybe (VariantInt (0)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_icon_check_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_icon_check_item" '[Texture, GodotString, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_icon_check_item {-# NOINLINE bindPopupMenu_add_icon_check_shortcut #-} -- | Adds a new checkable item and assigns the specified @ShortCut@ and icon @texture@ to it. Sets the label of the checkbox to the @ShortCut@'s name. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. bindPopupMenu_add_icon_check_shortcut :: MethodBind bindPopupMenu_add_icon_check_shortcut = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_icon_check_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new checkable item and assigns the specified @ShortCut@ and icon @texture@ to it. Sets the label of the checkbox to the @ShortCut@'s name. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. add_icon_check_shortcut :: (PopupMenu :< cls, Object :< cls) => cls -> Texture -> ShortCut -> Maybe Int -> Maybe Bool -> IO () add_icon_check_shortcut cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_icon_check_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_icon_check_shortcut" '[Texture, ShortCut, Maybe Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_icon_check_shortcut {-# NOINLINE bindPopupMenu_add_icon_item #-} -- | Adds a new item with text @label@ and icon @texture@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. bindPopupMenu_add_icon_item :: MethodBind bindPopupMenu_add_icon_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_icon_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new item with text @label@ and icon @texture@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. add_icon_item :: (PopupMenu :< cls, Object :< cls) => cls -> Texture -> GodotString -> Maybe Int -> Maybe Int -> IO () add_icon_item cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3, maybe (VariantInt (0)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_icon_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_icon_item" '[Texture, GodotString, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_icon_item {-# NOINLINE bindPopupMenu_add_icon_radio_check_item #-} -- | Same as @method add_icon_check_item@, but uses a radio check button. bindPopupMenu_add_icon_radio_check_item :: MethodBind bindPopupMenu_add_icon_radio_check_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_icon_radio_check_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Same as @method add_icon_check_item@, but uses a radio check button. add_icon_radio_check_item :: (PopupMenu :< cls, Object :< cls) => cls -> Texture -> GodotString -> Maybe Int -> Maybe Int -> IO () add_icon_radio_check_item cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3, maybe (VariantInt (0)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_icon_radio_check_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_icon_radio_check_item" '[Texture, GodotString, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_icon_radio_check_item {-# NOINLINE bindPopupMenu_add_icon_radio_check_shortcut #-} -- | Same as @method add_icon_check_shortcut@, but uses a radio check button. bindPopupMenu_add_icon_radio_check_shortcut :: MethodBind bindPopupMenu_add_icon_radio_check_shortcut = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_icon_radio_check_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Same as @method add_icon_check_shortcut@, but uses a radio check button. add_icon_radio_check_shortcut :: (PopupMenu :< cls, Object :< cls) => cls -> Texture -> ShortCut -> Maybe Int -> Maybe Bool -> IO () add_icon_radio_check_shortcut cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_icon_radio_check_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_icon_radio_check_shortcut" '[Texture, ShortCut, Maybe Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_icon_radio_check_shortcut {-# NOINLINE bindPopupMenu_add_icon_shortcut #-} -- | Adds a new item and assigns the specified @ShortCut@ and icon @texture@ to it. Sets the label of the checkbox to the @ShortCut@'s name. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. bindPopupMenu_add_icon_shortcut :: MethodBind bindPopupMenu_add_icon_shortcut = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_icon_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new item and assigns the specified @ShortCut@ and icon @texture@ to it. Sets the label of the checkbox to the @ShortCut@'s name. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. add_icon_shortcut :: (PopupMenu :< cls, Object :< cls) => cls -> Texture -> ShortCut -> Maybe Int -> Maybe Bool -> IO () add_icon_shortcut cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_icon_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_icon_shortcut" '[Texture, ShortCut, Maybe Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_icon_shortcut {-# NOINLINE bindPopupMenu_add_item #-} -- | Adds a new item with text @label@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. bindPopupMenu_add_item :: MethodBind bindPopupMenu_add_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new item with text @label@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. add_item :: (PopupMenu :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> Maybe Int -> IO () add_item cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_item" '[GodotString, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_item {-# NOINLINE bindPopupMenu_add_multistate_item #-} -- | Adds a new multistate item with text @label@. -- Contrarily to normal binary items, multistate items can have more than two states, as defined by @max_states@. Each press or activate of the item will increase the state by one. The default value is defined by @default_state@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. bindPopupMenu_add_multistate_item :: MethodBind bindPopupMenu_add_multistate_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_multistate_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new multistate item with text @label@. -- Contrarily to normal binary items, multistate items can have more than two states, as defined by @max_states@. Each press or activate of the item will increase the state by one. The default value is defined by @default_state@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. add_multistate_item :: (PopupMenu :< cls, Object :< cls) => cls -> GodotString -> Int -> Maybe Int -> Maybe Int -> Maybe Int -> IO () add_multistate_item cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (0)) toVariant arg3, maybe (VariantInt (-1)) toVariant arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_multistate_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_multistate_item" '[GodotString, Int, Maybe Int, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_multistate_item {-# NOINLINE bindPopupMenu_add_radio_check_item #-} -- | Adds a new radio check button with text @label@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. bindPopupMenu_add_radio_check_item :: MethodBind bindPopupMenu_add_radio_check_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_radio_check_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new radio check button with text @label@. -- An @id@ can optionally be provided, as well as an accelerator (@accel@). If no @id@ is provided, one will be created from the index. If no @accel@ is provided then the default @0@ will be assigned to it. See @method get_item_accelerator@ for more info on accelerators. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. add_radio_check_item :: (PopupMenu :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> Maybe Int -> IO () add_radio_check_item cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_radio_check_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_radio_check_item" '[GodotString, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_radio_check_item {-# NOINLINE bindPopupMenu_add_radio_check_shortcut #-} -- | Adds a new radio check button and assigns a @ShortCut@ to it. Sets the label of the checkbox to the @ShortCut@'s name. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. bindPopupMenu_add_radio_check_shortcut :: MethodBind bindPopupMenu_add_radio_check_shortcut = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_radio_check_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new radio check button and assigns a @ShortCut@ to it. Sets the label of the checkbox to the @ShortCut@'s name. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See @method set_item_checked@ for more info on how to control it. add_radio_check_shortcut :: (PopupMenu :< cls, Object :< cls) => cls -> ShortCut -> Maybe Int -> Maybe Bool -> IO () add_radio_check_shortcut cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_radio_check_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_radio_check_shortcut" '[ShortCut, Maybe Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_radio_check_shortcut {-# NOINLINE bindPopupMenu_add_separator #-} -- | Adds a separator between items. Separators also occupy an index. bindPopupMenu_add_separator :: MethodBind bindPopupMenu_add_separator = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_separator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a separator between items. Separators also occupy an index. add_separator :: (PopupMenu :< cls, Object :< cls) => cls -> Maybe GodotString -> IO () add_separator cls arg1 = withVariantArray [defaultedVariant VariantString "" arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_separator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_separator" '[Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_separator {-# NOINLINE bindPopupMenu_add_shortcut #-} -- | Adds a @ShortCut@. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. bindPopupMenu_add_shortcut :: MethodBind bindPopupMenu_add_shortcut = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @ShortCut@. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. add_shortcut :: (PopupMenu :< cls, Object :< cls) => cls -> ShortCut -> Maybe Int -> Maybe Bool -> IO () add_shortcut cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_shortcut" '[ShortCut, Maybe Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_shortcut {-# NOINLINE bindPopupMenu_add_submenu_item #-} -- | Adds an item that will act as a submenu of the parent @PopupMenu@ node when clicked. The @submenu@ argument is the name of the child @PopupMenu@ node that will be shown when the item is clicked. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. bindPopupMenu_add_submenu_item :: MethodBind bindPopupMenu_add_submenu_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "add_submenu_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an item that will act as a submenu of the parent @PopupMenu@ node when clicked. The @submenu@ argument is the name of the child @PopupMenu@ node that will be shown when the item is clicked. -- An @id@ can optionally be provided. If no @id@ is provided, one will be created from the index. add_submenu_item :: (PopupMenu :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Maybe Int -> IO () add_submenu_item cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_add_submenu_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "add_submenu_item" '[GodotString, GodotString, Maybe Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.add_submenu_item {-# NOINLINE bindPopupMenu_clear #-} -- | Removes all items from the @PopupMenu@. bindPopupMenu_clear :: MethodBind bindPopupMenu_clear = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all items from the @PopupMenu@. clear :: (PopupMenu :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "clear" '[] (IO ()) where nodeMethod = Godot.Core.PopupMenu.clear {-# NOINLINE bindPopupMenu_get_allow_search #-} -- | If @true@, allows to navigate @PopupMenu@ with letter keys. bindPopupMenu_get_allow_search :: MethodBind bindPopupMenu_get_allow_search = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_allow_search" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allows to navigate @PopupMenu@ with letter keys. get_allow_search :: (PopupMenu :< cls, Object :< cls) => cls -> IO Bool get_allow_search cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_allow_search (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_allow_search" '[] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.get_allow_search {-# NOINLINE bindPopupMenu_get_item_accelerator #-} -- | Returns the accelerator of the item at index @idx@. Accelerators are special combinations of keys that activate the item, no matter which control is focused. bindPopupMenu_get_item_accelerator :: MethodBind bindPopupMenu_get_item_accelerator = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_accelerator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the accelerator of the item at index @idx@. Accelerators are special combinations of keys that activate the item, no matter which control is focused. get_item_accelerator :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Int get_item_accelerator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_accelerator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_accelerator" '[Int] (IO Int) where nodeMethod = Godot.Core.PopupMenu.get_item_accelerator {-# NOINLINE bindPopupMenu_get_item_count #-} -- | Returns the number of items in the @PopupMenu@. bindPopupMenu_get_item_count :: MethodBind bindPopupMenu_get_item_count = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of items in the @PopupMenu@. get_item_count :: (PopupMenu :< cls, Object :< cls) => cls -> IO Int get_item_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_count" '[] (IO Int) where nodeMethod = Godot.Core.PopupMenu.get_item_count {-# NOINLINE bindPopupMenu_get_item_icon #-} -- | Returns the icon of the item at index @idx@. bindPopupMenu_get_item_icon :: MethodBind bindPopupMenu_get_item_icon = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the icon of the item at index @idx@. get_item_icon :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Texture get_item_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_icon" '[Int] (IO Texture) where nodeMethod = Godot.Core.PopupMenu.get_item_icon {-# NOINLINE bindPopupMenu_get_item_id #-} -- | Returns the id of the item at index @idx@. @id@ can be manually assigned, while index can not. bindPopupMenu_get_item_id :: MethodBind bindPopupMenu_get_item_id = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the id of the item at index @idx@. @id@ can be manually assigned, while index can not. get_item_id :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Int get_item_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_id" '[Int] (IO Int) where nodeMethod = Godot.Core.PopupMenu.get_item_id {-# NOINLINE bindPopupMenu_get_item_index #-} -- | Returns the index of the item containing the specified @id@. Index is automatically assigned to each item by the engine. Index can not be set manually. bindPopupMenu_get_item_index :: MethodBind bindPopupMenu_get_item_index = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the item containing the specified @id@. Index is automatically assigned to each item by the engine. Index can not be set manually. get_item_index :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Int get_item_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_index" '[Int] (IO Int) where nodeMethod = Godot.Core.PopupMenu.get_item_index {-# NOINLINE bindPopupMenu_get_item_metadata #-} -- | Returns the metadata of the specified item, which might be of any type. You can set it with @method set_item_metadata@, which provides a simple way of assigning context data to items. bindPopupMenu_get_item_metadata :: MethodBind bindPopupMenu_get_item_metadata = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the metadata of the specified item, which might be of any type. You can set it with @method set_item_metadata@, which provides a simple way of assigning context data to items. get_item_metadata :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_item_metadata cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_metadata" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.PopupMenu.get_item_metadata {-# NOINLINE bindPopupMenu_get_item_shortcut #-} -- | Returns the @ShortCut@ associated with the specified @idx@ item. bindPopupMenu_get_item_shortcut :: MethodBind bindPopupMenu_get_item_shortcut = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @ShortCut@ associated with the specified @idx@ item. get_item_shortcut :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO ShortCut get_item_shortcut cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_shortcut" '[Int] (IO ShortCut) where nodeMethod = Godot.Core.PopupMenu.get_item_shortcut {-# NOINLINE bindPopupMenu_get_item_submenu #-} -- | Returns the submenu name of the item at index @idx@. See @method add_submenu_item@ for more info on how to add a submenu. bindPopupMenu_get_item_submenu :: MethodBind bindPopupMenu_get_item_submenu = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_submenu" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the submenu name of the item at index @idx@. See @method add_submenu_item@ for more info on how to add a submenu. get_item_submenu :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO GodotString get_item_submenu cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_submenu (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_submenu" '[Int] (IO GodotString) where nodeMethod = Godot.Core.PopupMenu.get_item_submenu {-# NOINLINE bindPopupMenu_get_item_text #-} -- | Returns the text of the item at index @idx@. bindPopupMenu_get_item_text :: MethodBind bindPopupMenu_get_item_text = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the text of the item at index @idx@. get_item_text :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO GodotString get_item_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_text" '[Int] (IO GodotString) where nodeMethod = Godot.Core.PopupMenu.get_item_text {-# NOINLINE bindPopupMenu_get_item_tooltip #-} -- | Returns the tooltip associated with the specified index index @idx@. bindPopupMenu_get_item_tooltip :: MethodBind bindPopupMenu_get_item_tooltip = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_item_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tooltip associated with the specified index index @idx@. get_item_tooltip :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO GodotString get_item_tooltip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_item_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_item_tooltip" '[Int] (IO GodotString) where nodeMethod = Godot.Core.PopupMenu.get_item_tooltip {-# NOINLINE bindPopupMenu_get_submenu_popup_delay #-} -- | Sets the delay time in seconds for the submenu item to popup on mouse hovering. If the popup menu is added as a child of another (acting as a submenu), it will inherit the delay time of the parent menu item. bindPopupMenu_get_submenu_popup_delay :: MethodBind bindPopupMenu_get_submenu_popup_delay = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "get_submenu_popup_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the delay time in seconds for the submenu item to popup on mouse hovering. If the popup menu is added as a child of another (acting as a submenu), it will inherit the delay time of the parent menu item. get_submenu_popup_delay :: (PopupMenu :< cls, Object :< cls) => cls -> IO Float get_submenu_popup_delay cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_get_submenu_popup_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "get_submenu_popup_delay" '[] (IO Float) where nodeMethod = Godot.Core.PopupMenu.get_submenu_popup_delay {-# NOINLINE bindPopupMenu_is_hide_on_checkable_item_selection #-} -- | If @true@, hides the @PopupMenu@ when a checkbox or radio button is selected. bindPopupMenu_is_hide_on_checkable_item_selection :: MethodBind bindPopupMenu_is_hide_on_checkable_item_selection = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_hide_on_checkable_item_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hides the @PopupMenu@ when a checkbox or radio button is selected. is_hide_on_checkable_item_selection :: (PopupMenu :< cls, Object :< cls) => cls -> IO Bool is_hide_on_checkable_item_selection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_hide_on_checkable_item_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_hide_on_checkable_item_selection" '[] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_hide_on_checkable_item_selection {-# NOINLINE bindPopupMenu_is_hide_on_item_selection #-} -- | If @true@, hides the @PopupMenu@ when an item is selected. bindPopupMenu_is_hide_on_item_selection :: MethodBind bindPopupMenu_is_hide_on_item_selection = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_hide_on_item_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hides the @PopupMenu@ when an item is selected. is_hide_on_item_selection :: (PopupMenu :< cls, Object :< cls) => cls -> IO Bool is_hide_on_item_selection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_hide_on_item_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_hide_on_item_selection" '[] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_hide_on_item_selection {-# NOINLINE bindPopupMenu_is_hide_on_state_item_selection #-} -- | If @true@, hides the @PopupMenu@ when a state item is selected. bindPopupMenu_is_hide_on_state_item_selection :: MethodBind bindPopupMenu_is_hide_on_state_item_selection = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_hide_on_state_item_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hides the @PopupMenu@ when a state item is selected. is_hide_on_state_item_selection :: (PopupMenu :< cls, Object :< cls) => cls -> IO Bool is_hide_on_state_item_selection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_hide_on_state_item_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_hide_on_state_item_selection" '[] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_hide_on_state_item_selection {-# NOINLINE bindPopupMenu_is_hide_on_window_lose_focus #-} -- | Returns @true@ if the popup will be hidden when the window loses focus or not. bindPopupMenu_is_hide_on_window_lose_focus :: MethodBind bindPopupMenu_is_hide_on_window_lose_focus = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_hide_on_window_lose_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the popup will be hidden when the window loses focus or not. is_hide_on_window_lose_focus :: (PopupMenu :< cls, Object :< cls) => cls -> IO Bool is_hide_on_window_lose_focus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_hide_on_window_lose_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_hide_on_window_lose_focus" '[] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_hide_on_window_lose_focus {-# NOINLINE bindPopupMenu_is_item_checkable #-} -- | Returns @true@ if the item at index @idx@ is checkable in some way, i.e. if it has a checkbox or radio button. -- __Note:__ Checkable items just display a checkmark or radio button, but don't have any built-in checking behavior and must be checked/unchecked manually. bindPopupMenu_is_item_checkable :: MethodBind bindPopupMenu_is_item_checkable = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_item_checkable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item at index @idx@ is checkable in some way, i.e. if it has a checkbox or radio button. -- __Note:__ Checkable items just display a checkmark or radio button, but don't have any built-in checking behavior and must be checked/unchecked manually. is_item_checkable :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_checkable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_item_checkable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_item_checkable" '[Int] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_item_checkable {-# NOINLINE bindPopupMenu_is_item_checked #-} -- | Returns @true@ if the item at index @idx@ is checked. bindPopupMenu_is_item_checked :: MethodBind bindPopupMenu_is_item_checked = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_item_checked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item at index @idx@ is checked. is_item_checked :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_checked cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_item_checked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_item_checked" '[Int] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_item_checked {-# NOINLINE bindPopupMenu_is_item_disabled #-} -- | Returns @true@ if the item at index @idx@ is disabled. When it is disabled it can't be selected, or its action invoked. -- See @method set_item_disabled@ for more info on how to disable an item. bindPopupMenu_is_item_disabled :: MethodBind bindPopupMenu_is_item_disabled = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_item_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item at index @idx@ is disabled. When it is disabled it can't be selected, or its action invoked. -- See @method set_item_disabled@ for more info on how to disable an item. is_item_disabled :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_item_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_item_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_item_disabled {-# NOINLINE bindPopupMenu_is_item_radio_checkable #-} -- | Returns @true@ if the item at index @idx@ has radio button-style checkability. -- __Note:__ This is purely cosmetic; you must add the logic for checking/unchecking items in radio groups. bindPopupMenu_is_item_radio_checkable :: MethodBind bindPopupMenu_is_item_radio_checkable = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_item_radio_checkable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item at index @idx@ has radio button-style checkability. -- __Note:__ This is purely cosmetic; you must add the logic for checking/unchecking items in radio groups. is_item_radio_checkable :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_radio_checkable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_item_radio_checkable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_item_radio_checkable" '[Int] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_item_radio_checkable {-# NOINLINE bindPopupMenu_is_item_separator #-} -- | Returns @true@ if the item is a separator. If it is, it will be displayed as a line. See @method add_separator@ for more info on how to add a separator. bindPopupMenu_is_item_separator :: MethodBind bindPopupMenu_is_item_separator = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_item_separator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the item is a separator. If it is, it will be displayed as a line. See @method add_separator@ for more info on how to add a separator. is_item_separator :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_separator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_item_separator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_item_separator" '[Int] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_item_separator {-# NOINLINE bindPopupMenu_is_item_shortcut_disabled #-} -- | Returns @true@ if the specified item's shortcut is disabled. bindPopupMenu_is_item_shortcut_disabled :: MethodBind bindPopupMenu_is_item_shortcut_disabled = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "is_item_shortcut_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified item's shortcut is disabled. is_item_shortcut_disabled :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO Bool is_item_shortcut_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_is_item_shortcut_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "is_item_shortcut_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.PopupMenu.is_item_shortcut_disabled {-# NOINLINE bindPopupMenu_remove_item #-} -- | Removes the item at index @idx@ from the menu. -- __Note:__ The indices of items after the removed item will be shifted by one. bindPopupMenu_remove_item :: MethodBind bindPopupMenu_remove_item = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "remove_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the item at index @idx@ from the menu. -- __Note:__ The indices of items after the removed item will be shifted by one. remove_item :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO () remove_item cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_remove_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "remove_item" '[Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.remove_item {-# NOINLINE bindPopupMenu_set_allow_search #-} -- | If @true@, allows to navigate @PopupMenu@ with letter keys. bindPopupMenu_set_allow_search :: MethodBind bindPopupMenu_set_allow_search = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_allow_search" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allows to navigate @PopupMenu@ with letter keys. set_allow_search :: (PopupMenu :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_search cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_allow_search (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_allow_search" '[Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_allow_search {-# NOINLINE bindPopupMenu_set_hide_on_checkable_item_selection #-} -- | If @true@, hides the @PopupMenu@ when a checkbox or radio button is selected. bindPopupMenu_set_hide_on_checkable_item_selection :: MethodBind bindPopupMenu_set_hide_on_checkable_item_selection = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_hide_on_checkable_item_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hides the @PopupMenu@ when a checkbox or radio button is selected. set_hide_on_checkable_item_selection :: (PopupMenu :< cls, Object :< cls) => cls -> Bool -> IO () set_hide_on_checkable_item_selection cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_hide_on_checkable_item_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_hide_on_checkable_item_selection" '[Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_hide_on_checkable_item_selection {-# NOINLINE bindPopupMenu_set_hide_on_item_selection #-} -- | If @true@, hides the @PopupMenu@ when an item is selected. bindPopupMenu_set_hide_on_item_selection :: MethodBind bindPopupMenu_set_hide_on_item_selection = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_hide_on_item_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hides the @PopupMenu@ when an item is selected. set_hide_on_item_selection :: (PopupMenu :< cls, Object :< cls) => cls -> Bool -> IO () set_hide_on_item_selection cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_hide_on_item_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_hide_on_item_selection" '[Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_hide_on_item_selection {-# NOINLINE bindPopupMenu_set_hide_on_state_item_selection #-} -- | If @true@, hides the @PopupMenu@ when a state item is selected. bindPopupMenu_set_hide_on_state_item_selection :: MethodBind bindPopupMenu_set_hide_on_state_item_selection = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_hide_on_state_item_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hides the @PopupMenu@ when a state item is selected. set_hide_on_state_item_selection :: (PopupMenu :< cls, Object :< cls) => cls -> Bool -> IO () set_hide_on_state_item_selection cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_hide_on_state_item_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_hide_on_state_item_selection" '[Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_hide_on_state_item_selection {-# NOINLINE bindPopupMenu_set_hide_on_window_lose_focus #-} -- | Hides the @PopupMenu@ when the window loses focus. bindPopupMenu_set_hide_on_window_lose_focus :: MethodBind bindPopupMenu_set_hide_on_window_lose_focus = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_hide_on_window_lose_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Hides the @PopupMenu@ when the window loses focus. set_hide_on_window_lose_focus :: (PopupMenu :< cls, Object :< cls) => cls -> Bool -> IO () set_hide_on_window_lose_focus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_hide_on_window_lose_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_hide_on_window_lose_focus" '[Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_hide_on_window_lose_focus {-# NOINLINE bindPopupMenu_set_item_accelerator #-} -- | Sets the accelerator of the item at index @idx@. Accelerators are special combinations of keys that activate the item, no matter which control is focused. bindPopupMenu_set_item_accelerator :: MethodBind bindPopupMenu_set_item_accelerator = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_accelerator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the accelerator of the item at index @idx@. Accelerators are special combinations of keys that activate the item, no matter which control is focused. set_item_accelerator :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_item_accelerator cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_accelerator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_accelerator" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_accelerator {-# NOINLINE bindPopupMenu_set_item_as_checkable #-} -- | Sets whether the item at index @idx@ has a checkbox. If @false@, sets the type of the item to plain text. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. bindPopupMenu_set_item_as_checkable :: MethodBind bindPopupMenu_set_item_as_checkable = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_as_checkable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the item at index @idx@ has a checkbox. If @false@, sets the type of the item to plain text. -- __Note:__ Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. set_item_as_checkable :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_as_checkable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_as_checkable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_as_checkable" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_as_checkable {-# NOINLINE bindPopupMenu_set_item_as_radio_checkable #-} -- | Sets the type of the item at the specified index @idx@ to radio button. If @false@, sets the type of the item to plain text. bindPopupMenu_set_item_as_radio_checkable :: MethodBind bindPopupMenu_set_item_as_radio_checkable = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_as_radio_checkable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the type of the item at the specified index @idx@ to radio button. If @false@, sets the type of the item to plain text. set_item_as_radio_checkable :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_as_radio_checkable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_as_radio_checkable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_as_radio_checkable" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_as_radio_checkable {-# NOINLINE bindPopupMenu_set_item_as_separator #-} -- | Mark the item at index @idx@ as a separator, which means that it would be displayed as a line. If @false@, sets the type of the item to plain text. bindPopupMenu_set_item_as_separator :: MethodBind bindPopupMenu_set_item_as_separator = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_as_separator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Mark the item at index @idx@ as a separator, which means that it would be displayed as a line. If @false@, sets the type of the item to plain text. set_item_as_separator :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_as_separator cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_as_separator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_as_separator" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_as_separator {-# NOINLINE bindPopupMenu_set_item_checked #-} -- | Sets the checkstate status of the item at index @idx@. bindPopupMenu_set_item_checked :: MethodBind bindPopupMenu_set_item_checked = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_checked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the checkstate status of the item at index @idx@. set_item_checked :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_checked cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_checked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_checked" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_checked {-# NOINLINE bindPopupMenu_set_item_disabled #-} -- | Enables/disables the item at index @idx@. When it is disabled, it can't be selected and its action can't be invoked. bindPopupMenu_set_item_disabled :: MethodBind bindPopupMenu_set_item_disabled = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables/disables the item at index @idx@. When it is disabled, it can't be selected and its action can't be invoked. set_item_disabled :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_disabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_disabled {-# NOINLINE bindPopupMenu_set_item_icon #-} -- | Replaces the @Texture@ icon of the specified @idx@. bindPopupMenu_set_item_icon :: MethodBind bindPopupMenu_set_item_icon = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Replaces the @Texture@ icon of the specified @idx@. set_item_icon :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_item_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_icon" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_icon {-# NOINLINE bindPopupMenu_set_item_id #-} -- | Sets the @id@ of the item at index @idx@. bindPopupMenu_set_item_id :: MethodBind bindPopupMenu_set_item_id = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @id@ of the item at index @idx@. set_item_id :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_item_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_id" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_id {-# NOINLINE bindPopupMenu_set_item_metadata #-} -- | Sets the metadata of an item, which may be of any type. You can later get it with @method get_item_metadata@, which provides a simple way of assigning context data to items. bindPopupMenu_set_item_metadata :: MethodBind bindPopupMenu_set_item_metadata = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the metadata of an item, which may be of any type. You can later get it with @method get_item_metadata@, which provides a simple way of assigning context data to items. set_item_metadata :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_item_metadata cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_metadata" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_metadata {-# NOINLINE bindPopupMenu_set_item_multistate #-} -- | Sets the state of an multistate item. See @method add_multistate_item@ for details. bindPopupMenu_set_item_multistate :: MethodBind bindPopupMenu_set_item_multistate = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_multistate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the state of an multistate item. See @method add_multistate_item@ for details. set_item_multistate :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_item_multistate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_multistate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_multistate" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_multistate {-# NOINLINE bindPopupMenu_set_item_shortcut #-} -- | Sets a @ShortCut@ for the specified item @idx@. bindPopupMenu_set_item_shortcut :: MethodBind bindPopupMenu_set_item_shortcut = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a @ShortCut@ for the specified item @idx@. set_item_shortcut :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> ShortCut -> Maybe Bool -> IO () set_item_shortcut cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_shortcut" '[Int, ShortCut, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_shortcut {-# NOINLINE bindPopupMenu_set_item_shortcut_disabled #-} -- | Disables the @ShortCut@ of the specified index @idx@. bindPopupMenu_set_item_shortcut_disabled :: MethodBind bindPopupMenu_set_item_shortcut_disabled = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_shortcut_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables the @ShortCut@ of the specified index @idx@. set_item_shortcut_disabled :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_item_shortcut_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_shortcut_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_shortcut_disabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_shortcut_disabled {-# NOINLINE bindPopupMenu_set_item_submenu #-} -- | Sets the submenu of the item at index @idx@. The submenu is the name of a child @PopupMenu@ node that would be shown when the item is clicked. bindPopupMenu_set_item_submenu :: MethodBind bindPopupMenu_set_item_submenu = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_submenu" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the submenu of the item at index @idx@. The submenu is the name of a child @PopupMenu@ node that would be shown when the item is clicked. set_item_submenu :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_item_submenu cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_submenu (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_submenu" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_submenu {-# NOINLINE bindPopupMenu_set_item_text #-} -- | Sets the text of the item at index @idx@. bindPopupMenu_set_item_text :: MethodBind bindPopupMenu_set_item_text = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the text of the item at index @idx@. set_item_text :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_item_text cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_text" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_text {-# NOINLINE bindPopupMenu_set_item_tooltip #-} -- | Sets the @String@ tooltip of the item at the specified index @idx@. bindPopupMenu_set_item_tooltip :: MethodBind bindPopupMenu_set_item_tooltip = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_item_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @String@ tooltip of the item at the specified index @idx@. set_item_tooltip :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_item_tooltip cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_item_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_item_tooltip" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_item_tooltip {-# NOINLINE bindPopupMenu_set_submenu_popup_delay #-} -- | Sets the delay time in seconds for the submenu item to popup on mouse hovering. If the popup menu is added as a child of another (acting as a submenu), it will inherit the delay time of the parent menu item. bindPopupMenu_set_submenu_popup_delay :: MethodBind bindPopupMenu_set_submenu_popup_delay = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "set_submenu_popup_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the delay time in seconds for the submenu item to popup on mouse hovering. If the popup menu is added as a child of another (acting as a submenu), it will inherit the delay time of the parent menu item. set_submenu_popup_delay :: (PopupMenu :< cls, Object :< cls) => cls -> Float -> IO () set_submenu_popup_delay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_set_submenu_popup_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "set_submenu_popup_delay" '[Float] (IO ()) where nodeMethod = Godot.Core.PopupMenu.set_submenu_popup_delay {-# NOINLINE bindPopupMenu_toggle_item_checked #-} -- | Toggles the check state of the item of the specified index @idx@. bindPopupMenu_toggle_item_checked :: MethodBind bindPopupMenu_toggle_item_checked = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "toggle_item_checked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Toggles the check state of the item of the specified index @idx@. toggle_item_checked :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO () toggle_item_checked cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_toggle_item_checked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "toggle_item_checked" '[Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.toggle_item_checked {-# NOINLINE bindPopupMenu_toggle_item_multistate #-} -- | Cycle to the next state of an multistate item. See @method add_multistate_item@ for details. bindPopupMenu_toggle_item_multistate :: MethodBind bindPopupMenu_toggle_item_multistate = unsafePerformIO $ withCString "PopupMenu" $ \ clsNamePtr -> withCString "toggle_item_multistate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Cycle to the next state of an multistate item. See @method add_multistate_item@ for details. toggle_item_multistate :: (PopupMenu :< cls, Object :< cls) => cls -> Int -> IO () toggle_item_multistate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPopupMenu_toggle_item_multistate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PopupMenu "toggle_item_multistate" '[Int] (IO ()) where nodeMethod = Godot.Core.PopupMenu.toggle_item_multistate ================================================ FILE: src/Godot/Core/PopupPanel.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PopupPanel () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Popup() ================================================ FILE: src/Godot/Core/Position2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Position2D (Godot.Core.Position2D._get_gizmo_extents, Godot.Core.Position2D._set_gizmo_extents) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty Position2D "gizmo_extents" Float 'False where nodeProperty = (_get_gizmo_extents, wrapDroppingSetter _set_gizmo_extents, Nothing) {-# NOINLINE bindPosition2D__get_gizmo_extents #-} bindPosition2D__get_gizmo_extents :: MethodBind bindPosition2D__get_gizmo_extents = unsafePerformIO $ withCString "Position2D" $ \ clsNamePtr -> withCString "_get_gizmo_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_gizmo_extents :: (Position2D :< cls, Object :< cls) => cls -> IO Float _get_gizmo_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPosition2D__get_gizmo_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Position2D "_get_gizmo_extents" '[] (IO Float) where nodeMethod = Godot.Core.Position2D._get_gizmo_extents {-# NOINLINE bindPosition2D__set_gizmo_extents #-} bindPosition2D__set_gizmo_extents :: MethodBind bindPosition2D__set_gizmo_extents = unsafePerformIO $ withCString "Position2D" $ \ clsNamePtr -> withCString "_set_gizmo_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_gizmo_extents :: (Position2D :< cls, Object :< cls) => cls -> Float -> IO () _set_gizmo_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPosition2D__set_gizmo_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Position2D "_set_gizmo_extents" '[Float] (IO ()) where nodeMethod = Godot.Core.Position2D._set_gizmo_extents ================================================ FILE: src/Godot/Core/Position3D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Position3D () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() ================================================ FILE: src/Godot/Core/PrimitiveMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PrimitiveMesh (Godot.Core.PrimitiveMesh._update, Godot.Core.PrimitiveMesh.get_custom_aabb, Godot.Core.PrimitiveMesh.get_flip_faces, Godot.Core.PrimitiveMesh.get_material, Godot.Core.PrimitiveMesh.get_mesh_arrays, Godot.Core.PrimitiveMesh.set_custom_aabb, Godot.Core.PrimitiveMesh.set_flip_faces, Godot.Core.PrimitiveMesh.set_material) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Mesh() instance NodeProperty PrimitiveMesh "custom_aabb" Aabb 'False where nodeProperty = (get_custom_aabb, wrapDroppingSetter set_custom_aabb, Nothing) instance NodeProperty PrimitiveMesh "flip_faces" Bool 'False where nodeProperty = (get_flip_faces, wrapDroppingSetter set_flip_faces, Nothing) instance NodeProperty PrimitiveMesh "material" Material 'False where nodeProperty = (get_material, wrapDroppingSetter set_material, Nothing) {-# NOINLINE bindPrimitiveMesh__update #-} bindPrimitiveMesh__update :: MethodBind bindPrimitiveMesh__update = unsafePerformIO $ withCString "PrimitiveMesh" $ \ clsNamePtr -> withCString "_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update :: (PrimitiveMesh :< cls, Object :< cls) => cls -> IO () _update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrimitiveMesh__update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrimitiveMesh "_update" '[] (IO ()) where nodeMethod = Godot.Core.PrimitiveMesh._update {-# NOINLINE bindPrimitiveMesh_get_custom_aabb #-} -- | Overrides the @AABB@ with one defined by user for use with frustum culling. Especially useful to avoid unnexpected culling when using a shader to offset vertices. bindPrimitiveMesh_get_custom_aabb :: MethodBind bindPrimitiveMesh_get_custom_aabb = unsafePerformIO $ withCString "PrimitiveMesh" $ \ clsNamePtr -> withCString "get_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the @AABB@ with one defined by user for use with frustum culling. Especially useful to avoid unnexpected culling when using a shader to offset vertices. get_custom_aabb :: (PrimitiveMesh :< cls, Object :< cls) => cls -> IO Aabb get_custom_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrimitiveMesh_get_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrimitiveMesh "get_custom_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.PrimitiveMesh.get_custom_aabb {-# NOINLINE bindPrimitiveMesh_get_flip_faces #-} -- | If set, the order of the vertices in each triangle are reversed resulting in the backside of the mesh being drawn. -- This gives the same result as using @SpatialMaterial.CULL_BACK@ in @SpatialMaterial.params_cull_mode@. bindPrimitiveMesh_get_flip_faces :: MethodBind bindPrimitiveMesh_get_flip_faces = unsafePerformIO $ withCString "PrimitiveMesh" $ \ clsNamePtr -> withCString "get_flip_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If set, the order of the vertices in each triangle are reversed resulting in the backside of the mesh being drawn. -- This gives the same result as using @SpatialMaterial.CULL_BACK@ in @SpatialMaterial.params_cull_mode@. get_flip_faces :: (PrimitiveMesh :< cls, Object :< cls) => cls -> IO Bool get_flip_faces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrimitiveMesh_get_flip_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrimitiveMesh "get_flip_faces" '[] (IO Bool) where nodeMethod = Godot.Core.PrimitiveMesh.get_flip_faces {-# NOINLINE bindPrimitiveMesh_get_material #-} -- | The current @Material@ of the primitive mesh. bindPrimitiveMesh_get_material :: MethodBind bindPrimitiveMesh_get_material = unsafePerformIO $ withCString "PrimitiveMesh" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current @Material@ of the primitive mesh. get_material :: (PrimitiveMesh :< cls, Object :< cls) => cls -> IO Material get_material cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrimitiveMesh_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrimitiveMesh "get_material" '[] (IO Material) where nodeMethod = Godot.Core.PrimitiveMesh.get_material {-# NOINLINE bindPrimitiveMesh_get_mesh_arrays #-} -- | Returns mesh arrays used to constitute surface of @Mesh@. The result can be passed to @method ArrayMesh.add_surface_from_arrays@ to create a new surface. For example: -- -- @ -- -- var c := CylinderMesh.new() -- var arr_mesh := ArrayMesh.new() -- arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, c.get_mesh_arrays()) -- -- @ bindPrimitiveMesh_get_mesh_arrays :: MethodBind bindPrimitiveMesh_get_mesh_arrays = unsafePerformIO $ withCString "PrimitiveMesh" $ \ clsNamePtr -> withCString "get_mesh_arrays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns mesh arrays used to constitute surface of @Mesh@. The result can be passed to @method ArrayMesh.add_surface_from_arrays@ to create a new surface. For example: -- -- @ -- -- var c := CylinderMesh.new() -- var arr_mesh := ArrayMesh.new() -- arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, c.get_mesh_arrays()) -- -- @ get_mesh_arrays :: (PrimitiveMesh :< cls, Object :< cls) => cls -> IO Array get_mesh_arrays cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrimitiveMesh_get_mesh_arrays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrimitiveMesh "get_mesh_arrays" '[] (IO Array) where nodeMethod = Godot.Core.PrimitiveMesh.get_mesh_arrays {-# NOINLINE bindPrimitiveMesh_set_custom_aabb #-} -- | Overrides the @AABB@ with one defined by user for use with frustum culling. Especially useful to avoid unnexpected culling when using a shader to offset vertices. bindPrimitiveMesh_set_custom_aabb :: MethodBind bindPrimitiveMesh_set_custom_aabb = unsafePerformIO $ withCString "PrimitiveMesh" $ \ clsNamePtr -> withCString "set_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the @AABB@ with one defined by user for use with frustum culling. Especially useful to avoid unnexpected culling when using a shader to offset vertices. set_custom_aabb :: (PrimitiveMesh :< cls, Object :< cls) => cls -> Aabb -> IO () set_custom_aabb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPrimitiveMesh_set_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrimitiveMesh "set_custom_aabb" '[Aabb] (IO ()) where nodeMethod = Godot.Core.PrimitiveMesh.set_custom_aabb {-# NOINLINE bindPrimitiveMesh_set_flip_faces #-} -- | If set, the order of the vertices in each triangle are reversed resulting in the backside of the mesh being drawn. -- This gives the same result as using @SpatialMaterial.CULL_BACK@ in @SpatialMaterial.params_cull_mode@. bindPrimitiveMesh_set_flip_faces :: MethodBind bindPrimitiveMesh_set_flip_faces = unsafePerformIO $ withCString "PrimitiveMesh" $ \ clsNamePtr -> withCString "set_flip_faces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If set, the order of the vertices in each triangle are reversed resulting in the backside of the mesh being drawn. -- This gives the same result as using @SpatialMaterial.CULL_BACK@ in @SpatialMaterial.params_cull_mode@. set_flip_faces :: (PrimitiveMesh :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_faces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPrimitiveMesh_set_flip_faces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrimitiveMesh "set_flip_faces" '[Bool] (IO ()) where nodeMethod = Godot.Core.PrimitiveMesh.set_flip_faces {-# NOINLINE bindPrimitiveMesh_set_material #-} -- | The current @Material@ of the primitive mesh. bindPrimitiveMesh_set_material :: MethodBind bindPrimitiveMesh_set_material = unsafePerformIO $ withCString "PrimitiveMesh" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current @Material@ of the primitive mesh. set_material :: (PrimitiveMesh :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPrimitiveMesh_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrimitiveMesh "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.PrimitiveMesh.set_material ================================================ FILE: src/Godot/Core/PrismMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.PrismMesh (Godot.Core.PrismMesh.get_left_to_right, Godot.Core.PrismMesh.get_size, Godot.Core.PrismMesh.get_subdivide_depth, Godot.Core.PrismMesh.get_subdivide_height, Godot.Core.PrismMesh.get_subdivide_width, Godot.Core.PrismMesh.set_left_to_right, Godot.Core.PrismMesh.set_size, Godot.Core.PrismMesh.set_subdivide_depth, Godot.Core.PrismMesh.set_subdivide_height, Godot.Core.PrismMesh.set_subdivide_width) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PrimitiveMesh() instance NodeProperty PrismMesh "left_to_right" Float 'False where nodeProperty = (get_left_to_right, wrapDroppingSetter set_left_to_right, Nothing) instance NodeProperty PrismMesh "size" Vector3 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) instance NodeProperty PrismMesh "subdivide_depth" Int 'False where nodeProperty = (get_subdivide_depth, wrapDroppingSetter set_subdivide_depth, Nothing) instance NodeProperty PrismMesh "subdivide_height" Int 'False where nodeProperty = (get_subdivide_height, wrapDroppingSetter set_subdivide_height, Nothing) instance NodeProperty PrismMesh "subdivide_width" Int 'False where nodeProperty = (get_subdivide_width, wrapDroppingSetter set_subdivide_width, Nothing) {-# NOINLINE bindPrismMesh_get_left_to_right #-} -- | Displacement of the upper edge along the X axis. 0.0 positions edge straight above the bottom-left edge. bindPrismMesh_get_left_to_right :: MethodBind bindPrismMesh_get_left_to_right = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "get_left_to_right" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Displacement of the upper edge along the X axis. 0.0 positions edge straight above the bottom-left edge. get_left_to_right :: (PrismMesh :< cls, Object :< cls) => cls -> IO Float get_left_to_right cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_get_left_to_right (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "get_left_to_right" '[] (IO Float) where nodeMethod = Godot.Core.PrismMesh.get_left_to_right {-# NOINLINE bindPrismMesh_get_size #-} -- | Size of the prism. bindPrismMesh_get_size :: MethodBind bindPrismMesh_get_size = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size of the prism. get_size :: (PrismMesh :< cls, Object :< cls) => cls -> IO Vector3 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "get_size" '[] (IO Vector3) where nodeMethod = Godot.Core.PrismMesh.get_size {-# NOINLINE bindPrismMesh_get_subdivide_depth #-} -- | Number of added edge loops along the Z axis. bindPrismMesh_get_subdivide_depth :: MethodBind bindPrismMesh_get_subdivide_depth = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "get_subdivide_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of added edge loops along the Z axis. get_subdivide_depth :: (PrismMesh :< cls, Object :< cls) => cls -> IO Int get_subdivide_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_get_subdivide_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "get_subdivide_depth" '[] (IO Int) where nodeMethod = Godot.Core.PrismMesh.get_subdivide_depth {-# NOINLINE bindPrismMesh_get_subdivide_height #-} -- | Number of added edge loops along the Y axis. bindPrismMesh_get_subdivide_height :: MethodBind bindPrismMesh_get_subdivide_height = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "get_subdivide_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of added edge loops along the Y axis. get_subdivide_height :: (PrismMesh :< cls, Object :< cls) => cls -> IO Int get_subdivide_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_get_subdivide_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "get_subdivide_height" '[] (IO Int) where nodeMethod = Godot.Core.PrismMesh.get_subdivide_height {-# NOINLINE bindPrismMesh_get_subdivide_width #-} -- | Number of added edge loops along the X axis. bindPrismMesh_get_subdivide_width :: MethodBind bindPrismMesh_get_subdivide_width = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "get_subdivide_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of added edge loops along the X axis. get_subdivide_width :: (PrismMesh :< cls, Object :< cls) => cls -> IO Int get_subdivide_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_get_subdivide_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "get_subdivide_width" '[] (IO Int) where nodeMethod = Godot.Core.PrismMesh.get_subdivide_width {-# NOINLINE bindPrismMesh_set_left_to_right #-} -- | Displacement of the upper edge along the X axis. 0.0 positions edge straight above the bottom-left edge. bindPrismMesh_set_left_to_right :: MethodBind bindPrismMesh_set_left_to_right = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "set_left_to_right" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Displacement of the upper edge along the X axis. 0.0 positions edge straight above the bottom-left edge. set_left_to_right :: (PrismMesh :< cls, Object :< cls) => cls -> Float -> IO () set_left_to_right cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_set_left_to_right (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "set_left_to_right" '[Float] (IO ()) where nodeMethod = Godot.Core.PrismMesh.set_left_to_right {-# NOINLINE bindPrismMesh_set_size #-} -- | Size of the prism. bindPrismMesh_set_size :: MethodBind bindPrismMesh_set_size = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size of the prism. set_size :: (PrismMesh :< cls, Object :< cls) => cls -> Vector3 -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "set_size" '[Vector3] (IO ()) where nodeMethod = Godot.Core.PrismMesh.set_size {-# NOINLINE bindPrismMesh_set_subdivide_depth #-} -- | Number of added edge loops along the Z axis. bindPrismMesh_set_subdivide_depth :: MethodBind bindPrismMesh_set_subdivide_depth = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "set_subdivide_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of added edge loops along the Z axis. set_subdivide_depth :: (PrismMesh :< cls, Object :< cls) => cls -> Int -> IO () set_subdivide_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_set_subdivide_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "set_subdivide_depth" '[Int] (IO ()) where nodeMethod = Godot.Core.PrismMesh.set_subdivide_depth {-# NOINLINE bindPrismMesh_set_subdivide_height #-} -- | Number of added edge loops along the Y axis. bindPrismMesh_set_subdivide_height :: MethodBind bindPrismMesh_set_subdivide_height = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "set_subdivide_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of added edge loops along the Y axis. set_subdivide_height :: (PrismMesh :< cls, Object :< cls) => cls -> Int -> IO () set_subdivide_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_set_subdivide_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "set_subdivide_height" '[Int] (IO ()) where nodeMethod = Godot.Core.PrismMesh.set_subdivide_height {-# NOINLINE bindPrismMesh_set_subdivide_width #-} -- | Number of added edge loops along the X axis. bindPrismMesh_set_subdivide_width :: MethodBind bindPrismMesh_set_subdivide_width = unsafePerformIO $ withCString "PrismMesh" $ \ clsNamePtr -> withCString "set_subdivide_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of added edge loops along the X axis. set_subdivide_width :: (PrismMesh :< cls, Object :< cls) => cls -> Int -> IO () set_subdivide_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindPrismMesh_set_subdivide_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod PrismMesh "set_subdivide_width" '[Int] (IO ()) where nodeMethod = Godot.Core.PrismMesh.set_subdivide_width ================================================ FILE: src/Godot/Core/ProceduralSky.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ProceduralSky (Godot.Core.ProceduralSky._TEXTURE_SIZE_512, Godot.Core.ProceduralSky._TEXTURE_SIZE_2048, Godot.Core.ProceduralSky._TEXTURE_SIZE_1024, Godot.Core.ProceduralSky._TEXTURE_SIZE_256, Godot.Core.ProceduralSky._TEXTURE_SIZE_MAX, Godot.Core.ProceduralSky._TEXTURE_SIZE_4096, Godot.Core.ProceduralSky._thread_done, Godot.Core.ProceduralSky._update_sky, Godot.Core.ProceduralSky.get_ground_bottom_color, Godot.Core.ProceduralSky.get_ground_curve, Godot.Core.ProceduralSky.get_ground_energy, Godot.Core.ProceduralSky.get_ground_horizon_color, Godot.Core.ProceduralSky.get_sky_curve, Godot.Core.ProceduralSky.get_sky_energy, Godot.Core.ProceduralSky.get_sky_horizon_color, Godot.Core.ProceduralSky.get_sky_top_color, Godot.Core.ProceduralSky.get_sun_angle_max, Godot.Core.ProceduralSky.get_sun_angle_min, Godot.Core.ProceduralSky.get_sun_color, Godot.Core.ProceduralSky.get_sun_curve, Godot.Core.ProceduralSky.get_sun_energy, Godot.Core.ProceduralSky.get_sun_latitude, Godot.Core.ProceduralSky.get_sun_longitude, Godot.Core.ProceduralSky.get_texture_size, Godot.Core.ProceduralSky.set_ground_bottom_color, Godot.Core.ProceduralSky.set_ground_curve, Godot.Core.ProceduralSky.set_ground_energy, Godot.Core.ProceduralSky.set_ground_horizon_color, Godot.Core.ProceduralSky.set_sky_curve, Godot.Core.ProceduralSky.set_sky_energy, Godot.Core.ProceduralSky.set_sky_horizon_color, Godot.Core.ProceduralSky.set_sky_top_color, Godot.Core.ProceduralSky.set_sun_angle_max, Godot.Core.ProceduralSky.set_sun_angle_min, Godot.Core.ProceduralSky.set_sun_color, Godot.Core.ProceduralSky.set_sun_curve, Godot.Core.ProceduralSky.set_sun_energy, Godot.Core.ProceduralSky.set_sun_latitude, Godot.Core.ProceduralSky.set_sun_longitude, Godot.Core.ProceduralSky.set_texture_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Sky() _TEXTURE_SIZE_512 :: Int _TEXTURE_SIZE_512 = 1 _TEXTURE_SIZE_2048 :: Int _TEXTURE_SIZE_2048 = 3 _TEXTURE_SIZE_1024 :: Int _TEXTURE_SIZE_1024 = 2 _TEXTURE_SIZE_256 :: Int _TEXTURE_SIZE_256 = 0 _TEXTURE_SIZE_MAX :: Int _TEXTURE_SIZE_MAX = 5 _TEXTURE_SIZE_4096 :: Int _TEXTURE_SIZE_4096 = 4 instance NodeProperty ProceduralSky "ground_bottom_color" Color 'False where nodeProperty = (get_ground_bottom_color, wrapDroppingSetter set_ground_bottom_color, Nothing) instance NodeProperty ProceduralSky "ground_curve" Float 'False where nodeProperty = (get_ground_curve, wrapDroppingSetter set_ground_curve, Nothing) instance NodeProperty ProceduralSky "ground_energy" Float 'False where nodeProperty = (get_ground_energy, wrapDroppingSetter set_ground_energy, Nothing) instance NodeProperty ProceduralSky "ground_horizon_color" Color 'False where nodeProperty = (get_ground_horizon_color, wrapDroppingSetter set_ground_horizon_color, Nothing) instance NodeProperty ProceduralSky "sky_curve" Float 'False where nodeProperty = (get_sky_curve, wrapDroppingSetter set_sky_curve, Nothing) instance NodeProperty ProceduralSky "sky_energy" Float 'False where nodeProperty = (get_sky_energy, wrapDroppingSetter set_sky_energy, Nothing) instance NodeProperty ProceduralSky "sky_horizon_color" Color 'False where nodeProperty = (get_sky_horizon_color, wrapDroppingSetter set_sky_horizon_color, Nothing) instance NodeProperty ProceduralSky "sky_top_color" Color 'False where nodeProperty = (get_sky_top_color, wrapDroppingSetter set_sky_top_color, Nothing) instance NodeProperty ProceduralSky "sun_angle_max" Float 'False where nodeProperty = (get_sun_angle_max, wrapDroppingSetter set_sun_angle_max, Nothing) instance NodeProperty ProceduralSky "sun_angle_min" Float 'False where nodeProperty = (get_sun_angle_min, wrapDroppingSetter set_sun_angle_min, Nothing) instance NodeProperty ProceduralSky "sun_color" Color 'False where nodeProperty = (get_sun_color, wrapDroppingSetter set_sun_color, Nothing) instance NodeProperty ProceduralSky "sun_curve" Float 'False where nodeProperty = (get_sun_curve, wrapDroppingSetter set_sun_curve, Nothing) instance NodeProperty ProceduralSky "sun_energy" Float 'False where nodeProperty = (get_sun_energy, wrapDroppingSetter set_sun_energy, Nothing) instance NodeProperty ProceduralSky "sun_latitude" Float 'False where nodeProperty = (get_sun_latitude, wrapDroppingSetter set_sun_latitude, Nothing) instance NodeProperty ProceduralSky "sun_longitude" Float 'False where nodeProperty = (get_sun_longitude, wrapDroppingSetter set_sun_longitude, Nothing) instance NodeProperty ProceduralSky "texture_size" Int 'False where nodeProperty = (get_texture_size, wrapDroppingSetter set_texture_size, Nothing) {-# NOINLINE bindProceduralSky__thread_done #-} bindProceduralSky__thread_done :: MethodBind bindProceduralSky__thread_done = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "_thread_done" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _thread_done :: (ProceduralSky :< cls, Object :< cls) => cls -> Image -> IO () _thread_done cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky__thread_done (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "_thread_done" '[Image] (IO ()) where nodeMethod = Godot.Core.ProceduralSky._thread_done {-# NOINLINE bindProceduralSky__update_sky #-} bindProceduralSky__update_sky :: MethodBind bindProceduralSky__update_sky = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "_update_sky" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_sky :: (ProceduralSky :< cls, Object :< cls) => cls -> IO () _update_sky cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky__update_sky (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "_update_sky" '[] (IO ()) where nodeMethod = Godot.Core.ProceduralSky._update_sky {-# NOINLINE bindProceduralSky_get_ground_bottom_color #-} -- | Color of the ground at the bottom. bindProceduralSky_get_ground_bottom_color :: MethodBind bindProceduralSky_get_ground_bottom_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_ground_bottom_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color of the ground at the bottom. get_ground_bottom_color :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Color get_ground_bottom_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_ground_bottom_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_ground_bottom_color" '[] (IO Color) where nodeMethod = Godot.Core.ProceduralSky.get_ground_bottom_color {-# NOINLINE bindProceduralSky_get_ground_curve #-} -- | How quickly the @ground_horizon_color@ fades into the @ground_bottom_color@. bindProceduralSky_get_ground_curve :: MethodBind bindProceduralSky_get_ground_curve = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_ground_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How quickly the @ground_horizon_color@ fades into the @ground_bottom_color@. get_ground_curve :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_ground_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_ground_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_ground_curve" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_ground_curve {-# NOINLINE bindProceduralSky_get_ground_energy #-} -- | Amount of energy contribution from the ground. bindProceduralSky_get_ground_energy :: MethodBind bindProceduralSky_get_ground_energy = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_ground_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of energy contribution from the ground. get_ground_energy :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_ground_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_ground_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_ground_energy" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_ground_energy {-# NOINLINE bindProceduralSky_get_ground_horizon_color #-} -- | Color of the ground at the horizon. bindProceduralSky_get_ground_horizon_color :: MethodBind bindProceduralSky_get_ground_horizon_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_ground_horizon_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color of the ground at the horizon. get_ground_horizon_color :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Color get_ground_horizon_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_ground_horizon_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_ground_horizon_color" '[] (IO Color) where nodeMethod = Godot.Core.ProceduralSky.get_ground_horizon_color {-# NOINLINE bindProceduralSky_get_sky_curve #-} -- | How quickly the @sky_horizon_color@ fades into the @sky_top_color@. bindProceduralSky_get_sky_curve :: MethodBind bindProceduralSky_get_sky_curve = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sky_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How quickly the @sky_horizon_color@ fades into the @sky_top_color@. get_sky_curve :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_sky_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sky_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sky_curve" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_sky_curve {-# NOINLINE bindProceduralSky_get_sky_energy #-} -- | Amount of energy contribution from the sky. bindProceduralSky_get_sky_energy :: MethodBind bindProceduralSky_get_sky_energy = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sky_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of energy contribution from the sky. get_sky_energy :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_sky_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sky_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sky_energy" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_sky_energy {-# NOINLINE bindProceduralSky_get_sky_horizon_color #-} -- | Color of the sky at the horizon. bindProceduralSky_get_sky_horizon_color :: MethodBind bindProceduralSky_get_sky_horizon_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sky_horizon_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color of the sky at the horizon. get_sky_horizon_color :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Color get_sky_horizon_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sky_horizon_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sky_horizon_color" '[] (IO Color) where nodeMethod = Godot.Core.ProceduralSky.get_sky_horizon_color {-# NOINLINE bindProceduralSky_get_sky_top_color #-} -- | Color of the sky at the top. bindProceduralSky_get_sky_top_color :: MethodBind bindProceduralSky_get_sky_top_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sky_top_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color of the sky at the top. get_sky_top_color :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Color get_sky_top_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sky_top_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sky_top_color" '[] (IO Color) where nodeMethod = Godot.Core.ProceduralSky.get_sky_top_color {-# NOINLINE bindProceduralSky_get_sun_angle_max #-} -- | Distance from center of sun where it fades out completely. bindProceduralSky_get_sun_angle_max :: MethodBind bindProceduralSky_get_sun_angle_max = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sun_angle_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance from center of sun where it fades out completely. get_sun_angle_max :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_sun_angle_max cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sun_angle_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sun_angle_max" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_sun_angle_max {-# NOINLINE bindProceduralSky_get_sun_angle_min #-} -- | Distance from sun where it goes from solid to starting to fade. bindProceduralSky_get_sun_angle_min :: MethodBind bindProceduralSky_get_sun_angle_min = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sun_angle_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance from sun where it goes from solid to starting to fade. get_sun_angle_min :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_sun_angle_min cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sun_angle_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sun_angle_min" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_sun_angle_min {-# NOINLINE bindProceduralSky_get_sun_color #-} -- | The sun's color. bindProceduralSky_get_sun_color :: MethodBind bindProceduralSky_get_sun_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sun_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sun's color. get_sun_color :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Color get_sun_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sun_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sun_color" '[] (IO Color) where nodeMethod = Godot.Core.ProceduralSky.get_sun_color {-# NOINLINE bindProceduralSky_get_sun_curve #-} -- | How quickly the sun fades away between @sun_angle_min@ and @sun_angle_max@. bindProceduralSky_get_sun_curve :: MethodBind bindProceduralSky_get_sun_curve = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sun_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How quickly the sun fades away between @sun_angle_min@ and @sun_angle_max@. get_sun_curve :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_sun_curve cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sun_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sun_curve" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_sun_curve {-# NOINLINE bindProceduralSky_get_sun_energy #-} -- | Amount of energy contribution from the sun. bindProceduralSky_get_sun_energy :: MethodBind bindProceduralSky_get_sun_energy = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sun_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of energy contribution from the sun. get_sun_energy :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_sun_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sun_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sun_energy" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_sun_energy {-# NOINLINE bindProceduralSky_get_sun_latitude #-} -- | The sun's height using polar coordinates. bindProceduralSky_get_sun_latitude :: MethodBind bindProceduralSky_get_sun_latitude = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sun_latitude" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sun's height using polar coordinates. get_sun_latitude :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_sun_latitude cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sun_latitude (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sun_latitude" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_sun_latitude {-# NOINLINE bindProceduralSky_get_sun_longitude #-} -- | The direction of the sun using polar coordinates. bindProceduralSky_get_sun_longitude :: MethodBind bindProceduralSky_get_sun_longitude = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_sun_longitude" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The direction of the sun using polar coordinates. get_sun_longitude :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Float get_sun_longitude cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_sun_longitude (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_sun_longitude" '[] (IO Float) where nodeMethod = Godot.Core.ProceduralSky.get_sun_longitude {-# NOINLINE bindProceduralSky_get_texture_size #-} -- | Size of @Texture@ that the ProceduralSky will generate. The size is set using @enum TextureSize@. bindProceduralSky_get_texture_size :: MethodBind bindProceduralSky_get_texture_size = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "get_texture_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size of @Texture@ that the ProceduralSky will generate. The size is set using @enum TextureSize@. get_texture_size :: (ProceduralSky :< cls, Object :< cls) => cls -> IO Int get_texture_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_get_texture_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "get_texture_size" '[] (IO Int) where nodeMethod = Godot.Core.ProceduralSky.get_texture_size {-# NOINLINE bindProceduralSky_set_ground_bottom_color #-} -- | Color of the ground at the bottom. bindProceduralSky_set_ground_bottom_color :: MethodBind bindProceduralSky_set_ground_bottom_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_ground_bottom_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color of the ground at the bottom. set_ground_bottom_color :: (ProceduralSky :< cls, Object :< cls) => cls -> Color -> IO () set_ground_bottom_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_ground_bottom_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_ground_bottom_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_ground_bottom_color {-# NOINLINE bindProceduralSky_set_ground_curve #-} -- | How quickly the @ground_horizon_color@ fades into the @ground_bottom_color@. bindProceduralSky_set_ground_curve :: MethodBind bindProceduralSky_set_ground_curve = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_ground_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How quickly the @ground_horizon_color@ fades into the @ground_bottom_color@. set_ground_curve :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_ground_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_ground_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_ground_curve" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_ground_curve {-# NOINLINE bindProceduralSky_set_ground_energy #-} -- | Amount of energy contribution from the ground. bindProceduralSky_set_ground_energy :: MethodBind bindProceduralSky_set_ground_energy = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_ground_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of energy contribution from the ground. set_ground_energy :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_ground_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_ground_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_ground_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_ground_energy {-# NOINLINE bindProceduralSky_set_ground_horizon_color #-} -- | Color of the ground at the horizon. bindProceduralSky_set_ground_horizon_color :: MethodBind bindProceduralSky_set_ground_horizon_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_ground_horizon_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color of the ground at the horizon. set_ground_horizon_color :: (ProceduralSky :< cls, Object :< cls) => cls -> Color -> IO () set_ground_horizon_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_ground_horizon_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_ground_horizon_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_ground_horizon_color {-# NOINLINE bindProceduralSky_set_sky_curve #-} -- | How quickly the @sky_horizon_color@ fades into the @sky_top_color@. bindProceduralSky_set_sky_curve :: MethodBind bindProceduralSky_set_sky_curve = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sky_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How quickly the @sky_horizon_color@ fades into the @sky_top_color@. set_sky_curve :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_sky_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sky_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sky_curve" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sky_curve {-# NOINLINE bindProceduralSky_set_sky_energy #-} -- | Amount of energy contribution from the sky. bindProceduralSky_set_sky_energy :: MethodBind bindProceduralSky_set_sky_energy = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sky_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of energy contribution from the sky. set_sky_energy :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_sky_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sky_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sky_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sky_energy {-# NOINLINE bindProceduralSky_set_sky_horizon_color #-} -- | Color of the sky at the horizon. bindProceduralSky_set_sky_horizon_color :: MethodBind bindProceduralSky_set_sky_horizon_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sky_horizon_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color of the sky at the horizon. set_sky_horizon_color :: (ProceduralSky :< cls, Object :< cls) => cls -> Color -> IO () set_sky_horizon_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sky_horizon_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sky_horizon_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sky_horizon_color {-# NOINLINE bindProceduralSky_set_sky_top_color #-} -- | Color of the sky at the top. bindProceduralSky_set_sky_top_color :: MethodBind bindProceduralSky_set_sky_top_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sky_top_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color of the sky at the top. set_sky_top_color :: (ProceduralSky :< cls, Object :< cls) => cls -> Color -> IO () set_sky_top_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sky_top_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sky_top_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sky_top_color {-# NOINLINE bindProceduralSky_set_sun_angle_max #-} -- | Distance from center of sun where it fades out completely. bindProceduralSky_set_sun_angle_max :: MethodBind bindProceduralSky_set_sun_angle_max = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sun_angle_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance from center of sun where it fades out completely. set_sun_angle_max :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_sun_angle_max cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sun_angle_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sun_angle_max" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sun_angle_max {-# NOINLINE bindProceduralSky_set_sun_angle_min #-} -- | Distance from sun where it goes from solid to starting to fade. bindProceduralSky_set_sun_angle_min :: MethodBind bindProceduralSky_set_sun_angle_min = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sun_angle_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance from sun where it goes from solid to starting to fade. set_sun_angle_min :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_sun_angle_min cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sun_angle_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sun_angle_min" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sun_angle_min {-# NOINLINE bindProceduralSky_set_sun_color #-} -- | The sun's color. bindProceduralSky_set_sun_color :: MethodBind bindProceduralSky_set_sun_color = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sun_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sun's color. set_sun_color :: (ProceduralSky :< cls, Object :< cls) => cls -> Color -> IO () set_sun_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sun_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sun_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sun_color {-# NOINLINE bindProceduralSky_set_sun_curve #-} -- | How quickly the sun fades away between @sun_angle_min@ and @sun_angle_max@. bindProceduralSky_set_sun_curve :: MethodBind bindProceduralSky_set_sun_curve = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sun_curve" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How quickly the sun fades away between @sun_angle_min@ and @sun_angle_max@. set_sun_curve :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_sun_curve cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sun_curve (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sun_curve" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sun_curve {-# NOINLINE bindProceduralSky_set_sun_energy #-} -- | Amount of energy contribution from the sun. bindProceduralSky_set_sun_energy :: MethodBind bindProceduralSky_set_sun_energy = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sun_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of energy contribution from the sun. set_sun_energy :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_sun_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sun_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sun_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sun_energy {-# NOINLINE bindProceduralSky_set_sun_latitude #-} -- | The sun's height using polar coordinates. bindProceduralSky_set_sun_latitude :: MethodBind bindProceduralSky_set_sun_latitude = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sun_latitude" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sun's height using polar coordinates. set_sun_latitude :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_sun_latitude cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sun_latitude (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sun_latitude" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sun_latitude {-# NOINLINE bindProceduralSky_set_sun_longitude #-} -- | The direction of the sun using polar coordinates. bindProceduralSky_set_sun_longitude :: MethodBind bindProceduralSky_set_sun_longitude = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_sun_longitude" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The direction of the sun using polar coordinates. set_sun_longitude :: (ProceduralSky :< cls, Object :< cls) => cls -> Float -> IO () set_sun_longitude cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_sun_longitude (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_sun_longitude" '[Float] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_sun_longitude {-# NOINLINE bindProceduralSky_set_texture_size #-} -- | Size of @Texture@ that the ProceduralSky will generate. The size is set using @enum TextureSize@. bindProceduralSky_set_texture_size :: MethodBind bindProceduralSky_set_texture_size = unsafePerformIO $ withCString "ProceduralSky" $ \ clsNamePtr -> withCString "set_texture_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size of @Texture@ that the ProceduralSky will generate. The size is set using @enum TextureSize@. set_texture_size :: (ProceduralSky :< cls, Object :< cls) => cls -> Int -> IO () set_texture_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProceduralSky_set_texture_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProceduralSky "set_texture_size" '[Int] (IO ()) where nodeMethod = Godot.Core.ProceduralSky.set_texture_size ================================================ FILE: src/Godot/Core/ProgressBar.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ProgressBar (Godot.Core.ProgressBar.is_percent_visible, Godot.Core.ProgressBar.set_percent_visible) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Range() instance NodeProperty ProgressBar "percent_visible" Bool 'False where nodeProperty = (is_percent_visible, wrapDroppingSetter set_percent_visible, Nothing) {-# NOINLINE bindProgressBar_is_percent_visible #-} -- | If @true@, the fill percentage is displayed on the bar. bindProgressBar_is_percent_visible :: MethodBind bindProgressBar_is_percent_visible = unsafePerformIO $ withCString "ProgressBar" $ \ clsNamePtr -> withCString "is_percent_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the fill percentage is displayed on the bar. is_percent_visible :: (ProgressBar :< cls, Object :< cls) => cls -> IO Bool is_percent_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProgressBar_is_percent_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProgressBar "is_percent_visible" '[] (IO Bool) where nodeMethod = Godot.Core.ProgressBar.is_percent_visible {-# NOINLINE bindProgressBar_set_percent_visible #-} -- | If @true@, the fill percentage is displayed on the bar. bindProgressBar_set_percent_visible :: MethodBind bindProgressBar_set_percent_visible = unsafePerformIO $ withCString "ProgressBar" $ \ clsNamePtr -> withCString "set_percent_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the fill percentage is displayed on the bar. set_percent_visible :: (ProgressBar :< cls, Object :< cls) => cls -> Bool -> IO () set_percent_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProgressBar_set_percent_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProgressBar "set_percent_visible" '[Bool] (IO ()) where nodeMethod = Godot.Core.ProgressBar.set_percent_visible ================================================ FILE: src/Godot/Core/ProjectSettings.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ProjectSettings (Godot.Core.ProjectSettings.add_property_info, Godot.Core.ProjectSettings.clear, Godot.Core.ProjectSettings.get_order, Godot.Core.ProjectSettings.get_setting, Godot.Core.ProjectSettings.globalize_path, Godot.Core.ProjectSettings.has_setting, Godot.Core.ProjectSettings.load_resource_pack, Godot.Core.ProjectSettings.localize_path, Godot.Core.ProjectSettings.property_can_revert, Godot.Core.ProjectSettings.property_get_revert, Godot.Core.ProjectSettings.save, Godot.Core.ProjectSettings.save_custom, Godot.Core.ProjectSettings.set_initial_value, Godot.Core.ProjectSettings.set_order, Godot.Core.ProjectSettings.set_setting) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindProjectSettings_add_property_info #-} -- | Adds a custom property info to a property. The dictionary must contain: -- - @name@: @String@ (the property's name) -- - @type@: @int@ (see @enum Variant.Type@) -- - optionally @hint@: @int@ (see @enum PropertyHint@) and @hint_string@: @String@ -- __Example:__ -- -- @ -- -- ProjectSettings.set("category/property_name", 0) -- -- var property_info = { -- "name": "category/property_name", -- "type": TYPE_INT, -- "hint": PROPERTY_HINT_ENUM, -- "hint_string": "one,two,three" -- } -- -- ProjectSettings.add_property_info(property_info) -- -- @ bindProjectSettings_add_property_info :: MethodBind bindProjectSettings_add_property_info = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "add_property_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a custom property info to a property. The dictionary must contain: -- - @name@: @String@ (the property's name) -- - @type@: @int@ (see @enum Variant.Type@) -- - optionally @hint@: @int@ (see @enum PropertyHint@) and @hint_string@: @String@ -- __Example:__ -- -- @ -- -- ProjectSettings.set("category/property_name", 0) -- -- var property_info = { -- "name": "category/property_name", -- "type": TYPE_INT, -- "hint": PROPERTY_HINT_ENUM, -- "hint_string": "one,two,three" -- } -- -- ProjectSettings.add_property_info(property_info) -- -- @ add_property_info :: (ProjectSettings :< cls, Object :< cls) => cls -> Dictionary -> IO () add_property_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_add_property_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "add_property_info" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.ProjectSettings.add_property_info {-# NOINLINE bindProjectSettings_clear #-} -- | Clears the whole configuration (not recommended, may break things). bindProjectSettings_clear :: MethodBind bindProjectSettings_clear = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the whole configuration (not recommended, may break things). clear :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO () clear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "clear" '[GodotString] (IO ()) where nodeMethod = Godot.Core.ProjectSettings.clear {-# NOINLINE bindProjectSettings_get_order #-} -- | Returns the order of a configuration value (influences when saved to the config file). bindProjectSettings_get_order :: MethodBind bindProjectSettings_get_order = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "get_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the order of a configuration value (influences when saved to the config file). get_order :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO Int get_order cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_get_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "get_order" '[GodotString] (IO Int) where nodeMethod = Godot.Core.ProjectSettings.get_order {-# NOINLINE bindProjectSettings_get_setting #-} -- | Returns the value of a setting. -- __Example:__ -- -- @ -- -- print(ProjectSettings.get_setting("application/config/name")) -- -- @ bindProjectSettings_get_setting :: MethodBind bindProjectSettings_get_setting = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "get_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a setting. -- __Example:__ -- -- @ -- -- print(ProjectSettings.get_setting("application/config/name")) -- -- @ get_setting :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get_setting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_get_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "get_setting" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.ProjectSettings.get_setting {-# NOINLINE bindProjectSettings_globalize_path #-} -- | Converts a localized path (@res://@) to a full native OS path. bindProjectSettings_globalize_path :: MethodBind bindProjectSettings_globalize_path = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "globalize_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Converts a localized path (@res://@) to a full native OS path. globalize_path :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO GodotString globalize_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_globalize_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "globalize_path" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.ProjectSettings.globalize_path {-# NOINLINE bindProjectSettings_has_setting #-} -- | Returns @true@ if a configuration value is present. bindProjectSettings_has_setting :: MethodBind bindProjectSettings_has_setting = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "has_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a configuration value is present. has_setting :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_setting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_has_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "has_setting" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ProjectSettings.has_setting {-# NOINLINE bindProjectSettings_load_resource_pack #-} -- | Loads the contents of the .pck or .zip file specified by @pack@ into the resource filesystem (@res://@). Returns @true@ on success. -- __Note:__ If a file from @pack@ shares the same path as a file already in the resource filesystem, any attempts to load that file will use the file from @pack@ unless @replace_files@ is set to @false@. bindProjectSettings_load_resource_pack :: MethodBind bindProjectSettings_load_resource_pack = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "load_resource_pack" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads the contents of the .pck or .zip file specified by @pack@ into the resource filesystem (@res://@). Returns @true@ on success. -- __Note:__ If a file from @pack@ shares the same path as a file already in the resource filesystem, any attempts to load that file will use the file from @pack@ unless @replace_files@ is set to @false@. load_resource_pack :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO Bool load_resource_pack cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_load_resource_pack (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "load_resource_pack" '[GodotString, Maybe Bool] (IO Bool) where nodeMethod = Godot.Core.ProjectSettings.load_resource_pack {-# NOINLINE bindProjectSettings_localize_path #-} -- | Convert a path to a localized path (@res://@ path). bindProjectSettings_localize_path :: MethodBind bindProjectSettings_localize_path = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "localize_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Convert a path to a localized path (@res://@ path). localize_path :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO GodotString localize_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_localize_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "localize_path" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.ProjectSettings.localize_path {-# NOINLINE bindProjectSettings_property_can_revert #-} -- | Returns @true@ if the specified property exists and its initial value differs from the current value. bindProjectSettings_property_can_revert :: MethodBind bindProjectSettings_property_can_revert = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "property_can_revert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified property exists and its initial value differs from the current value. property_can_revert :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO Bool property_can_revert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_property_can_revert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "property_can_revert" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ProjectSettings.property_can_revert {-# NOINLINE bindProjectSettings_property_get_revert #-} -- | Returns the specified property's initial value. Returns @null@ if the property does not exist. bindProjectSettings_property_get_revert :: MethodBind bindProjectSettings_property_get_revert = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "property_get_revert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the specified property's initial value. Returns @null@ if the property does not exist. property_get_revert :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant property_get_revert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_property_get_revert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "property_get_revert" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.ProjectSettings.property_get_revert {-# NOINLINE bindProjectSettings_save #-} -- | Saves the configuration to the @project.godot@ file. bindProjectSettings_save :: MethodBind bindProjectSettings_save = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "save" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the configuration to the @project.godot@ file. save :: (ProjectSettings :< cls, Object :< cls) => cls -> IO Int save cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_save (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "save" '[] (IO Int) where nodeMethod = Godot.Core.ProjectSettings.save {-# NOINLINE bindProjectSettings_save_custom #-} -- | Saves the configuration to a custom file. The file extension must be @.godot@ (to save in text-based @ConfigFile@ format) or @.binary@ (to save in binary format). bindProjectSettings_save_custom :: MethodBind bindProjectSettings_save_custom = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "save_custom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the configuration to a custom file. The file extension must be @.godot@ (to save in text-based @ConfigFile@ format) or @.binary@ (to save in binary format). save_custom :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> IO Int save_custom cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_save_custom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "save_custom" '[GodotString] (IO Int) where nodeMethod = Godot.Core.ProjectSettings.save_custom {-# NOINLINE bindProjectSettings_set_initial_value #-} -- | Sets the specified property's initial value. This is the value the property reverts to. bindProjectSettings_set_initial_value :: MethodBind bindProjectSettings_set_initial_value = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "set_initial_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified property's initial value. This is the value the property reverts to. set_initial_value :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set_initial_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_set_initial_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "set_initial_value" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.ProjectSettings.set_initial_value {-# NOINLINE bindProjectSettings_set_order #-} -- | Sets the order of a configuration value (influences when saved to the config file). bindProjectSettings_set_order :: MethodBind bindProjectSettings_set_order = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "set_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the order of a configuration value (influences when saved to the config file). set_order :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () set_order cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_set_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "set_order" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.ProjectSettings.set_order {-# NOINLINE bindProjectSettings_set_setting #-} -- | Sets the value of a setting. -- __Example:__ -- -- @ -- -- ProjectSettings.set_setting("application/config/name", "Example") -- -- @ bindProjectSettings_set_setting :: MethodBind bindProjectSettings_set_setting = unsafePerformIO $ withCString "ProjectSettings" $ \ clsNamePtr -> withCString "set_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the value of a setting. -- __Example:__ -- -- @ -- -- ProjectSettings.set_setting("application/config/name", "Example") -- -- @ set_setting :: (ProjectSettings :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set_setting cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindProjectSettings_set_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProjectSettings "set_setting" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.ProjectSettings.set_setting ================================================ FILE: src/Godot/Core/ProximityGroup.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ProximityGroup (Godot.Core.ProximityGroup._MODE_SIGNAL, Godot.Core.ProximityGroup._MODE_PROXY, Godot.Core.ProximityGroup.sig_broadcast, Godot.Core.ProximityGroup._proximity_group_broadcast, Godot.Core.ProximityGroup.broadcast, Godot.Core.ProximityGroup.get_dispatch_mode, Godot.Core.ProximityGroup.get_grid_radius, Godot.Core.ProximityGroup.get_group_name, Godot.Core.ProximityGroup.set_dispatch_mode, Godot.Core.ProximityGroup.set_grid_radius, Godot.Core.ProximityGroup.set_group_name) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() _MODE_SIGNAL :: Int _MODE_SIGNAL = 1 _MODE_PROXY :: Int _MODE_PROXY = 0 sig_broadcast :: Godot.Internal.Dispatch.Signal ProximityGroup sig_broadcast = Godot.Internal.Dispatch.Signal "broadcast" instance NodeSignal ProximityGroup "broadcast" '[GodotString, Array] instance NodeProperty ProximityGroup "dispatch_mode" Int 'False where nodeProperty = (get_dispatch_mode, wrapDroppingSetter set_dispatch_mode, Nothing) instance NodeProperty ProximityGroup "grid_radius" Vector3 'False where nodeProperty = (get_grid_radius, wrapDroppingSetter set_grid_radius, Nothing) instance NodeProperty ProximityGroup "group_name" GodotString 'False where nodeProperty = (get_group_name, wrapDroppingSetter set_group_name, Nothing) {-# NOINLINE bindProximityGroup__proximity_group_broadcast #-} bindProximityGroup__proximity_group_broadcast :: MethodBind bindProximityGroup__proximity_group_broadcast = unsafePerformIO $ withCString "ProximityGroup" $ \ clsNamePtr -> withCString "_proximity_group_broadcast" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _proximity_group_broadcast :: (ProximityGroup :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () _proximity_group_broadcast cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindProximityGroup__proximity_group_broadcast (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProximityGroup "_proximity_group_broadcast" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.ProximityGroup._proximity_group_broadcast {-# NOINLINE bindProximityGroup_broadcast #-} bindProximityGroup_broadcast :: MethodBind bindProximityGroup_broadcast = unsafePerformIO $ withCString "ProximityGroup" $ \ clsNamePtr -> withCString "broadcast" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr broadcast :: (ProximityGroup :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () broadcast cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindProximityGroup_broadcast (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProximityGroup "broadcast" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.ProximityGroup.broadcast {-# NOINLINE bindProximityGroup_get_dispatch_mode #-} bindProximityGroup_get_dispatch_mode :: MethodBind bindProximityGroup_get_dispatch_mode = unsafePerformIO $ withCString "ProximityGroup" $ \ clsNamePtr -> withCString "get_dispatch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_dispatch_mode :: (ProximityGroup :< cls, Object :< cls) => cls -> IO Int get_dispatch_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProximityGroup_get_dispatch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProximityGroup "get_dispatch_mode" '[] (IO Int) where nodeMethod = Godot.Core.ProximityGroup.get_dispatch_mode {-# NOINLINE bindProximityGroup_get_grid_radius #-} bindProximityGroup_get_grid_radius :: MethodBind bindProximityGroup_get_grid_radius = unsafePerformIO $ withCString "ProximityGroup" $ \ clsNamePtr -> withCString "get_grid_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_grid_radius :: (ProximityGroup :< cls, Object :< cls) => cls -> IO Vector3 get_grid_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProximityGroup_get_grid_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProximityGroup "get_grid_radius" '[] (IO Vector3) where nodeMethod = Godot.Core.ProximityGroup.get_grid_radius {-# NOINLINE bindProximityGroup_get_group_name #-} bindProximityGroup_get_group_name :: MethodBind bindProximityGroup_get_group_name = unsafePerformIO $ withCString "ProximityGroup" $ \ clsNamePtr -> withCString "get_group_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_group_name :: (ProximityGroup :< cls, Object :< cls) => cls -> IO GodotString get_group_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProximityGroup_get_group_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProximityGroup "get_group_name" '[] (IO GodotString) where nodeMethod = Godot.Core.ProximityGroup.get_group_name {-# NOINLINE bindProximityGroup_set_dispatch_mode #-} bindProximityGroup_set_dispatch_mode :: MethodBind bindProximityGroup_set_dispatch_mode = unsafePerformIO $ withCString "ProximityGroup" $ \ clsNamePtr -> withCString "set_dispatch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_dispatch_mode :: (ProximityGroup :< cls, Object :< cls) => cls -> Int -> IO () set_dispatch_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProximityGroup_set_dispatch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProximityGroup "set_dispatch_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.ProximityGroup.set_dispatch_mode {-# NOINLINE bindProximityGroup_set_grid_radius #-} bindProximityGroup_set_grid_radius :: MethodBind bindProximityGroup_set_grid_radius = unsafePerformIO $ withCString "ProximityGroup" $ \ clsNamePtr -> withCString "set_grid_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_grid_radius :: (ProximityGroup :< cls, Object :< cls) => cls -> Vector3 -> IO () set_grid_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProximityGroup_set_grid_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProximityGroup "set_grid_radius" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ProximityGroup.set_grid_radius {-# NOINLINE bindProximityGroup_set_group_name #-} bindProximityGroup_set_group_name :: MethodBind bindProximityGroup_set_group_name = unsafePerformIO $ withCString "ProximityGroup" $ \ clsNamePtr -> withCString "set_group_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_group_name :: (ProximityGroup :< cls, Object :< cls) => cls -> GodotString -> IO () set_group_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProximityGroup_set_group_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProximityGroup "set_group_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.ProximityGroup.set_group_name ================================================ FILE: src/Godot/Core/ProxyTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ProxyTexture (Godot.Core.ProxyTexture.get_base, Godot.Core.ProxyTexture.set_base) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty ProxyTexture "base" Texture 'False where nodeProperty = (get_base, wrapDroppingSetter set_base, Nothing) {-# NOINLINE bindProxyTexture_get_base #-} bindProxyTexture_get_base :: MethodBind bindProxyTexture_get_base = unsafePerformIO $ withCString "ProxyTexture" $ \ clsNamePtr -> withCString "get_base" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base :: (ProxyTexture :< cls, Object :< cls) => cls -> IO Texture get_base cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindProxyTexture_get_base (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProxyTexture "get_base" '[] (IO Texture) where nodeMethod = Godot.Core.ProxyTexture.get_base {-# NOINLINE bindProxyTexture_set_base #-} bindProxyTexture_set_base :: MethodBind bindProxyTexture_set_base = unsafePerformIO $ withCString "ProxyTexture" $ \ clsNamePtr -> withCString "set_base" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base :: (ProxyTexture :< cls, Object :< cls) => cls -> Texture -> IO () set_base cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindProxyTexture_set_base (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ProxyTexture "set_base" '[Texture] (IO ()) where nodeMethod = Godot.Core.ProxyTexture.set_base ================================================ FILE: src/Godot/Core/QuadMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.QuadMesh (Godot.Core.QuadMesh.get_size, Godot.Core.QuadMesh.set_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PrimitiveMesh() instance NodeProperty QuadMesh "size" Vector2 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) {-# NOINLINE bindQuadMesh_get_size #-} -- | Size on the X and Y axes. bindQuadMesh_get_size :: MethodBind bindQuadMesh_get_size = unsafePerformIO $ withCString "QuadMesh" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size on the X and Y axes. get_size :: (QuadMesh :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindQuadMesh_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod QuadMesh "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.QuadMesh.get_size {-# NOINLINE bindQuadMesh_set_size #-} -- | Size on the X and Y axes. bindQuadMesh_set_size :: MethodBind bindQuadMesh_set_size = unsafePerformIO $ withCString "QuadMesh" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Size on the X and Y axes. set_size :: (QuadMesh :< cls, Object :< cls) => cls -> Vector2 -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindQuadMesh_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod QuadMesh "set_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.QuadMesh.set_size ================================================ FILE: src/Godot/Core/RandomNumberGenerator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RandomNumberGenerator (Godot.Core.RandomNumberGenerator.get_seed, Godot.Core.RandomNumberGenerator.randf, Godot.Core.RandomNumberGenerator.randf_range, Godot.Core.RandomNumberGenerator.randfn, Godot.Core.RandomNumberGenerator.randi, Godot.Core.RandomNumberGenerator.randi_range, Godot.Core.RandomNumberGenerator.randomize, Godot.Core.RandomNumberGenerator.set_seed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty RandomNumberGenerator "seed" Int 'False where nodeProperty = (get_seed, wrapDroppingSetter set_seed, Nothing) {-# NOINLINE bindRandomNumberGenerator_get_seed #-} -- | The seed used by the random number generator. A given seed will give a reproducible sequence of pseudo-random numbers. -- __Note:__ The RNG does not have an avalanche effect, and can output similar random streams given similar seeds. Consider using a hash function to improve your seed quality if they're sourced externally. bindRandomNumberGenerator_get_seed :: MethodBind bindRandomNumberGenerator_get_seed = unsafePerformIO $ withCString "RandomNumberGenerator" $ \ clsNamePtr -> withCString "get_seed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The seed used by the random number generator. A given seed will give a reproducible sequence of pseudo-random numbers. -- __Note:__ The RNG does not have an avalanche effect, and can output similar random streams given similar seeds. Consider using a hash function to improve your seed quality if they're sourced externally. get_seed :: (RandomNumberGenerator :< cls, Object :< cls) => cls -> IO Int get_seed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRandomNumberGenerator_get_seed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RandomNumberGenerator "get_seed" '[] (IO Int) where nodeMethod = Godot.Core.RandomNumberGenerator.get_seed {-# NOINLINE bindRandomNumberGenerator_randf #-} -- | Generates a pseudo-random float between @0.0@ and @1.0@ (inclusive). bindRandomNumberGenerator_randf :: MethodBind bindRandomNumberGenerator_randf = unsafePerformIO $ withCString "RandomNumberGenerator" $ \ clsNamePtr -> withCString "randf" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a pseudo-random float between @0.0@ and @1.0@ (inclusive). randf :: (RandomNumberGenerator :< cls, Object :< cls) => cls -> IO Float randf cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRandomNumberGenerator_randf (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RandomNumberGenerator "randf" '[] (IO Float) where nodeMethod = Godot.Core.RandomNumberGenerator.randf {-# NOINLINE bindRandomNumberGenerator_randf_range #-} -- | Generates a pseudo-random float between @from@ and @to@ (inclusive). bindRandomNumberGenerator_randf_range :: MethodBind bindRandomNumberGenerator_randf_range = unsafePerformIO $ withCString "RandomNumberGenerator" $ \ clsNamePtr -> withCString "randf_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a pseudo-random float between @from@ and @to@ (inclusive). randf_range :: (RandomNumberGenerator :< cls, Object :< cls) => cls -> Float -> Float -> IO Float randf_range cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRandomNumberGenerator_randf_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RandomNumberGenerator "randf_range" '[Float, Float] (IO Float) where nodeMethod = Godot.Core.RandomNumberGenerator.randf_range {-# NOINLINE bindRandomNumberGenerator_randfn #-} -- | Generates a @url=https://en.wikipedia.org/wiki/Normal_distribution@normally-distributed@/url@ pseudo-random number, using Box-Muller transform with the specified @mean@ and a standard @deviation@. This is also called Gaussian distribution. bindRandomNumberGenerator_randfn :: MethodBind bindRandomNumberGenerator_randfn = unsafePerformIO $ withCString "RandomNumberGenerator" $ \ clsNamePtr -> withCString "randfn" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a @url=https://en.wikipedia.org/wiki/Normal_distribution@normally-distributed@/url@ pseudo-random number, using Box-Muller transform with the specified @mean@ and a standard @deviation@. This is also called Gaussian distribution. randfn :: (RandomNumberGenerator :< cls, Object :< cls) => cls -> Maybe Float -> Maybe Float -> IO Float randfn cls arg1 arg2 = withVariantArray [maybe (VariantReal (0)) toVariant arg1, maybe (VariantReal (1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRandomNumberGenerator_randfn (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RandomNumberGenerator "randfn" '[Maybe Float, Maybe Float] (IO Float) where nodeMethod = Godot.Core.RandomNumberGenerator.randfn {-# NOINLINE bindRandomNumberGenerator_randi #-} -- | Generates a pseudo-random 32-bit unsigned integer between @0@ and @4294967295@ (inclusive). bindRandomNumberGenerator_randi :: MethodBind bindRandomNumberGenerator_randi = unsafePerformIO $ withCString "RandomNumberGenerator" $ \ clsNamePtr -> withCString "randi" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a pseudo-random 32-bit unsigned integer between @0@ and @4294967295@ (inclusive). randi :: (RandomNumberGenerator :< cls, Object :< cls) => cls -> IO Int randi cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRandomNumberGenerator_randi (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RandomNumberGenerator "randi" '[] (IO Int) where nodeMethod = Godot.Core.RandomNumberGenerator.randi {-# NOINLINE bindRandomNumberGenerator_randi_range #-} -- | Generates a pseudo-random 32-bit signed integer between @from@ and @to@ (inclusive). bindRandomNumberGenerator_randi_range :: MethodBind bindRandomNumberGenerator_randi_range = unsafePerformIO $ withCString "RandomNumberGenerator" $ \ clsNamePtr -> withCString "randi_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a pseudo-random 32-bit signed integer between @from@ and @to@ (inclusive). randi_range :: (RandomNumberGenerator :< cls, Object :< cls) => cls -> Int -> Int -> IO Int randi_range cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRandomNumberGenerator_randi_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RandomNumberGenerator "randi_range" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.RandomNumberGenerator.randi_range {-# NOINLINE bindRandomNumberGenerator_randomize #-} -- | Setups a time-based seed to generator. bindRandomNumberGenerator_randomize :: MethodBind bindRandomNumberGenerator_randomize = unsafePerformIO $ withCString "RandomNumberGenerator" $ \ clsNamePtr -> withCString "randomize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Setups a time-based seed to generator. randomize :: (RandomNumberGenerator :< cls, Object :< cls) => cls -> IO () randomize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRandomNumberGenerator_randomize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RandomNumberGenerator "randomize" '[] (IO ()) where nodeMethod = Godot.Core.RandomNumberGenerator.randomize {-# NOINLINE bindRandomNumberGenerator_set_seed #-} -- | The seed used by the random number generator. A given seed will give a reproducible sequence of pseudo-random numbers. -- __Note:__ The RNG does not have an avalanche effect, and can output similar random streams given similar seeds. Consider using a hash function to improve your seed quality if they're sourced externally. bindRandomNumberGenerator_set_seed :: MethodBind bindRandomNumberGenerator_set_seed = unsafePerformIO $ withCString "RandomNumberGenerator" $ \ clsNamePtr -> withCString "set_seed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The seed used by the random number generator. A given seed will give a reproducible sequence of pseudo-random numbers. -- __Note:__ The RNG does not have an avalanche effect, and can output similar random streams given similar seeds. Consider using a hash function to improve your seed quality if they're sourced externally. set_seed :: (RandomNumberGenerator :< cls, Object :< cls) => cls -> Int -> IO () set_seed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRandomNumberGenerator_set_seed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RandomNumberGenerator "set_seed" '[Int] (IO ()) where nodeMethod = Godot.Core.RandomNumberGenerator.set_seed ================================================ FILE: src/Godot/Core/Range.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Range (Godot.Core.Range.sig_changed, Godot.Core.Range.sig_value_changed, Godot.Core.Range.get_as_ratio, Godot.Core.Range.get_max, Godot.Core.Range.get_min, Godot.Core.Range.get_page, Godot.Core.Range.get_step, Godot.Core.Range.get_value, Godot.Core.Range.is_greater_allowed, Godot.Core.Range.is_lesser_allowed, Godot.Core.Range.is_ratio_exp, Godot.Core.Range.is_using_rounded_values, Godot.Core.Range.set_allow_greater, Godot.Core.Range.set_allow_lesser, Godot.Core.Range.set_as_ratio, Godot.Core.Range.set_exp_ratio, Godot.Core.Range.set_max, Godot.Core.Range.set_min, Godot.Core.Range.set_page, Godot.Core.Range.set_step, Godot.Core.Range.set_use_rounded_values, Godot.Core.Range.set_value, Godot.Core.Range.share, Godot.Core.Range.unshare) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() -- | Emitted when @min_value@, @max_value@, @page@, or @step@ change. sig_changed :: Godot.Internal.Dispatch.Signal Range sig_changed = Godot.Internal.Dispatch.Signal "changed" instance NodeSignal Range "changed" '[] -- | Emitted when @value@ changes. sig_value_changed :: Godot.Internal.Dispatch.Signal Range sig_value_changed = Godot.Internal.Dispatch.Signal "value_changed" instance NodeSignal Range "value_changed" '[Float] instance NodeProperty Range "allow_greater" Bool 'False where nodeProperty = (is_greater_allowed, wrapDroppingSetter set_allow_greater, Nothing) instance NodeProperty Range "allow_lesser" Bool 'False where nodeProperty = (is_lesser_allowed, wrapDroppingSetter set_allow_lesser, Nothing) instance NodeProperty Range "exp_edit" Bool 'False where nodeProperty = (is_ratio_exp, wrapDroppingSetter set_exp_ratio, Nothing) instance NodeProperty Range "max_value" Float 'False where nodeProperty = (get_max, wrapDroppingSetter set_max, Nothing) instance NodeProperty Range "min_value" Float 'False where nodeProperty = (get_min, wrapDroppingSetter set_min, Nothing) instance NodeProperty Range "page" Float 'False where nodeProperty = (get_page, wrapDroppingSetter set_page, Nothing) instance NodeProperty Range "ratio" Float 'False where nodeProperty = (get_as_ratio, wrapDroppingSetter set_as_ratio, Nothing) instance NodeProperty Range "rounded" Bool 'False where nodeProperty = (is_using_rounded_values, wrapDroppingSetter set_use_rounded_values, Nothing) instance NodeProperty Range "step" Float 'False where nodeProperty = (get_step, wrapDroppingSetter set_step, Nothing) instance NodeProperty Range "value" Float 'False where nodeProperty = (get_value, wrapDroppingSetter set_value, Nothing) {-# NOINLINE bindRange_get_as_ratio #-} -- | The value mapped between 0 and 1. bindRange_get_as_ratio :: MethodBind bindRange_get_as_ratio = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "get_as_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The value mapped between 0 and 1. get_as_ratio :: (Range :< cls, Object :< cls) => cls -> IO Float get_as_ratio cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_get_as_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "get_as_ratio" '[] (IO Float) where nodeMethod = Godot.Core.Range.get_as_ratio {-# NOINLINE bindRange_get_max #-} -- | Maximum value. Range is clamped if @value@ is greater than @max_value@. bindRange_get_max :: MethodBind bindRange_get_max = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "get_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum value. Range is clamped if @value@ is greater than @max_value@. get_max :: (Range :< cls, Object :< cls) => cls -> IO Float get_max cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_get_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "get_max" '[] (IO Float) where nodeMethod = Godot.Core.Range.get_max {-# NOINLINE bindRange_get_min #-} -- | Minimum value. Range is clamped if @value@ is less than @min_value@. bindRange_get_min :: MethodBind bindRange_get_min = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "get_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Minimum value. Range is clamped if @value@ is less than @min_value@. get_min :: (Range :< cls, Object :< cls) => cls -> IO Float get_min cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_get_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "get_min" '[] (IO Float) where nodeMethod = Godot.Core.Range.get_min {-# NOINLINE bindRange_get_page #-} -- | Page size. Used mainly for @ScrollBar@. ScrollBar's length is its size multiplied by @page@ over the difference between @min_value@ and @max_value@. bindRange_get_page :: MethodBind bindRange_get_page = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "get_page" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Page size. Used mainly for @ScrollBar@. ScrollBar's length is its size multiplied by @page@ over the difference between @min_value@ and @max_value@. get_page :: (Range :< cls, Object :< cls) => cls -> IO Float get_page cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_get_page (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "get_page" '[] (IO Float) where nodeMethod = Godot.Core.Range.get_page {-# NOINLINE bindRange_get_step #-} -- | If greater than 0, @value@ will always be rounded to a multiple of @step@. If @rounded@ is also @true@, @value@ will first be rounded to a multiple of @step@ then rounded to the nearest integer. bindRange_get_step :: MethodBind bindRange_get_step = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "get_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If greater than 0, @value@ will always be rounded to a multiple of @step@. If @rounded@ is also @true@, @value@ will first be rounded to a multiple of @step@ then rounded to the nearest integer. get_step :: (Range :< cls, Object :< cls) => cls -> IO Float get_step cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_get_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "get_step" '[] (IO Float) where nodeMethod = Godot.Core.Range.get_step {-# NOINLINE bindRange_get_value #-} -- | Range's current value. bindRange_get_value :: MethodBind bindRange_get_value = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "get_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Range's current value. get_value :: (Range :< cls, Object :< cls) => cls -> IO Float get_value cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_get_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "get_value" '[] (IO Float) where nodeMethod = Godot.Core.Range.get_value {-# NOINLINE bindRange_is_greater_allowed #-} -- | If @true@, @value@ may be greater than @max_value@. bindRange_is_greater_allowed :: MethodBind bindRange_is_greater_allowed = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "is_greater_allowed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @value@ may be greater than @max_value@. is_greater_allowed :: (Range :< cls, Object :< cls) => cls -> IO Bool is_greater_allowed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_is_greater_allowed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "is_greater_allowed" '[] (IO Bool) where nodeMethod = Godot.Core.Range.is_greater_allowed {-# NOINLINE bindRange_is_lesser_allowed #-} -- | If @true@, @value@ may be less than @min_value@. bindRange_is_lesser_allowed :: MethodBind bindRange_is_lesser_allowed = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "is_lesser_allowed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @value@ may be less than @min_value@. is_lesser_allowed :: (Range :< cls, Object :< cls) => cls -> IO Bool is_lesser_allowed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_is_lesser_allowed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "is_lesser_allowed" '[] (IO Bool) where nodeMethod = Godot.Core.Range.is_lesser_allowed {-# NOINLINE bindRange_is_ratio_exp #-} -- | If @true@, and @min_value@ is greater than 0, @value@ will be represented exponentially rather than linearly. bindRange_is_ratio_exp :: MethodBind bindRange_is_ratio_exp = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "is_ratio_exp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, and @min_value@ is greater than 0, @value@ will be represented exponentially rather than linearly. is_ratio_exp :: (Range :< cls, Object :< cls) => cls -> IO Bool is_ratio_exp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_is_ratio_exp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "is_ratio_exp" '[] (IO Bool) where nodeMethod = Godot.Core.Range.is_ratio_exp {-# NOINLINE bindRange_is_using_rounded_values #-} -- | If @true@, @value@ will always be rounded to the nearest integer. bindRange_is_using_rounded_values :: MethodBind bindRange_is_using_rounded_values = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "is_using_rounded_values" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @value@ will always be rounded to the nearest integer. is_using_rounded_values :: (Range :< cls, Object :< cls) => cls -> IO Bool is_using_rounded_values cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_is_using_rounded_values (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "is_using_rounded_values" '[] (IO Bool) where nodeMethod = Godot.Core.Range.is_using_rounded_values {-# NOINLINE bindRange_set_allow_greater #-} -- | If @true@, @value@ may be greater than @max_value@. bindRange_set_allow_greater :: MethodBind bindRange_set_allow_greater = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_allow_greater" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @value@ may be greater than @max_value@. set_allow_greater :: (Range :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_greater cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_allow_greater (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_allow_greater" '[Bool] (IO ()) where nodeMethod = Godot.Core.Range.set_allow_greater {-# NOINLINE bindRange_set_allow_lesser #-} -- | If @true@, @value@ may be less than @min_value@. bindRange_set_allow_lesser :: MethodBind bindRange_set_allow_lesser = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_allow_lesser" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @value@ may be less than @min_value@. set_allow_lesser :: (Range :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_lesser cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_allow_lesser (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_allow_lesser" '[Bool] (IO ()) where nodeMethod = Godot.Core.Range.set_allow_lesser {-# NOINLINE bindRange_set_as_ratio #-} -- | The value mapped between 0 and 1. bindRange_set_as_ratio :: MethodBind bindRange_set_as_ratio = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_as_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The value mapped between 0 and 1. set_as_ratio :: (Range :< cls, Object :< cls) => cls -> Float -> IO () set_as_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_as_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_as_ratio" '[Float] (IO ()) where nodeMethod = Godot.Core.Range.set_as_ratio {-# NOINLINE bindRange_set_exp_ratio #-} -- | If @true@, and @min_value@ is greater than 0, @value@ will be represented exponentially rather than linearly. bindRange_set_exp_ratio :: MethodBind bindRange_set_exp_ratio = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_exp_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, and @min_value@ is greater than 0, @value@ will be represented exponentially rather than linearly. set_exp_ratio :: (Range :< cls, Object :< cls) => cls -> Bool -> IO () set_exp_ratio cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_exp_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_exp_ratio" '[Bool] (IO ()) where nodeMethod = Godot.Core.Range.set_exp_ratio {-# NOINLINE bindRange_set_max #-} -- | Maximum value. Range is clamped if @value@ is greater than @max_value@. bindRange_set_max :: MethodBind bindRange_set_max = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_max" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Maximum value. Range is clamped if @value@ is greater than @max_value@. set_max :: (Range :< cls, Object :< cls) => cls -> Float -> IO () set_max cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_max (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_max" '[Float] (IO ()) where nodeMethod = Godot.Core.Range.set_max {-# NOINLINE bindRange_set_min #-} -- | Minimum value. Range is clamped if @value@ is less than @min_value@. bindRange_set_min :: MethodBind bindRange_set_min = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Minimum value. Range is clamped if @value@ is less than @min_value@. set_min :: (Range :< cls, Object :< cls) => cls -> Float -> IO () set_min cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_min" '[Float] (IO ()) where nodeMethod = Godot.Core.Range.set_min {-# NOINLINE bindRange_set_page #-} -- | Page size. Used mainly for @ScrollBar@. ScrollBar's length is its size multiplied by @page@ over the difference between @min_value@ and @max_value@. bindRange_set_page :: MethodBind bindRange_set_page = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_page" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Page size. Used mainly for @ScrollBar@. ScrollBar's length is its size multiplied by @page@ over the difference between @min_value@ and @max_value@. set_page :: (Range :< cls, Object :< cls) => cls -> Float -> IO () set_page cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_page (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_page" '[Float] (IO ()) where nodeMethod = Godot.Core.Range.set_page {-# NOINLINE bindRange_set_step #-} -- | If greater than 0, @value@ will always be rounded to a multiple of @step@. If @rounded@ is also @true@, @value@ will first be rounded to a multiple of @step@ then rounded to the nearest integer. bindRange_set_step :: MethodBind bindRange_set_step = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If greater than 0, @value@ will always be rounded to a multiple of @step@. If @rounded@ is also @true@, @value@ will first be rounded to a multiple of @step@ then rounded to the nearest integer. set_step :: (Range :< cls, Object :< cls) => cls -> Float -> IO () set_step cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_step" '[Float] (IO ()) where nodeMethod = Godot.Core.Range.set_step {-# NOINLINE bindRange_set_use_rounded_values #-} -- | If @true@, @value@ will always be rounded to the nearest integer. bindRange_set_use_rounded_values :: MethodBind bindRange_set_use_rounded_values = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_use_rounded_values" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, @value@ will always be rounded to the nearest integer. set_use_rounded_values :: (Range :< cls, Object :< cls) => cls -> Bool -> IO () set_use_rounded_values cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_use_rounded_values (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_use_rounded_values" '[Bool] (IO ()) where nodeMethod = Godot.Core.Range.set_use_rounded_values {-# NOINLINE bindRange_set_value #-} -- | Range's current value. bindRange_set_value :: MethodBind bindRange_set_value = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "set_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Range's current value. set_value :: (Range :< cls, Object :< cls) => cls -> Float -> IO () set_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_set_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "set_value" '[Float] (IO ()) where nodeMethod = Godot.Core.Range.set_value {-# NOINLINE bindRange_share #-} -- | Binds two ranges together along with any ranges previously grouped with either of them. When any of range's member variables change, it will share the new value with all other ranges in its group. bindRange_share :: MethodBind bindRange_share = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "share" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Binds two ranges together along with any ranges previously grouped with either of them. When any of range's member variables change, it will share the new value with all other ranges in its group. share :: (Range :< cls, Object :< cls) => cls -> Node -> IO () share cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRange_share (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "share" '[Node] (IO ()) where nodeMethod = Godot.Core.Range.share {-# NOINLINE bindRange_unshare #-} -- | Stops range from sharing its member variables with any other. bindRange_unshare :: MethodBind bindRange_unshare = unsafePerformIO $ withCString "Range" $ \ clsNamePtr -> withCString "unshare" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops range from sharing its member variables with any other. unshare :: (Range :< cls, Object :< cls) => cls -> IO () unshare cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRange_unshare (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Range "unshare" '[] (IO ()) where nodeMethod = Godot.Core.Range.unshare ================================================ FILE: src/Godot/Core/RayCast.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RayCast (Godot.Core.RayCast.add_exception, Godot.Core.RayCast.add_exception_rid, Godot.Core.RayCast.clear_exceptions, Godot.Core.RayCast.force_raycast_update, Godot.Core.RayCast.get_cast_to, Godot.Core.RayCast.get_collider, Godot.Core.RayCast.get_collider_shape, Godot.Core.RayCast.get_collision_mask, Godot.Core.RayCast.get_collision_mask_bit, Godot.Core.RayCast.get_collision_normal, Godot.Core.RayCast.get_collision_point, Godot.Core.RayCast.get_exclude_parent_body, Godot.Core.RayCast.is_collide_with_areas_enabled, Godot.Core.RayCast.is_collide_with_bodies_enabled, Godot.Core.RayCast.is_colliding, Godot.Core.RayCast.is_enabled, Godot.Core.RayCast.remove_exception, Godot.Core.RayCast.remove_exception_rid, Godot.Core.RayCast.set_cast_to, Godot.Core.RayCast.set_collide_with_areas, Godot.Core.RayCast.set_collide_with_bodies, Godot.Core.RayCast.set_collision_mask, Godot.Core.RayCast.set_collision_mask_bit, Godot.Core.RayCast.set_enabled, Godot.Core.RayCast.set_exclude_parent_body) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty RayCast "cast_to" Vector3 'False where nodeProperty = (get_cast_to, wrapDroppingSetter set_cast_to, Nothing) instance NodeProperty RayCast "collide_with_areas" Bool 'False where nodeProperty = (is_collide_with_areas_enabled, wrapDroppingSetter set_collide_with_areas, Nothing) instance NodeProperty RayCast "collide_with_bodies" Bool 'False where nodeProperty = (is_collide_with_bodies_enabled, wrapDroppingSetter set_collide_with_bodies, Nothing) instance NodeProperty RayCast "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty RayCast "enabled" Bool 'False where nodeProperty = (is_enabled, wrapDroppingSetter set_enabled, Nothing) instance NodeProperty RayCast "exclude_parent" Bool 'False where nodeProperty = (get_exclude_parent_body, wrapDroppingSetter set_exclude_parent_body, Nothing) {-# NOINLINE bindRayCast_add_exception #-} -- | Adds a collision exception so the ray does not report collisions with the specified node. bindRayCast_add_exception :: MethodBind bindRayCast_add_exception = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "add_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a collision exception so the ray does not report collisions with the specified node. add_exception :: (RayCast :< cls, Object :< cls) => cls -> Object -> IO () add_exception cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_add_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "add_exception" '[Object] (IO ()) where nodeMethod = Godot.Core.RayCast.add_exception {-# NOINLINE bindRayCast_add_exception_rid #-} -- | Adds a collision exception so the ray does not report collisions with the specified @RID@. bindRayCast_add_exception_rid :: MethodBind bindRayCast_add_exception_rid = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "add_exception_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a collision exception so the ray does not report collisions with the specified @RID@. add_exception_rid :: (RayCast :< cls, Object :< cls) => cls -> Rid -> IO () add_exception_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_add_exception_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "add_exception_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.RayCast.add_exception_rid {-# NOINLINE bindRayCast_clear_exceptions #-} -- | Removes all collision exceptions for this ray. bindRayCast_clear_exceptions :: MethodBind bindRayCast_clear_exceptions = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "clear_exceptions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all collision exceptions for this ray. clear_exceptions :: (RayCast :< cls, Object :< cls) => cls -> IO () clear_exceptions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_clear_exceptions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "clear_exceptions" '[] (IO ()) where nodeMethod = Godot.Core.RayCast.clear_exceptions {-# NOINLINE bindRayCast_force_raycast_update #-} -- | Updates the collision information for the ray. -- Use this method to update the collision information immediately instead of waiting for the next @_physics_process@ call, for example if the ray or its parent has changed state. -- __Note:__ @enabled@ is not required for this to work. bindRayCast_force_raycast_update :: MethodBind bindRayCast_force_raycast_update = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "force_raycast_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the collision information for the ray. -- Use this method to update the collision information immediately instead of waiting for the next @_physics_process@ call, for example if the ray or its parent has changed state. -- __Note:__ @enabled@ is not required for this to work. force_raycast_update :: (RayCast :< cls, Object :< cls) => cls -> IO () force_raycast_update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_force_raycast_update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "force_raycast_update" '[] (IO ()) where nodeMethod = Godot.Core.RayCast.force_raycast_update {-# NOINLINE bindRayCast_get_cast_to #-} -- | The ray's destination point, relative to the RayCast's @position@. bindRayCast_get_cast_to :: MethodBind bindRayCast_get_cast_to = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "get_cast_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's destination point, relative to the RayCast's @position@. get_cast_to :: (RayCast :< cls, Object :< cls) => cls -> IO Vector3 get_cast_to cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_get_cast_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "get_cast_to" '[] (IO Vector3) where nodeMethod = Godot.Core.RayCast.get_cast_to {-# NOINLINE bindRayCast_get_collider #-} -- | Returns the first object that the ray intersects, or @null@ if no object is intersecting the ray (i.e. @method is_colliding@ returns @false@). bindRayCast_get_collider :: MethodBind bindRayCast_get_collider = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "get_collider" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the first object that the ray intersects, or @null@ if no object is intersecting the ray (i.e. @method is_colliding@ returns @false@). get_collider :: (RayCast :< cls, Object :< cls) => cls -> IO Object get_collider cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_get_collider (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "get_collider" '[] (IO Object) where nodeMethod = Godot.Core.RayCast.get_collider {-# NOINLINE bindRayCast_get_collider_shape #-} -- | Returns the shape ID of the first object that the ray intersects, or @0@ if no object is intersecting the ray (i.e. @method is_colliding@ returns @false@). bindRayCast_get_collider_shape :: MethodBind bindRayCast_get_collider_shape = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "get_collider_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shape ID of the first object that the ray intersects, or @0@ if no object is intersecting the ray (i.e. @method is_colliding@ returns @false@). get_collider_shape :: (RayCast :< cls, Object :< cls) => cls -> IO Int get_collider_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_get_collider_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "get_collider_shape" '[] (IO Int) where nodeMethod = Godot.Core.RayCast.get_collider_shape {-# NOINLINE bindRayCast_get_collision_mask #-} -- | The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindRayCast_get_collision_mask :: MethodBind bindRayCast_get_collision_mask = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (RayCast :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.RayCast.get_collision_mask {-# NOINLINE bindRayCast_get_collision_mask_bit #-} -- | Returns @true@ if the bit index passed is turned on. -- __Note:__ Bit indices range from 0-19. bindRayCast_get_collision_mask_bit :: MethodBind bindRayCast_get_collision_mask_bit = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the bit index passed is turned on. -- __Note:__ Bit indices range from 0-19. get_collision_mask_bit :: (RayCast :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.RayCast.get_collision_mask_bit {-# NOINLINE bindRayCast_get_collision_normal #-} -- | Returns the normal of the intersecting object's shape at the collision point. bindRayCast_get_collision_normal :: MethodBind bindRayCast_get_collision_normal = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "get_collision_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the normal of the intersecting object's shape at the collision point. get_collision_normal :: (RayCast :< cls, Object :< cls) => cls -> IO Vector3 get_collision_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_get_collision_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "get_collision_normal" '[] (IO Vector3) where nodeMethod = Godot.Core.RayCast.get_collision_normal {-# NOINLINE bindRayCast_get_collision_point #-} -- | Returns the collision point at which the ray intersects the closest object. -- __Note:__ This point is in the __global__ coordinate system. bindRayCast_get_collision_point :: MethodBind bindRayCast_get_collision_point = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "get_collision_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collision point at which the ray intersects the closest object. -- __Note:__ This point is in the __global__ coordinate system. get_collision_point :: (RayCast :< cls, Object :< cls) => cls -> IO Vector3 get_collision_point cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_get_collision_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "get_collision_point" '[] (IO Vector3) where nodeMethod = Godot.Core.RayCast.get_collision_point {-# NOINLINE bindRayCast_get_exclude_parent_body #-} -- | If @true@, collisions will be ignored for this RayCast's immediate parent. bindRayCast_get_exclude_parent_body :: MethodBind bindRayCast_get_exclude_parent_body = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "get_exclude_parent_body" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collisions will be ignored for this RayCast's immediate parent. get_exclude_parent_body :: (RayCast :< cls, Object :< cls) => cls -> IO Bool get_exclude_parent_body cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_get_exclude_parent_body (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "get_exclude_parent_body" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast.get_exclude_parent_body {-# NOINLINE bindRayCast_is_collide_with_areas_enabled #-} -- | If @true@, collision with @Area@s will be reported. bindRayCast_is_collide_with_areas_enabled :: MethodBind bindRayCast_is_collide_with_areas_enabled = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "is_collide_with_areas_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision with @Area@s will be reported. is_collide_with_areas_enabled :: (RayCast :< cls, Object :< cls) => cls -> IO Bool is_collide_with_areas_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_is_collide_with_areas_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "is_collide_with_areas_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast.is_collide_with_areas_enabled {-# NOINLINE bindRayCast_is_collide_with_bodies_enabled #-} -- | If @true@, collision with @PhysicsBody@s will be reported. bindRayCast_is_collide_with_bodies_enabled :: MethodBind bindRayCast_is_collide_with_bodies_enabled = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "is_collide_with_bodies_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision with @PhysicsBody@s will be reported. is_collide_with_bodies_enabled :: (RayCast :< cls, Object :< cls) => cls -> IO Bool is_collide_with_bodies_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_is_collide_with_bodies_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "is_collide_with_bodies_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast.is_collide_with_bodies_enabled {-# NOINLINE bindRayCast_is_colliding #-} -- | Returns whether any object is intersecting with the ray's vector (considering the vector length). bindRayCast_is_colliding :: MethodBind bindRayCast_is_colliding = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "is_colliding" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether any object is intersecting with the ray's vector (considering the vector length). is_colliding :: (RayCast :< cls, Object :< cls) => cls -> IO Bool is_colliding cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_is_colliding (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "is_colliding" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast.is_colliding {-# NOINLINE bindRayCast_is_enabled #-} -- | If @true@, collisions will be reported. bindRayCast_is_enabled :: MethodBind bindRayCast_is_enabled = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "is_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collisions will be reported. is_enabled :: (RayCast :< cls, Object :< cls) => cls -> IO Bool is_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_is_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "is_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast.is_enabled {-# NOINLINE bindRayCast_remove_exception #-} -- | Removes a collision exception so the ray does report collisions with the specified node. bindRayCast_remove_exception :: MethodBind bindRayCast_remove_exception = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "remove_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a collision exception so the ray does report collisions with the specified node. remove_exception :: (RayCast :< cls, Object :< cls) => cls -> Object -> IO () remove_exception cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_remove_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "remove_exception" '[Object] (IO ()) where nodeMethod = Godot.Core.RayCast.remove_exception {-# NOINLINE bindRayCast_remove_exception_rid #-} -- | Removes a collision exception so the ray does report collisions with the specified @RID@. bindRayCast_remove_exception_rid :: MethodBind bindRayCast_remove_exception_rid = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "remove_exception_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a collision exception so the ray does report collisions with the specified @RID@. remove_exception_rid :: (RayCast :< cls, Object :< cls) => cls -> Rid -> IO () remove_exception_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_remove_exception_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "remove_exception_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.RayCast.remove_exception_rid {-# NOINLINE bindRayCast_set_cast_to #-} -- | The ray's destination point, relative to the RayCast's @position@. bindRayCast_set_cast_to :: MethodBind bindRayCast_set_cast_to = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "set_cast_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's destination point, relative to the RayCast's @position@. set_cast_to :: (RayCast :< cls, Object :< cls) => cls -> Vector3 -> IO () set_cast_to cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_set_cast_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "set_cast_to" '[Vector3] (IO ()) where nodeMethod = Godot.Core.RayCast.set_cast_to {-# NOINLINE bindRayCast_set_collide_with_areas #-} -- | If @true@, collision with @Area@s will be reported. bindRayCast_set_collide_with_areas :: MethodBind bindRayCast_set_collide_with_areas = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "set_collide_with_areas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision with @Area@s will be reported. set_collide_with_areas :: (RayCast :< cls, Object :< cls) => cls -> Bool -> IO () set_collide_with_areas cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_set_collide_with_areas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "set_collide_with_areas" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayCast.set_collide_with_areas {-# NOINLINE bindRayCast_set_collide_with_bodies #-} -- | If @true@, collision with @PhysicsBody@s will be reported. bindRayCast_set_collide_with_bodies :: MethodBind bindRayCast_set_collide_with_bodies = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "set_collide_with_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision with @PhysicsBody@s will be reported. set_collide_with_bodies :: (RayCast :< cls, Object :< cls) => cls -> Bool -> IO () set_collide_with_bodies cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_set_collide_with_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "set_collide_with_bodies" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayCast.set_collide_with_bodies {-# NOINLINE bindRayCast_set_collision_mask #-} -- | The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindRayCast_set_collision_mask :: MethodBind bindRayCast_set_collision_mask = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (RayCast :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.RayCast.set_collision_mask {-# NOINLINE bindRayCast_set_collision_mask_bit #-} -- | Sets the bit index passed to the @value@ passed. -- __Note:__ Bit indexes range from 0-19. bindRayCast_set_collision_mask_bit :: MethodBind bindRayCast_set_collision_mask_bit = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the bit index passed to the @value@ passed. -- __Note:__ Bit indexes range from 0-19. set_collision_mask_bit :: (RayCast :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.RayCast.set_collision_mask_bit {-# NOINLINE bindRayCast_set_enabled #-} -- | If @true@, collisions will be reported. bindRayCast_set_enabled :: MethodBind bindRayCast_set_enabled = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "set_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collisions will be reported. set_enabled :: (RayCast :< cls, Object :< cls) => cls -> Bool -> IO () set_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_set_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "set_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayCast.set_enabled {-# NOINLINE bindRayCast_set_exclude_parent_body #-} -- | If @true@, collisions will be ignored for this RayCast's immediate parent. bindRayCast_set_exclude_parent_body :: MethodBind bindRayCast_set_exclude_parent_body = unsafePerformIO $ withCString "RayCast" $ \ clsNamePtr -> withCString "set_exclude_parent_body" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collisions will be ignored for this RayCast's immediate parent. set_exclude_parent_body :: (RayCast :< cls, Object :< cls) => cls -> Bool -> IO () set_exclude_parent_body cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast_set_exclude_parent_body (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast "set_exclude_parent_body" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayCast.set_exclude_parent_body ================================================ FILE: src/Godot/Core/RayCast2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RayCast2D (Godot.Core.RayCast2D.add_exception, Godot.Core.RayCast2D.add_exception_rid, Godot.Core.RayCast2D.clear_exceptions, Godot.Core.RayCast2D.force_raycast_update, Godot.Core.RayCast2D.get_cast_to, Godot.Core.RayCast2D.get_collider, Godot.Core.RayCast2D.get_collider_shape, Godot.Core.RayCast2D.get_collision_mask, Godot.Core.RayCast2D.get_collision_mask_bit, Godot.Core.RayCast2D.get_collision_normal, Godot.Core.RayCast2D.get_collision_point, Godot.Core.RayCast2D.get_exclude_parent_body, Godot.Core.RayCast2D.is_collide_with_areas_enabled, Godot.Core.RayCast2D.is_collide_with_bodies_enabled, Godot.Core.RayCast2D.is_colliding, Godot.Core.RayCast2D.is_enabled, Godot.Core.RayCast2D.remove_exception, Godot.Core.RayCast2D.remove_exception_rid, Godot.Core.RayCast2D.set_cast_to, Godot.Core.RayCast2D.set_collide_with_areas, Godot.Core.RayCast2D.set_collide_with_bodies, Godot.Core.RayCast2D.set_collision_mask, Godot.Core.RayCast2D.set_collision_mask_bit, Godot.Core.RayCast2D.set_enabled, Godot.Core.RayCast2D.set_exclude_parent_body) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty RayCast2D "cast_to" Vector2 'False where nodeProperty = (get_cast_to, wrapDroppingSetter set_cast_to, Nothing) instance NodeProperty RayCast2D "collide_with_areas" Bool 'False where nodeProperty = (is_collide_with_areas_enabled, wrapDroppingSetter set_collide_with_areas, Nothing) instance NodeProperty RayCast2D "collide_with_bodies" Bool 'False where nodeProperty = (is_collide_with_bodies_enabled, wrapDroppingSetter set_collide_with_bodies, Nothing) instance NodeProperty RayCast2D "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty RayCast2D "enabled" Bool 'False where nodeProperty = (is_enabled, wrapDroppingSetter set_enabled, Nothing) instance NodeProperty RayCast2D "exclude_parent" Bool 'False where nodeProperty = (get_exclude_parent_body, wrapDroppingSetter set_exclude_parent_body, Nothing) {-# NOINLINE bindRayCast2D_add_exception #-} -- | Adds a collision exception so the ray does not report collisions with the specified node. bindRayCast2D_add_exception :: MethodBind bindRayCast2D_add_exception = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "add_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a collision exception so the ray does not report collisions with the specified node. add_exception :: (RayCast2D :< cls, Object :< cls) => cls -> Object -> IO () add_exception cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_add_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "add_exception" '[Object] (IO ()) where nodeMethod = Godot.Core.RayCast2D.add_exception {-# NOINLINE bindRayCast2D_add_exception_rid #-} -- | Adds a collision exception so the ray does not report collisions with the specified @RID@. bindRayCast2D_add_exception_rid :: MethodBind bindRayCast2D_add_exception_rid = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "add_exception_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a collision exception so the ray does not report collisions with the specified @RID@. add_exception_rid :: (RayCast2D :< cls, Object :< cls) => cls -> Rid -> IO () add_exception_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_add_exception_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "add_exception_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.RayCast2D.add_exception_rid {-# NOINLINE bindRayCast2D_clear_exceptions #-} -- | Removes all collision exceptions for this ray. bindRayCast2D_clear_exceptions :: MethodBind bindRayCast2D_clear_exceptions = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "clear_exceptions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all collision exceptions for this ray. clear_exceptions :: (RayCast2D :< cls, Object :< cls) => cls -> IO () clear_exceptions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_clear_exceptions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "clear_exceptions" '[] (IO ()) where nodeMethod = Godot.Core.RayCast2D.clear_exceptions {-# NOINLINE bindRayCast2D_force_raycast_update #-} -- | Updates the collision information for the ray. Use this method to update the collision information immediately instead of waiting for the next @_physics_process@ call, for example if the ray or its parent has changed state. -- __Note:__ @enabled@ is not required for this to work. bindRayCast2D_force_raycast_update :: MethodBind bindRayCast2D_force_raycast_update = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "force_raycast_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the collision information for the ray. Use this method to update the collision information immediately instead of waiting for the next @_physics_process@ call, for example if the ray or its parent has changed state. -- __Note:__ @enabled@ is not required for this to work. force_raycast_update :: (RayCast2D :< cls, Object :< cls) => cls -> IO () force_raycast_update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_force_raycast_update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "force_raycast_update" '[] (IO ()) where nodeMethod = Godot.Core.RayCast2D.force_raycast_update {-# NOINLINE bindRayCast2D_get_cast_to #-} -- | The ray's destination point, relative to the RayCast's @position@. bindRayCast2D_get_cast_to :: MethodBind bindRayCast2D_get_cast_to = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "get_cast_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's destination point, relative to the RayCast's @position@. get_cast_to :: (RayCast2D :< cls, Object :< cls) => cls -> IO Vector2 get_cast_to cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_get_cast_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "get_cast_to" '[] (IO Vector2) where nodeMethod = Godot.Core.RayCast2D.get_cast_to {-# NOINLINE bindRayCast2D_get_collider #-} -- | Returns the first object that the ray intersects, or @null@ if no object is intersecting the ray (i.e. @method is_colliding@ returns @false@). bindRayCast2D_get_collider :: MethodBind bindRayCast2D_get_collider = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "get_collider" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the first object that the ray intersects, or @null@ if no object is intersecting the ray (i.e. @method is_colliding@ returns @false@). get_collider :: (RayCast2D :< cls, Object :< cls) => cls -> IO Object get_collider cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_get_collider (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "get_collider" '[] (IO Object) where nodeMethod = Godot.Core.RayCast2D.get_collider {-# NOINLINE bindRayCast2D_get_collider_shape #-} -- | Returns the shape ID of the first object that the ray intersects, or @0@ if no object is intersecting the ray (i.e. @method is_colliding@ returns @false@). bindRayCast2D_get_collider_shape :: MethodBind bindRayCast2D_get_collider_shape = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "get_collider_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shape ID of the first object that the ray intersects, or @0@ if no object is intersecting the ray (i.e. @method is_colliding@ returns @false@). get_collider_shape :: (RayCast2D :< cls, Object :< cls) => cls -> IO Int get_collider_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_get_collider_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "get_collider_shape" '[] (IO Int) where nodeMethod = Godot.Core.RayCast2D.get_collider_shape {-# NOINLINE bindRayCast2D_get_collision_mask #-} -- | The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindRayCast2D_get_collision_mask :: MethodBind bindRayCast2D_get_collision_mask = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (RayCast2D :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.RayCast2D.get_collision_mask {-# NOINLINE bindRayCast2D_get_collision_mask_bit #-} -- | Returns an individual bit on the collision mask. bindRayCast2D_get_collision_mask_bit :: MethodBind bindRayCast2D_get_collision_mask_bit = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the collision mask. get_collision_mask_bit :: (RayCast2D :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.RayCast2D.get_collision_mask_bit {-# NOINLINE bindRayCast2D_get_collision_normal #-} -- | Returns the normal of the intersecting object's shape at the collision point. bindRayCast2D_get_collision_normal :: MethodBind bindRayCast2D_get_collision_normal = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "get_collision_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the normal of the intersecting object's shape at the collision point. get_collision_normal :: (RayCast2D :< cls, Object :< cls) => cls -> IO Vector2 get_collision_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_get_collision_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "get_collision_normal" '[] (IO Vector2) where nodeMethod = Godot.Core.RayCast2D.get_collision_normal {-# NOINLINE bindRayCast2D_get_collision_point #-} -- | Returns the collision point at which the ray intersects the closest object. -- __Note:__ this point is in the __global__ coordinate system. bindRayCast2D_get_collision_point :: MethodBind bindRayCast2D_get_collision_point = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "get_collision_point" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the collision point at which the ray intersects the closest object. -- __Note:__ this point is in the __global__ coordinate system. get_collision_point :: (RayCast2D :< cls, Object :< cls) => cls -> IO Vector2 get_collision_point cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_get_collision_point (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "get_collision_point" '[] (IO Vector2) where nodeMethod = Godot.Core.RayCast2D.get_collision_point {-# NOINLINE bindRayCast2D_get_exclude_parent_body #-} -- | If @true@, the parent node will be excluded from collision detection. bindRayCast2D_get_exclude_parent_body :: MethodBind bindRayCast2D_get_exclude_parent_body = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "get_exclude_parent_body" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the parent node will be excluded from collision detection. get_exclude_parent_body :: (RayCast2D :< cls, Object :< cls) => cls -> IO Bool get_exclude_parent_body cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_get_exclude_parent_body (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "get_exclude_parent_body" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast2D.get_exclude_parent_body {-# NOINLINE bindRayCast2D_is_collide_with_areas_enabled #-} -- | If @true@, collision with @Area2D@s will be reported. bindRayCast2D_is_collide_with_areas_enabled :: MethodBind bindRayCast2D_is_collide_with_areas_enabled = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "is_collide_with_areas_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision with @Area2D@s will be reported. is_collide_with_areas_enabled :: (RayCast2D :< cls, Object :< cls) => cls -> IO Bool is_collide_with_areas_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_is_collide_with_areas_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "is_collide_with_areas_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast2D.is_collide_with_areas_enabled {-# NOINLINE bindRayCast2D_is_collide_with_bodies_enabled #-} -- | If @true@, collision with @PhysicsBody2D@s will be reported. bindRayCast2D_is_collide_with_bodies_enabled :: MethodBind bindRayCast2D_is_collide_with_bodies_enabled = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "is_collide_with_bodies_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision with @PhysicsBody2D@s will be reported. is_collide_with_bodies_enabled :: (RayCast2D :< cls, Object :< cls) => cls -> IO Bool is_collide_with_bodies_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_is_collide_with_bodies_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "is_collide_with_bodies_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast2D.is_collide_with_bodies_enabled {-# NOINLINE bindRayCast2D_is_colliding #-} -- | Returns whether any object is intersecting with the ray's vector (considering the vector length). bindRayCast2D_is_colliding :: MethodBind bindRayCast2D_is_colliding = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "is_colliding" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether any object is intersecting with the ray's vector (considering the vector length). is_colliding :: (RayCast2D :< cls, Object :< cls) => cls -> IO Bool is_colliding cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_is_colliding (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "is_colliding" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast2D.is_colliding {-# NOINLINE bindRayCast2D_is_enabled #-} -- | If @true@, collisions will be reported. bindRayCast2D_is_enabled :: MethodBind bindRayCast2D_is_enabled = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "is_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collisions will be reported. is_enabled :: (RayCast2D :< cls, Object :< cls) => cls -> IO Bool is_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_is_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "is_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RayCast2D.is_enabled {-# NOINLINE bindRayCast2D_remove_exception #-} -- | Removes a collision exception so the ray does report collisions with the specified node. bindRayCast2D_remove_exception :: MethodBind bindRayCast2D_remove_exception = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "remove_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a collision exception so the ray does report collisions with the specified node. remove_exception :: (RayCast2D :< cls, Object :< cls) => cls -> Object -> IO () remove_exception cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_remove_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "remove_exception" '[Object] (IO ()) where nodeMethod = Godot.Core.RayCast2D.remove_exception {-# NOINLINE bindRayCast2D_remove_exception_rid #-} -- | Removes a collision exception so the ray does report collisions with the specified @RID@. bindRayCast2D_remove_exception_rid :: MethodBind bindRayCast2D_remove_exception_rid = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "remove_exception_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a collision exception so the ray does report collisions with the specified @RID@. remove_exception_rid :: (RayCast2D :< cls, Object :< cls) => cls -> Rid -> IO () remove_exception_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_remove_exception_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "remove_exception_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.RayCast2D.remove_exception_rid {-# NOINLINE bindRayCast2D_set_cast_to #-} -- | The ray's destination point, relative to the RayCast's @position@. bindRayCast2D_set_cast_to :: MethodBind bindRayCast2D_set_cast_to = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "set_cast_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's destination point, relative to the RayCast's @position@. set_cast_to :: (RayCast2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_cast_to cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_set_cast_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "set_cast_to" '[Vector2] (IO ()) where nodeMethod = Godot.Core.RayCast2D.set_cast_to {-# NOINLINE bindRayCast2D_set_collide_with_areas #-} -- | If @true@, collision with @Area2D@s will be reported. bindRayCast2D_set_collide_with_areas :: MethodBind bindRayCast2D_set_collide_with_areas = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "set_collide_with_areas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision with @Area2D@s will be reported. set_collide_with_areas :: (RayCast2D :< cls, Object :< cls) => cls -> Bool -> IO () set_collide_with_areas cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_set_collide_with_areas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "set_collide_with_areas" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayCast2D.set_collide_with_areas {-# NOINLINE bindRayCast2D_set_collide_with_bodies #-} -- | If @true@, collision with @PhysicsBody2D@s will be reported. bindRayCast2D_set_collide_with_bodies :: MethodBind bindRayCast2D_set_collide_with_bodies = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "set_collide_with_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision with @PhysicsBody2D@s will be reported. set_collide_with_bodies :: (RayCast2D :< cls, Object :< cls) => cls -> Bool -> IO () set_collide_with_bodies cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_set_collide_with_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "set_collide_with_bodies" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayCast2D.set_collide_with_bodies {-# NOINLINE bindRayCast2D_set_collision_mask #-} -- | The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindRayCast2D_set_collision_mask :: MethodBind bindRayCast2D_set_collision_mask = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (RayCast2D :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.RayCast2D.set_collision_mask {-# NOINLINE bindRayCast2D_set_collision_mask_bit #-} -- | Sets or clears individual bits on the collision mask. This makes selecting the areas scanned easier. bindRayCast2D_set_collision_mask_bit :: MethodBind bindRayCast2D_set_collision_mask_bit = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets or clears individual bits on the collision mask. This makes selecting the areas scanned easier. set_collision_mask_bit :: (RayCast2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.RayCast2D.set_collision_mask_bit {-# NOINLINE bindRayCast2D_set_enabled #-} -- | If @true@, collisions will be reported. bindRayCast2D_set_enabled :: MethodBind bindRayCast2D_set_enabled = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "set_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collisions will be reported. set_enabled :: (RayCast2D :< cls, Object :< cls) => cls -> Bool -> IO () set_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_set_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "set_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayCast2D.set_enabled {-# NOINLINE bindRayCast2D_set_exclude_parent_body #-} -- | If @true@, the parent node will be excluded from collision detection. bindRayCast2D_set_exclude_parent_body :: MethodBind bindRayCast2D_set_exclude_parent_body = unsafePerformIO $ withCString "RayCast2D" $ \ clsNamePtr -> withCString "set_exclude_parent_body" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the parent node will be excluded from collision detection. set_exclude_parent_body :: (RayCast2D :< cls, Object :< cls) => cls -> Bool -> IO () set_exclude_parent_body cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayCast2D_set_exclude_parent_body (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayCast2D "set_exclude_parent_body" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayCast2D.set_exclude_parent_body ================================================ FILE: src/Godot/Core/RayShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RayShape (Godot.Core.RayShape.get_length, Godot.Core.RayShape.get_slips_on_slope, Godot.Core.RayShape.set_length, Godot.Core.RayShape.set_slips_on_slope) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty RayShape "length" Float 'False where nodeProperty = (get_length, wrapDroppingSetter set_length, Nothing) instance NodeProperty RayShape "slips_on_slope" Bool 'False where nodeProperty = (get_slips_on_slope, wrapDroppingSetter set_slips_on_slope, Nothing) {-# NOINLINE bindRayShape_get_length #-} -- | The ray's length. bindRayShape_get_length :: MethodBind bindRayShape_get_length = unsafePerformIO $ withCString "RayShape" $ \ clsNamePtr -> withCString "get_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's length. get_length :: (RayShape :< cls, Object :< cls) => cls -> IO Float get_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayShape_get_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayShape "get_length" '[] (IO Float) where nodeMethod = Godot.Core.RayShape.get_length {-# NOINLINE bindRayShape_get_slips_on_slope #-} -- | If @true@, allow the shape to return the correct normal. bindRayShape_get_slips_on_slope :: MethodBind bindRayShape_get_slips_on_slope = unsafePerformIO $ withCString "RayShape" $ \ clsNamePtr -> withCString "get_slips_on_slope" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allow the shape to return the correct normal. get_slips_on_slope :: (RayShape :< cls, Object :< cls) => cls -> IO Bool get_slips_on_slope cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayShape_get_slips_on_slope (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayShape "get_slips_on_slope" '[] (IO Bool) where nodeMethod = Godot.Core.RayShape.get_slips_on_slope {-# NOINLINE bindRayShape_set_length #-} -- | The ray's length. bindRayShape_set_length :: MethodBind bindRayShape_set_length = unsafePerformIO $ withCString "RayShape" $ \ clsNamePtr -> withCString "set_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's length. set_length :: (RayShape :< cls, Object :< cls) => cls -> Float -> IO () set_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayShape_set_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayShape "set_length" '[Float] (IO ()) where nodeMethod = Godot.Core.RayShape.set_length {-# NOINLINE bindRayShape_set_slips_on_slope #-} -- | If @true@, allow the shape to return the correct normal. bindRayShape_set_slips_on_slope :: MethodBind bindRayShape_set_slips_on_slope = unsafePerformIO $ withCString "RayShape" $ \ clsNamePtr -> withCString "set_slips_on_slope" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allow the shape to return the correct normal. set_slips_on_slope :: (RayShape :< cls, Object :< cls) => cls -> Bool -> IO () set_slips_on_slope cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayShape_set_slips_on_slope (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayShape "set_slips_on_slope" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayShape.set_slips_on_slope ================================================ FILE: src/Godot/Core/RayShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RayShape2D (Godot.Core.RayShape2D.get_length, Godot.Core.RayShape2D.get_slips_on_slope, Godot.Core.RayShape2D.set_length, Godot.Core.RayShape2D.set_slips_on_slope) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape2D() instance NodeProperty RayShape2D "length" Float 'False where nodeProperty = (get_length, wrapDroppingSetter set_length, Nothing) instance NodeProperty RayShape2D "slips_on_slope" Bool 'False where nodeProperty = (get_slips_on_slope, wrapDroppingSetter set_slips_on_slope, Nothing) {-# NOINLINE bindRayShape2D_get_length #-} -- | The ray's length. bindRayShape2D_get_length :: MethodBind bindRayShape2D_get_length = unsafePerformIO $ withCString "RayShape2D" $ \ clsNamePtr -> withCString "get_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's length. get_length :: (RayShape2D :< cls, Object :< cls) => cls -> IO Float get_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayShape2D_get_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayShape2D "get_length" '[] (IO Float) where nodeMethod = Godot.Core.RayShape2D.get_length {-# NOINLINE bindRayShape2D_get_slips_on_slope #-} -- | If @true@, allow the shape to return the correct normal. bindRayShape2D_get_slips_on_slope :: MethodBind bindRayShape2D_get_slips_on_slope = unsafePerformIO $ withCString "RayShape2D" $ \ clsNamePtr -> withCString "get_slips_on_slope" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allow the shape to return the correct normal. get_slips_on_slope :: (RayShape2D :< cls, Object :< cls) => cls -> IO Bool get_slips_on_slope cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRayShape2D_get_slips_on_slope (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayShape2D "get_slips_on_slope" '[] (IO Bool) where nodeMethod = Godot.Core.RayShape2D.get_slips_on_slope {-# NOINLINE bindRayShape2D_set_length #-} -- | The ray's length. bindRayShape2D_set_length :: MethodBind bindRayShape2D_set_length = unsafePerformIO $ withCString "RayShape2D" $ \ clsNamePtr -> withCString "set_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The ray's length. set_length :: (RayShape2D :< cls, Object :< cls) => cls -> Float -> IO () set_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayShape2D_set_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayShape2D "set_length" '[Float] (IO ()) where nodeMethod = Godot.Core.RayShape2D.set_length {-# NOINLINE bindRayShape2D_set_slips_on_slope #-} -- | If @true@, allow the shape to return the correct normal. bindRayShape2D_set_slips_on_slope :: MethodBind bindRayShape2D_set_slips_on_slope = unsafePerformIO $ withCString "RayShape2D" $ \ clsNamePtr -> withCString "set_slips_on_slope" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, allow the shape to return the correct normal. set_slips_on_slope :: (RayShape2D :< cls, Object :< cls) => cls -> Bool -> IO () set_slips_on_slope cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRayShape2D_set_slips_on_slope (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RayShape2D "set_slips_on_slope" '[Bool] (IO ()) where nodeMethod = Godot.Core.RayShape2D.set_slips_on_slope ================================================ FILE: src/Godot/Core/RectangleShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RectangleShape2D (Godot.Core.RectangleShape2D.get_extents, Godot.Core.RectangleShape2D.set_extents) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape2D() instance NodeProperty RectangleShape2D "extents" Vector2 'False where nodeProperty = (get_extents, wrapDroppingSetter set_extents, Nothing) {-# NOINLINE bindRectangleShape2D_get_extents #-} -- | The rectangle's half extents. The width and height of this shape is twice the half extents. bindRectangleShape2D_get_extents :: MethodBind bindRectangleShape2D_get_extents = unsafePerformIO $ withCString "RectangleShape2D" $ \ clsNamePtr -> withCString "get_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rectangle's half extents. The width and height of this shape is twice the half extents. get_extents :: (RectangleShape2D :< cls, Object :< cls) => cls -> IO Vector2 get_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRectangleShape2D_get_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RectangleShape2D "get_extents" '[] (IO Vector2) where nodeMethod = Godot.Core.RectangleShape2D.get_extents {-# NOINLINE bindRectangleShape2D_set_extents #-} -- | The rectangle's half extents. The width and height of this shape is twice the half extents. bindRectangleShape2D_set_extents :: MethodBind bindRectangleShape2D_set_extents = unsafePerformIO $ withCString "RectangleShape2D" $ \ clsNamePtr -> withCString "set_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rectangle's half extents. The width and height of this shape is twice the half extents. set_extents :: (RectangleShape2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRectangleShape2D_set_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RectangleShape2D "set_extents" '[Vector2] (IO ()) where nodeMethod = Godot.Core.RectangleShape2D.set_extents ================================================ FILE: src/Godot/Core/Reference.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Reference (Godot.Core.Reference.init_ref, Godot.Core.Reference.reference, Godot.Core.Reference.unreference) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindReference_init_ref #-} -- | Initializes the internal reference counter. Use this only if you really know what you are doing. -- Returns whether the initialization was successful. bindReference_init_ref :: MethodBind bindReference_init_ref = unsafePerformIO $ withCString "Reference" $ \ clsNamePtr -> withCString "init_ref" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Initializes the internal reference counter. Use this only if you really know what you are doing. -- Returns whether the initialization was successful. init_ref :: (Reference :< cls, Object :< cls) => cls -> IO Bool init_ref cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReference_init_ref (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Reference "init_ref" '[] (IO Bool) where nodeMethod = Godot.Core.Reference.init_ref {-# NOINLINE bindReference_reference #-} -- | Increments the internal reference counter. Use this only if you really know what you are doing. -- Returns @true@ if the increment was successful, @false@ otherwise. bindReference_reference :: MethodBind bindReference_reference = unsafePerformIO $ withCString "Reference" $ \ clsNamePtr -> withCString "reference" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Increments the internal reference counter. Use this only if you really know what you are doing. -- Returns @true@ if the increment was successful, @false@ otherwise. reference :: (Reference :< cls, Object :< cls) => cls -> IO Bool reference cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReference_reference (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Reference "reference" '[] (IO Bool) where nodeMethod = Godot.Core.Reference.reference {-# NOINLINE bindReference_unreference #-} -- | Decrements the internal reference counter. Use this only if you really know what you are doing. -- Returns @true@ if the decrement was successful, @false@ otherwise. bindReference_unreference :: MethodBind bindReference_unreference = unsafePerformIO $ withCString "Reference" $ \ clsNamePtr -> withCString "unreference" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Decrements the internal reference counter. Use this only if you really know what you are doing. -- Returns @true@ if the decrement was successful, @false@ otherwise. unreference :: (Reference :< cls, Object :< cls) => cls -> IO Bool unreference cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReference_unreference (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Reference "unreference" '[] (IO Bool) where nodeMethod = Godot.Core.Reference.unreference ================================================ FILE: src/Godot/Core/ReferenceRect.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ReferenceRect (Godot.Core.ReferenceRect.get_border_color, Godot.Core.ReferenceRect.get_editor_only, Godot.Core.ReferenceRect.set_border_color, Godot.Core.ReferenceRect.set_editor_only) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() instance NodeProperty ReferenceRect "border_color" Color 'False where nodeProperty = (get_border_color, wrapDroppingSetter set_border_color, Nothing) instance NodeProperty ReferenceRect "editor_only" Bool 'False where nodeProperty = (get_editor_only, wrapDroppingSetter set_editor_only, Nothing) {-# NOINLINE bindReferenceRect_get_border_color #-} -- | Sets the border @Color@ of the @ReferenceRect@. bindReferenceRect_get_border_color :: MethodBind bindReferenceRect_get_border_color = unsafePerformIO $ withCString "ReferenceRect" $ \ clsNamePtr -> withCString "get_border_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the border @Color@ of the @ReferenceRect@. get_border_color :: (ReferenceRect :< cls, Object :< cls) => cls -> IO Color get_border_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReferenceRect_get_border_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReferenceRect "get_border_color" '[] (IO Color) where nodeMethod = Godot.Core.ReferenceRect.get_border_color {-# NOINLINE bindReferenceRect_get_editor_only #-} -- | If set to @true@, the @ReferenceRect@ will only be visible while in editor. Otherwise, @ReferenceRect@ will be visible in game. bindReferenceRect_get_editor_only :: MethodBind bindReferenceRect_get_editor_only = unsafePerformIO $ withCString "ReferenceRect" $ \ clsNamePtr -> withCString "get_editor_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If set to @true@, the @ReferenceRect@ will only be visible while in editor. Otherwise, @ReferenceRect@ will be visible in game. get_editor_only :: (ReferenceRect :< cls, Object :< cls) => cls -> IO Bool get_editor_only cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReferenceRect_get_editor_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReferenceRect "get_editor_only" '[] (IO Bool) where nodeMethod = Godot.Core.ReferenceRect.get_editor_only {-# NOINLINE bindReferenceRect_set_border_color #-} -- | Sets the border @Color@ of the @ReferenceRect@. bindReferenceRect_set_border_color :: MethodBind bindReferenceRect_set_border_color = unsafePerformIO $ withCString "ReferenceRect" $ \ clsNamePtr -> withCString "set_border_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the border @Color@ of the @ReferenceRect@. set_border_color :: (ReferenceRect :< cls, Object :< cls) => cls -> Color -> IO () set_border_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReferenceRect_set_border_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReferenceRect "set_border_color" '[Color] (IO ()) where nodeMethod = Godot.Core.ReferenceRect.set_border_color {-# NOINLINE bindReferenceRect_set_editor_only #-} -- | If set to @true@, the @ReferenceRect@ will only be visible while in editor. Otherwise, @ReferenceRect@ will be visible in game. bindReferenceRect_set_editor_only :: MethodBind bindReferenceRect_set_editor_only = unsafePerformIO $ withCString "ReferenceRect" $ \ clsNamePtr -> withCString "set_editor_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If set to @true@, the @ReferenceRect@ will only be visible while in editor. Otherwise, @ReferenceRect@ will be visible in game. set_editor_only :: (ReferenceRect :< cls, Object :< cls) => cls -> Bool -> IO () set_editor_only cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReferenceRect_set_editor_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReferenceRect "set_editor_only" '[Bool] (IO ()) where nodeMethod = Godot.Core.ReferenceRect.set_editor_only ================================================ FILE: src/Godot/Core/ReflectionProbe.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ReflectionProbe (Godot.Core.ReflectionProbe._UPDATE_ALWAYS, Godot.Core.ReflectionProbe._UPDATE_ONCE, Godot.Core.ReflectionProbe.are_shadows_enabled, Godot.Core.ReflectionProbe.get_cull_mask, Godot.Core.ReflectionProbe.get_extents, Godot.Core.ReflectionProbe.get_intensity, Godot.Core.ReflectionProbe.get_interior_ambient, Godot.Core.ReflectionProbe.get_interior_ambient_energy, Godot.Core.ReflectionProbe.get_interior_ambient_probe_contribution, Godot.Core.ReflectionProbe.get_max_distance, Godot.Core.ReflectionProbe.get_origin_offset, Godot.Core.ReflectionProbe.get_update_mode, Godot.Core.ReflectionProbe.is_box_projection_enabled, Godot.Core.ReflectionProbe.is_set_as_interior, Godot.Core.ReflectionProbe.set_as_interior, Godot.Core.ReflectionProbe.set_cull_mask, Godot.Core.ReflectionProbe.set_enable_box_projection, Godot.Core.ReflectionProbe.set_enable_shadows, Godot.Core.ReflectionProbe.set_extents, Godot.Core.ReflectionProbe.set_intensity, Godot.Core.ReflectionProbe.set_interior_ambient, Godot.Core.ReflectionProbe.set_interior_ambient_energy, Godot.Core.ReflectionProbe.set_interior_ambient_probe_contribution, Godot.Core.ReflectionProbe.set_max_distance, Godot.Core.ReflectionProbe.set_origin_offset, Godot.Core.ReflectionProbe.set_update_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualInstance() _UPDATE_ALWAYS :: Int _UPDATE_ALWAYS = 1 _UPDATE_ONCE :: Int _UPDATE_ONCE = 0 instance NodeProperty ReflectionProbe "box_projection" Bool 'False where nodeProperty = (is_box_projection_enabled, wrapDroppingSetter set_enable_box_projection, Nothing) instance NodeProperty ReflectionProbe "cull_mask" Int 'False where nodeProperty = (get_cull_mask, wrapDroppingSetter set_cull_mask, Nothing) instance NodeProperty ReflectionProbe "enable_shadows" Bool 'False where nodeProperty = (are_shadows_enabled, wrapDroppingSetter set_enable_shadows, Nothing) instance NodeProperty ReflectionProbe "extents" Vector3 'False where nodeProperty = (get_extents, wrapDroppingSetter set_extents, Nothing) instance NodeProperty ReflectionProbe "intensity" Float 'False where nodeProperty = (get_intensity, wrapDroppingSetter set_intensity, Nothing) instance NodeProperty ReflectionProbe "interior_ambient_color" Color 'False where nodeProperty = (get_interior_ambient, wrapDroppingSetter set_interior_ambient, Nothing) instance NodeProperty ReflectionProbe "interior_ambient_contrib" Float 'False where nodeProperty = (get_interior_ambient_probe_contribution, wrapDroppingSetter set_interior_ambient_probe_contribution, Nothing) instance NodeProperty ReflectionProbe "interior_ambient_energy" Float 'False where nodeProperty = (get_interior_ambient_energy, wrapDroppingSetter set_interior_ambient_energy, Nothing) instance NodeProperty ReflectionProbe "interior_enable" Bool 'False where nodeProperty = (is_set_as_interior, wrapDroppingSetter set_as_interior, Nothing) instance NodeProperty ReflectionProbe "max_distance" Float 'False where nodeProperty = (get_max_distance, wrapDroppingSetter set_max_distance, Nothing) instance NodeProperty ReflectionProbe "origin_offset" Vector3 'False where nodeProperty = (get_origin_offset, wrapDroppingSetter set_origin_offset, Nothing) instance NodeProperty ReflectionProbe "update_mode" Int 'False where nodeProperty = (get_update_mode, wrapDroppingSetter set_update_mode, Nothing) {-# NOINLINE bindReflectionProbe_are_shadows_enabled #-} -- | If @true@, computes shadows in the reflection probe. This makes the reflection probe slower to render; you may want to disable this if using the @UPDATE_ALWAYS@ @update_mode@. bindReflectionProbe_are_shadows_enabled :: MethodBind bindReflectionProbe_are_shadows_enabled = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "are_shadows_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, computes shadows in the reflection probe. This makes the reflection probe slower to render; you may want to disable this if using the @UPDATE_ALWAYS@ @update_mode@. are_shadows_enabled :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Bool are_shadows_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_are_shadows_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "are_shadows_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ReflectionProbe.are_shadows_enabled {-# NOINLINE bindReflectionProbe_get_cull_mask #-} -- | Sets the cull mask which determines what objects are drawn by this probe. Every @VisualInstance@ with a layer included in this cull mask will be rendered by the probe. It is best to only include large objects which are likely to take up a lot of space in the reflection in order to save on rendering cost. bindReflectionProbe_get_cull_mask :: MethodBind bindReflectionProbe_get_cull_mask = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the cull mask which determines what objects are drawn by this probe. Every @VisualInstance@ with a layer included in this cull mask will be rendered by the probe. It is best to only include large objects which are likely to take up a lot of space in the reflection in order to save on rendering cost. get_cull_mask :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Int get_cull_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_cull_mask" '[] (IO Int) where nodeMethod = Godot.Core.ReflectionProbe.get_cull_mask {-# NOINLINE bindReflectionProbe_get_extents #-} -- | The size of the reflection probe. The larger the extents the more space covered by the probe which will lower the perceived resolution. It is best to keep the extents only as large as you need them. bindReflectionProbe_get_extents :: MethodBind bindReflectionProbe_get_extents = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the reflection probe. The larger the extents the more space covered by the probe which will lower the perceived resolution. It is best to keep the extents only as large as you need them. get_extents :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Vector3 get_extents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_extents" '[] (IO Vector3) where nodeMethod = Godot.Core.ReflectionProbe.get_extents {-# NOINLINE bindReflectionProbe_get_intensity #-} -- | Defines the reflection intensity. Intensity modulates the strength of the reflection. bindReflectionProbe_get_intensity :: MethodBind bindReflectionProbe_get_intensity = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_intensity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the reflection intensity. Intensity modulates the strength of the reflection. get_intensity :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Float get_intensity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_intensity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_intensity" '[] (IO Float) where nodeMethod = Godot.Core.ReflectionProbe.get_intensity {-# NOINLINE bindReflectionProbe_get_interior_ambient #-} -- | Sets the ambient light color to be used when this probe is set to @interior_enable@. bindReflectionProbe_get_interior_ambient :: MethodBind bindReflectionProbe_get_interior_ambient = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_interior_ambient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the ambient light color to be used when this probe is set to @interior_enable@. get_interior_ambient :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Color get_interior_ambient cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_interior_ambient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_interior_ambient" '[] (IO Color) where nodeMethod = Godot.Core.ReflectionProbe.get_interior_ambient {-# NOINLINE bindReflectionProbe_get_interior_ambient_energy #-} -- | Sets the energy multiplier for this reflection probe's ambient light contribution when set to @interior_enable@. bindReflectionProbe_get_interior_ambient_energy :: MethodBind bindReflectionProbe_get_interior_ambient_energy = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_interior_ambient_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the energy multiplier for this reflection probe's ambient light contribution when set to @interior_enable@. get_interior_ambient_energy :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Float get_interior_ambient_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_interior_ambient_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_interior_ambient_energy" '[] (IO Float) where nodeMethod = Godot.Core.ReflectionProbe.get_interior_ambient_energy {-# NOINLINE bindReflectionProbe_get_interior_ambient_probe_contribution #-} -- | Sets the contribution value for how much the reflection affects the ambient light for this reflection probe when set to @interior_enable@. Useful so that ambient light matches the color of the room. bindReflectionProbe_get_interior_ambient_probe_contribution :: MethodBind bindReflectionProbe_get_interior_ambient_probe_contribution = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_interior_ambient_probe_contribution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the contribution value for how much the reflection affects the ambient light for this reflection probe when set to @interior_enable@. Useful so that ambient light matches the color of the room. get_interior_ambient_probe_contribution :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Float get_interior_ambient_probe_contribution cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_interior_ambient_probe_contribution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_interior_ambient_probe_contribution" '[] (IO Float) where nodeMethod = Godot.Core.ReflectionProbe.get_interior_ambient_probe_contribution {-# NOINLINE bindReflectionProbe_get_max_distance #-} -- | Sets the max distance away from the probe an object can be before it is culled. bindReflectionProbe_get_max_distance :: MethodBind bindReflectionProbe_get_max_distance = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the max distance away from the probe an object can be before it is culled. get_max_distance :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Float get_max_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_max_distance" '[] (IO Float) where nodeMethod = Godot.Core.ReflectionProbe.get_max_distance {-# NOINLINE bindReflectionProbe_get_origin_offset #-} -- | Sets the origin offset to be used when this reflection probe is in box project mode. bindReflectionProbe_get_origin_offset :: MethodBind bindReflectionProbe_get_origin_offset = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_origin_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the origin offset to be used when this reflection probe is in box project mode. get_origin_offset :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Vector3 get_origin_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_origin_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_origin_offset" '[] (IO Vector3) where nodeMethod = Godot.Core.ReflectionProbe.get_origin_offset {-# NOINLINE bindReflectionProbe_get_update_mode #-} -- | Sets how frequently the probe is updated. Can be @UPDATE_ONCE@ or @UPDATE_ALWAYS@. bindReflectionProbe_get_update_mode :: MethodBind bindReflectionProbe_get_update_mode = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "get_update_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets how frequently the probe is updated. Can be @UPDATE_ONCE@ or @UPDATE_ALWAYS@. get_update_mode :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Int get_update_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_get_update_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "get_update_mode" '[] (IO Int) where nodeMethod = Godot.Core.ReflectionProbe.get_update_mode {-# NOINLINE bindReflectionProbe_is_box_projection_enabled #-} -- | If @true@, enables box projection. This makes reflections look more correct in rectangle-shaped rooms by offsetting the reflection center depending on the camera's location. bindReflectionProbe_is_box_projection_enabled :: MethodBind bindReflectionProbe_is_box_projection_enabled = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "is_box_projection_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables box projection. This makes reflections look more correct in rectangle-shaped rooms by offsetting the reflection center depending on the camera's location. is_box_projection_enabled :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Bool is_box_projection_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_is_box_projection_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "is_box_projection_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ReflectionProbe.is_box_projection_enabled {-# NOINLINE bindReflectionProbe_is_set_as_interior #-} -- | If @true@, reflections will ignore sky contribution. Ambient lighting is then controlled by the @interior_ambient_*@ properties. bindReflectionProbe_is_set_as_interior :: MethodBind bindReflectionProbe_is_set_as_interior = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "is_set_as_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, reflections will ignore sky contribution. Ambient lighting is then controlled by the @interior_ambient_*@ properties. is_set_as_interior :: (ReflectionProbe :< cls, Object :< cls) => cls -> IO Bool is_set_as_interior cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_is_set_as_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "is_set_as_interior" '[] (IO Bool) where nodeMethod = Godot.Core.ReflectionProbe.is_set_as_interior {-# NOINLINE bindReflectionProbe_set_as_interior #-} -- | If @true@, reflections will ignore sky contribution. Ambient lighting is then controlled by the @interior_ambient_*@ properties. bindReflectionProbe_set_as_interior :: MethodBind bindReflectionProbe_set_as_interior = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_as_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, reflections will ignore sky contribution. Ambient lighting is then controlled by the @interior_ambient_*@ properties. set_as_interior :: (ReflectionProbe :< cls, Object :< cls) => cls -> Bool -> IO () set_as_interior cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_as_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_as_interior" '[Bool] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_as_interior {-# NOINLINE bindReflectionProbe_set_cull_mask #-} -- | Sets the cull mask which determines what objects are drawn by this probe. Every @VisualInstance@ with a layer included in this cull mask will be rendered by the probe. It is best to only include large objects which are likely to take up a lot of space in the reflection in order to save on rendering cost. bindReflectionProbe_set_cull_mask :: MethodBind bindReflectionProbe_set_cull_mask = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the cull mask which determines what objects are drawn by this probe. Every @VisualInstance@ with a layer included in this cull mask will be rendered by the probe. It is best to only include large objects which are likely to take up a lot of space in the reflection in order to save on rendering cost. set_cull_mask :: (ReflectionProbe :< cls, Object :< cls) => cls -> Int -> IO () set_cull_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_cull_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_cull_mask {-# NOINLINE bindReflectionProbe_set_enable_box_projection #-} -- | If @true@, enables box projection. This makes reflections look more correct in rectangle-shaped rooms by offsetting the reflection center depending on the camera's location. bindReflectionProbe_set_enable_box_projection :: MethodBind bindReflectionProbe_set_enable_box_projection = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_enable_box_projection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables box projection. This makes reflections look more correct in rectangle-shaped rooms by offsetting the reflection center depending on the camera's location. set_enable_box_projection :: (ReflectionProbe :< cls, Object :< cls) => cls -> Bool -> IO () set_enable_box_projection cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_enable_box_projection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_enable_box_projection" '[Bool] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_enable_box_projection {-# NOINLINE bindReflectionProbe_set_enable_shadows #-} -- | If @true@, computes shadows in the reflection probe. This makes the reflection probe slower to render; you may want to disable this if using the @UPDATE_ALWAYS@ @update_mode@. bindReflectionProbe_set_enable_shadows :: MethodBind bindReflectionProbe_set_enable_shadows = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_enable_shadows" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, computes shadows in the reflection probe. This makes the reflection probe slower to render; you may want to disable this if using the @UPDATE_ALWAYS@ @update_mode@. set_enable_shadows :: (ReflectionProbe :< cls, Object :< cls) => cls -> Bool -> IO () set_enable_shadows cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_enable_shadows (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_enable_shadows" '[Bool] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_enable_shadows {-# NOINLINE bindReflectionProbe_set_extents #-} -- | The size of the reflection probe. The larger the extents the more space covered by the probe which will lower the perceived resolution. It is best to keep the extents only as large as you need them. bindReflectionProbe_set_extents :: MethodBind bindReflectionProbe_set_extents = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the reflection probe. The larger the extents the more space covered by the probe which will lower the perceived resolution. It is best to keep the extents only as large as you need them. set_extents :: (ReflectionProbe :< cls, Object :< cls) => cls -> Vector3 -> IO () set_extents cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_extents" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_extents {-# NOINLINE bindReflectionProbe_set_intensity #-} -- | Defines the reflection intensity. Intensity modulates the strength of the reflection. bindReflectionProbe_set_intensity :: MethodBind bindReflectionProbe_set_intensity = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_intensity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the reflection intensity. Intensity modulates the strength of the reflection. set_intensity :: (ReflectionProbe :< cls, Object :< cls) => cls -> Float -> IO () set_intensity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_intensity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_intensity" '[Float] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_intensity {-# NOINLINE bindReflectionProbe_set_interior_ambient #-} -- | Sets the ambient light color to be used when this probe is set to @interior_enable@. bindReflectionProbe_set_interior_ambient :: MethodBind bindReflectionProbe_set_interior_ambient = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_interior_ambient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the ambient light color to be used when this probe is set to @interior_enable@. set_interior_ambient :: (ReflectionProbe :< cls, Object :< cls) => cls -> Color -> IO () set_interior_ambient cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_interior_ambient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_interior_ambient" '[Color] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_interior_ambient {-# NOINLINE bindReflectionProbe_set_interior_ambient_energy #-} -- | Sets the energy multiplier for this reflection probe's ambient light contribution when set to @interior_enable@. bindReflectionProbe_set_interior_ambient_energy :: MethodBind bindReflectionProbe_set_interior_ambient_energy = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_interior_ambient_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the energy multiplier for this reflection probe's ambient light contribution when set to @interior_enable@. set_interior_ambient_energy :: (ReflectionProbe :< cls, Object :< cls) => cls -> Float -> IO () set_interior_ambient_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_interior_ambient_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_interior_ambient_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_interior_ambient_energy {-# NOINLINE bindReflectionProbe_set_interior_ambient_probe_contribution #-} -- | Sets the contribution value for how much the reflection affects the ambient light for this reflection probe when set to @interior_enable@. Useful so that ambient light matches the color of the room. bindReflectionProbe_set_interior_ambient_probe_contribution :: MethodBind bindReflectionProbe_set_interior_ambient_probe_contribution = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_interior_ambient_probe_contribution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the contribution value for how much the reflection affects the ambient light for this reflection probe when set to @interior_enable@. Useful so that ambient light matches the color of the room. set_interior_ambient_probe_contribution :: (ReflectionProbe :< cls, Object :< cls) => cls -> Float -> IO () set_interior_ambient_probe_contribution cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_interior_ambient_probe_contribution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_interior_ambient_probe_contribution" '[Float] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_interior_ambient_probe_contribution {-# NOINLINE bindReflectionProbe_set_max_distance #-} -- | Sets the max distance away from the probe an object can be before it is culled. bindReflectionProbe_set_max_distance :: MethodBind bindReflectionProbe_set_max_distance = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the max distance away from the probe an object can be before it is culled. set_max_distance :: (ReflectionProbe :< cls, Object :< cls) => cls -> Float -> IO () set_max_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_max_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_max_distance {-# NOINLINE bindReflectionProbe_set_origin_offset #-} -- | Sets the origin offset to be used when this reflection probe is in box project mode. bindReflectionProbe_set_origin_offset :: MethodBind bindReflectionProbe_set_origin_offset = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_origin_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the origin offset to be used when this reflection probe is in box project mode. set_origin_offset :: (ReflectionProbe :< cls, Object :< cls) => cls -> Vector3 -> IO () set_origin_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_origin_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_origin_offset" '[Vector3] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_origin_offset {-# NOINLINE bindReflectionProbe_set_update_mode #-} -- | Sets how frequently the probe is updated. Can be @UPDATE_ONCE@ or @UPDATE_ALWAYS@. bindReflectionProbe_set_update_mode :: MethodBind bindReflectionProbe_set_update_mode = unsafePerformIO $ withCString "ReflectionProbe" $ \ clsNamePtr -> withCString "set_update_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets how frequently the probe is updated. Can be @UPDATE_ONCE@ or @UPDATE_ALWAYS@. set_update_mode :: (ReflectionProbe :< cls, Object :< cls) => cls -> Int -> IO () set_update_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindReflectionProbe_set_update_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ReflectionProbe "set_update_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.ReflectionProbe.set_update_mode ================================================ FILE: src/Godot/Core/RegEx.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RegEx (Godot.Core.RegEx.clear, Godot.Core.RegEx.compile, Godot.Core.RegEx.get_group_count, Godot.Core.RegEx.get_names, Godot.Core.RegEx.get_pattern, Godot.Core.RegEx.is_valid, Godot.Core.RegEx.search, Godot.Core.RegEx.search_all, Godot.Core.RegEx.sub) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindRegEx_clear #-} bindRegEx_clear :: MethodBind bindRegEx_clear = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear :: (RegEx :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "clear" '[] (IO ()) where nodeMethod = Godot.Core.RegEx.clear {-# NOINLINE bindRegEx_compile #-} bindRegEx_compile :: MethodBind bindRegEx_compile = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "compile" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr compile :: (RegEx :< cls, Object :< cls) => cls -> GodotString -> IO Int compile cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_compile (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "compile" '[GodotString] (IO Int) where nodeMethod = Godot.Core.RegEx.compile {-# NOINLINE bindRegEx_get_group_count #-} bindRegEx_get_group_count :: MethodBind bindRegEx_get_group_count = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "get_group_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_group_count :: (RegEx :< cls, Object :< cls) => cls -> IO Int get_group_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_get_group_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "get_group_count" '[] (IO Int) where nodeMethod = Godot.Core.RegEx.get_group_count {-# NOINLINE bindRegEx_get_names #-} bindRegEx_get_names :: MethodBind bindRegEx_get_names = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "get_names" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_names :: (RegEx :< cls, Object :< cls) => cls -> IO Array get_names cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_get_names (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "get_names" '[] (IO Array) where nodeMethod = Godot.Core.RegEx.get_names {-# NOINLINE bindRegEx_get_pattern #-} bindRegEx_get_pattern :: MethodBind bindRegEx_get_pattern = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "get_pattern" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_pattern :: (RegEx :< cls, Object :< cls) => cls -> IO GodotString get_pattern cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_get_pattern (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "get_pattern" '[] (IO GodotString) where nodeMethod = Godot.Core.RegEx.get_pattern {-# NOINLINE bindRegEx_is_valid #-} bindRegEx_is_valid :: MethodBind bindRegEx_is_valid = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "is_valid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_valid :: (RegEx :< cls, Object :< cls) => cls -> IO Bool is_valid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_is_valid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "is_valid" '[] (IO Bool) where nodeMethod = Godot.Core.RegEx.is_valid {-# NOINLINE bindRegEx_search #-} bindRegEx_search :: MethodBind bindRegEx_search = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "search" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr search :: (RegEx :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> Maybe Int -> IO RegExMatch search cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, maybe (VariantInt (-1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_search (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "search" '[GodotString, Maybe Int, Maybe Int] (IO RegExMatch) where nodeMethod = Godot.Core.RegEx.search {-# NOINLINE bindRegEx_search_all #-} bindRegEx_search_all :: MethodBind bindRegEx_search_all = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "search_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr search_all :: (RegEx :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> Maybe Int -> IO Array search_all cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, maybe (VariantInt (-1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_search_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "search_all" '[GodotString, Maybe Int, Maybe Int] (IO Array) where nodeMethod = Godot.Core.RegEx.search_all {-# NOINLINE bindRegEx_sub #-} bindRegEx_sub :: MethodBind bindRegEx_sub = unsafePerformIO $ withCString "RegEx" $ \ clsNamePtr -> withCString "sub" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr sub :: (RegEx :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Maybe Bool -> Maybe Int -> Maybe Int -> IO GodotString sub cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3, maybe (VariantInt (0)) toVariant arg4, maybe (VariantInt (-1)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindRegEx_sub (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegEx "sub" '[GodotString, GodotString, Maybe Bool, Maybe Int, Maybe Int] (IO GodotString) where nodeMethod = Godot.Core.RegEx.sub ================================================ FILE: src/Godot/Core/RegExMatch.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RegExMatch (Godot.Core.RegExMatch.get_end, Godot.Core.RegExMatch.get_group_count, Godot.Core.RegExMatch.get_names, Godot.Core.RegExMatch.get_start, Godot.Core.RegExMatch.get_string, Godot.Core.RegExMatch.get_strings, Godot.Core.RegExMatch.get_subject) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty RegExMatch "names" Dictionary 'True where nodeProperty = (get_names, (), Nothing) instance NodeProperty RegExMatch "strings" Array 'True where nodeProperty = (get_strings, (), Nothing) instance NodeProperty RegExMatch "subject" GodotString 'True where nodeProperty = (get_subject, (), Nothing) {-# NOINLINE bindRegExMatch_get_end #-} bindRegExMatch_get_end :: MethodBind bindRegExMatch_get_end = unsafePerformIO $ withCString "RegExMatch" $ \ clsNamePtr -> withCString "get_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_end :: (RegExMatch :< cls, Object :< cls) => cls -> Maybe GodotVariant -> IO Int get_end cls arg1 = withVariantArray [maybe (VariantInt 0) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRegExMatch_get_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegExMatch "get_end" '[Maybe GodotVariant] (IO Int) where nodeMethod = Godot.Core.RegExMatch.get_end {-# NOINLINE bindRegExMatch_get_group_count #-} bindRegExMatch_get_group_count :: MethodBind bindRegExMatch_get_group_count = unsafePerformIO $ withCString "RegExMatch" $ \ clsNamePtr -> withCString "get_group_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_group_count :: (RegExMatch :< cls, Object :< cls) => cls -> IO Int get_group_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegExMatch_get_group_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegExMatch "get_group_count" '[] (IO Int) where nodeMethod = Godot.Core.RegExMatch.get_group_count {-# NOINLINE bindRegExMatch_get_names #-} bindRegExMatch_get_names :: MethodBind bindRegExMatch_get_names = unsafePerformIO $ withCString "RegExMatch" $ \ clsNamePtr -> withCString "get_names" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_names :: (RegExMatch :< cls, Object :< cls) => cls -> IO Dictionary get_names cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegExMatch_get_names (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegExMatch "get_names" '[] (IO Dictionary) where nodeMethod = Godot.Core.RegExMatch.get_names {-# NOINLINE bindRegExMatch_get_start #-} bindRegExMatch_get_start :: MethodBind bindRegExMatch_get_start = unsafePerformIO $ withCString "RegExMatch" $ \ clsNamePtr -> withCString "get_start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_start :: (RegExMatch :< cls, Object :< cls) => cls -> Maybe GodotVariant -> IO Int get_start cls arg1 = withVariantArray [maybe (VariantInt 0) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRegExMatch_get_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegExMatch "get_start" '[Maybe GodotVariant] (IO Int) where nodeMethod = Godot.Core.RegExMatch.get_start {-# NOINLINE bindRegExMatch_get_string #-} bindRegExMatch_get_string :: MethodBind bindRegExMatch_get_string = unsafePerformIO $ withCString "RegExMatch" $ \ clsNamePtr -> withCString "get_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_string :: (RegExMatch :< cls, Object :< cls) => cls -> Maybe GodotVariant -> IO GodotString get_string cls arg1 = withVariantArray [maybe (VariantInt 0) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRegExMatch_get_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegExMatch "get_string" '[Maybe GodotVariant] (IO GodotString) where nodeMethod = Godot.Core.RegExMatch.get_string {-# NOINLINE bindRegExMatch_get_strings #-} bindRegExMatch_get_strings :: MethodBind bindRegExMatch_get_strings = unsafePerformIO $ withCString "RegExMatch" $ \ clsNamePtr -> withCString "get_strings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_strings :: (RegExMatch :< cls, Object :< cls) => cls -> IO Array get_strings cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegExMatch_get_strings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegExMatch "get_strings" '[] (IO Array) where nodeMethod = Godot.Core.RegExMatch.get_strings {-# NOINLINE bindRegExMatch_get_subject #-} bindRegExMatch_get_subject :: MethodBind bindRegExMatch_get_subject = unsafePerformIO $ withCString "RegExMatch" $ \ clsNamePtr -> withCString "get_subject" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_subject :: (RegExMatch :< cls, Object :< cls) => cls -> IO GodotString get_subject cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRegExMatch_get_subject (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RegExMatch "get_subject" '[] (IO GodotString) where nodeMethod = Godot.Core.RegExMatch.get_subject ================================================ FILE: src/Godot/Core/RemoteTransform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RemoteTransform (Godot.Core.RemoteTransform.force_update_cache, Godot.Core.RemoteTransform.get_remote_node, Godot.Core.RemoteTransform.get_update_position, Godot.Core.RemoteTransform.get_update_rotation, Godot.Core.RemoteTransform.get_update_scale, Godot.Core.RemoteTransform.get_use_global_coordinates, Godot.Core.RemoteTransform.set_remote_node, Godot.Core.RemoteTransform.set_update_position, Godot.Core.RemoteTransform.set_update_rotation, Godot.Core.RemoteTransform.set_update_scale, Godot.Core.RemoteTransform.set_use_global_coordinates) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty RemoteTransform "remote_path" NodePath 'False where nodeProperty = (get_remote_node, wrapDroppingSetter set_remote_node, Nothing) instance NodeProperty RemoteTransform "update_position" Bool 'False where nodeProperty = (get_update_position, wrapDroppingSetter set_update_position, Nothing) instance NodeProperty RemoteTransform "update_rotation" Bool 'False where nodeProperty = (get_update_rotation, wrapDroppingSetter set_update_rotation, Nothing) instance NodeProperty RemoteTransform "update_scale" Bool 'False where nodeProperty = (get_update_scale, wrapDroppingSetter set_update_scale, Nothing) instance NodeProperty RemoteTransform "use_global_coordinates" Bool 'False where nodeProperty = (get_use_global_coordinates, wrapDroppingSetter set_use_global_coordinates, Nothing) {-# NOINLINE bindRemoteTransform_force_update_cache #-} -- | @RemoteTransform@ caches the remote node. It may not notice if the remote node disappears; @method force_update_cache@ forces it to update the cache again. bindRemoteTransform_force_update_cache :: MethodBind bindRemoteTransform_force_update_cache = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "force_update_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @RemoteTransform@ caches the remote node. It may not notice if the remote node disappears; @method force_update_cache@ forces it to update the cache again. force_update_cache :: (RemoteTransform :< cls, Object :< cls) => cls -> IO () force_update_cache cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_force_update_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "force_update_cache" '[] (IO ()) where nodeMethod = Godot.Core.RemoteTransform.force_update_cache {-# NOINLINE bindRemoteTransform_get_remote_node #-} -- | The @NodePath@ to the remote node, relative to the RemoteTransform's position in the scene. bindRemoteTransform_get_remote_node :: MethodBind bindRemoteTransform_get_remote_node = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "get_remote_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @NodePath@ to the remote node, relative to the RemoteTransform's position in the scene. get_remote_node :: (RemoteTransform :< cls, Object :< cls) => cls -> IO NodePath get_remote_node cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_get_remote_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "get_remote_node" '[] (IO NodePath) where nodeMethod = Godot.Core.RemoteTransform.get_remote_node {-# NOINLINE bindRemoteTransform_get_update_position #-} -- | If @true@, the remote node's position is updated. bindRemoteTransform_get_update_position :: MethodBind bindRemoteTransform_get_update_position = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "get_update_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's position is updated. get_update_position :: (RemoteTransform :< cls, Object :< cls) => cls -> IO Bool get_update_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_get_update_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "get_update_position" '[] (IO Bool) where nodeMethod = Godot.Core.RemoteTransform.get_update_position {-# NOINLINE bindRemoteTransform_get_update_rotation #-} -- | If @true@, the remote node's rotation is updated. bindRemoteTransform_get_update_rotation :: MethodBind bindRemoteTransform_get_update_rotation = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "get_update_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's rotation is updated. get_update_rotation :: (RemoteTransform :< cls, Object :< cls) => cls -> IO Bool get_update_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_get_update_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "get_update_rotation" '[] (IO Bool) where nodeMethod = Godot.Core.RemoteTransform.get_update_rotation {-# NOINLINE bindRemoteTransform_get_update_scale #-} -- | If @true@, the remote node's scale is updated. bindRemoteTransform_get_update_scale :: MethodBind bindRemoteTransform_get_update_scale = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "get_update_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's scale is updated. get_update_scale :: (RemoteTransform :< cls, Object :< cls) => cls -> IO Bool get_update_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_get_update_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "get_update_scale" '[] (IO Bool) where nodeMethod = Godot.Core.RemoteTransform.get_update_scale {-# NOINLINE bindRemoteTransform_get_use_global_coordinates #-} -- | If @true@, global coordinates are used. If @false@, local coordinates are used. bindRemoteTransform_get_use_global_coordinates :: MethodBind bindRemoteTransform_get_use_global_coordinates = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "get_use_global_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, global coordinates are used. If @false@, local coordinates are used. get_use_global_coordinates :: (RemoteTransform :< cls, Object :< cls) => cls -> IO Bool get_use_global_coordinates cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_get_use_global_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "get_use_global_coordinates" '[] (IO Bool) where nodeMethod = Godot.Core.RemoteTransform.get_use_global_coordinates {-# NOINLINE bindRemoteTransform_set_remote_node #-} -- | The @NodePath@ to the remote node, relative to the RemoteTransform's position in the scene. bindRemoteTransform_set_remote_node :: MethodBind bindRemoteTransform_set_remote_node = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "set_remote_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @NodePath@ to the remote node, relative to the RemoteTransform's position in the scene. set_remote_node :: (RemoteTransform :< cls, Object :< cls) => cls -> NodePath -> IO () set_remote_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_set_remote_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "set_remote_node" '[NodePath] (IO ()) where nodeMethod = Godot.Core.RemoteTransform.set_remote_node {-# NOINLINE bindRemoteTransform_set_update_position #-} -- | If @true@, the remote node's position is updated. bindRemoteTransform_set_update_position :: MethodBind bindRemoteTransform_set_update_position = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "set_update_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's position is updated. set_update_position :: (RemoteTransform :< cls, Object :< cls) => cls -> Bool -> IO () set_update_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_set_update_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "set_update_position" '[Bool] (IO ()) where nodeMethod = Godot.Core.RemoteTransform.set_update_position {-# NOINLINE bindRemoteTransform_set_update_rotation #-} -- | If @true@, the remote node's rotation is updated. bindRemoteTransform_set_update_rotation :: MethodBind bindRemoteTransform_set_update_rotation = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "set_update_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's rotation is updated. set_update_rotation :: (RemoteTransform :< cls, Object :< cls) => cls -> Bool -> IO () set_update_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_set_update_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "set_update_rotation" '[Bool] (IO ()) where nodeMethod = Godot.Core.RemoteTransform.set_update_rotation {-# NOINLINE bindRemoteTransform_set_update_scale #-} -- | If @true@, the remote node's scale is updated. bindRemoteTransform_set_update_scale :: MethodBind bindRemoteTransform_set_update_scale = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "set_update_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's scale is updated. set_update_scale :: (RemoteTransform :< cls, Object :< cls) => cls -> Bool -> IO () set_update_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_set_update_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "set_update_scale" '[Bool] (IO ()) where nodeMethod = Godot.Core.RemoteTransform.set_update_scale {-# NOINLINE bindRemoteTransform_set_use_global_coordinates #-} -- | If @true@, global coordinates are used. If @false@, local coordinates are used. bindRemoteTransform_set_use_global_coordinates :: MethodBind bindRemoteTransform_set_use_global_coordinates = unsafePerformIO $ withCString "RemoteTransform" $ \ clsNamePtr -> withCString "set_use_global_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, global coordinates are used. If @false@, local coordinates are used. set_use_global_coordinates :: (RemoteTransform :< cls, Object :< cls) => cls -> Bool -> IO () set_use_global_coordinates cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform_set_use_global_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform "set_use_global_coordinates" '[Bool] (IO ()) where nodeMethod = Godot.Core.RemoteTransform.set_use_global_coordinates ================================================ FILE: src/Godot/Core/RemoteTransform2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RemoteTransform2D (Godot.Core.RemoteTransform2D.force_update_cache, Godot.Core.RemoteTransform2D.get_remote_node, Godot.Core.RemoteTransform2D.get_update_position, Godot.Core.RemoteTransform2D.get_update_rotation, Godot.Core.RemoteTransform2D.get_update_scale, Godot.Core.RemoteTransform2D.get_use_global_coordinates, Godot.Core.RemoteTransform2D.set_remote_node, Godot.Core.RemoteTransform2D.set_update_position, Godot.Core.RemoteTransform2D.set_update_rotation, Godot.Core.RemoteTransform2D.set_update_scale, Godot.Core.RemoteTransform2D.set_use_global_coordinates) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty RemoteTransform2D "remote_path" NodePath 'False where nodeProperty = (get_remote_node, wrapDroppingSetter set_remote_node, Nothing) instance NodeProperty RemoteTransform2D "update_position" Bool 'False where nodeProperty = (get_update_position, wrapDroppingSetter set_update_position, Nothing) instance NodeProperty RemoteTransform2D "update_rotation" Bool 'False where nodeProperty = (get_update_rotation, wrapDroppingSetter set_update_rotation, Nothing) instance NodeProperty RemoteTransform2D "update_scale" Bool 'False where nodeProperty = (get_update_scale, wrapDroppingSetter set_update_scale, Nothing) instance NodeProperty RemoteTransform2D "use_global_coordinates" Bool 'False where nodeProperty = (get_use_global_coordinates, wrapDroppingSetter set_use_global_coordinates, Nothing) {-# NOINLINE bindRemoteTransform2D_force_update_cache #-} -- | @RemoteTransform2D@ caches the remote node. It may not notice if the remote node disappears; @method force_update_cache@ forces it to update the cache again. bindRemoteTransform2D_force_update_cache :: MethodBind bindRemoteTransform2D_force_update_cache = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "force_update_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @RemoteTransform2D@ caches the remote node. It may not notice if the remote node disappears; @method force_update_cache@ forces it to update the cache again. force_update_cache :: (RemoteTransform2D :< cls, Object :< cls) => cls -> IO () force_update_cache cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_force_update_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "force_update_cache" '[] (IO ()) where nodeMethod = Godot.Core.RemoteTransform2D.force_update_cache {-# NOINLINE bindRemoteTransform2D_get_remote_node #-} -- | The @NodePath@ to the remote node, relative to the RemoteTransform2D's position in the scene. bindRemoteTransform2D_get_remote_node :: MethodBind bindRemoteTransform2D_get_remote_node = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "get_remote_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @NodePath@ to the remote node, relative to the RemoteTransform2D's position in the scene. get_remote_node :: (RemoteTransform2D :< cls, Object :< cls) => cls -> IO NodePath get_remote_node cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_get_remote_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "get_remote_node" '[] (IO NodePath) where nodeMethod = Godot.Core.RemoteTransform2D.get_remote_node {-# NOINLINE bindRemoteTransform2D_get_update_position #-} -- | If @true@, the remote node's position is updated. bindRemoteTransform2D_get_update_position :: MethodBind bindRemoteTransform2D_get_update_position = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "get_update_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's position is updated. get_update_position :: (RemoteTransform2D :< cls, Object :< cls) => cls -> IO Bool get_update_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_get_update_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "get_update_position" '[] (IO Bool) where nodeMethod = Godot.Core.RemoteTransform2D.get_update_position {-# NOINLINE bindRemoteTransform2D_get_update_rotation #-} -- | If @true@, the remote node's rotation is updated. bindRemoteTransform2D_get_update_rotation :: MethodBind bindRemoteTransform2D_get_update_rotation = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "get_update_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's rotation is updated. get_update_rotation :: (RemoteTransform2D :< cls, Object :< cls) => cls -> IO Bool get_update_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_get_update_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "get_update_rotation" '[] (IO Bool) where nodeMethod = Godot.Core.RemoteTransform2D.get_update_rotation {-# NOINLINE bindRemoteTransform2D_get_update_scale #-} -- | If @true@, the remote node's scale is updated. bindRemoteTransform2D_get_update_scale :: MethodBind bindRemoteTransform2D_get_update_scale = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "get_update_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's scale is updated. get_update_scale :: (RemoteTransform2D :< cls, Object :< cls) => cls -> IO Bool get_update_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_get_update_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "get_update_scale" '[] (IO Bool) where nodeMethod = Godot.Core.RemoteTransform2D.get_update_scale {-# NOINLINE bindRemoteTransform2D_get_use_global_coordinates #-} -- | If @true@, global coordinates are used. If @false@, local coordinates are used. bindRemoteTransform2D_get_use_global_coordinates :: MethodBind bindRemoteTransform2D_get_use_global_coordinates = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "get_use_global_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, global coordinates are used. If @false@, local coordinates are used. get_use_global_coordinates :: (RemoteTransform2D :< cls, Object :< cls) => cls -> IO Bool get_use_global_coordinates cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_get_use_global_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "get_use_global_coordinates" '[] (IO Bool) where nodeMethod = Godot.Core.RemoteTransform2D.get_use_global_coordinates {-# NOINLINE bindRemoteTransform2D_set_remote_node #-} -- | The @NodePath@ to the remote node, relative to the RemoteTransform2D's position in the scene. bindRemoteTransform2D_set_remote_node :: MethodBind bindRemoteTransform2D_set_remote_node = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "set_remote_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @NodePath@ to the remote node, relative to the RemoteTransform2D's position in the scene. set_remote_node :: (RemoteTransform2D :< cls, Object :< cls) => cls -> NodePath -> IO () set_remote_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_set_remote_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "set_remote_node" '[NodePath] (IO ()) where nodeMethod = Godot.Core.RemoteTransform2D.set_remote_node {-# NOINLINE bindRemoteTransform2D_set_update_position #-} -- | If @true@, the remote node's position is updated. bindRemoteTransform2D_set_update_position :: MethodBind bindRemoteTransform2D_set_update_position = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "set_update_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's position is updated. set_update_position :: (RemoteTransform2D :< cls, Object :< cls) => cls -> Bool -> IO () set_update_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_set_update_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "set_update_position" '[Bool] (IO ()) where nodeMethod = Godot.Core.RemoteTransform2D.set_update_position {-# NOINLINE bindRemoteTransform2D_set_update_rotation #-} -- | If @true@, the remote node's rotation is updated. bindRemoteTransform2D_set_update_rotation :: MethodBind bindRemoteTransform2D_set_update_rotation = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "set_update_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's rotation is updated. set_update_rotation :: (RemoteTransform2D :< cls, Object :< cls) => cls -> Bool -> IO () set_update_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_set_update_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "set_update_rotation" '[Bool] (IO ()) where nodeMethod = Godot.Core.RemoteTransform2D.set_update_rotation {-# NOINLINE bindRemoteTransform2D_set_update_scale #-} -- | If @true@, the remote node's scale is updated. bindRemoteTransform2D_set_update_scale :: MethodBind bindRemoteTransform2D_set_update_scale = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "set_update_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the remote node's scale is updated. set_update_scale :: (RemoteTransform2D :< cls, Object :< cls) => cls -> Bool -> IO () set_update_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_set_update_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "set_update_scale" '[Bool] (IO ()) where nodeMethod = Godot.Core.RemoteTransform2D.set_update_scale {-# NOINLINE bindRemoteTransform2D_set_use_global_coordinates #-} -- | If @true@, global coordinates are used. If @false@, local coordinates are used. bindRemoteTransform2D_set_use_global_coordinates :: MethodBind bindRemoteTransform2D_set_use_global_coordinates = unsafePerformIO $ withCString "RemoteTransform2D" $ \ clsNamePtr -> withCString "set_use_global_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, global coordinates are used. If @false@, local coordinates are used. set_use_global_coordinates :: (RemoteTransform2D :< cls, Object :< cls) => cls -> Bool -> IO () set_use_global_coordinates cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRemoteTransform2D_set_use_global_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RemoteTransform2D "set_use_global_coordinates" '[Bool] (IO ()) where nodeMethod = Godot.Core.RemoteTransform2D.set_use_global_coordinates ================================================ FILE: src/Godot/Core/Resource.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Resource (Godot.Core.Resource.sig_changed, Godot.Core.Resource._setup_local_to_scene, Godot.Core.Resource.duplicate, Godot.Core.Resource.get_local_scene, Godot.Core.Resource.get_name, Godot.Core.Resource.get_path, Godot.Core.Resource.get_rid, Godot.Core.Resource.is_local_to_scene, Godot.Core.Resource.set_local_to_scene, Godot.Core.Resource.set_name, Godot.Core.Resource.set_path, Godot.Core.Resource.setup_local_to_scene, Godot.Core.Resource.take_over_path) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() -- | Emitted whenever the resource changes. sig_changed :: Godot.Internal.Dispatch.Signal Resource sig_changed = Godot.Internal.Dispatch.Signal "changed" instance NodeSignal Resource "changed" '[] instance NodeProperty Resource "resource_local_to_scene" Bool 'False where nodeProperty = (is_local_to_scene, wrapDroppingSetter set_local_to_scene, Nothing) instance NodeProperty Resource "resource_name" GodotString 'False where nodeProperty = (get_name, wrapDroppingSetter set_name, Nothing) instance NodeProperty Resource "resource_path" GodotString 'False where nodeProperty = (get_path, wrapDroppingSetter set_path, Nothing) {-# NOINLINE bindResource__setup_local_to_scene #-} -- | Virtual function which can be overridden to customize the behavior value of @method setup_local_to_scene@. bindResource__setup_local_to_scene :: MethodBind bindResource__setup_local_to_scene = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "_setup_local_to_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual function which can be overridden to customize the behavior value of @method setup_local_to_scene@. _setup_local_to_scene :: (Resource :< cls, Object :< cls) => cls -> IO () _setup_local_to_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResource__setup_local_to_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "_setup_local_to_scene" '[] (IO ()) where nodeMethod = Godot.Core.Resource._setup_local_to_scene {-# NOINLINE bindResource_duplicate #-} -- | Duplicates the resource, returning a new resource. By default, sub-resources are shared between resource copies for efficiency. This can be changed by passing @true@ to the @subresources@ argument which will copy the subresources. -- __Note:__ If @subresources@ is @true@, this method will only perform a shallow copy. Nested resources within subresources will not be duplicated and will still be shared. bindResource_duplicate :: MethodBind bindResource_duplicate = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "duplicate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Duplicates the resource, returning a new resource. By default, sub-resources are shared between resource copies for efficiency. This can be changed by passing @true@ to the @subresources@ argument which will copy the subresources. -- __Note:__ If @subresources@ is @true@, this method will only perform a shallow copy. Nested resources within subresources will not be duplicated and will still be shared. duplicate :: (Resource :< cls, Object :< cls) => cls -> Maybe Bool -> IO Resource duplicate cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResource_duplicate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "duplicate" '[Maybe Bool] (IO Resource) where nodeMethod = Godot.Core.Resource.duplicate {-# NOINLINE bindResource_get_local_scene #-} -- | If @resource_local_to_scene@ is enabled and the resource was loaded from a @PackedScene@ instantiation, returns the local scene where this resource's unique copy is in use. Otherwise, returns @null@. bindResource_get_local_scene :: MethodBind bindResource_get_local_scene = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "get_local_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @resource_local_to_scene@ is enabled and the resource was loaded from a @PackedScene@ instantiation, returns the local scene where this resource's unique copy is in use. Otherwise, returns @null@. get_local_scene :: (Resource :< cls, Object :< cls) => cls -> IO Node get_local_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResource_get_local_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "get_local_scene" '[] (IO Node) where nodeMethod = Godot.Core.Resource.get_local_scene {-# NOINLINE bindResource_get_name #-} -- | The name of the resource. This is an optional identifier. bindResource_get_name :: MethodBind bindResource_get_name = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the resource. This is an optional identifier. get_name :: (Resource :< cls, Object :< cls) => cls -> IO GodotString get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResource_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "get_name" '[] (IO GodotString) where nodeMethod = Godot.Core.Resource.get_name {-# NOINLINE bindResource_get_path #-} -- | The path to the resource. In case it has its own file, it will return its filepath. If it's tied to the scene, it will return the scene's path, followed by the resource's index. bindResource_get_path :: MethodBind bindResource_get_path = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "get_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the resource. In case it has its own file, it will return its filepath. If it's tied to the scene, it will return the scene's path, followed by the resource's index. get_path :: (Resource :< cls, Object :< cls) => cls -> IO GodotString get_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResource_get_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "get_path" '[] (IO GodotString) where nodeMethod = Godot.Core.Resource.get_path {-# NOINLINE bindResource_get_rid #-} -- | Returns the RID of the resource (or an empty RID). Many resources (such as @Texture@, @Mesh@, etc) are high-level abstractions of resources stored in a server, so this function will return the original RID. bindResource_get_rid :: MethodBind bindResource_get_rid = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "get_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the RID of the resource (or an empty RID). Many resources (such as @Texture@, @Mesh@, etc) are high-level abstractions of resources stored in a server, so this function will return the original RID. get_rid :: (Resource :< cls, Object :< cls) => cls -> IO Rid get_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResource_get_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "get_rid" '[] (IO Rid) where nodeMethod = Godot.Core.Resource.get_rid {-# NOINLINE bindResource_is_local_to_scene #-} -- | If @true@, the resource will be made unique in each instance of its local scene. It can thus be modified in a scene instance without impacting other instances of that same scene. bindResource_is_local_to_scene :: MethodBind bindResource_is_local_to_scene = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "is_local_to_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the resource will be made unique in each instance of its local scene. It can thus be modified in a scene instance without impacting other instances of that same scene. is_local_to_scene :: (Resource :< cls, Object :< cls) => cls -> IO Bool is_local_to_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResource_is_local_to_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "is_local_to_scene" '[] (IO Bool) where nodeMethod = Godot.Core.Resource.is_local_to_scene {-# NOINLINE bindResource_set_local_to_scene #-} -- | If @true@, the resource will be made unique in each instance of its local scene. It can thus be modified in a scene instance without impacting other instances of that same scene. bindResource_set_local_to_scene :: MethodBind bindResource_set_local_to_scene = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "set_local_to_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the resource will be made unique in each instance of its local scene. It can thus be modified in a scene instance without impacting other instances of that same scene. set_local_to_scene :: (Resource :< cls, Object :< cls) => cls -> Bool -> IO () set_local_to_scene cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResource_set_local_to_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "set_local_to_scene" '[Bool] (IO ()) where nodeMethod = Godot.Core.Resource.set_local_to_scene {-# NOINLINE bindResource_set_name #-} -- | The name of the resource. This is an optional identifier. bindResource_set_name :: MethodBind bindResource_set_name = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "set_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The name of the resource. This is an optional identifier. set_name :: (Resource :< cls, Object :< cls) => cls -> GodotString -> IO () set_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResource_set_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "set_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Resource.set_name {-# NOINLINE bindResource_set_path #-} -- | The path to the resource. In case it has its own file, it will return its filepath. If it's tied to the scene, it will return the scene's path, followed by the resource's index. bindResource_set_path :: MethodBind bindResource_set_path = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "set_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the resource. In case it has its own file, it will return its filepath. If it's tied to the scene, it will return the scene's path, followed by the resource's index. set_path :: (Resource :< cls, Object :< cls) => cls -> GodotString -> IO () set_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResource_set_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "set_path" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Resource.set_path {-# NOINLINE bindResource_setup_local_to_scene #-} -- | This method is called when a resource with @resource_local_to_scene@ enabled is loaded from a @PackedScene@ instantiation. Its behavior can be customized by overriding @method _setup_local_to_scene@ from script. -- For most resources, this method performs no base logic. @ViewportTexture@ performs custom logic to properly set the proxy texture and flags in the local viewport. bindResource_setup_local_to_scene :: MethodBind bindResource_setup_local_to_scene = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "setup_local_to_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This method is called when a resource with @resource_local_to_scene@ enabled is loaded from a @PackedScene@ instantiation. Its behavior can be customized by overriding @method _setup_local_to_scene@ from script. -- For most resources, this method performs no base logic. @ViewportTexture@ performs custom logic to properly set the proxy texture and flags in the local viewport. setup_local_to_scene :: (Resource :< cls, Object :< cls) => cls -> IO () setup_local_to_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResource_setup_local_to_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "setup_local_to_scene" '[] (IO ()) where nodeMethod = Godot.Core.Resource.setup_local_to_scene {-# NOINLINE bindResource_take_over_path #-} -- | Sets the path of the resource, potentially overriding an existing cache entry for this path. This differs from setting @resource_path@, as the latter would error out if another resource was already cached for the given path. bindResource_take_over_path :: MethodBind bindResource_take_over_path = unsafePerformIO $ withCString "Resource" $ \ clsNamePtr -> withCString "take_over_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the path of the resource, potentially overriding an existing cache entry for this path. This differs from setting @resource_path@, as the latter would error out if another resource was already cached for the given path. take_over_path :: (Resource :< cls, Object :< cls) => cls -> GodotString -> IO () take_over_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResource_take_over_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Resource "take_over_path" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Resource.take_over_path ================================================ FILE: src/Godot/Core/ResourceFormatLoader.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourceFormatLoader (Godot.Core.ResourceFormatLoader.get_dependencies, Godot.Core.ResourceFormatLoader.get_recognized_extensions, Godot.Core.ResourceFormatLoader.get_resource_type, Godot.Core.ResourceFormatLoader.handles_type, Godot.Core.ResourceFormatLoader.load, Godot.Core.ResourceFormatLoader.rename_dependencies) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindResourceFormatLoader_get_dependencies #-} -- | If implemented, gets the dependencies of a given resource. If @add_types@ is @true@, paths should be appended @::TypeName@, where @TypeName@ is the class name of the dependency. -- __Note:__ Custom resource types defined by scripts aren't known by the @ClassDB@, so you might just return @"Resource"@ for them. bindResourceFormatLoader_get_dependencies :: MethodBind bindResourceFormatLoader_get_dependencies = unsafePerformIO $ withCString "ResourceFormatLoader" $ \ clsNamePtr -> withCString "get_dependencies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If implemented, gets the dependencies of a given resource. If @add_types@ is @true@, paths should be appended @::TypeName@, where @TypeName@ is the class name of the dependency. -- __Note:__ Custom resource types defined by scripts aren't known by the @ClassDB@, so you might just return @"Resource"@ for them. get_dependencies :: (ResourceFormatLoader :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () get_dependencies cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatLoader_get_dependencies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatLoader "get_dependencies" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.ResourceFormatLoader.get_dependencies {-# NOINLINE bindResourceFormatLoader_get_recognized_extensions #-} -- | Gets the list of extensions for files this loader is able to read. bindResourceFormatLoader_get_recognized_extensions :: MethodBind bindResourceFormatLoader_get_recognized_extensions = unsafePerformIO $ withCString "ResourceFormatLoader" $ \ clsNamePtr -> withCString "get_recognized_extensions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the list of extensions for files this loader is able to read. get_recognized_extensions :: (ResourceFormatLoader :< cls, Object :< cls) => cls -> IO PoolStringArray get_recognized_extensions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatLoader_get_recognized_extensions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatLoader "get_recognized_extensions" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.ResourceFormatLoader.get_recognized_extensions {-# NOINLINE bindResourceFormatLoader_get_resource_type #-} -- | Gets the class name of the resource associated with the given path. If the loader cannot handle it, it should return @""@. -- __Note:__ Custom resource types defined by scripts aren't known by the @ClassDB@, so you might just return @"Resource"@ for them. bindResourceFormatLoader_get_resource_type :: MethodBind bindResourceFormatLoader_get_resource_type = unsafePerformIO $ withCString "ResourceFormatLoader" $ \ clsNamePtr -> withCString "get_resource_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the class name of the resource associated with the given path. If the loader cannot handle it, it should return @""@. -- __Note:__ Custom resource types defined by scripts aren't known by the @ClassDB@, so you might just return @"Resource"@ for them. get_resource_type :: (ResourceFormatLoader :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_resource_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatLoader_get_resource_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatLoader "get_resource_type" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.ResourceFormatLoader.get_resource_type {-# NOINLINE bindResourceFormatLoader_handles_type #-} -- | Tells which resource class this loader can load. -- __Note:__ Custom resource types defined by scripts aren't known by the @ClassDB@, so you might just handle @"Resource"@ for them. bindResourceFormatLoader_handles_type :: MethodBind bindResourceFormatLoader_handles_type = unsafePerformIO $ withCString "ResourceFormatLoader" $ \ clsNamePtr -> withCString "handles_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tells which resource class this loader can load. -- __Note:__ Custom resource types defined by scripts aren't known by the @ClassDB@, so you might just handle @"Resource"@ for them. handles_type :: (ResourceFormatLoader :< cls, Object :< cls) => cls -> GodotString -> IO Bool handles_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatLoader_handles_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatLoader "handles_type" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ResourceFormatLoader.handles_type {-# NOINLINE bindResourceFormatLoader_load #-} -- | Loads a resource when the engine finds this loader to be compatible. If the loaded resource is the result of an import, @original_path@ will target the source file. Returns a @Resource@ object on success, or an @enum Error@ constant in case of failure. bindResourceFormatLoader_load :: MethodBind bindResourceFormatLoader_load = unsafePerformIO $ withCString "ResourceFormatLoader" $ \ clsNamePtr -> withCString "load" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads a resource when the engine finds this loader to be compatible. If the loaded resource is the result of an import, @original_path@ will target the source file. Returns a @Resource@ object on success, or an @enum Error@ constant in case of failure. load :: (ResourceFormatLoader :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO GodotVariant load cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatLoader_load (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatLoader "load" '[GodotString, GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.ResourceFormatLoader.load {-# NOINLINE bindResourceFormatLoader_rename_dependencies #-} -- | If implemented, renames dependencies within the given resource and saves it. @renames@ is a dictionary @{ String => String }@ mapping old dependency paths to new paths. -- Returns @OK@ on success, or an @enum Error@ constant in case of failure. bindResourceFormatLoader_rename_dependencies :: MethodBind bindResourceFormatLoader_rename_dependencies = unsafePerformIO $ withCString "ResourceFormatLoader" $ \ clsNamePtr -> withCString "rename_dependencies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If implemented, renames dependencies within the given resource and saves it. @renames@ is a dictionary @{ String => String }@ mapping old dependency paths to new paths. -- Returns @OK@ on success, or an @enum Error@ constant in case of failure. rename_dependencies :: (ResourceFormatLoader :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int rename_dependencies cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatLoader_rename_dependencies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatLoader "rename_dependencies" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.ResourceFormatLoader.rename_dependencies ================================================ FILE: src/Godot/Core/ResourceFormatLoaderCrypto.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourceFormatLoaderCrypto () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ResourceFormatLoader() ================================================ FILE: src/Godot/Core/ResourceFormatSaver.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourceFormatSaver (Godot.Core.ResourceFormatSaver.get_recognized_extensions, Godot.Core.ResourceFormatSaver.recognize, Godot.Core.ResourceFormatSaver.save) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindResourceFormatSaver_get_recognized_extensions #-} -- | Returns the list of extensions available for saving the resource object, provided it is recognized (see @method recognize@). bindResourceFormatSaver_get_recognized_extensions :: MethodBind bindResourceFormatSaver_get_recognized_extensions = unsafePerformIO $ withCString "ResourceFormatSaver" $ \ clsNamePtr -> withCString "get_recognized_extensions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of extensions available for saving the resource object, provided it is recognized (see @method recognize@). get_recognized_extensions :: (ResourceFormatSaver :< cls, Object :< cls) => cls -> Resource -> IO PoolStringArray get_recognized_extensions cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatSaver_get_recognized_extensions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatSaver "get_recognized_extensions" '[Resource] (IO PoolStringArray) where nodeMethod = Godot.Core.ResourceFormatSaver.get_recognized_extensions {-# NOINLINE bindResourceFormatSaver_recognize #-} -- | Returns whether the given resource object can be saved by this saver. bindResourceFormatSaver_recognize :: MethodBind bindResourceFormatSaver_recognize = unsafePerformIO $ withCString "ResourceFormatSaver" $ \ clsNamePtr -> withCString "recognize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the given resource object can be saved by this saver. recognize :: (ResourceFormatSaver :< cls, Object :< cls) => cls -> Resource -> IO Bool recognize cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatSaver_recognize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatSaver "recognize" '[Resource] (IO Bool) where nodeMethod = Godot.Core.ResourceFormatSaver.recognize {-# NOINLINE bindResourceFormatSaver_save #-} -- | Saves the given resource object to a file at the target @path@. @flags@ is a bitmask composed with @enum ResourceSaver.SaverFlags@ constants. -- Returns @OK@ on success, or an @enum Error@ constant in case of failure. bindResourceFormatSaver_save :: MethodBind bindResourceFormatSaver_save = unsafePerformIO $ withCString "ResourceFormatSaver" $ \ clsNamePtr -> withCString "save" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the given resource object to a file at the target @path@. @flags@ is a bitmask composed with @enum ResourceSaver.SaverFlags@ constants. -- Returns @OK@ on success, or an @enum Error@ constant in case of failure. save :: (ResourceFormatSaver :< cls, Object :< cls) => cls -> GodotString -> Resource -> Int -> IO Int save cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindResourceFormatSaver_save (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceFormatSaver "save" '[GodotString, Resource, Int] (IO Int) where nodeMethod = Godot.Core.ResourceFormatSaver.save ================================================ FILE: src/Godot/Core/ResourceFormatSaverCrypto.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourceFormatSaverCrypto () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ResourceFormatSaver() ================================================ FILE: src/Godot/Core/ResourceImporter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourceImporter () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() ================================================ FILE: src/Godot/Core/ResourceInteractiveLoader.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourceInteractiveLoader (Godot.Core.ResourceInteractiveLoader.get_resource, Godot.Core.ResourceInteractiveLoader.get_stage, Godot.Core.ResourceInteractiveLoader.get_stage_count, Godot.Core.ResourceInteractiveLoader.poll, Godot.Core.ResourceInteractiveLoader.wait) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindResourceInteractiveLoader_get_resource #-} -- | Returns the loaded resource if the load operation completed successfully, @null@ otherwise. bindResourceInteractiveLoader_get_resource :: MethodBind bindResourceInteractiveLoader_get_resource = unsafePerformIO $ withCString "ResourceInteractiveLoader" $ \ clsNamePtr -> withCString "get_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the loaded resource if the load operation completed successfully, @null@ otherwise. get_resource :: (ResourceInteractiveLoader :< cls, Object :< cls) => cls -> IO Resource get_resource cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResourceInteractiveLoader_get_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceInteractiveLoader "get_resource" '[] (IO Resource) where nodeMethod = Godot.Core.ResourceInteractiveLoader.get_resource {-# NOINLINE bindResourceInteractiveLoader_get_stage #-} -- | Returns the load stage. The total amount of stages can be queried with @method get_stage_count@. bindResourceInteractiveLoader_get_stage :: MethodBind bindResourceInteractiveLoader_get_stage = unsafePerformIO $ withCString "ResourceInteractiveLoader" $ \ clsNamePtr -> withCString "get_stage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the load stage. The total amount of stages can be queried with @method get_stage_count@. get_stage :: (ResourceInteractiveLoader :< cls, Object :< cls) => cls -> IO Int get_stage cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResourceInteractiveLoader_get_stage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceInteractiveLoader "get_stage" '[] (IO Int) where nodeMethod = Godot.Core.ResourceInteractiveLoader.get_stage {-# NOINLINE bindResourceInteractiveLoader_get_stage_count #-} -- | Returns the total amount of stages (calls to @method poll@) needed to completely load this resource. bindResourceInteractiveLoader_get_stage_count :: MethodBind bindResourceInteractiveLoader_get_stage_count = unsafePerformIO $ withCString "ResourceInteractiveLoader" $ \ clsNamePtr -> withCString "get_stage_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total amount of stages (calls to @method poll@) needed to completely load this resource. get_stage_count :: (ResourceInteractiveLoader :< cls, Object :< cls) => cls -> IO Int get_stage_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResourceInteractiveLoader_get_stage_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceInteractiveLoader "get_stage_count" '[] (IO Int) where nodeMethod = Godot.Core.ResourceInteractiveLoader.get_stage_count {-# NOINLINE bindResourceInteractiveLoader_poll #-} -- | Polls the loading operation, i.e. loads a data chunk up to the next stage. -- Returns @OK@ if the poll is successful but the load operation has not finished yet (intermediate stage). This means @method poll@ will have to be called again until the last stage is completed. -- Returns @ERR_FILE_EOF@ if the load operation has completed successfully. The loaded resource can be obtained by calling @method get_resource@. -- Returns another @enum Error@ code if the poll has failed. bindResourceInteractiveLoader_poll :: MethodBind bindResourceInteractiveLoader_poll = unsafePerformIO $ withCString "ResourceInteractiveLoader" $ \ clsNamePtr -> withCString "poll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Polls the loading operation, i.e. loads a data chunk up to the next stage. -- Returns @OK@ if the poll is successful but the load operation has not finished yet (intermediate stage). This means @method poll@ will have to be called again until the last stage is completed. -- Returns @ERR_FILE_EOF@ if the load operation has completed successfully. The loaded resource can be obtained by calling @method get_resource@. -- Returns another @enum Error@ code if the poll has failed. poll :: (ResourceInteractiveLoader :< cls, Object :< cls) => cls -> IO Int poll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResourceInteractiveLoader_poll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceInteractiveLoader "poll" '[] (IO Int) where nodeMethod = Godot.Core.ResourceInteractiveLoader.poll {-# NOINLINE bindResourceInteractiveLoader_wait #-} -- | Polls the loading operation successively until the resource is completely loaded or a @method poll@ fails. -- Returns @ERR_FILE_EOF@ if the load operation has completed successfully. The loaded resource can be obtained by calling @method get_resource@. -- Returns another @enum Error@ code if a poll has failed, aborting the operation. bindResourceInteractiveLoader_wait :: MethodBind bindResourceInteractiveLoader_wait = unsafePerformIO $ withCString "ResourceInteractiveLoader" $ \ clsNamePtr -> withCString "wait" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Polls the loading operation successively until the resource is completely loaded or a @method poll@ fails. -- Returns @ERR_FILE_EOF@ if the load operation has completed successfully. The loaded resource can be obtained by calling @method get_resource@. -- Returns another @enum Error@ code if a poll has failed, aborting the operation. wait :: (ResourceInteractiveLoader :< cls, Object :< cls) => cls -> IO Int wait cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResourceInteractiveLoader_wait (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceInteractiveLoader "wait" '[] (IO Int) where nodeMethod = Godot.Core.ResourceInteractiveLoader.wait ================================================ FILE: src/Godot/Core/ResourceLoader.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourceLoader (Godot.Core.ResourceLoader.exists, Godot.Core.ResourceLoader.get_dependencies, Godot.Core.ResourceLoader.get_recognized_extensions_for_type, Godot.Core.ResourceLoader.has, Godot.Core.ResourceLoader.has_cached, Godot.Core.ResourceLoader.load, Godot.Core.ResourceLoader.load_interactive, Godot.Core.ResourceLoader.set_abort_on_missing_resources) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindResourceLoader_exists #-} -- | Returns whether a recognized resource exists for the given @path@. -- An optional @type_hint@ can be used to further specify the @Resource@ type that should be handled by the @ResourceFormatLoader@. bindResourceLoader_exists :: MethodBind bindResourceLoader_exists = unsafePerformIO $ withCString "_ResourceLoader" $ \ clsNamePtr -> withCString "exists" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a recognized resource exists for the given @path@. -- An optional @type_hint@ can be used to further specify the @Resource@ type that should be handled by the @ResourceFormatLoader@. exists :: (ResourceLoader :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO Bool exists cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindResourceLoader_exists (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceLoader "exists" '[GodotString, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.ResourceLoader.exists {-# NOINLINE bindResourceLoader_get_dependencies #-} -- | Returns the dependencies for the resource at the given @path@. bindResourceLoader_get_dependencies :: MethodBind bindResourceLoader_get_dependencies = unsafePerformIO $ withCString "_ResourceLoader" $ \ clsNamePtr -> withCString "get_dependencies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the dependencies for the resource at the given @path@. get_dependencies :: (ResourceLoader :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_dependencies cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceLoader_get_dependencies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceLoader "get_dependencies" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.ResourceLoader.get_dependencies {-# NOINLINE bindResourceLoader_get_recognized_extensions_for_type #-} -- | Returns the list of recognized extensions for a resource type. bindResourceLoader_get_recognized_extensions_for_type :: MethodBind bindResourceLoader_get_recognized_extensions_for_type = unsafePerformIO $ withCString "_ResourceLoader" $ \ clsNamePtr -> withCString "get_recognized_extensions_for_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of recognized extensions for a resource type. get_recognized_extensions_for_type :: (ResourceLoader :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_recognized_extensions_for_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceLoader_get_recognized_extensions_for_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceLoader "get_recognized_extensions_for_type" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.ResourceLoader.get_recognized_extensions_for_type {-# NOINLINE bindResourceLoader_has #-} -- | @i@Deprecated method.@/i@ Use @method has_cached@ or @method exists@ instead. bindResourceLoader_has :: MethodBind bindResourceLoader_has = unsafePerformIO $ withCString "_ResourceLoader" $ \ clsNamePtr -> withCString "has" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @i@Deprecated method.@/i@ Use @method has_cached@ or @method exists@ instead. has :: (ResourceLoader :< cls, Object :< cls) => cls -> GodotString -> IO Bool has cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceLoader_has (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceLoader "has" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ResourceLoader.has {-# NOINLINE bindResourceLoader_has_cached #-} -- | Returns whether a cached resource is available for the given @path@. -- Once a resource has been loaded by the engine, it is cached in memory for faster access, and future calls to the @method load@ or @method load_interactive@ methods will use the cached version. The cached resource can be overridden by using @method Resource.take_over_path@ on a new resource for that same path. bindResourceLoader_has_cached :: MethodBind bindResourceLoader_has_cached = unsafePerformIO $ withCString "_ResourceLoader" $ \ clsNamePtr -> withCString "has_cached" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether a cached resource is available for the given @path@. -- Once a resource has been loaded by the engine, it is cached in memory for faster access, and future calls to the @method load@ or @method load_interactive@ methods will use the cached version. The cached resource can be overridden by using @method Resource.take_over_path@ on a new resource for that same path. has_cached :: (ResourceLoader :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_cached cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceLoader_has_cached (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceLoader "has_cached" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ResourceLoader.has_cached {-# NOINLINE bindResourceLoader_load #-} -- | Loads a resource at the given @path@, caching the result for further access. -- The registered @ResourceFormatLoader@s are queried sequentially to find the first one which can handle the file's extension, and then attempt loading. If loading fails, the remaining ResourceFormatLoaders are also attempted. -- An optional @type_hint@ can be used to further specify the @Resource@ type that should be handled by the @ResourceFormatLoader@. -- If @no_cache@ is @true@, the resource cache will be bypassed and the resource will be loaded anew. Otherwise, the cached resource will be returned if it exists. -- Returns an empty resource if no ResourceFormatLoader could handle the file. bindResourceLoader_load :: MethodBind bindResourceLoader_load = unsafePerformIO $ withCString "_ResourceLoader" $ \ clsNamePtr -> withCString "load" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads a resource at the given @path@, caching the result for further access. -- The registered @ResourceFormatLoader@s are queried sequentially to find the first one which can handle the file's extension, and then attempt loading. If loading fails, the remaining ResourceFormatLoaders are also attempted. -- An optional @type_hint@ can be used to further specify the @Resource@ type that should be handled by the @ResourceFormatLoader@. -- If @no_cache@ is @true@, the resource cache will be bypassed and the resource will be loaded anew. Otherwise, the cached resource will be returned if it exists. -- Returns an empty resource if no ResourceFormatLoader could handle the file. load :: (ResourceLoader :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> Maybe Bool -> IO Resource load cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindResourceLoader_load (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceLoader "load" '[GodotString, Maybe GodotString, Maybe Bool] (IO Resource) where nodeMethod = Godot.Core.ResourceLoader.load {-# NOINLINE bindResourceLoader_load_interactive #-} -- | Starts loading a resource interactively. The returned @ResourceInteractiveLoader@ object allows to load with high granularity, calling its @method ResourceInteractiveLoader.poll@ method successively to load chunks. -- An optional @type_hint@ can be used to further specify the @Resource@ type that should be handled by the @ResourceFormatLoader@. bindResourceLoader_load_interactive :: MethodBind bindResourceLoader_load_interactive = unsafePerformIO $ withCString "_ResourceLoader" $ \ clsNamePtr -> withCString "load_interactive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts loading a resource interactively. The returned @ResourceInteractiveLoader@ object allows to load with high granularity, calling its @method ResourceInteractiveLoader.poll@ method successively to load chunks. -- An optional @type_hint@ can be used to further specify the @Resource@ type that should be handled by the @ResourceFormatLoader@. load_interactive :: (ResourceLoader :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotString -> IO ResourceInteractiveLoader load_interactive cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindResourceLoader_load_interactive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceLoader "load_interactive" '[GodotString, Maybe GodotString] (IO ResourceInteractiveLoader) where nodeMethod = Godot.Core.ResourceLoader.load_interactive {-# NOINLINE bindResourceLoader_set_abort_on_missing_resources #-} -- | Changes the behavior on missing sub-resources. The default behavior is to abort loading. bindResourceLoader_set_abort_on_missing_resources :: MethodBind bindResourceLoader_set_abort_on_missing_resources = unsafePerformIO $ withCString "_ResourceLoader" $ \ clsNamePtr -> withCString "set_abort_on_missing_resources" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the behavior on missing sub-resources. The default behavior is to abort loading. set_abort_on_missing_resources :: (ResourceLoader :< cls, Object :< cls) => cls -> Bool -> IO () set_abort_on_missing_resources cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceLoader_set_abort_on_missing_resources (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceLoader "set_abort_on_missing_resources" '[Bool] (IO ()) where nodeMethod = Godot.Core.ResourceLoader.set_abort_on_missing_resources ================================================ FILE: src/Godot/Core/ResourcePreloader.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourcePreloader (Godot.Core.ResourcePreloader._get_resources, Godot.Core.ResourcePreloader._set_resources, Godot.Core.ResourcePreloader.add_resource, Godot.Core.ResourcePreloader.get_resource, Godot.Core.ResourcePreloader.get_resource_list, Godot.Core.ResourcePreloader.has_resource, Godot.Core.ResourcePreloader.remove_resource, Godot.Core.ResourcePreloader.rename_resource) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() instance NodeProperty ResourcePreloader "resources" Array 'False where nodeProperty = (_get_resources, wrapDroppingSetter _set_resources, Nothing) {-# NOINLINE bindResourcePreloader__get_resources #-} bindResourcePreloader__get_resources :: MethodBind bindResourcePreloader__get_resources = unsafePerformIO $ withCString "ResourcePreloader" $ \ clsNamePtr -> withCString "_get_resources" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_resources :: (ResourcePreloader :< cls, Object :< cls) => cls -> IO Array _get_resources cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResourcePreloader__get_resources (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourcePreloader "_get_resources" '[] (IO Array) where nodeMethod = Godot.Core.ResourcePreloader._get_resources {-# NOINLINE bindResourcePreloader__set_resources #-} bindResourcePreloader__set_resources :: MethodBind bindResourcePreloader__set_resources = unsafePerformIO $ withCString "ResourcePreloader" $ \ clsNamePtr -> withCString "_set_resources" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_resources :: (ResourcePreloader :< cls, Object :< cls) => cls -> Array -> IO () _set_resources cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourcePreloader__set_resources (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourcePreloader "_set_resources" '[Array] (IO ()) where nodeMethod = Godot.Core.ResourcePreloader._set_resources {-# NOINLINE bindResourcePreloader_add_resource #-} -- | Adds a resource to the preloader with the given @name@. If a resource with the given @name@ already exists, the new resource will be renamed to "@name@ N" where N is an incrementing number starting from 2. bindResourcePreloader_add_resource :: MethodBind bindResourcePreloader_add_resource = unsafePerformIO $ withCString "ResourcePreloader" $ \ clsNamePtr -> withCString "add_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a resource to the preloader with the given @name@. If a resource with the given @name@ already exists, the new resource will be renamed to "@name@ N" where N is an incrementing number starting from 2. add_resource :: (ResourcePreloader :< cls, Object :< cls) => cls -> GodotString -> Resource -> IO () add_resource cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindResourcePreloader_add_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourcePreloader "add_resource" '[GodotString, Resource] (IO ()) where nodeMethod = Godot.Core.ResourcePreloader.add_resource {-# NOINLINE bindResourcePreloader_get_resource #-} -- | Returns the resource associated to @name@. bindResourcePreloader_get_resource :: MethodBind bindResourcePreloader_get_resource = unsafePerformIO $ withCString "ResourcePreloader" $ \ clsNamePtr -> withCString "get_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the resource associated to @name@. get_resource :: (ResourcePreloader :< cls, Object :< cls) => cls -> GodotString -> IO Resource get_resource cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourcePreloader_get_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourcePreloader "get_resource" '[GodotString] (IO Resource) where nodeMethod = Godot.Core.ResourcePreloader.get_resource {-# NOINLINE bindResourcePreloader_get_resource_list #-} -- | Returns the list of resources inside the preloader. bindResourcePreloader_get_resource_list :: MethodBind bindResourcePreloader_get_resource_list = unsafePerformIO $ withCString "ResourcePreloader" $ \ clsNamePtr -> withCString "get_resource_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of resources inside the preloader. get_resource_list :: (ResourcePreloader :< cls, Object :< cls) => cls -> IO PoolStringArray get_resource_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindResourcePreloader_get_resource_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourcePreloader "get_resource_list" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.ResourcePreloader.get_resource_list {-# NOINLINE bindResourcePreloader_has_resource #-} -- | Returns @true@ if the preloader contains a resource associated to @name@. bindResourcePreloader_has_resource :: MethodBind bindResourcePreloader_has_resource = unsafePerformIO $ withCString "ResourcePreloader" $ \ clsNamePtr -> withCString "has_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the preloader contains a resource associated to @name@. has_resource :: (ResourcePreloader :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_resource cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourcePreloader_has_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourcePreloader "has_resource" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ResourcePreloader.has_resource {-# NOINLINE bindResourcePreloader_remove_resource #-} -- | Removes the resource associated to @name@ from the preloader. bindResourcePreloader_remove_resource :: MethodBind bindResourcePreloader_remove_resource = unsafePerformIO $ withCString "ResourcePreloader" $ \ clsNamePtr -> withCString "remove_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the resource associated to @name@ from the preloader. remove_resource :: (ResourcePreloader :< cls, Object :< cls) => cls -> GodotString -> IO () remove_resource cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourcePreloader_remove_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourcePreloader "remove_resource" '[GodotString] (IO ()) where nodeMethod = Godot.Core.ResourcePreloader.remove_resource {-# NOINLINE bindResourcePreloader_rename_resource #-} -- | Renames a resource inside the preloader from @name@ to @newname@. bindResourcePreloader_rename_resource :: MethodBind bindResourcePreloader_rename_resource = unsafePerformIO $ withCString "ResourcePreloader" $ \ clsNamePtr -> withCString "rename_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Renames a resource inside the preloader from @name@ to @newname@. rename_resource :: (ResourcePreloader :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_resource cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindResourcePreloader_rename_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourcePreloader "rename_resource" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.ResourcePreloader.rename_resource ================================================ FILE: src/Godot/Core/ResourceSaver.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ResourceSaver (Godot.Core.ResourceSaver._FLAG_REPLACE_SUBRESOURCE_PATHS, Godot.Core.ResourceSaver._FLAG_RELATIVE_PATHS, Godot.Core.ResourceSaver._FLAG_OMIT_EDITOR_PROPERTIES, Godot.Core.ResourceSaver._FLAG_SAVE_BIG_ENDIAN, Godot.Core.ResourceSaver._FLAG_CHANGE_PATH, Godot.Core.ResourceSaver._FLAG_COMPRESS, Godot.Core.ResourceSaver._FLAG_BUNDLE_RESOURCES, Godot.Core.ResourceSaver.get_recognized_extensions, Godot.Core.ResourceSaver.save) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _FLAG_REPLACE_SUBRESOURCE_PATHS :: Int _FLAG_REPLACE_SUBRESOURCE_PATHS = 64 _FLAG_RELATIVE_PATHS :: Int _FLAG_RELATIVE_PATHS = 1 _FLAG_OMIT_EDITOR_PROPERTIES :: Int _FLAG_OMIT_EDITOR_PROPERTIES = 8 _FLAG_SAVE_BIG_ENDIAN :: Int _FLAG_SAVE_BIG_ENDIAN = 16 _FLAG_CHANGE_PATH :: Int _FLAG_CHANGE_PATH = 4 _FLAG_COMPRESS :: Int _FLAG_COMPRESS = 32 _FLAG_BUNDLE_RESOURCES :: Int _FLAG_BUNDLE_RESOURCES = 2 {-# NOINLINE bindResourceSaver_get_recognized_extensions #-} -- | Returns the list of extensions available for saving a resource of a given type. bindResourceSaver_get_recognized_extensions :: MethodBind bindResourceSaver_get_recognized_extensions = unsafePerformIO $ withCString "_ResourceSaver" $ \ clsNamePtr -> withCString "get_recognized_extensions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of extensions available for saving a resource of a given type. get_recognized_extensions :: (ResourceSaver :< cls, Object :< cls) => cls -> Resource -> IO PoolStringArray get_recognized_extensions cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindResourceSaver_get_recognized_extensions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceSaver "get_recognized_extensions" '[Resource] (IO PoolStringArray) where nodeMethod = Godot.Core.ResourceSaver.get_recognized_extensions {-# NOINLINE bindResourceSaver_save #-} -- | Saves a resource to disk to the given path, using a @ResourceFormatSaver@ that recognizes the resource object. -- The @flags@ bitmask can be specified to customize the save behavior. -- Returns @OK@ on success. bindResourceSaver_save :: MethodBind bindResourceSaver_save = unsafePerformIO $ withCString "_ResourceSaver" $ \ clsNamePtr -> withCString "save" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves a resource to disk to the given path, using a @ResourceFormatSaver@ that recognizes the resource object. -- The @flags@ bitmask can be specified to customize the save behavior. -- Returns @OK@ on success. save :: (ResourceSaver :< cls, Object :< cls) => cls -> GodotString -> Resource -> Maybe Int -> IO Int save cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindResourceSaver_save (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ResourceSaver "save" '[GodotString, Resource, Maybe Int] (IO Int) where nodeMethod = Godot.Core.ResourceSaver.save ================================================ FILE: src/Godot/Core/RichTextEffect.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RichTextEffect (Godot.Core.RichTextEffect._process_custom_fx) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindRichTextEffect__process_custom_fx #-} -- | Override this method to modify properties in @char_fx@. The method must return @true@ if the character could be transformed successfully. If the method returns @false@, it will skip transformation to avoid displaying broken text. bindRichTextEffect__process_custom_fx :: MethodBind bindRichTextEffect__process_custom_fx = unsafePerformIO $ withCString "RichTextEffect" $ \ clsNamePtr -> withCString "_process_custom_fx" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to modify properties in @char_fx@. The method must return @true@ if the character could be transformed successfully. If the method returns @false@, it will skip transformation to avoid displaying broken text. _process_custom_fx :: (RichTextEffect :< cls, Object :< cls) => cls -> CharFXTransform -> IO Bool _process_custom_fx cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextEffect__process_custom_fx (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextEffect "_process_custom_fx" '[CharFXTransform] (IO Bool) where nodeMethod = Godot.Core.RichTextEffect._process_custom_fx ================================================ FILE: src/Godot/Core/RichTextLabel.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RichTextLabel (Godot.Core.RichTextLabel._ITEM_UNDERLINE, Godot.Core.RichTextLabel._ITEM_RAINBOW, Godot.Core.RichTextLabel._ITEM_CUSTOMFX, Godot.Core.RichTextLabel._ITEM_META, Godot.Core.RichTextLabel._ITEM_ALIGN, Godot.Core.RichTextLabel._ITEM_TORNADO, Godot.Core.RichTextLabel._ITEM_FRAME, Godot.Core.RichTextLabel._ALIGN_RIGHT, Godot.Core.RichTextLabel._ALIGN_FILL, Godot.Core.RichTextLabel._ITEM_STRIKETHROUGH, Godot.Core.RichTextLabel._ITEM_SHAKE, Godot.Core.RichTextLabel._ITEM_FONT, Godot.Core.RichTextLabel._ITEM_FADE, Godot.Core.RichTextLabel._ITEM_TABLE, Godot.Core.RichTextLabel._ITEM_WAVE, Godot.Core.RichTextLabel._ITEM_COLOR, Godot.Core.RichTextLabel._ITEM_TEXT, Godot.Core.RichTextLabel._ITEM_IMAGE, Godot.Core.RichTextLabel._LIST_NUMBERS, Godot.Core.RichTextLabel._LIST_LETTERS, Godot.Core.RichTextLabel._ITEM_LIST, Godot.Core.RichTextLabel._ITEM_NEWLINE, Godot.Core.RichTextLabel._ITEM_INDENT, Godot.Core.RichTextLabel._LIST_DOTS, Godot.Core.RichTextLabel._ALIGN_LEFT, Godot.Core.RichTextLabel._ALIGN_CENTER, Godot.Core.RichTextLabel.sig_meta_clicked, Godot.Core.RichTextLabel.sig_meta_hover_ended, Godot.Core.RichTextLabel.sig_meta_hover_started, Godot.Core.RichTextLabel._gui_input, Godot.Core.RichTextLabel._scroll_changed, Godot.Core.RichTextLabel.add_image, Godot.Core.RichTextLabel.add_text, Godot.Core.RichTextLabel.append_bbcode, Godot.Core.RichTextLabel.clear, Godot.Core.RichTextLabel.get_bbcode, Godot.Core.RichTextLabel.get_content_height, Godot.Core.RichTextLabel.get_effects, Godot.Core.RichTextLabel.get_line_count, Godot.Core.RichTextLabel.get_percent_visible, Godot.Core.RichTextLabel.get_tab_size, Godot.Core.RichTextLabel.get_text, Godot.Core.RichTextLabel.get_total_character_count, Godot.Core.RichTextLabel.get_v_scroll, Godot.Core.RichTextLabel.get_visible_characters, Godot.Core.RichTextLabel.get_visible_line_count, Godot.Core.RichTextLabel.install_effect, Godot.Core.RichTextLabel.is_meta_underlined, Godot.Core.RichTextLabel.is_overriding_selected_font_color, Godot.Core.RichTextLabel.is_scroll_active, Godot.Core.RichTextLabel.is_scroll_following, Godot.Core.RichTextLabel.is_selection_enabled, Godot.Core.RichTextLabel.is_using_bbcode, Godot.Core.RichTextLabel.newline, Godot.Core.RichTextLabel.parse_bbcode, Godot.Core.RichTextLabel.parse_expressions_for_values, Godot.Core.RichTextLabel.pop, Godot.Core.RichTextLabel.push_align, Godot.Core.RichTextLabel.push_bold, Godot.Core.RichTextLabel.push_bold_italics, Godot.Core.RichTextLabel.push_cell, Godot.Core.RichTextLabel.push_color, Godot.Core.RichTextLabel.push_font, Godot.Core.RichTextLabel.push_indent, Godot.Core.RichTextLabel.push_italics, Godot.Core.RichTextLabel.push_list, Godot.Core.RichTextLabel.push_meta, Godot.Core.RichTextLabel.push_mono, Godot.Core.RichTextLabel.push_normal, Godot.Core.RichTextLabel.push_strikethrough, Godot.Core.RichTextLabel.push_table, Godot.Core.RichTextLabel.push_underline, Godot.Core.RichTextLabel.remove_line, Godot.Core.RichTextLabel.scroll_to_line, Godot.Core.RichTextLabel.set_bbcode, Godot.Core.RichTextLabel.set_effects, Godot.Core.RichTextLabel.set_meta_underline, Godot.Core.RichTextLabel.set_override_selected_font_color, Godot.Core.RichTextLabel.set_percent_visible, Godot.Core.RichTextLabel.set_scroll_active, Godot.Core.RichTextLabel.set_scroll_follow, Godot.Core.RichTextLabel.set_selection_enabled, Godot.Core.RichTextLabel.set_tab_size, Godot.Core.RichTextLabel.set_table_column_expand, Godot.Core.RichTextLabel.set_text, Godot.Core.RichTextLabel.set_use_bbcode, Godot.Core.RichTextLabel.set_visible_characters) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _ITEM_UNDERLINE :: Int _ITEM_UNDERLINE = 6 _ITEM_RAINBOW :: Int _ITEM_RAINBOW = 16 _ITEM_CUSTOMFX :: Int _ITEM_CUSTOMFX = 18 _ITEM_META :: Int _ITEM_META = 17 _ITEM_ALIGN :: Int _ITEM_ALIGN = 8 _ITEM_TORNADO :: Int _ITEM_TORNADO = 15 _ITEM_FRAME :: Int _ITEM_FRAME = 0 _ALIGN_RIGHT :: Int _ALIGN_RIGHT = 2 _ALIGN_FILL :: Int _ALIGN_FILL = 3 _ITEM_STRIKETHROUGH :: Int _ITEM_STRIKETHROUGH = 7 _ITEM_SHAKE :: Int _ITEM_SHAKE = 13 _ITEM_FONT :: Int _ITEM_FONT = 4 _ITEM_FADE :: Int _ITEM_FADE = 12 _ITEM_TABLE :: Int _ITEM_TABLE = 11 _ITEM_WAVE :: Int _ITEM_WAVE = 14 _ITEM_COLOR :: Int _ITEM_COLOR = 5 _ITEM_TEXT :: Int _ITEM_TEXT = 1 _ITEM_IMAGE :: Int _ITEM_IMAGE = 2 _LIST_NUMBERS :: Int _LIST_NUMBERS = 0 _LIST_LETTERS :: Int _LIST_LETTERS = 1 _ITEM_LIST :: Int _ITEM_LIST = 10 _ITEM_NEWLINE :: Int _ITEM_NEWLINE = 3 _ITEM_INDENT :: Int _ITEM_INDENT = 9 _LIST_DOTS :: Int _LIST_DOTS = 2 _ALIGN_LEFT :: Int _ALIGN_LEFT = 0 _ALIGN_CENTER :: Int _ALIGN_CENTER = 1 -- | Triggered when the user clicks on content between meta tags. If the meta is defined in text, e.g. @@url={"data"="hi"}@hi@/url@@, then the parameter for this signal will be a @String@ type. If a particular type or an object is desired, the @method push_meta@ method must be used to manually insert the data into the tag stack. sig_meta_clicked :: Godot.Internal.Dispatch.Signal RichTextLabel sig_meta_clicked = Godot.Internal.Dispatch.Signal "meta_clicked" instance NodeSignal RichTextLabel "meta_clicked" '[GodotVariant] -- | Triggers when the mouse exits a meta tag. sig_meta_hover_ended :: Godot.Internal.Dispatch.Signal RichTextLabel sig_meta_hover_ended = Godot.Internal.Dispatch.Signal "meta_hover_ended" instance NodeSignal RichTextLabel "meta_hover_ended" '[GodotVariant] -- | Triggers when the mouse enters a meta tag. sig_meta_hover_started :: Godot.Internal.Dispatch.Signal RichTextLabel sig_meta_hover_started = Godot.Internal.Dispatch.Signal "meta_hover_started" instance NodeSignal RichTextLabel "meta_hover_started" '[GodotVariant] instance NodeProperty RichTextLabel "bbcode_enabled" Bool 'False where nodeProperty = (is_using_bbcode, wrapDroppingSetter set_use_bbcode, Nothing) instance NodeProperty RichTextLabel "bbcode_text" GodotString 'False where nodeProperty = (get_bbcode, wrapDroppingSetter set_bbcode, Nothing) instance NodeProperty RichTextLabel "custom_effects" Array 'False where nodeProperty = (get_effects, wrapDroppingSetter set_effects, Nothing) instance NodeProperty RichTextLabel "meta_underlined" Bool 'False where nodeProperty = (is_meta_underlined, wrapDroppingSetter set_meta_underline, Nothing) instance NodeProperty RichTextLabel "override_selected_font_color" Bool 'False where nodeProperty = (is_overriding_selected_font_color, wrapDroppingSetter set_override_selected_font_color, Nothing) instance NodeProperty RichTextLabel "percent_visible" Float 'False where nodeProperty = (get_percent_visible, wrapDroppingSetter set_percent_visible, Nothing) instance NodeProperty RichTextLabel "scroll_active" Bool 'False where nodeProperty = (is_scroll_active, wrapDroppingSetter set_scroll_active, Nothing) instance NodeProperty RichTextLabel "scroll_following" Bool 'False where nodeProperty = (is_scroll_following, wrapDroppingSetter set_scroll_follow, Nothing) instance NodeProperty RichTextLabel "selection_enabled" Bool 'False where nodeProperty = (is_selection_enabled, wrapDroppingSetter set_selection_enabled, Nothing) instance NodeProperty RichTextLabel "tab_size" Int 'False where nodeProperty = (get_tab_size, wrapDroppingSetter set_tab_size, Nothing) instance NodeProperty RichTextLabel "text" GodotString 'False where nodeProperty = (get_text, wrapDroppingSetter set_text, Nothing) instance NodeProperty RichTextLabel "visible_characters" Int 'False where nodeProperty = (get_visible_characters, wrapDroppingSetter set_visible_characters, Nothing) {-# NOINLINE bindRichTextLabel__gui_input #-} bindRichTextLabel__gui_input :: MethodBind bindRichTextLabel__gui_input = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (RichTextLabel :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.RichTextLabel._gui_input {-# NOINLINE bindRichTextLabel__scroll_changed #-} bindRichTextLabel__scroll_changed :: MethodBind bindRichTextLabel__scroll_changed = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "_scroll_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _scroll_changed :: (RichTextLabel :< cls, Object :< cls) => cls -> Float -> IO () _scroll_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel__scroll_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "_scroll_changed" '[Float] (IO ()) where nodeMethod = Godot.Core.RichTextLabel._scroll_changed {-# NOINLINE bindRichTextLabel_add_image #-} -- | Adds an image's opening and closing tags to the tag stack, optionally providing a @width@ and @height@ to resize the image. -- If @width@ or @height@ is set to 0, the image size will be adjusted in order to keep the original aspect ratio. bindRichTextLabel_add_image :: MethodBind bindRichTextLabel_add_image = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "add_image" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an image's opening and closing tags to the tag stack, optionally providing a @width@ and @height@ to resize the image. -- If @width@ or @height@ is set to 0, the image size will be adjusted in order to keep the original aspect ratio. add_image :: (RichTextLabel :< cls, Object :< cls) => cls -> Texture -> Maybe Int -> Maybe Int -> IO () add_image cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_add_image (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "add_image" '[Texture, Maybe Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.add_image {-# NOINLINE bindRichTextLabel_add_text #-} -- | Adds raw non-BBCode-parsed text to the tag stack. bindRichTextLabel_add_text :: MethodBind bindRichTextLabel_add_text = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "add_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds raw non-BBCode-parsed text to the tag stack. add_text :: (RichTextLabel :< cls, Object :< cls) => cls -> GodotString -> IO () add_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_add_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "add_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.add_text {-# NOINLINE bindRichTextLabel_append_bbcode #-} -- | Parses @bbcode@ and adds tags to the tag stack as needed. Returns the result of the parsing, @OK@ if successful. bindRichTextLabel_append_bbcode :: MethodBind bindRichTextLabel_append_bbcode = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "append_bbcode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Parses @bbcode@ and adds tags to the tag stack as needed. Returns the result of the parsing, @OK@ if successful. append_bbcode :: (RichTextLabel :< cls, Object :< cls) => cls -> GodotString -> IO Int append_bbcode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_append_bbcode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "append_bbcode" '[GodotString] (IO Int) where nodeMethod = Godot.Core.RichTextLabel.append_bbcode {-# NOINLINE bindRichTextLabel_clear #-} -- | Clears the tag stack and sets @bbcode_text@ to an empty string. bindRichTextLabel_clear :: MethodBind bindRichTextLabel_clear = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the tag stack and sets @bbcode_text@ to an empty string. clear :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "clear" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.clear {-# NOINLINE bindRichTextLabel_get_bbcode #-} -- | The label's text in BBCode format. Is not representative of manual modifications to the internal tag stack. Erases changes made by other methods when edited. -- __Note:__ It is unadvised to use @+=@ operator with @bbcode_text@ (e.g. @bbcode_text += "some string"@) as it replaces the whole text and can cause slowdowns. Use @method append_bbcode@ for adding text instead. bindRichTextLabel_get_bbcode :: MethodBind bindRichTextLabel_get_bbcode = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_bbcode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The label's text in BBCode format. Is not representative of manual modifications to the internal tag stack. Erases changes made by other methods when edited. -- __Note:__ It is unadvised to use @+=@ operator with @bbcode_text@ (e.g. @bbcode_text += "some string"@) as it replaces the whole text and can cause slowdowns. Use @method append_bbcode@ for adding text instead. get_bbcode :: (RichTextLabel :< cls, Object :< cls) => cls -> IO GodotString get_bbcode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_bbcode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_bbcode" '[] (IO GodotString) where nodeMethod = Godot.Core.RichTextLabel.get_bbcode {-# NOINLINE bindRichTextLabel_get_content_height #-} -- | Returns the height of the content. bindRichTextLabel_get_content_height :: MethodBind bindRichTextLabel_get_content_height = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_content_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the height of the content. get_content_height :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Int get_content_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_content_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_content_height" '[] (IO Int) where nodeMethod = Godot.Core.RichTextLabel.get_content_height {-# NOINLINE bindRichTextLabel_get_effects #-} -- | The currently installed custom effects. This is an array of @RichTextEffect@s. -- To add a custom effect, it's more convenient to use @method install_effect@. bindRichTextLabel_get_effects :: MethodBind bindRichTextLabel_get_effects = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_effects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently installed custom effects. This is an array of @RichTextEffect@s. -- To add a custom effect, it's more convenient to use @method install_effect@. get_effects :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Array get_effects cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_effects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_effects" '[] (IO Array) where nodeMethod = Godot.Core.RichTextLabel.get_effects {-# NOINLINE bindRichTextLabel_get_line_count #-} -- | Returns the total number of newlines in the tag stack's text tags. Considers wrapped text as one line. bindRichTextLabel_get_line_count :: MethodBind bindRichTextLabel_get_line_count = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_line_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total number of newlines in the tag stack's text tags. Considers wrapped text as one line. get_line_count :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Int get_line_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_line_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_line_count" '[] (IO Int) where nodeMethod = Godot.Core.RichTextLabel.get_line_count {-# NOINLINE bindRichTextLabel_get_percent_visible #-} -- | The range of characters to display, as a @float@ between 0.0 and 1.0. When assigned an out of range value, it's the same as assigning 1.0. -- __Note:__ Setting this property updates @visible_characters@ based on current @method get_total_character_count@. bindRichTextLabel_get_percent_visible :: MethodBind bindRichTextLabel_get_percent_visible = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_percent_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The range of characters to display, as a @float@ between 0.0 and 1.0. When assigned an out of range value, it's the same as assigning 1.0. -- __Note:__ Setting this property updates @visible_characters@ based on current @method get_total_character_count@. get_percent_visible :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Float get_percent_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_percent_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_percent_visible" '[] (IO Float) where nodeMethod = Godot.Core.RichTextLabel.get_percent_visible {-# NOINLINE bindRichTextLabel_get_tab_size #-} -- | The number of spaces associated with a single tab length. Does not affect @\t@ in text tags, only indent tags. bindRichTextLabel_get_tab_size :: MethodBind bindRichTextLabel_get_tab_size = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_tab_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of spaces associated with a single tab length. Does not affect @\t@ in text tags, only indent tags. get_tab_size :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Int get_tab_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_tab_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_tab_size" '[] (IO Int) where nodeMethod = Godot.Core.RichTextLabel.get_tab_size {-# NOINLINE bindRichTextLabel_get_text #-} -- | The raw text of the label. -- When set, clears the tag stack and adds a raw text tag to the top of it. Does not parse BBCodes. Does not modify @bbcode_text@. bindRichTextLabel_get_text :: MethodBind bindRichTextLabel_get_text = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The raw text of the label. -- When set, clears the tag stack and adds a raw text tag to the top of it. Does not parse BBCodes. Does not modify @bbcode_text@. get_text :: (RichTextLabel :< cls, Object :< cls) => cls -> IO GodotString get_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_text" '[] (IO GodotString) where nodeMethod = Godot.Core.RichTextLabel.get_text {-# NOINLINE bindRichTextLabel_get_total_character_count #-} -- | Returns the total number of characters from text tags. Does not include BBCodes. bindRichTextLabel_get_total_character_count :: MethodBind bindRichTextLabel_get_total_character_count = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_total_character_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total number of characters from text tags. Does not include BBCodes. get_total_character_count :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Int get_total_character_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_total_character_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_total_character_count" '[] (IO Int) where nodeMethod = Godot.Core.RichTextLabel.get_total_character_count {-# NOINLINE bindRichTextLabel_get_v_scroll #-} -- | Returns the vertical scrollbar. bindRichTextLabel_get_v_scroll :: MethodBind bindRichTextLabel_get_v_scroll = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_v_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the vertical scrollbar. get_v_scroll :: (RichTextLabel :< cls, Object :< cls) => cls -> IO VScrollBar get_v_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_v_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_v_scroll" '[] (IO VScrollBar) where nodeMethod = Godot.Core.RichTextLabel.get_v_scroll {-# NOINLINE bindRichTextLabel_get_visible_characters #-} -- | The restricted number of characters to display in the label. If @-1@, all characters will be displayed. bindRichTextLabel_get_visible_characters :: MethodBind bindRichTextLabel_get_visible_characters = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_visible_characters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The restricted number of characters to display in the label. If @-1@, all characters will be displayed. get_visible_characters :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Int get_visible_characters cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_visible_characters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_visible_characters" '[] (IO Int) where nodeMethod = Godot.Core.RichTextLabel.get_visible_characters {-# NOINLINE bindRichTextLabel_get_visible_line_count #-} -- | Returns the number of visible lines. bindRichTextLabel_get_visible_line_count :: MethodBind bindRichTextLabel_get_visible_line_count = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "get_visible_line_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of visible lines. get_visible_line_count :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Int get_visible_line_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_get_visible_line_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "get_visible_line_count" '[] (IO Int) where nodeMethod = Godot.Core.RichTextLabel.get_visible_line_count {-# NOINLINE bindRichTextLabel_install_effect #-} -- | Installs a custom effect. @effect@ should be a valid @RichTextEffect@. bindRichTextLabel_install_effect :: MethodBind bindRichTextLabel_install_effect = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "install_effect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Installs a custom effect. @effect@ should be a valid @RichTextEffect@. install_effect :: (RichTextLabel :< cls, Object :< cls) => cls -> GodotVariant -> IO () install_effect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_install_effect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "install_effect" '[GodotVariant] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.install_effect {-# NOINLINE bindRichTextLabel_is_meta_underlined #-} -- | If @true@, the label underlines meta tags such as @@url@{text}@/url@@. bindRichTextLabel_is_meta_underlined :: MethodBind bindRichTextLabel_is_meta_underlined = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "is_meta_underlined" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the label underlines meta tags such as @@url@{text}@/url@@. is_meta_underlined :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Bool is_meta_underlined cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_is_meta_underlined (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "is_meta_underlined" '[] (IO Bool) where nodeMethod = Godot.Core.RichTextLabel.is_meta_underlined {-# NOINLINE bindRichTextLabel_is_overriding_selected_font_color #-} -- | If @true@, the label uses the custom font color. bindRichTextLabel_is_overriding_selected_font_color :: MethodBind bindRichTextLabel_is_overriding_selected_font_color = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "is_overriding_selected_font_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the label uses the custom font color. is_overriding_selected_font_color :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Bool is_overriding_selected_font_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_is_overriding_selected_font_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "is_overriding_selected_font_color" '[] (IO Bool) where nodeMethod = Godot.Core.RichTextLabel.is_overriding_selected_font_color {-# NOINLINE bindRichTextLabel_is_scroll_active #-} -- | If @true@, the scrollbar is visible. Setting this to @false@ does not block scrolling completely. See @method scroll_to_line@. bindRichTextLabel_is_scroll_active :: MethodBind bindRichTextLabel_is_scroll_active = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "is_scroll_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the scrollbar is visible. Setting this to @false@ does not block scrolling completely. See @method scroll_to_line@. is_scroll_active :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Bool is_scroll_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_is_scroll_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "is_scroll_active" '[] (IO Bool) where nodeMethod = Godot.Core.RichTextLabel.is_scroll_active {-# NOINLINE bindRichTextLabel_is_scroll_following #-} -- | If @true@, the window scrolls down to display new content automatically. bindRichTextLabel_is_scroll_following :: MethodBind bindRichTextLabel_is_scroll_following = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "is_scroll_following" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window scrolls down to display new content automatically. is_scroll_following :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Bool is_scroll_following cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_is_scroll_following (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "is_scroll_following" '[] (IO Bool) where nodeMethod = Godot.Core.RichTextLabel.is_scroll_following {-# NOINLINE bindRichTextLabel_is_selection_enabled #-} -- | If @true@, the label allows text selection. bindRichTextLabel_is_selection_enabled :: MethodBind bindRichTextLabel_is_selection_enabled = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "is_selection_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the label allows text selection. is_selection_enabled :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Bool is_selection_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_is_selection_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "is_selection_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RichTextLabel.is_selection_enabled {-# NOINLINE bindRichTextLabel_is_using_bbcode #-} -- | If @true@, the label uses BBCode formatting. bindRichTextLabel_is_using_bbcode :: MethodBind bindRichTextLabel_is_using_bbcode = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "is_using_bbcode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the label uses BBCode formatting. is_using_bbcode :: (RichTextLabel :< cls, Object :< cls) => cls -> IO Bool is_using_bbcode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_is_using_bbcode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "is_using_bbcode" '[] (IO Bool) where nodeMethod = Godot.Core.RichTextLabel.is_using_bbcode {-# NOINLINE bindRichTextLabel_newline #-} -- | Adds a newline tag to the tag stack. bindRichTextLabel_newline :: MethodBind bindRichTextLabel_newline = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "newline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a newline tag to the tag stack. newline :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () newline cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_newline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "newline" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.newline {-# NOINLINE bindRichTextLabel_parse_bbcode #-} -- | The assignment version of @method append_bbcode@. Clears the tag stack and inserts the new content. Returns @OK@ if parses @bbcode@ successfully. bindRichTextLabel_parse_bbcode :: MethodBind bindRichTextLabel_parse_bbcode = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "parse_bbcode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The assignment version of @method append_bbcode@. Clears the tag stack and inserts the new content. Returns @OK@ if parses @bbcode@ successfully. parse_bbcode :: (RichTextLabel :< cls, Object :< cls) => cls -> GodotString -> IO Int parse_bbcode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_parse_bbcode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "parse_bbcode" '[GodotString] (IO Int) where nodeMethod = Godot.Core.RichTextLabel.parse_bbcode {-# NOINLINE bindRichTextLabel_parse_expressions_for_values #-} -- | Parses BBCode parameter @expressions@ into a dictionary. bindRichTextLabel_parse_expressions_for_values :: MethodBind bindRichTextLabel_parse_expressions_for_values = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "parse_expressions_for_values" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Parses BBCode parameter @expressions@ into a dictionary. parse_expressions_for_values :: (RichTextLabel :< cls, Object :< cls) => cls -> PoolStringArray -> IO Dictionary parse_expressions_for_values cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_parse_expressions_for_values (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "parse_expressions_for_values" '[PoolStringArray] (IO Dictionary) where nodeMethod = Godot.Core.RichTextLabel.parse_expressions_for_values {-# NOINLINE bindRichTextLabel_pop #-} -- | Terminates the current tag. Use after @push_*@ methods to close BBCodes manually. Does not need to follow @add_*@ methods. bindRichTextLabel_pop :: MethodBind bindRichTextLabel_pop = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "pop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Terminates the current tag. Use after @push_*@ methods to close BBCodes manually. Does not need to follow @add_*@ methods. pop :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () pop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_pop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "pop" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.pop {-# NOINLINE bindRichTextLabel_push_align #-} -- | Adds an @@align@@ tag based on the given @align@ value. See @enum Align@ for possible values. bindRichTextLabel_push_align :: MethodBind bindRichTextLabel_push_align = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an @@align@@ tag based on the given @align@ value. See @enum Align@ for possible values. push_align :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> IO () push_align cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_align" '[Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_align {-# NOINLINE bindRichTextLabel_push_bold #-} -- | Adds a @@font@@ tag with a bold font to the tag stack. This is the same as adding a @__@ tag if not currently in a @@i@@ tag. bindRichTextLabel_push_bold :: MethodBind bindRichTextLabel_push_bold = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_bold" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@font@@ tag with a bold font to the tag stack. This is the same as adding a @__@ tag if not currently in a @@i@@ tag. push_bold :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () push_bold cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_bold (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_bold" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_bold {-# NOINLINE bindRichTextLabel_push_bold_italics #-} -- | Adds a @@font@@ tag with a bold italics font to the tag stack. bindRichTextLabel_push_bold_italics :: MethodBind bindRichTextLabel_push_bold_italics = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_bold_italics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@font@@ tag with a bold italics font to the tag stack. push_bold_italics :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () push_bold_italics cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_bold_italics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_bold_italics" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_bold_italics {-# NOINLINE bindRichTextLabel_push_cell #-} -- | Adds a @@cell@@ tag to the tag stack. Must be inside a @@table@@ tag. See @method push_table@ for details. bindRichTextLabel_push_cell :: MethodBind bindRichTextLabel_push_cell = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_cell" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@cell@@ tag to the tag stack. Must be inside a @@table@@ tag. See @method push_table@ for details. push_cell :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () push_cell cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_cell (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_cell" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_cell {-# NOINLINE bindRichTextLabel_push_color #-} -- | Adds a @@color@@ tag to the tag stack. bindRichTextLabel_push_color :: MethodBind bindRichTextLabel_push_color = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@color@@ tag to the tag stack. push_color :: (RichTextLabel :< cls, Object :< cls) => cls -> Color -> IO () push_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_color" '[Color] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_color {-# NOINLINE bindRichTextLabel_push_font #-} -- | Adds a @@font@@ tag to the tag stack. Overrides default fonts for its duration. bindRichTextLabel_push_font :: MethodBind bindRichTextLabel_push_font = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@font@@ tag to the tag stack. Overrides default fonts for its duration. push_font :: (RichTextLabel :< cls, Object :< cls) => cls -> Font -> IO () push_font cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_font" '[Font] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_font {-# NOINLINE bindRichTextLabel_push_indent #-} -- | Adds an @@indent@@ tag to the tag stack. Multiplies @level@ by current @tab_size@ to determine new margin length. bindRichTextLabel_push_indent :: MethodBind bindRichTextLabel_push_indent = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_indent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an @@indent@@ tag to the tag stack. Multiplies @level@ by current @tab_size@ to determine new margin length. push_indent :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> IO () push_indent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_indent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_indent" '[Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_indent {-# NOINLINE bindRichTextLabel_push_italics #-} -- | Adds a @@font@@ tag with a italics font to the tag stack. This is the same as adding a @@i@@ tag if not currently in a @__@ tag. bindRichTextLabel_push_italics :: MethodBind bindRichTextLabel_push_italics = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_italics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@font@@ tag with a italics font to the tag stack. This is the same as adding a @@i@@ tag if not currently in a @__@ tag. push_italics :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () push_italics cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_italics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_italics" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_italics {-# NOINLINE bindRichTextLabel_push_list #-} -- | Adds a @@list@@ tag to the tag stack. Similar to the BBCodes @@ol@@ or @@ul@@, but supports more list types. Not fully implemented! bindRichTextLabel_push_list :: MethodBind bindRichTextLabel_push_list = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@list@@ tag to the tag stack. Similar to the BBCodes @@ol@@ or @@ul@@, but supports more list types. Not fully implemented! push_list :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> IO () push_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_list" '[Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_list {-# NOINLINE bindRichTextLabel_push_meta #-} -- | Adds a @@meta@@ tag to the tag stack. Similar to the BBCode @@url=something@{text}@/url@@, but supports non-@String@ metadata types. bindRichTextLabel_push_meta :: MethodBind bindRichTextLabel_push_meta = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_meta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@meta@@ tag to the tag stack. Similar to the BBCode @@url=something@{text}@/url@@, but supports non-@String@ metadata types. push_meta :: (RichTextLabel :< cls, Object :< cls) => cls -> GodotVariant -> IO () push_meta cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_meta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_meta" '[GodotVariant] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_meta {-# NOINLINE bindRichTextLabel_push_mono #-} -- | Adds a @@font@@ tag with a monospace font to the tag stack. bindRichTextLabel_push_mono :: MethodBind bindRichTextLabel_push_mono = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_mono" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@font@@ tag with a monospace font to the tag stack. push_mono :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () push_mono cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_mono (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_mono" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_mono {-# NOINLINE bindRichTextLabel_push_normal #-} -- | Adds a @@font@@ tag with a normal font to the tag stack. bindRichTextLabel_push_normal :: MethodBind bindRichTextLabel_push_normal = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@font@@ tag with a normal font to the tag stack. push_normal :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () push_normal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_normal" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_normal {-# NOINLINE bindRichTextLabel_push_strikethrough #-} -- | Adds a @@s@@ tag to the tag stack. bindRichTextLabel_push_strikethrough :: MethodBind bindRichTextLabel_push_strikethrough = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_strikethrough" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@s@@ tag to the tag stack. push_strikethrough :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () push_strikethrough cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_strikethrough (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_strikethrough" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_strikethrough {-# NOINLINE bindRichTextLabel_push_table #-} -- | Adds a @@table=columns@@ tag to the tag stack. bindRichTextLabel_push_table :: MethodBind bindRichTextLabel_push_table = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_table" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@table=columns@@ tag to the tag stack. push_table :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> IO () push_table cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_table (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_table" '[Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_table {-# NOINLINE bindRichTextLabel_push_underline #-} -- | Adds a @@u@@ tag to the tag stack. bindRichTextLabel_push_underline :: MethodBind bindRichTextLabel_push_underline = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "push_underline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @@u@@ tag to the tag stack. push_underline :: (RichTextLabel :< cls, Object :< cls) => cls -> IO () push_underline cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_push_underline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "push_underline" '[] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.push_underline {-# NOINLINE bindRichTextLabel_remove_line #-} -- | Removes a line of content from the label. Returns @true@ if the line exists. -- The @line@ argument is the index of the line to remove, it can take values in the interval @@0, get_line_count() - 1@@. bindRichTextLabel_remove_line :: MethodBind bindRichTextLabel_remove_line = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "remove_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a line of content from the label. Returns @true@ if the line exists. -- The @line@ argument is the index of the line to remove, it can take values in the interval @@0, get_line_count() - 1@@. remove_line :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> IO Bool remove_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_remove_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "remove_line" '[Int] (IO Bool) where nodeMethod = Godot.Core.RichTextLabel.remove_line {-# NOINLINE bindRichTextLabel_scroll_to_line #-} -- | Scrolls the window's top line to match @line@. bindRichTextLabel_scroll_to_line :: MethodBind bindRichTextLabel_scroll_to_line = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "scroll_to_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scrolls the window's top line to match @line@. scroll_to_line :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> IO () scroll_to_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_scroll_to_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "scroll_to_line" '[Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.scroll_to_line {-# NOINLINE bindRichTextLabel_set_bbcode #-} -- | The label's text in BBCode format. Is not representative of manual modifications to the internal tag stack. Erases changes made by other methods when edited. -- __Note:__ It is unadvised to use @+=@ operator with @bbcode_text@ (e.g. @bbcode_text += "some string"@) as it replaces the whole text and can cause slowdowns. Use @method append_bbcode@ for adding text instead. bindRichTextLabel_set_bbcode :: MethodBind bindRichTextLabel_set_bbcode = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_bbcode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The label's text in BBCode format. Is not representative of manual modifications to the internal tag stack. Erases changes made by other methods when edited. -- __Note:__ It is unadvised to use @+=@ operator with @bbcode_text@ (e.g. @bbcode_text += "some string"@) as it replaces the whole text and can cause slowdowns. Use @method append_bbcode@ for adding text instead. set_bbcode :: (RichTextLabel :< cls, Object :< cls) => cls -> GodotString -> IO () set_bbcode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_bbcode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_bbcode" '[GodotString] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_bbcode {-# NOINLINE bindRichTextLabel_set_effects #-} -- | The currently installed custom effects. This is an array of @RichTextEffect@s. -- To add a custom effect, it's more convenient to use @method install_effect@. bindRichTextLabel_set_effects :: MethodBind bindRichTextLabel_set_effects = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_effects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently installed custom effects. This is an array of @RichTextEffect@s. -- To add a custom effect, it's more convenient to use @method install_effect@. set_effects :: (RichTextLabel :< cls, Object :< cls) => cls -> Array -> IO () set_effects cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_effects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_effects" '[Array] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_effects {-# NOINLINE bindRichTextLabel_set_meta_underline #-} -- | If @true@, the label underlines meta tags such as @@url@{text}@/url@@. bindRichTextLabel_set_meta_underline :: MethodBind bindRichTextLabel_set_meta_underline = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_meta_underline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the label underlines meta tags such as @@url@{text}@/url@@. set_meta_underline :: (RichTextLabel :< cls, Object :< cls) => cls -> Bool -> IO () set_meta_underline cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_meta_underline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_meta_underline" '[Bool] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_meta_underline {-# NOINLINE bindRichTextLabel_set_override_selected_font_color #-} -- | If @true@, the label uses the custom font color. bindRichTextLabel_set_override_selected_font_color :: MethodBind bindRichTextLabel_set_override_selected_font_color = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_override_selected_font_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the label uses the custom font color. set_override_selected_font_color :: (RichTextLabel :< cls, Object :< cls) => cls -> Bool -> IO () set_override_selected_font_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_override_selected_font_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_override_selected_font_color" '[Bool] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_override_selected_font_color {-# NOINLINE bindRichTextLabel_set_percent_visible #-} -- | The range of characters to display, as a @float@ between 0.0 and 1.0. When assigned an out of range value, it's the same as assigning 1.0. -- __Note:__ Setting this property updates @visible_characters@ based on current @method get_total_character_count@. bindRichTextLabel_set_percent_visible :: MethodBind bindRichTextLabel_set_percent_visible = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_percent_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The range of characters to display, as a @float@ between 0.0 and 1.0. When assigned an out of range value, it's the same as assigning 1.0. -- __Note:__ Setting this property updates @visible_characters@ based on current @method get_total_character_count@. set_percent_visible :: (RichTextLabel :< cls, Object :< cls) => cls -> Float -> IO () set_percent_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_percent_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_percent_visible" '[Float] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_percent_visible {-# NOINLINE bindRichTextLabel_set_scroll_active #-} -- | If @true@, the scrollbar is visible. Setting this to @false@ does not block scrolling completely. See @method scroll_to_line@. bindRichTextLabel_set_scroll_active :: MethodBind bindRichTextLabel_set_scroll_active = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_scroll_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the scrollbar is visible. Setting this to @false@ does not block scrolling completely. See @method scroll_to_line@. set_scroll_active :: (RichTextLabel :< cls, Object :< cls) => cls -> Bool -> IO () set_scroll_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_scroll_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_scroll_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_scroll_active {-# NOINLINE bindRichTextLabel_set_scroll_follow #-} -- | If @true@, the window scrolls down to display new content automatically. bindRichTextLabel_set_scroll_follow :: MethodBind bindRichTextLabel_set_scroll_follow = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_scroll_follow" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the window scrolls down to display new content automatically. set_scroll_follow :: (RichTextLabel :< cls, Object :< cls) => cls -> Bool -> IO () set_scroll_follow cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_scroll_follow (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_scroll_follow" '[Bool] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_scroll_follow {-# NOINLINE bindRichTextLabel_set_selection_enabled #-} -- | If @true@, the label allows text selection. bindRichTextLabel_set_selection_enabled :: MethodBind bindRichTextLabel_set_selection_enabled = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_selection_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the label allows text selection. set_selection_enabled :: (RichTextLabel :< cls, Object :< cls) => cls -> Bool -> IO () set_selection_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_selection_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_selection_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_selection_enabled {-# NOINLINE bindRichTextLabel_set_tab_size #-} -- | The number of spaces associated with a single tab length. Does not affect @\t@ in text tags, only indent tags. bindRichTextLabel_set_tab_size :: MethodBind bindRichTextLabel_set_tab_size = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_tab_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of spaces associated with a single tab length. Does not affect @\t@ in text tags, only indent tags. set_tab_size :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> IO () set_tab_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_tab_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_tab_size" '[Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_tab_size {-# NOINLINE bindRichTextLabel_set_table_column_expand #-} -- | Edits the selected column's expansion options. If @expand@ is @true@, the column expands in proportion to its expansion ratio versus the other columns' ratios. -- For example, 2 columns with ratios 3 and 4 plus 70 pixels in available width would expand 30 and 40 pixels, respectively. -- If @expand@ is @false@, the column will not contribute to the total ratio. bindRichTextLabel_set_table_column_expand :: MethodBind bindRichTextLabel_set_table_column_expand = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_table_column_expand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Edits the selected column's expansion options. If @expand@ is @true@, the column expands in proportion to its expansion ratio versus the other columns' ratios. -- For example, 2 columns with ratios 3 and 4 plus 70 pixels in available width would expand 30 and 40 pixels, respectively. -- If @expand@ is @false@, the column will not contribute to the total ratio. set_table_column_expand :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> Bool -> Int -> IO () set_table_column_expand cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_table_column_expand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_table_column_expand" '[Int, Bool, Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_table_column_expand {-# NOINLINE bindRichTextLabel_set_text #-} -- | The raw text of the label. -- When set, clears the tag stack and adds a raw text tag to the top of it. Does not parse BBCodes. Does not modify @bbcode_text@. bindRichTextLabel_set_text :: MethodBind bindRichTextLabel_set_text = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The raw text of the label. -- When set, clears the tag stack and adds a raw text tag to the top of it. Does not parse BBCodes. Does not modify @bbcode_text@. set_text :: (RichTextLabel :< cls, Object :< cls) => cls -> GodotString -> IO () set_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_text {-# NOINLINE bindRichTextLabel_set_use_bbcode #-} -- | If @true@, the label uses BBCode formatting. bindRichTextLabel_set_use_bbcode :: MethodBind bindRichTextLabel_set_use_bbcode = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_use_bbcode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the label uses BBCode formatting. set_use_bbcode :: (RichTextLabel :< cls, Object :< cls) => cls -> Bool -> IO () set_use_bbcode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_use_bbcode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_use_bbcode" '[Bool] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_use_bbcode {-# NOINLINE bindRichTextLabel_set_visible_characters #-} -- | The restricted number of characters to display in the label. If @-1@, all characters will be displayed. bindRichTextLabel_set_visible_characters :: MethodBind bindRichTextLabel_set_visible_characters = unsafePerformIO $ withCString "RichTextLabel" $ \ clsNamePtr -> withCString "set_visible_characters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The restricted number of characters to display in the label. If @-1@, all characters will be displayed. set_visible_characters :: (RichTextLabel :< cls, Object :< cls) => cls -> Int -> IO () set_visible_characters cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRichTextLabel_set_visible_characters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RichTextLabel "set_visible_characters" '[Int] (IO ()) where nodeMethod = Godot.Core.RichTextLabel.set_visible_characters ================================================ FILE: src/Godot/Core/RigidBody.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RigidBody (Godot.Core.RigidBody._MODE_STATIC, Godot.Core.RigidBody._MODE_KINEMATIC, Godot.Core.RigidBody._MODE_RIGID, Godot.Core.RigidBody._MODE_CHARACTER, Godot.Core.RigidBody.sig_body_entered, Godot.Core.RigidBody.sig_body_exited, Godot.Core.RigidBody.sig_body_shape_entered, Godot.Core.RigidBody.sig_body_shape_exited, Godot.Core.RigidBody.sig_sleeping_state_changed, Godot.Core.RigidBody._body_enter_tree, Godot.Core.RigidBody._body_exit_tree, Godot.Core.RigidBody._direct_state_changed, Godot.Core.RigidBody._integrate_forces, Godot.Core.RigidBody._reload_physics_characteristics, Godot.Core.RigidBody.add_central_force, Godot.Core.RigidBody.add_force, Godot.Core.RigidBody.add_torque, Godot.Core.RigidBody.apply_central_impulse, Godot.Core.RigidBody.apply_impulse, Godot.Core.RigidBody.apply_torque_impulse, Godot.Core.RigidBody.get_angular_damp, Godot.Core.RigidBody.get_angular_velocity, Godot.Core.RigidBody.get_axis_lock, Godot.Core.RigidBody.get_bounce, Godot.Core.RigidBody.get_colliding_bodies, Godot.Core.RigidBody.get_friction, Godot.Core.RigidBody.get_gravity_scale, Godot.Core.RigidBody.get_linear_damp, Godot.Core.RigidBody.get_linear_velocity, Godot.Core.RigidBody.get_mass, Godot.Core.RigidBody.get_max_contacts_reported, Godot.Core.RigidBody.get_mode, Godot.Core.RigidBody.get_physics_material_override, Godot.Core.RigidBody.get_weight, Godot.Core.RigidBody.is_able_to_sleep, Godot.Core.RigidBody.is_contact_monitor_enabled, Godot.Core.RigidBody.is_sleeping, Godot.Core.RigidBody.is_using_continuous_collision_detection, Godot.Core.RigidBody.is_using_custom_integrator, Godot.Core.RigidBody.set_angular_damp, Godot.Core.RigidBody.set_angular_velocity, Godot.Core.RigidBody.set_axis_lock, Godot.Core.RigidBody.set_axis_velocity, Godot.Core.RigidBody.set_bounce, Godot.Core.RigidBody.set_can_sleep, Godot.Core.RigidBody.set_contact_monitor, Godot.Core.RigidBody.set_friction, Godot.Core.RigidBody.set_gravity_scale, Godot.Core.RigidBody.set_linear_damp, Godot.Core.RigidBody.set_linear_velocity, Godot.Core.RigidBody.set_mass, Godot.Core.RigidBody.set_max_contacts_reported, Godot.Core.RigidBody.set_mode, Godot.Core.RigidBody.set_physics_material_override, Godot.Core.RigidBody.set_sleeping, Godot.Core.RigidBody.set_use_continuous_collision_detection, Godot.Core.RigidBody.set_use_custom_integrator, Godot.Core.RigidBody.set_weight) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsBody() _MODE_STATIC :: Int _MODE_STATIC = 1 _MODE_KINEMATIC :: Int _MODE_KINEMATIC = 3 _MODE_RIGID :: Int _MODE_RIGID = 0 _MODE_CHARACTER :: Int _MODE_CHARACTER = 2 -- | Emitted when a body enters into contact with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. sig_body_entered :: Godot.Internal.Dispatch.Signal RigidBody sig_body_entered = Godot.Internal.Dispatch.Signal "body_entered" instance NodeSignal RigidBody "body_entered" '[Node] -- | Emitted when a body shape exits contact with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. sig_body_exited :: Godot.Internal.Dispatch.Signal RigidBody sig_body_exited = Godot.Internal.Dispatch.Signal "body_exited" instance NodeSignal RigidBody "body_exited" '[Node] -- | Emitted when a body enters into contact with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. -- This signal not only receives the body that collided with this one, but also its @RID@ (@body_id@), the shape index from the colliding body (@body_shape@), and the shape index from this body (@local_shape@) the other body collided with. sig_body_shape_entered :: Godot.Internal.Dispatch.Signal RigidBody sig_body_shape_entered = Godot.Internal.Dispatch.Signal "body_shape_entered" instance NodeSignal RigidBody "body_shape_entered" '[Int, Node, Int, Int] -- | Emitted when a body shape exits contact with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. -- This signal not only receives the body that stopped colliding with this one, but also its @RID@ (@body_id@), the shape index from the colliding body (@body_shape@), and the shape index from this body (@local_shape@) the other body stopped colliding with. sig_body_shape_exited :: Godot.Internal.Dispatch.Signal RigidBody sig_body_shape_exited = Godot.Internal.Dispatch.Signal "body_shape_exited" instance NodeSignal RigidBody "body_shape_exited" '[Int, Node, Int, Int] -- | Emitted when the physics engine changes the body's sleeping state. -- __Note:__ Changing the value @sleeping@ will not trigger this signal. It is only emitted if the sleeping state is changed by the physics engine or @emit_signal("sleeping_state_changed")@ is used. sig_sleeping_state_changed :: Godot.Internal.Dispatch.Signal RigidBody sig_sleeping_state_changed = Godot.Internal.Dispatch.Signal "sleeping_state_changed" instance NodeSignal RigidBody "sleeping_state_changed" '[] instance NodeProperty RigidBody "angular_damp" Float 'False where nodeProperty = (get_angular_damp, wrapDroppingSetter set_angular_damp, Nothing) instance NodeProperty RigidBody "angular_velocity" Vector3 'False where nodeProperty = (get_angular_velocity, wrapDroppingSetter set_angular_velocity, Nothing) instance NodeProperty RigidBody "axis_lock_angular_x" Bool 'False where nodeProperty = (wrapIndexedGetter 8 get_axis_lock, wrapIndexedSetter 8 set_axis_lock, Nothing) instance NodeProperty RigidBody "axis_lock_angular_y" Bool 'False where nodeProperty = (wrapIndexedGetter 16 get_axis_lock, wrapIndexedSetter 16 set_axis_lock, Nothing) instance NodeProperty RigidBody "axis_lock_angular_z" Bool 'False where nodeProperty = (wrapIndexedGetter 32 get_axis_lock, wrapIndexedSetter 32 set_axis_lock, Nothing) instance NodeProperty RigidBody "axis_lock_linear_x" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_axis_lock, wrapIndexedSetter 1 set_axis_lock, Nothing) instance NodeProperty RigidBody "axis_lock_linear_y" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_axis_lock, wrapIndexedSetter 2 set_axis_lock, Nothing) instance NodeProperty RigidBody "axis_lock_linear_z" Bool 'False where nodeProperty = (wrapIndexedGetter 4 get_axis_lock, wrapIndexedSetter 4 set_axis_lock, Nothing) instance NodeProperty RigidBody "bounce" Float 'False where nodeProperty = (get_bounce, wrapDroppingSetter set_bounce, Nothing) instance NodeProperty RigidBody "can_sleep" Bool 'False where nodeProperty = (is_able_to_sleep, wrapDroppingSetter set_can_sleep, Nothing) instance NodeProperty RigidBody "contact_monitor" Bool 'False where nodeProperty = (is_contact_monitor_enabled, wrapDroppingSetter set_contact_monitor, Nothing) instance NodeProperty RigidBody "contacts_reported" Int 'False where nodeProperty = (get_max_contacts_reported, wrapDroppingSetter set_max_contacts_reported, Nothing) instance NodeProperty RigidBody "continuous_cd" Bool 'False where nodeProperty = (is_using_continuous_collision_detection, wrapDroppingSetter set_use_continuous_collision_detection, Nothing) instance NodeProperty RigidBody "custom_integrator" Bool 'False where nodeProperty = (is_using_custom_integrator, wrapDroppingSetter set_use_custom_integrator, Nothing) instance NodeProperty RigidBody "friction" Float 'False where nodeProperty = (get_friction, wrapDroppingSetter set_friction, Nothing) instance NodeProperty RigidBody "gravity_scale" Float 'False where nodeProperty = (get_gravity_scale, wrapDroppingSetter set_gravity_scale, Nothing) instance NodeProperty RigidBody "linear_damp" Float 'False where nodeProperty = (get_linear_damp, wrapDroppingSetter set_linear_damp, Nothing) instance NodeProperty RigidBody "linear_velocity" Vector3 'False where nodeProperty = (get_linear_velocity, wrapDroppingSetter set_linear_velocity, Nothing) instance NodeProperty RigidBody "mass" Float 'False where nodeProperty = (get_mass, wrapDroppingSetter set_mass, Nothing) instance NodeProperty RigidBody "mode" Int 'False where nodeProperty = (get_mode, wrapDroppingSetter set_mode, Nothing) instance NodeProperty RigidBody "physics_material_override" PhysicsMaterial 'False where nodeProperty = (get_physics_material_override, wrapDroppingSetter set_physics_material_override, Nothing) instance NodeProperty RigidBody "sleeping" Bool 'False where nodeProperty = (is_sleeping, wrapDroppingSetter set_sleeping, Nothing) instance NodeProperty RigidBody "weight" Float 'False where nodeProperty = (get_weight, wrapDroppingSetter set_weight, Nothing) {-# NOINLINE bindRigidBody__body_enter_tree #-} bindRigidBody__body_enter_tree :: MethodBind bindRigidBody__body_enter_tree = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "_body_enter_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_enter_tree :: (RigidBody :< cls, Object :< cls) => cls -> Int -> IO () _body_enter_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody__body_enter_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "_body_enter_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody._body_enter_tree {-# NOINLINE bindRigidBody__body_exit_tree #-} bindRigidBody__body_exit_tree :: MethodBind bindRigidBody__body_exit_tree = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "_body_exit_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_exit_tree :: (RigidBody :< cls, Object :< cls) => cls -> Int -> IO () _body_exit_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody__body_exit_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "_body_exit_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody._body_exit_tree {-# NOINLINE bindRigidBody__direct_state_changed #-} bindRigidBody__direct_state_changed :: MethodBind bindRigidBody__direct_state_changed = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "_direct_state_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _direct_state_changed :: (RigidBody :< cls, Object :< cls) => cls -> Object -> IO () _direct_state_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody__direct_state_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "_direct_state_changed" '[Object] (IO ()) where nodeMethod = Godot.Core.RigidBody._direct_state_changed {-# NOINLINE bindRigidBody__integrate_forces #-} -- | Called during physics processing, allowing you to read and safely modify the simulation state for the object. By default, it works in addition to the usual physics behavior, but the @custom_integrator@ property allows you to disable the default behavior and do fully custom force integration for a body. bindRigidBody__integrate_forces :: MethodBind bindRigidBody__integrate_forces = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "_integrate_forces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called during physics processing, allowing you to read and safely modify the simulation state for the object. By default, it works in addition to the usual physics behavior, but the @custom_integrator@ property allows you to disable the default behavior and do fully custom force integration for a body. _integrate_forces :: (RigidBody :< cls, Object :< cls) => cls -> PhysicsDirectBodyState -> IO () _integrate_forces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody__integrate_forces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "_integrate_forces" '[PhysicsDirectBodyState] (IO ()) where nodeMethod = Godot.Core.RigidBody._integrate_forces {-# NOINLINE bindRigidBody__reload_physics_characteristics #-} bindRigidBody__reload_physics_characteristics :: MethodBind bindRigidBody__reload_physics_characteristics = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "_reload_physics_characteristics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _reload_physics_characteristics :: (RigidBody :< cls, Object :< cls) => cls -> IO () _reload_physics_characteristics cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody__reload_physics_characteristics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "_reload_physics_characteristics" '[] (IO ()) where nodeMethod = Godot.Core.RigidBody._reload_physics_characteristics {-# NOINLINE bindRigidBody_add_central_force #-} -- | Adds a constant directional force (i.e. acceleration) without affecting rotation. -- This is equivalent to @add_force(force, Vector3(0,0,0))@. bindRigidBody_add_central_force :: MethodBind bindRigidBody_add_central_force = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "add_central_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant directional force (i.e. acceleration) without affecting rotation. -- This is equivalent to @add_force(force, Vector3(0,0,0))@. add_central_force :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> IO () add_central_force cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_add_central_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "add_central_force" '[Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.add_central_force {-# NOINLINE bindRigidBody_add_force #-} -- | Adds a constant directional force (i.e. acceleration). -- The position uses the rotation of the global coordinate system, but is centered at the object's origin. bindRigidBody_add_force :: MethodBind bindRigidBody_add_force = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "add_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant directional force (i.e. acceleration). -- The position uses the rotation of the global coordinate system, but is centered at the object's origin. add_force :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> IO () add_force cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_add_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "add_force" '[Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.add_force {-# NOINLINE bindRigidBody_add_torque #-} -- | Adds a constant rotational force (i.e. a motor) without affecting position. bindRigidBody_add_torque :: MethodBind bindRigidBody_add_torque = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "add_torque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant rotational force (i.e. a motor) without affecting position. add_torque :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> IO () add_torque cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_add_torque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "add_torque" '[Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.add_torque {-# NOINLINE bindRigidBody_apply_central_impulse #-} -- | Applies a directional impulse without affecting rotation. -- This is equivalent to @apply_impulse(Vector3(0,0,0), impulse)@. bindRigidBody_apply_central_impulse :: MethodBind bindRigidBody_apply_central_impulse = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "apply_central_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a directional impulse without affecting rotation. -- This is equivalent to @apply_impulse(Vector3(0,0,0), impulse)@. apply_central_impulse :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> IO () apply_central_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_apply_central_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "apply_central_impulse" '[Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.apply_central_impulse {-# NOINLINE bindRigidBody_apply_impulse #-} -- | Applies a positioned impulse to the body. An impulse is time independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason it should only be used when simulating one-time impacts. The position uses the rotation of the global coordinate system, but is centered at the object's origin. bindRigidBody_apply_impulse :: MethodBind bindRigidBody_apply_impulse = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "apply_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a positioned impulse to the body. An impulse is time independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason it should only be used when simulating one-time impacts. The position uses the rotation of the global coordinate system, but is centered at the object's origin. apply_impulse :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> IO () apply_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_apply_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "apply_impulse" '[Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.apply_impulse {-# NOINLINE bindRigidBody_apply_torque_impulse #-} -- | Applies a torque impulse which will be affected by the body mass and shape. This will rotate the body around the @impulse@ vector passed. bindRigidBody_apply_torque_impulse :: MethodBind bindRigidBody_apply_torque_impulse = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "apply_torque_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a torque impulse which will be affected by the body mass and shape. This will rotate the body around the @impulse@ vector passed. apply_torque_impulse :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> IO () apply_torque_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_apply_torque_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "apply_torque_impulse" '[Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.apply_torque_impulse {-# NOINLINE bindRigidBody_get_angular_damp #-} -- | Damps RigidBody's rotational forces. bindRigidBody_get_angular_damp :: MethodBind bindRigidBody_get_angular_damp = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Damps RigidBody's rotational forces. get_angular_damp :: (RigidBody :< cls, Object :< cls) => cls -> IO Float get_angular_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_angular_damp" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody.get_angular_damp {-# NOINLINE bindRigidBody_get_angular_velocity #-} -- | RigidBody's rotational velocity. bindRigidBody_get_angular_velocity :: MethodBind bindRigidBody_get_angular_velocity = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | RigidBody's rotational velocity. get_angular_velocity :: (RigidBody :< cls, Object :< cls) => cls -> IO Vector3 get_angular_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_angular_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.RigidBody.get_angular_velocity {-# NOINLINE bindRigidBody_get_axis_lock #-} -- | Returns @true@ if the specified linear or rotational axis is locked. bindRigidBody_get_axis_lock :: MethodBind bindRigidBody_get_axis_lock = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_axis_lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified linear or rotational axis is locked. get_axis_lock :: (RigidBody :< cls, Object :< cls) => cls -> Int -> IO Bool get_axis_lock cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_axis_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_axis_lock" '[Int] (IO Bool) where nodeMethod = Godot.Core.RigidBody.get_axis_lock {-# NOINLINE bindRigidBody_get_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. bindRigidBody_get_bounce :: MethodBind bindRigidBody_get_bounce = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. get_bounce :: (RigidBody :< cls, Object :< cls) => cls -> IO Float get_bounce cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_bounce" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody.get_bounce {-# NOINLINE bindRigidBody_get_colliding_bodies #-} -- | Returns a list of the bodies colliding with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of collisions is updated once per frame and before the physics step. Consider using signals instead. bindRigidBody_get_colliding_bodies :: MethodBind bindRigidBody_get_colliding_bodies = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_colliding_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of the bodies colliding with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of collisions is updated once per frame and before the physics step. Consider using signals instead. get_colliding_bodies :: (RigidBody :< cls, Object :< cls) => cls -> IO Array get_colliding_bodies cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_colliding_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_colliding_bodies" '[] (IO Array) where nodeMethod = Godot.Core.RigidBody.get_colliding_bodies {-# NOINLINE bindRigidBody_get_friction #-} -- | The body's friction, from 0 (frictionless) to 1 (max friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. bindRigidBody_get_friction :: MethodBind bindRigidBody_get_friction = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction, from 0 (frictionless) to 1 (max friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. get_friction :: (RigidBody :< cls, Object :< cls) => cls -> IO Float get_friction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_friction" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody.get_friction {-# NOINLINE bindRigidBody_get_gravity_scale #-} -- | This is multiplied by the global 3D gravity setting found in __Project > Project Settings > Physics > 3d__ to produce RigidBody's gravity. For example, a value of 1 will be normal gravity, 2 will apply double gravity, and 0.5 will apply half gravity to this object. bindRigidBody_get_gravity_scale :: MethodBind bindRigidBody_get_gravity_scale = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_gravity_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This is multiplied by the global 3D gravity setting found in __Project > Project Settings > Physics > 3d__ to produce RigidBody's gravity. For example, a value of 1 will be normal gravity, 2 will apply double gravity, and 0.5 will apply half gravity to this object. get_gravity_scale :: (RigidBody :< cls, Object :< cls) => cls -> IO Float get_gravity_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_gravity_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_gravity_scale" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody.get_gravity_scale {-# NOINLINE bindRigidBody_get_linear_damp #-} -- | The body's linear damp. Cannot be less than -1.0. If this value is different from -1.0, any linear damp derived from the world or areas will be overridden. bindRigidBody_get_linear_damp :: MethodBind bindRigidBody_get_linear_damp = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear damp. Cannot be less than -1.0. If this value is different from -1.0, any linear damp derived from the world or areas will be overridden. get_linear_damp :: (RigidBody :< cls, Object :< cls) => cls -> IO Float get_linear_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_linear_damp" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody.get_linear_damp {-# NOINLINE bindRigidBody_get_linear_velocity #-} -- | The body's linear velocity. Can be used sporadically, but __don't set this every frame__, because physics may run in another thread and runs at a different granularity. Use @method _integrate_forces@ as your process loop for precise control of the body state. bindRigidBody_get_linear_velocity :: MethodBind bindRigidBody_get_linear_velocity = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear velocity. Can be used sporadically, but __don't set this every frame__, because physics may run in another thread and runs at a different granularity. Use @method _integrate_forces@ as your process loop for precise control of the body state. get_linear_velocity :: (RigidBody :< cls, Object :< cls) => cls -> IO Vector3 get_linear_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_linear_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.RigidBody.get_linear_velocity {-# NOINLINE bindRigidBody_get_mass #-} -- | The body's mass. bindRigidBody_get_mass :: MethodBind bindRigidBody_get_mass = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's mass. get_mass :: (RigidBody :< cls, Object :< cls) => cls -> IO Float get_mass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_mass" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody.get_mass {-# NOINLINE bindRigidBody_get_max_contacts_reported #-} -- | The maximum number of contacts that will be recorded. Requires @contact_monitor@ to be set to @true@. -- __Note:__ The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner). bindRigidBody_get_max_contacts_reported :: MethodBind bindRigidBody_get_max_contacts_reported = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_max_contacts_reported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum number of contacts that will be recorded. Requires @contact_monitor@ to be set to @true@. -- __Note:__ The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner). get_max_contacts_reported :: (RigidBody :< cls, Object :< cls) => cls -> IO Int get_max_contacts_reported cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_max_contacts_reported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_max_contacts_reported" '[] (IO Int) where nodeMethod = Godot.Core.RigidBody.get_max_contacts_reported {-# NOINLINE bindRigidBody_get_mode #-} -- | The body mode. See @enum Mode@ for possible values. bindRigidBody_get_mode :: MethodBind bindRigidBody_get_mode = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body mode. See @enum Mode@ for possible values. get_mode :: (RigidBody :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_mode" '[] (IO Int) where nodeMethod = Godot.Core.RigidBody.get_mode {-# NOINLINE bindRigidBody_get_physics_material_override #-} -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. bindRigidBody_get_physics_material_override :: MethodBind bindRigidBody_get_physics_material_override = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_physics_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. get_physics_material_override :: (RigidBody :< cls, Object :< cls) => cls -> IO PhysicsMaterial get_physics_material_override cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_physics_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_physics_material_override" '[] (IO PhysicsMaterial) where nodeMethod = Godot.Core.RigidBody.get_physics_material_override {-# NOINLINE bindRigidBody_get_weight #-} -- | The body's weight based on its mass and the global 3D gravity. Global values are set in __Project > Project Settings > Physics > 3d__. bindRigidBody_get_weight :: MethodBind bindRigidBody_get_weight = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "get_weight" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's weight based on its mass and the global 3D gravity. Global values are set in __Project > Project Settings > Physics > 3d__. get_weight :: (RigidBody :< cls, Object :< cls) => cls -> IO Float get_weight cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_get_weight (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "get_weight" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody.get_weight {-# NOINLINE bindRigidBody_is_able_to_sleep #-} -- | If @true@, the body can enter sleep mode when there is no movement. See @sleeping@. -- __Note:__ A RigidBody3D will never enter sleep mode automatically if its @mode@ is @MODE_CHARACTER@. It can still be put to sleep manually by setting its @sleeping@ property to @true@. bindRigidBody_is_able_to_sleep :: MethodBind bindRigidBody_is_able_to_sleep = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "is_able_to_sleep" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body can enter sleep mode when there is no movement. See @sleeping@. -- __Note:__ A RigidBody3D will never enter sleep mode automatically if its @mode@ is @MODE_CHARACTER@. It can still be put to sleep manually by setting its @sleeping@ property to @true@. is_able_to_sleep :: (RigidBody :< cls, Object :< cls) => cls -> IO Bool is_able_to_sleep cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_is_able_to_sleep (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "is_able_to_sleep" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody.is_able_to_sleep {-# NOINLINE bindRigidBody_is_contact_monitor_enabled #-} -- | If @true@, the RigidBody will emit signals when it collides with another RigidBody. See also @contacts_reported@. bindRigidBody_is_contact_monitor_enabled :: MethodBind bindRigidBody_is_contact_monitor_enabled = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "is_contact_monitor_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the RigidBody will emit signals when it collides with another RigidBody. See also @contacts_reported@. is_contact_monitor_enabled :: (RigidBody :< cls, Object :< cls) => cls -> IO Bool is_contact_monitor_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_is_contact_monitor_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "is_contact_monitor_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody.is_contact_monitor_enabled {-# NOINLINE bindRigidBody_is_sleeping #-} -- | If @true@, the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the @method apply_impulse@ or @method add_force@ methods. bindRigidBody_is_sleeping :: MethodBind bindRigidBody_is_sleeping = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "is_sleeping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the @method apply_impulse@ or @method add_force@ methods. is_sleeping :: (RigidBody :< cls, Object :< cls) => cls -> IO Bool is_sleeping cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_is_sleeping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "is_sleeping" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody.is_sleeping {-# NOINLINE bindRigidBody_is_using_continuous_collision_detection #-} -- | If @true@, continuous collision detection is used. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. Continuous collision detection is more precise, and misses fewer impacts by small, fast-moving objects. Not using continuous collision detection is faster to compute, but can miss small, fast-moving objects. bindRigidBody_is_using_continuous_collision_detection :: MethodBind bindRigidBody_is_using_continuous_collision_detection = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "is_using_continuous_collision_detection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, continuous collision detection is used. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. Continuous collision detection is more precise, and misses fewer impacts by small, fast-moving objects. Not using continuous collision detection is faster to compute, but can miss small, fast-moving objects. is_using_continuous_collision_detection :: (RigidBody :< cls, Object :< cls) => cls -> IO Bool is_using_continuous_collision_detection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_is_using_continuous_collision_detection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "is_using_continuous_collision_detection" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody.is_using_continuous_collision_detection {-# NOINLINE bindRigidBody_is_using_custom_integrator #-} -- | If @true@, internal force integration will be disabled (like gravity or air friction) for this body. Other than collision response, the body will only move as determined by the @method _integrate_forces@ function, if defined. bindRigidBody_is_using_custom_integrator :: MethodBind bindRigidBody_is_using_custom_integrator = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "is_using_custom_integrator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, internal force integration will be disabled (like gravity or air friction) for this body. Other than collision response, the body will only move as determined by the @method _integrate_forces@ function, if defined. is_using_custom_integrator :: (RigidBody :< cls, Object :< cls) => cls -> IO Bool is_using_custom_integrator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_is_using_custom_integrator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "is_using_custom_integrator" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody.is_using_custom_integrator {-# NOINLINE bindRigidBody_set_angular_damp #-} -- | Damps RigidBody's rotational forces. bindRigidBody_set_angular_damp :: MethodBind bindRigidBody_set_angular_damp = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Damps RigidBody's rotational forces. set_angular_damp :: (RigidBody :< cls, Object :< cls) => cls -> Float -> IO () set_angular_damp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_angular_damp" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_angular_damp {-# NOINLINE bindRigidBody_set_angular_velocity #-} -- | RigidBody's rotational velocity. bindRigidBody_set_angular_velocity :: MethodBind bindRigidBody_set_angular_velocity = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | RigidBody's rotational velocity. set_angular_velocity :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> IO () set_angular_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_angular_velocity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_angular_velocity {-# NOINLINE bindRigidBody_set_axis_lock #-} -- | Locks the specified linear or rotational axis. bindRigidBody_set_axis_lock :: MethodBind bindRigidBody_set_axis_lock = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_axis_lock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Locks the specified linear or rotational axis. set_axis_lock :: (RigidBody :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_axis_lock cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_axis_lock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_axis_lock" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_axis_lock {-# NOINLINE bindRigidBody_set_axis_velocity #-} -- | Sets an axis velocity. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior. bindRigidBody_set_axis_velocity :: MethodBind bindRigidBody_set_axis_velocity = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_axis_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an axis velocity. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior. set_axis_velocity :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> IO () set_axis_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_axis_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_axis_velocity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_axis_velocity {-# NOINLINE bindRigidBody_set_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. bindRigidBody_set_bounce :: MethodBind bindRigidBody_set_bounce = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. set_bounce :: (RigidBody :< cls, Object :< cls) => cls -> Float -> IO () set_bounce cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_bounce" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_bounce {-# NOINLINE bindRigidBody_set_can_sleep #-} -- | If @true@, the body can enter sleep mode when there is no movement. See @sleeping@. -- __Note:__ A RigidBody3D will never enter sleep mode automatically if its @mode@ is @MODE_CHARACTER@. It can still be put to sleep manually by setting its @sleeping@ property to @true@. bindRigidBody_set_can_sleep :: MethodBind bindRigidBody_set_can_sleep = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_can_sleep" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body can enter sleep mode when there is no movement. See @sleeping@. -- __Note:__ A RigidBody3D will never enter sleep mode automatically if its @mode@ is @MODE_CHARACTER@. It can still be put to sleep manually by setting its @sleeping@ property to @true@. set_can_sleep :: (RigidBody :< cls, Object :< cls) => cls -> Bool -> IO () set_can_sleep cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_can_sleep (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_can_sleep" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_can_sleep {-# NOINLINE bindRigidBody_set_contact_monitor #-} -- | If @true@, the RigidBody will emit signals when it collides with another RigidBody. See also @contacts_reported@. bindRigidBody_set_contact_monitor :: MethodBind bindRigidBody_set_contact_monitor = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_contact_monitor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the RigidBody will emit signals when it collides with another RigidBody. See also @contacts_reported@. set_contact_monitor :: (RigidBody :< cls, Object :< cls) => cls -> Bool -> IO () set_contact_monitor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_contact_monitor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_contact_monitor" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_contact_monitor {-# NOINLINE bindRigidBody_set_friction #-} -- | The body's friction, from 0 (frictionless) to 1 (max friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. bindRigidBody_set_friction :: MethodBind bindRigidBody_set_friction = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction, from 0 (frictionless) to 1 (max friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. set_friction :: (RigidBody :< cls, Object :< cls) => cls -> Float -> IO () set_friction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_friction" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_friction {-# NOINLINE bindRigidBody_set_gravity_scale #-} -- | This is multiplied by the global 3D gravity setting found in __Project > Project Settings > Physics > 3d__ to produce RigidBody's gravity. For example, a value of 1 will be normal gravity, 2 will apply double gravity, and 0.5 will apply half gravity to this object. bindRigidBody_set_gravity_scale :: MethodBind bindRigidBody_set_gravity_scale = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_gravity_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This is multiplied by the global 3D gravity setting found in __Project > Project Settings > Physics > 3d__ to produce RigidBody's gravity. For example, a value of 1 will be normal gravity, 2 will apply double gravity, and 0.5 will apply half gravity to this object. set_gravity_scale :: (RigidBody :< cls, Object :< cls) => cls -> Float -> IO () set_gravity_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_gravity_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_gravity_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_gravity_scale {-# NOINLINE bindRigidBody_set_linear_damp #-} -- | The body's linear damp. Cannot be less than -1.0. If this value is different from -1.0, any linear damp derived from the world or areas will be overridden. bindRigidBody_set_linear_damp :: MethodBind bindRigidBody_set_linear_damp = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear damp. Cannot be less than -1.0. If this value is different from -1.0, any linear damp derived from the world or areas will be overridden. set_linear_damp :: (RigidBody :< cls, Object :< cls) => cls -> Float -> IO () set_linear_damp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_linear_damp" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_linear_damp {-# NOINLINE bindRigidBody_set_linear_velocity #-} -- | The body's linear velocity. Can be used sporadically, but __don't set this every frame__, because physics may run in another thread and runs at a different granularity. Use @method _integrate_forces@ as your process loop for precise control of the body state. bindRigidBody_set_linear_velocity :: MethodBind bindRigidBody_set_linear_velocity = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear velocity. Can be used sporadically, but __don't set this every frame__, because physics may run in another thread and runs at a different granularity. Use @method _integrate_forces@ as your process loop for precise control of the body state. set_linear_velocity :: (RigidBody :< cls, Object :< cls) => cls -> Vector3 -> IO () set_linear_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_linear_velocity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_linear_velocity {-# NOINLINE bindRigidBody_set_mass #-} -- | The body's mass. bindRigidBody_set_mass :: MethodBind bindRigidBody_set_mass = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's mass. set_mass :: (RigidBody :< cls, Object :< cls) => cls -> Float -> IO () set_mass cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_mass" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_mass {-# NOINLINE bindRigidBody_set_max_contacts_reported #-} -- | The maximum number of contacts that will be recorded. Requires @contact_monitor@ to be set to @true@. -- __Note:__ The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner). bindRigidBody_set_max_contacts_reported :: MethodBind bindRigidBody_set_max_contacts_reported = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_max_contacts_reported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum number of contacts that will be recorded. Requires @contact_monitor@ to be set to @true@. -- __Note:__ The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner). set_max_contacts_reported :: (RigidBody :< cls, Object :< cls) => cls -> Int -> IO () set_max_contacts_reported cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_max_contacts_reported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_max_contacts_reported" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_max_contacts_reported {-# NOINLINE bindRigidBody_set_mode #-} -- | The body mode. See @enum Mode@ for possible values. bindRigidBody_set_mode :: MethodBind bindRigidBody_set_mode = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body mode. See @enum Mode@ for possible values. set_mode :: (RigidBody :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_mode {-# NOINLINE bindRigidBody_set_physics_material_override #-} -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. bindRigidBody_set_physics_material_override :: MethodBind bindRigidBody_set_physics_material_override = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_physics_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. set_physics_material_override :: (RigidBody :< cls, Object :< cls) => cls -> PhysicsMaterial -> IO () set_physics_material_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_physics_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_physics_material_override" '[PhysicsMaterial] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_physics_material_override {-# NOINLINE bindRigidBody_set_sleeping #-} -- | If @true@, the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the @method apply_impulse@ or @method add_force@ methods. bindRigidBody_set_sleeping :: MethodBind bindRigidBody_set_sleeping = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_sleeping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the @method apply_impulse@ or @method add_force@ methods. set_sleeping :: (RigidBody :< cls, Object :< cls) => cls -> Bool -> IO () set_sleeping cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_sleeping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_sleeping" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_sleeping {-# NOINLINE bindRigidBody_set_use_continuous_collision_detection #-} -- | If @true@, continuous collision detection is used. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. Continuous collision detection is more precise, and misses fewer impacts by small, fast-moving objects. Not using continuous collision detection is faster to compute, but can miss small, fast-moving objects. bindRigidBody_set_use_continuous_collision_detection :: MethodBind bindRigidBody_set_use_continuous_collision_detection = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_use_continuous_collision_detection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, continuous collision detection is used. -- Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. Continuous collision detection is more precise, and misses fewer impacts by small, fast-moving objects. Not using continuous collision detection is faster to compute, but can miss small, fast-moving objects. set_use_continuous_collision_detection :: (RigidBody :< cls, Object :< cls) => cls -> Bool -> IO () set_use_continuous_collision_detection cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_use_continuous_collision_detection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_use_continuous_collision_detection" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_use_continuous_collision_detection {-# NOINLINE bindRigidBody_set_use_custom_integrator #-} -- | If @true@, internal force integration will be disabled (like gravity or air friction) for this body. Other than collision response, the body will only move as determined by the @method _integrate_forces@ function, if defined. bindRigidBody_set_use_custom_integrator :: MethodBind bindRigidBody_set_use_custom_integrator = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_use_custom_integrator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, internal force integration will be disabled (like gravity or air friction) for this body. Other than collision response, the body will only move as determined by the @method _integrate_forces@ function, if defined. set_use_custom_integrator :: (RigidBody :< cls, Object :< cls) => cls -> Bool -> IO () set_use_custom_integrator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_use_custom_integrator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_use_custom_integrator" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_use_custom_integrator {-# NOINLINE bindRigidBody_set_weight #-} -- | The body's weight based on its mass and the global 3D gravity. Global values are set in __Project > Project Settings > Physics > 3d__. bindRigidBody_set_weight :: MethodBind bindRigidBody_set_weight = unsafePerformIO $ withCString "RigidBody" $ \ clsNamePtr -> withCString "set_weight" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's weight based on its mass and the global 3D gravity. Global values are set in __Project > Project Settings > Physics > 3d__. set_weight :: (RigidBody :< cls, Object :< cls) => cls -> Float -> IO () set_weight cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody_set_weight (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody "set_weight" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody.set_weight ================================================ FILE: src/Godot/Core/RigidBody2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RigidBody2D (Godot.Core.RigidBody2D._MODE_STATIC, Godot.Core.RigidBody2D._CCD_MODE_DISABLED, Godot.Core.RigidBody2D._CCD_MODE_CAST_RAY, Godot.Core.RigidBody2D._MODE_KINEMATIC, Godot.Core.RigidBody2D._CCD_MODE_CAST_SHAPE, Godot.Core.RigidBody2D._MODE_RIGID, Godot.Core.RigidBody2D._MODE_CHARACTER, Godot.Core.RigidBody2D.sig_body_entered, Godot.Core.RigidBody2D.sig_body_exited, Godot.Core.RigidBody2D.sig_body_shape_entered, Godot.Core.RigidBody2D.sig_body_shape_exited, Godot.Core.RigidBody2D.sig_sleeping_state_changed, Godot.Core.RigidBody2D._body_enter_tree, Godot.Core.RigidBody2D._body_exit_tree, Godot.Core.RigidBody2D._direct_state_changed, Godot.Core.RigidBody2D._integrate_forces, Godot.Core.RigidBody2D._reload_physics_characteristics, Godot.Core.RigidBody2D.add_central_force, Godot.Core.RigidBody2D.add_force, Godot.Core.RigidBody2D.add_torque, Godot.Core.RigidBody2D.apply_central_impulse, Godot.Core.RigidBody2D.apply_impulse, Godot.Core.RigidBody2D.apply_torque_impulse, Godot.Core.RigidBody2D.get_angular_damp, Godot.Core.RigidBody2D.get_angular_velocity, Godot.Core.RigidBody2D.get_applied_force, Godot.Core.RigidBody2D.get_applied_torque, Godot.Core.RigidBody2D.get_bounce, Godot.Core.RigidBody2D.get_colliding_bodies, Godot.Core.RigidBody2D.get_continuous_collision_detection_mode, Godot.Core.RigidBody2D.get_friction, Godot.Core.RigidBody2D.get_gravity_scale, Godot.Core.RigidBody2D.get_inertia, Godot.Core.RigidBody2D.get_linear_damp, Godot.Core.RigidBody2D.get_linear_velocity, Godot.Core.RigidBody2D.get_mass, Godot.Core.RigidBody2D.get_max_contacts_reported, Godot.Core.RigidBody2D.get_mode, Godot.Core.RigidBody2D.get_physics_material_override, Godot.Core.RigidBody2D.get_weight, Godot.Core.RigidBody2D.is_able_to_sleep, Godot.Core.RigidBody2D.is_contact_monitor_enabled, Godot.Core.RigidBody2D.is_sleeping, Godot.Core.RigidBody2D.is_using_custom_integrator, Godot.Core.RigidBody2D.set_angular_damp, Godot.Core.RigidBody2D.set_angular_velocity, Godot.Core.RigidBody2D.set_applied_force, Godot.Core.RigidBody2D.set_applied_torque, Godot.Core.RigidBody2D.set_axis_velocity, Godot.Core.RigidBody2D.set_bounce, Godot.Core.RigidBody2D.set_can_sleep, Godot.Core.RigidBody2D.set_contact_monitor, Godot.Core.RigidBody2D.set_continuous_collision_detection_mode, Godot.Core.RigidBody2D.set_friction, Godot.Core.RigidBody2D.set_gravity_scale, Godot.Core.RigidBody2D.set_inertia, Godot.Core.RigidBody2D.set_linear_damp, Godot.Core.RigidBody2D.set_linear_velocity, Godot.Core.RigidBody2D.set_mass, Godot.Core.RigidBody2D.set_max_contacts_reported, Godot.Core.RigidBody2D.set_mode, Godot.Core.RigidBody2D.set_physics_material_override, Godot.Core.RigidBody2D.set_sleeping, Godot.Core.RigidBody2D.set_use_custom_integrator, Godot.Core.RigidBody2D.set_weight, Godot.Core.RigidBody2D.test_motion) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsBody2D() _MODE_STATIC :: Int _MODE_STATIC = 1 _CCD_MODE_DISABLED :: Int _CCD_MODE_DISABLED = 0 _CCD_MODE_CAST_RAY :: Int _CCD_MODE_CAST_RAY = 1 _MODE_KINEMATIC :: Int _MODE_KINEMATIC = 3 _CCD_MODE_CAST_SHAPE :: Int _CCD_MODE_CAST_SHAPE = 2 _MODE_RIGID :: Int _MODE_RIGID = 0 _MODE_CHARACTER :: Int _MODE_CHARACTER = 2 -- | Emitted when a body enters into contact with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. sig_body_entered :: Godot.Internal.Dispatch.Signal RigidBody2D sig_body_entered = Godot.Internal.Dispatch.Signal "body_entered" instance NodeSignal RigidBody2D "body_entered" '[Node] -- | Emitted when a body exits contact with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. sig_body_exited :: Godot.Internal.Dispatch.Signal RigidBody2D sig_body_exited = Godot.Internal.Dispatch.Signal "body_exited" instance NodeSignal RigidBody2D "body_exited" '[Node] -- | Emitted when a body enters into contact with this one. Reports colliding shape information. See @CollisionObject2D@ for shape index information. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. sig_body_shape_entered :: Godot.Internal.Dispatch.Signal RigidBody2D sig_body_shape_entered = Godot.Internal.Dispatch.Signal "body_shape_entered" instance NodeSignal RigidBody2D "body_shape_entered" '[Int, Node, Int, Int] -- | Emitted when a body shape exits contact with this one. Reports colliding shape information. See @CollisionObject2D@ for shape index information. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. sig_body_shape_exited :: Godot.Internal.Dispatch.Signal RigidBody2D sig_body_shape_exited = Godot.Internal.Dispatch.Signal "body_shape_exited" instance NodeSignal RigidBody2D "body_shape_exited" '[Int, Node, Int, Int] -- | Emitted when the physics engine changes the body's sleeping state. -- __Note:__ Changing the value @sleeping@ will not trigger this signal. It is only emitted if the sleeping state is changed by the physics engine or @emit_signal("sleeping_state_changed")@ is used. sig_sleeping_state_changed :: Godot.Internal.Dispatch.Signal RigidBody2D sig_sleeping_state_changed = Godot.Internal.Dispatch.Signal "sleeping_state_changed" instance NodeSignal RigidBody2D "sleeping_state_changed" '[] instance NodeProperty RigidBody2D "angular_damp" Float 'False where nodeProperty = (get_angular_damp, wrapDroppingSetter set_angular_damp, Nothing) instance NodeProperty RigidBody2D "angular_velocity" Float 'False where nodeProperty = (get_angular_velocity, wrapDroppingSetter set_angular_velocity, Nothing) instance NodeProperty RigidBody2D "applied_force" Vector2 'False where nodeProperty = (get_applied_force, wrapDroppingSetter set_applied_force, Nothing) instance NodeProperty RigidBody2D "applied_torque" Float 'False where nodeProperty = (get_applied_torque, wrapDroppingSetter set_applied_torque, Nothing) instance NodeProperty RigidBody2D "bounce" Float 'False where nodeProperty = (get_bounce, wrapDroppingSetter set_bounce, Nothing) instance NodeProperty RigidBody2D "can_sleep" Bool 'False where nodeProperty = (is_able_to_sleep, wrapDroppingSetter set_can_sleep, Nothing) instance NodeProperty RigidBody2D "contact_monitor" Bool 'False where nodeProperty = (is_contact_monitor_enabled, wrapDroppingSetter set_contact_monitor, Nothing) instance NodeProperty RigidBody2D "contacts_reported" Int 'False where nodeProperty = (get_max_contacts_reported, wrapDroppingSetter set_max_contacts_reported, Nothing) instance NodeProperty RigidBody2D "continuous_cd" Int 'False where nodeProperty = (get_continuous_collision_detection_mode, wrapDroppingSetter set_continuous_collision_detection_mode, Nothing) instance NodeProperty RigidBody2D "custom_integrator" Bool 'False where nodeProperty = (is_using_custom_integrator, wrapDroppingSetter set_use_custom_integrator, Nothing) instance NodeProperty RigidBody2D "friction" Float 'False where nodeProperty = (get_friction, wrapDroppingSetter set_friction, Nothing) instance NodeProperty RigidBody2D "gravity_scale" Float 'False where nodeProperty = (get_gravity_scale, wrapDroppingSetter set_gravity_scale, Nothing) instance NodeProperty RigidBody2D "inertia" Float 'False where nodeProperty = (get_inertia, wrapDroppingSetter set_inertia, Nothing) instance NodeProperty RigidBody2D "linear_damp" Float 'False where nodeProperty = (get_linear_damp, wrapDroppingSetter set_linear_damp, Nothing) instance NodeProperty RigidBody2D "linear_velocity" Vector2 'False where nodeProperty = (get_linear_velocity, wrapDroppingSetter set_linear_velocity, Nothing) instance NodeProperty RigidBody2D "mass" Float 'False where nodeProperty = (get_mass, wrapDroppingSetter set_mass, Nothing) instance NodeProperty RigidBody2D "mode" Int 'False where nodeProperty = (get_mode, wrapDroppingSetter set_mode, Nothing) instance NodeProperty RigidBody2D "physics_material_override" PhysicsMaterial 'False where nodeProperty = (get_physics_material_override, wrapDroppingSetter set_physics_material_override, Nothing) instance NodeProperty RigidBody2D "sleeping" Bool 'False where nodeProperty = (is_sleeping, wrapDroppingSetter set_sleeping, Nothing) instance NodeProperty RigidBody2D "weight" Float 'False where nodeProperty = (get_weight, wrapDroppingSetter set_weight, Nothing) {-# NOINLINE bindRigidBody2D__body_enter_tree #-} bindRigidBody2D__body_enter_tree :: MethodBind bindRigidBody2D__body_enter_tree = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "_body_enter_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_enter_tree :: (RigidBody2D :< cls, Object :< cls) => cls -> Int -> IO () _body_enter_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D__body_enter_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "_body_enter_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody2D._body_enter_tree {-# NOINLINE bindRigidBody2D__body_exit_tree #-} bindRigidBody2D__body_exit_tree :: MethodBind bindRigidBody2D__body_exit_tree = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "_body_exit_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _body_exit_tree :: (RigidBody2D :< cls, Object :< cls) => cls -> Int -> IO () _body_exit_tree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D__body_exit_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "_body_exit_tree" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody2D._body_exit_tree {-# NOINLINE bindRigidBody2D__direct_state_changed #-} bindRigidBody2D__direct_state_changed :: MethodBind bindRigidBody2D__direct_state_changed = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "_direct_state_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _direct_state_changed :: (RigidBody2D :< cls, Object :< cls) => cls -> Object -> IO () _direct_state_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D__direct_state_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "_direct_state_changed" '[Object] (IO ()) where nodeMethod = Godot.Core.RigidBody2D._direct_state_changed {-# NOINLINE bindRigidBody2D__integrate_forces #-} -- | Allows you to read and safely modify the simulation state for the object. Use this instead of @method Node._physics_process@ if you need to directly change the body's @position@ or other physics properties. By default, it works in addition to the usual physics behavior, but @custom_integrator@ allows you to disable the default behavior and write custom force integration for a body. bindRigidBody2D__integrate_forces :: MethodBind bindRigidBody2D__integrate_forces = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "_integrate_forces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows you to read and safely modify the simulation state for the object. Use this instead of @method Node._physics_process@ if you need to directly change the body's @position@ or other physics properties. By default, it works in addition to the usual physics behavior, but @custom_integrator@ allows you to disable the default behavior and write custom force integration for a body. _integrate_forces :: (RigidBody2D :< cls, Object :< cls) => cls -> Physics2DDirectBodyState -> IO () _integrate_forces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D__integrate_forces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "_integrate_forces" '[Physics2DDirectBodyState] (IO ()) where nodeMethod = Godot.Core.RigidBody2D._integrate_forces {-# NOINLINE bindRigidBody2D__reload_physics_characteristics #-} bindRigidBody2D__reload_physics_characteristics :: MethodBind bindRigidBody2D__reload_physics_characteristics = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "_reload_physics_characteristics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _reload_physics_characteristics :: (RigidBody2D :< cls, Object :< cls) => cls -> IO () _reload_physics_characteristics cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D__reload_physics_characteristics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "_reload_physics_characteristics" '[] (IO ()) where nodeMethod = Godot.Core.RigidBody2D._reload_physics_characteristics {-# NOINLINE bindRigidBody2D_add_central_force #-} -- | Adds a constant directional force without affecting rotation. bindRigidBody2D_add_central_force :: MethodBind bindRigidBody2D_add_central_force = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "add_central_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant directional force without affecting rotation. add_central_force :: (RigidBody2D :< cls, Object :< cls) => cls -> Vector2 -> IO () add_central_force cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_add_central_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "add_central_force" '[Vector2] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.add_central_force {-# NOINLINE bindRigidBody2D_add_force #-} -- | Adds a positioned force to the body. Both the force and the offset from the body origin are in global coordinates. bindRigidBody2D_add_force :: MethodBind bindRigidBody2D_add_force = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "add_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a positioned force to the body. Both the force and the offset from the body origin are in global coordinates. add_force :: (RigidBody2D :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> IO () add_force cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_add_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "add_force" '[Vector2, Vector2] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.add_force {-# NOINLINE bindRigidBody2D_add_torque #-} -- | Adds a constant rotational force. bindRigidBody2D_add_torque :: MethodBind bindRigidBody2D_add_torque = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "add_torque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a constant rotational force. add_torque :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () add_torque cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_add_torque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "add_torque" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.add_torque {-# NOINLINE bindRigidBody2D_apply_central_impulse #-} -- | Applies a directional impulse without affecting rotation. bindRigidBody2D_apply_central_impulse :: MethodBind bindRigidBody2D_apply_central_impulse = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "apply_central_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a directional impulse without affecting rotation. apply_central_impulse :: (RigidBody2D :< cls, Object :< cls) => cls -> Vector2 -> IO () apply_central_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_apply_central_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "apply_central_impulse" '[Vector2] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.apply_central_impulse {-# NOINLINE bindRigidBody2D_apply_impulse #-} -- | Applies a positioned impulse to the body. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason it should only be used when simulating one-time impacts (use the "_force" functions otherwise). The position uses the rotation of the global coordinate system, but is centered at the object's origin. bindRigidBody2D_apply_impulse :: MethodBind bindRigidBody2D_apply_impulse = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "apply_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a positioned impulse to the body. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason it should only be used when simulating one-time impacts (use the "_force" functions otherwise). The position uses the rotation of the global coordinate system, but is centered at the object's origin. apply_impulse :: (RigidBody2D :< cls, Object :< cls) => cls -> Vector2 -> Vector2 -> IO () apply_impulse cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_apply_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "apply_impulse" '[Vector2, Vector2] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.apply_impulse {-# NOINLINE bindRigidBody2D_apply_torque_impulse #-} -- | Applies a rotational impulse to the body. bindRigidBody2D_apply_torque_impulse :: MethodBind bindRigidBody2D_apply_torque_impulse = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "apply_torque_impulse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies a rotational impulse to the body. apply_torque_impulse :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () apply_torque_impulse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_apply_torque_impulse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "apply_torque_impulse" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.apply_torque_impulse {-# NOINLINE bindRigidBody2D_get_angular_damp #-} -- | Damps the body's @angular_velocity@. If @-1@, the body will use the __Default Angular Damp__ defined in __Project > Project Settings > Physics > 2d__. bindRigidBody2D_get_angular_damp :: MethodBind bindRigidBody2D_get_angular_damp = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Damps the body's @angular_velocity@. If @-1@, the body will use the __Default Angular Damp__ defined in __Project > Project Settings > Physics > 2d__. get_angular_damp :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_angular_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_angular_damp" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_angular_damp {-# NOINLINE bindRigidBody2D_get_angular_velocity #-} -- | The body's rotational velocity. bindRigidBody2D_get_angular_velocity :: MethodBind bindRigidBody2D_get_angular_velocity = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's rotational velocity. get_angular_velocity :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_angular_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_angular_velocity" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_angular_velocity {-# NOINLINE bindRigidBody2D_get_applied_force #-} -- | The body's total applied force. bindRigidBody2D_get_applied_force :: MethodBind bindRigidBody2D_get_applied_force = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_applied_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's total applied force. get_applied_force :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Vector2 get_applied_force cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_applied_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_applied_force" '[] (IO Vector2) where nodeMethod = Godot.Core.RigidBody2D.get_applied_force {-# NOINLINE bindRigidBody2D_get_applied_torque #-} -- | The body's total applied torque. bindRigidBody2D_get_applied_torque :: MethodBind bindRigidBody2D_get_applied_torque = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_applied_torque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's total applied torque. get_applied_torque :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_applied_torque cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_applied_torque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_applied_torque" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_applied_torque {-# NOINLINE bindRigidBody2D_get_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. bindRigidBody2D_get_bounce :: MethodBind bindRigidBody2D_get_bounce = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. get_bounce :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_bounce cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_bounce" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_bounce {-# NOINLINE bindRigidBody2D_get_colliding_bodies #-} -- | Returns a list of the bodies colliding with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of collisions is updated once per frame and before the physics step. Consider using signals instead. bindRigidBody2D_get_colliding_bodies :: MethodBind bindRigidBody2D_get_colliding_bodies = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_colliding_bodies" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of the bodies colliding with this one. Requires @contact_monitor@ to be set to @true@ and @contacts_reported@ to be set high enough to detect all the collisions. -- __Note:__ The result of this test is not immediate after moving objects. For performance, list of collisions is updated once per frame and before the physics step. Consider using signals instead. get_colliding_bodies :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Array get_colliding_bodies cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_colliding_bodies (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_colliding_bodies" '[] (IO Array) where nodeMethod = Godot.Core.RigidBody2D.get_colliding_bodies {-# NOINLINE bindRigidBody2D_get_continuous_collision_detection_mode #-} -- | Continuous collision detection mode. -- Continuous collision detection tries to predict where a moving body will collide instead of moving it and correcting its movement after collision. Continuous collision detection is slower, but more precise and misses fewer collisions with small, fast-moving objects. Raycasting and shapecasting methods are available. See @enum CCDMode@ for details. bindRigidBody2D_get_continuous_collision_detection_mode :: MethodBind bindRigidBody2D_get_continuous_collision_detection_mode = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_continuous_collision_detection_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Continuous collision detection mode. -- Continuous collision detection tries to predict where a moving body will collide instead of moving it and correcting its movement after collision. Continuous collision detection is slower, but more precise and misses fewer collisions with small, fast-moving objects. Raycasting and shapecasting methods are available. See @enum CCDMode@ for details. get_continuous_collision_detection_mode :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Int get_continuous_collision_detection_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_continuous_collision_detection_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_continuous_collision_detection_mode" '[] (IO Int) where nodeMethod = Godot.Core.RigidBody2D.get_continuous_collision_detection_mode {-# NOINLINE bindRigidBody2D_get_friction #-} -- | The body's friction. Values range from @0@ (frictionless) to @1@ (maximum friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. bindRigidBody2D_get_friction :: MethodBind bindRigidBody2D_get_friction = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction. Values range from @0@ (frictionless) to @1@ (maximum friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. get_friction :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_friction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_friction" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_friction {-# NOINLINE bindRigidBody2D_get_gravity_scale #-} -- | Multiplies the gravity applied to the body. The body's gravity is calculated from the __Default Gravity__ value in __Project > Project Settings > Physics > 2d__ and/or any additional gravity vector applied by @Area2D@s. bindRigidBody2D_get_gravity_scale :: MethodBind bindRigidBody2D_get_gravity_scale = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_gravity_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the gravity applied to the body. The body's gravity is calculated from the __Default Gravity__ value in __Project > Project Settings > Physics > 2d__ and/or any additional gravity vector applied by @Area2D@s. get_gravity_scale :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_gravity_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_gravity_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_gravity_scale" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_gravity_scale {-# NOINLINE bindRigidBody2D_get_inertia #-} -- | The body's moment of inertia. This is like mass, but for rotation: it determines how much torque it takes to rotate the body. The moment of inertia is usually computed automatically from the mass and the shapes, but this function allows you to set a custom value. Set 0 inertia to return to automatically computing it. bindRigidBody2D_get_inertia :: MethodBind bindRigidBody2D_get_inertia = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_inertia" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's moment of inertia. This is like mass, but for rotation: it determines how much torque it takes to rotate the body. The moment of inertia is usually computed automatically from the mass and the shapes, but this function allows you to set a custom value. Set 0 inertia to return to automatically computing it. get_inertia :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_inertia cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_inertia (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_inertia" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_inertia {-# NOINLINE bindRigidBody2D_get_linear_damp #-} -- | Damps the body's @linear_velocity@. If @-1@, the body will use the __Default Linear Damp__ in __Project > Project Settings > Physics > 2d__. bindRigidBody2D_get_linear_damp :: MethodBind bindRigidBody2D_get_linear_damp = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Damps the body's @linear_velocity@. If @-1@, the body will use the __Default Linear Damp__ in __Project > Project Settings > Physics > 2d__. get_linear_damp :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_linear_damp cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_linear_damp" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_linear_damp {-# NOINLINE bindRigidBody2D_get_linear_velocity #-} -- | The body's linear velocity. bindRigidBody2D_get_linear_velocity :: MethodBind bindRigidBody2D_get_linear_velocity = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear velocity. get_linear_velocity :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Vector2 get_linear_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_linear_velocity" '[] (IO Vector2) where nodeMethod = Godot.Core.RigidBody2D.get_linear_velocity {-# NOINLINE bindRigidBody2D_get_mass #-} -- | The body's mass. bindRigidBody2D_get_mass :: MethodBind bindRigidBody2D_get_mass = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's mass. get_mass :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_mass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_mass" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_mass {-# NOINLINE bindRigidBody2D_get_max_contacts_reported #-} -- | The maximum number of contacts that will be recorded. Requires @contact_monitor@ to be set to @true@. -- __Note:__ The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner). bindRigidBody2D_get_max_contacts_reported :: MethodBind bindRigidBody2D_get_max_contacts_reported = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_max_contacts_reported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum number of contacts that will be recorded. Requires @contact_monitor@ to be set to @true@. -- __Note:__ The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner). get_max_contacts_reported :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Int get_max_contacts_reported cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_max_contacts_reported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_max_contacts_reported" '[] (IO Int) where nodeMethod = Godot.Core.RigidBody2D.get_max_contacts_reported {-# NOINLINE bindRigidBody2D_get_mode #-} -- | The body's mode. See @enum Mode@ for possible values. bindRigidBody2D_get_mode :: MethodBind bindRigidBody2D_get_mode = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's mode. See @enum Mode@ for possible values. get_mode :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_mode" '[] (IO Int) where nodeMethod = Godot.Core.RigidBody2D.get_mode {-# NOINLINE bindRigidBody2D_get_physics_material_override #-} -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. bindRigidBody2D_get_physics_material_override :: MethodBind bindRigidBody2D_get_physics_material_override = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_physics_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. get_physics_material_override :: (RigidBody2D :< cls, Object :< cls) => cls -> IO PhysicsMaterial get_physics_material_override cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_physics_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_physics_material_override" '[] (IO PhysicsMaterial) where nodeMethod = Godot.Core.RigidBody2D.get_physics_material_override {-# NOINLINE bindRigidBody2D_get_weight #-} -- | The body's weight based on its mass and the __Default Gravity__ value in __Project > Project Settings > Physics > 2d__. bindRigidBody2D_get_weight :: MethodBind bindRigidBody2D_get_weight = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "get_weight" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's weight based on its mass and the __Default Gravity__ value in __Project > Project Settings > Physics > 2d__. get_weight :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Float get_weight cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_get_weight (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "get_weight" '[] (IO Float) where nodeMethod = Godot.Core.RigidBody2D.get_weight {-# NOINLINE bindRigidBody2D_is_able_to_sleep #-} -- | If @true@, the body can enter sleep mode when there is no movement. See @sleeping@. -- __Note:__ A RigidBody2D will never enter sleep mode automatically if its @mode@ is @MODE_CHARACTER@. It can still be put to sleep manually by setting its @sleeping@ property to @true@. bindRigidBody2D_is_able_to_sleep :: MethodBind bindRigidBody2D_is_able_to_sleep = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "is_able_to_sleep" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body can enter sleep mode when there is no movement. See @sleeping@. -- __Note:__ A RigidBody2D will never enter sleep mode automatically if its @mode@ is @MODE_CHARACTER@. It can still be put to sleep manually by setting its @sleeping@ property to @true@. is_able_to_sleep :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Bool is_able_to_sleep cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_is_able_to_sleep (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "is_able_to_sleep" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody2D.is_able_to_sleep {-# NOINLINE bindRigidBody2D_is_contact_monitor_enabled #-} -- | If @true@, the body will emit signals when it collides with another RigidBody2D. See also @contacts_reported@. bindRigidBody2D_is_contact_monitor_enabled :: MethodBind bindRigidBody2D_is_contact_monitor_enabled = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "is_contact_monitor_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body will emit signals when it collides with another RigidBody2D. See also @contacts_reported@. is_contact_monitor_enabled :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Bool is_contact_monitor_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_is_contact_monitor_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "is_contact_monitor_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody2D.is_contact_monitor_enabled {-# NOINLINE bindRigidBody2D_is_sleeping #-} -- | If @true@, the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the @method apply_impulse@ or @method add_force@ methods. bindRigidBody2D_is_sleeping :: MethodBind bindRigidBody2D_is_sleeping = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "is_sleeping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the @method apply_impulse@ or @method add_force@ methods. is_sleeping :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Bool is_sleeping cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_is_sleeping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "is_sleeping" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody2D.is_sleeping {-# NOINLINE bindRigidBody2D_is_using_custom_integrator #-} -- | If @true@, internal force integration is disabled for this body. Aside from collision response, the body will only move as determined by the @method _integrate_forces@ function. bindRigidBody2D_is_using_custom_integrator :: MethodBind bindRigidBody2D_is_using_custom_integrator = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "is_using_custom_integrator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, internal force integration is disabled for this body. Aside from collision response, the body will only move as determined by the @method _integrate_forces@ function. is_using_custom_integrator :: (RigidBody2D :< cls, Object :< cls) => cls -> IO Bool is_using_custom_integrator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_is_using_custom_integrator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "is_using_custom_integrator" '[] (IO Bool) where nodeMethod = Godot.Core.RigidBody2D.is_using_custom_integrator {-# NOINLINE bindRigidBody2D_set_angular_damp #-} -- | Damps the body's @angular_velocity@. If @-1@, the body will use the __Default Angular Damp__ defined in __Project > Project Settings > Physics > 2d__. bindRigidBody2D_set_angular_damp :: MethodBind bindRigidBody2D_set_angular_damp = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_angular_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Damps the body's @angular_velocity@. If @-1@, the body will use the __Default Angular Damp__ defined in __Project > Project Settings > Physics > 2d__. set_angular_damp :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_angular_damp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_angular_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_angular_damp" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_angular_damp {-# NOINLINE bindRigidBody2D_set_angular_velocity #-} -- | The body's rotational velocity. bindRigidBody2D_set_angular_velocity :: MethodBind bindRigidBody2D_set_angular_velocity = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's rotational velocity. set_angular_velocity :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_angular_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_angular_velocity" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_angular_velocity {-# NOINLINE bindRigidBody2D_set_applied_force #-} -- | The body's total applied force. bindRigidBody2D_set_applied_force :: MethodBind bindRigidBody2D_set_applied_force = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_applied_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's total applied force. set_applied_force :: (RigidBody2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_applied_force cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_applied_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_applied_force" '[Vector2] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_applied_force {-# NOINLINE bindRigidBody2D_set_applied_torque #-} -- | The body's total applied torque. bindRigidBody2D_set_applied_torque :: MethodBind bindRigidBody2D_set_applied_torque = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_applied_torque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's total applied torque. set_applied_torque :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_applied_torque cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_applied_torque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_applied_torque" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_applied_torque {-# NOINLINE bindRigidBody2D_set_axis_velocity #-} -- | Sets the body's velocity on the given axis. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior. bindRigidBody2D_set_axis_velocity :: MethodBind bindRigidBody2D_set_axis_velocity = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_axis_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the body's velocity on the given axis. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior. set_axis_velocity :: (RigidBody2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_axis_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_axis_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_axis_velocity" '[Vector2] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_axis_velocity {-# NOINLINE bindRigidBody2D_set_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. bindRigidBody2D_set_bounce :: MethodBind bindRigidBody2D_set_bounce = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. set_bounce :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_bounce cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_bounce" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_bounce {-# NOINLINE bindRigidBody2D_set_can_sleep #-} -- | If @true@, the body can enter sleep mode when there is no movement. See @sleeping@. -- __Note:__ A RigidBody2D will never enter sleep mode automatically if its @mode@ is @MODE_CHARACTER@. It can still be put to sleep manually by setting its @sleeping@ property to @true@. bindRigidBody2D_set_can_sleep :: MethodBind bindRigidBody2D_set_can_sleep = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_can_sleep" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body can enter sleep mode when there is no movement. See @sleeping@. -- __Note:__ A RigidBody2D will never enter sleep mode automatically if its @mode@ is @MODE_CHARACTER@. It can still be put to sleep manually by setting its @sleeping@ property to @true@. set_can_sleep :: (RigidBody2D :< cls, Object :< cls) => cls -> Bool -> IO () set_can_sleep cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_can_sleep (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_can_sleep" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_can_sleep {-# NOINLINE bindRigidBody2D_set_contact_monitor #-} -- | If @true@, the body will emit signals when it collides with another RigidBody2D. See also @contacts_reported@. bindRigidBody2D_set_contact_monitor :: MethodBind bindRigidBody2D_set_contact_monitor = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_contact_monitor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body will emit signals when it collides with another RigidBody2D. See also @contacts_reported@. set_contact_monitor :: (RigidBody2D :< cls, Object :< cls) => cls -> Bool -> IO () set_contact_monitor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_contact_monitor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_contact_monitor" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_contact_monitor {-# NOINLINE bindRigidBody2D_set_continuous_collision_detection_mode #-} -- | Continuous collision detection mode. -- Continuous collision detection tries to predict where a moving body will collide instead of moving it and correcting its movement after collision. Continuous collision detection is slower, but more precise and misses fewer collisions with small, fast-moving objects. Raycasting and shapecasting methods are available. See @enum CCDMode@ for details. bindRigidBody2D_set_continuous_collision_detection_mode :: MethodBind bindRigidBody2D_set_continuous_collision_detection_mode = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_continuous_collision_detection_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Continuous collision detection mode. -- Continuous collision detection tries to predict where a moving body will collide instead of moving it and correcting its movement after collision. Continuous collision detection is slower, but more precise and misses fewer collisions with small, fast-moving objects. Raycasting and shapecasting methods are available. See @enum CCDMode@ for details. set_continuous_collision_detection_mode :: (RigidBody2D :< cls, Object :< cls) => cls -> Int -> IO () set_continuous_collision_detection_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_continuous_collision_detection_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_continuous_collision_detection_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_continuous_collision_detection_mode {-# NOINLINE bindRigidBody2D_set_friction #-} -- | The body's friction. Values range from @0@ (frictionless) to @1@ (maximum friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. bindRigidBody2D_set_friction :: MethodBind bindRigidBody2D_set_friction = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction. Values range from @0@ (frictionless) to @1@ (maximum friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. set_friction :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_friction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_friction" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_friction {-# NOINLINE bindRigidBody2D_set_gravity_scale #-} -- | Multiplies the gravity applied to the body. The body's gravity is calculated from the __Default Gravity__ value in __Project > Project Settings > Physics > 2d__ and/or any additional gravity vector applied by @Area2D@s. bindRigidBody2D_set_gravity_scale :: MethodBind bindRigidBody2D_set_gravity_scale = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_gravity_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the gravity applied to the body. The body's gravity is calculated from the __Default Gravity__ value in __Project > Project Settings > Physics > 2d__ and/or any additional gravity vector applied by @Area2D@s. set_gravity_scale :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_gravity_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_gravity_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_gravity_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_gravity_scale {-# NOINLINE bindRigidBody2D_set_inertia #-} -- | The body's moment of inertia. This is like mass, but for rotation: it determines how much torque it takes to rotate the body. The moment of inertia is usually computed automatically from the mass and the shapes, but this function allows you to set a custom value. Set 0 inertia to return to automatically computing it. bindRigidBody2D_set_inertia :: MethodBind bindRigidBody2D_set_inertia = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_inertia" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's moment of inertia. This is like mass, but for rotation: it determines how much torque it takes to rotate the body. The moment of inertia is usually computed automatically from the mass and the shapes, but this function allows you to set a custom value. Set 0 inertia to return to automatically computing it. set_inertia :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_inertia cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_inertia (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_inertia" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_inertia {-# NOINLINE bindRigidBody2D_set_linear_damp #-} -- | Damps the body's @linear_velocity@. If @-1@, the body will use the __Default Linear Damp__ in __Project > Project Settings > Physics > 2d__. bindRigidBody2D_set_linear_damp :: MethodBind bindRigidBody2D_set_linear_damp = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_linear_damp" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Damps the body's @linear_velocity@. If @-1@, the body will use the __Default Linear Damp__ in __Project > Project Settings > Physics > 2d__. set_linear_damp :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_linear_damp cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_linear_damp (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_linear_damp" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_linear_damp {-# NOINLINE bindRigidBody2D_set_linear_velocity #-} -- | The body's linear velocity. bindRigidBody2D_set_linear_velocity :: MethodBind bindRigidBody2D_set_linear_velocity = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's linear velocity. set_linear_velocity :: (RigidBody2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_linear_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_linear_velocity" '[Vector2] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_linear_velocity {-# NOINLINE bindRigidBody2D_set_mass #-} -- | The body's mass. bindRigidBody2D_set_mass :: MethodBind bindRigidBody2D_set_mass = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's mass. set_mass :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_mass cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_mass" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_mass {-# NOINLINE bindRigidBody2D_set_max_contacts_reported #-} -- | The maximum number of contacts that will be recorded. Requires @contact_monitor@ to be set to @true@. -- __Note:__ The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner). bindRigidBody2D_set_max_contacts_reported :: MethodBind bindRigidBody2D_set_max_contacts_reported = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_max_contacts_reported" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum number of contacts that will be recorded. Requires @contact_monitor@ to be set to @true@. -- __Note:__ The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner). set_max_contacts_reported :: (RigidBody2D :< cls, Object :< cls) => cls -> Int -> IO () set_max_contacts_reported cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_max_contacts_reported (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_max_contacts_reported" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_max_contacts_reported {-# NOINLINE bindRigidBody2D_set_mode #-} -- | The body's mode. See @enum Mode@ for possible values. bindRigidBody2D_set_mode :: MethodBind bindRigidBody2D_set_mode = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's mode. See @enum Mode@ for possible values. set_mode :: (RigidBody2D :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_mode {-# NOINLINE bindRigidBody2D_set_physics_material_override #-} -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. bindRigidBody2D_set_physics_material_override :: MethodBind bindRigidBody2D_set_physics_material_override = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_physics_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. set_physics_material_override :: (RigidBody2D :< cls, Object :< cls) => cls -> PhysicsMaterial -> IO () set_physics_material_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_physics_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_physics_material_override" '[PhysicsMaterial] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_physics_material_override {-# NOINLINE bindRigidBody2D_set_sleeping #-} -- | If @true@, the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the @method apply_impulse@ or @method add_force@ methods. bindRigidBody2D_set_sleeping :: MethodBind bindRigidBody2D_set_sleeping = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_sleeping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the @method apply_impulse@ or @method add_force@ methods. set_sleeping :: (RigidBody2D :< cls, Object :< cls) => cls -> Bool -> IO () set_sleeping cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_sleeping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_sleeping" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_sleeping {-# NOINLINE bindRigidBody2D_set_use_custom_integrator #-} -- | If @true@, internal force integration is disabled for this body. Aside from collision response, the body will only move as determined by the @method _integrate_forces@ function. bindRigidBody2D_set_use_custom_integrator :: MethodBind bindRigidBody2D_set_use_custom_integrator = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_use_custom_integrator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, internal force integration is disabled for this body. Aside from collision response, the body will only move as determined by the @method _integrate_forces@ function. set_use_custom_integrator :: (RigidBody2D :< cls, Object :< cls) => cls -> Bool -> IO () set_use_custom_integrator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_use_custom_integrator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_use_custom_integrator" '[Bool] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_use_custom_integrator {-# NOINLINE bindRigidBody2D_set_weight #-} -- | The body's weight based on its mass and the __Default Gravity__ value in __Project > Project Settings > Physics > 2d__. bindRigidBody2D_set_weight :: MethodBind bindRigidBody2D_set_weight = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "set_weight" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's weight based on its mass and the __Default Gravity__ value in __Project > Project Settings > Physics > 2d__. set_weight :: (RigidBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_weight cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_set_weight (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "set_weight" '[Float] (IO ()) where nodeMethod = Godot.Core.RigidBody2D.set_weight {-# NOINLINE bindRigidBody2D_test_motion #-} -- | Returns @true@ if a collision would result from moving in the given vector. @margin@ increases the size of the shapes involved in the collision detection, and @result@ is an object of type @Physics2DTestMotionResult@, which contains additional information about the collision (should there be one). bindRigidBody2D_test_motion :: MethodBind bindRigidBody2D_test_motion = unsafePerformIO $ withCString "RigidBody2D" $ \ clsNamePtr -> withCString "test_motion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a collision would result from moving in the given vector. @margin@ increases the size of the shapes involved in the collision detection, and @result@ is an object of type @Physics2DTestMotionResult@, which contains additional information about the collision (should there be one). test_motion :: (RigidBody2D :< cls, Object :< cls) => cls -> Vector2 -> Maybe Bool -> Maybe Float -> Maybe Physics2DTestMotionResult -> IO Bool test_motion cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2, maybe (VariantReal (0.08)) toVariant arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindRigidBody2D_test_motion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RigidBody2D "test_motion" '[Vector2, Maybe Bool, Maybe Float, Maybe Physics2DTestMotionResult] (IO Bool) where nodeMethod = Godot.Core.RigidBody2D.test_motion ================================================ FILE: src/Godot/Core/RootMotionView.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.RootMotionView (Godot.Core.RootMotionView.get_animation_path, Godot.Core.RootMotionView.set_animation_path, Godot.Core.RootMotionView.get_cell_size, Godot.Core.RootMotionView.set_cell_size, Godot.Core.RootMotionView.get_color, Godot.Core.RootMotionView.set_color, Godot.Core.RootMotionView.get_radius, Godot.Core.RootMotionView.set_radius, Godot.Core.RootMotionView.get_zero_y, Godot.Core.RootMotionView.set_zero_y) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualInstance() {-# NOINLINE bindRootMotionView_get_animation_path #-} bindRootMotionView_get_animation_path :: MethodBind bindRootMotionView_get_animation_path = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "get_animation_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_animation_path :: (RootMotionView :< cls, Object :< cls) => cls -> IO NodePath get_animation_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_get_animation_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "get_animation_path" '[] (IO NodePath) where nodeMethod = Godot.Core.RootMotionView.get_animation_path {-# NOINLINE bindRootMotionView_set_animation_path #-} bindRootMotionView_set_animation_path :: MethodBind bindRootMotionView_set_animation_path = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "set_animation_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_animation_path :: (RootMotionView :< cls, Object :< cls) => cls -> NodePath -> IO () set_animation_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_set_animation_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "set_animation_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.RootMotionView.set_animation_path instance NodeProperty RootMotionView "animation_path" NodePath 'False where nodeProperty = (get_animation_path, wrapDroppingSetter set_animation_path, Nothing) {-# NOINLINE bindRootMotionView_get_cell_size #-} bindRootMotionView_get_cell_size :: MethodBind bindRootMotionView_get_cell_size = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "get_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_cell_size :: (RootMotionView :< cls, Object :< cls) => cls -> IO Float get_cell_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_get_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "get_cell_size" '[] (IO Float) where nodeMethod = Godot.Core.RootMotionView.get_cell_size {-# NOINLINE bindRootMotionView_set_cell_size #-} bindRootMotionView_set_cell_size :: MethodBind bindRootMotionView_set_cell_size = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "set_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_cell_size :: (RootMotionView :< cls, Object :< cls) => cls -> Float -> IO () set_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_set_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "set_cell_size" '[Float] (IO ()) where nodeMethod = Godot.Core.RootMotionView.set_cell_size instance NodeProperty RootMotionView "cell_size" Float 'False where nodeProperty = (get_cell_size, wrapDroppingSetter set_cell_size, Nothing) {-# NOINLINE bindRootMotionView_get_color #-} bindRootMotionView_get_color :: MethodBind bindRootMotionView_get_color = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_color :: (RootMotionView :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "get_color" '[] (IO Color) where nodeMethod = Godot.Core.RootMotionView.get_color {-# NOINLINE bindRootMotionView_set_color #-} bindRootMotionView_set_color :: MethodBind bindRootMotionView_set_color = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_color :: (RootMotionView :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.RootMotionView.set_color instance NodeProperty RootMotionView "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) {-# NOINLINE bindRootMotionView_get_radius #-} bindRootMotionView_get_radius :: MethodBind bindRootMotionView_get_radius = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_radius :: (RootMotionView :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.RootMotionView.get_radius {-# NOINLINE bindRootMotionView_set_radius #-} bindRootMotionView_set_radius :: MethodBind bindRootMotionView_set_radius = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_radius :: (RootMotionView :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.RootMotionView.set_radius instance NodeProperty RootMotionView "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) {-# NOINLINE bindRootMotionView_get_zero_y #-} bindRootMotionView_get_zero_y :: MethodBind bindRootMotionView_get_zero_y = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "get_zero_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_zero_y :: (RootMotionView :< cls, Object :< cls) => cls -> IO Bool get_zero_y cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_get_zero_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "get_zero_y" '[] (IO Bool) where nodeMethod = Godot.Core.RootMotionView.get_zero_y {-# NOINLINE bindRootMotionView_set_zero_y #-} bindRootMotionView_set_zero_y :: MethodBind bindRootMotionView_set_zero_y = unsafePerformIO $ withCString "RootMotionView" $ \ clsNamePtr -> withCString "set_zero_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_zero_y :: (RootMotionView :< cls, Object :< cls) => cls -> Bool -> IO () set_zero_y cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindRootMotionView_set_zero_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod RootMotionView "set_zero_y" '[Bool] (IO ()) where nodeMethod = Godot.Core.RootMotionView.set_zero_y instance NodeProperty RootMotionView "zero_y" Bool 'False where nodeProperty = (get_zero_y, wrapDroppingSetter set_zero_y, Nothing) ================================================ FILE: src/Godot/Core/SceneState.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SceneState (Godot.Core.SceneState._GEN_EDIT_STATE_DISABLED, Godot.Core.SceneState._GEN_EDIT_STATE_MAIN, Godot.Core.SceneState._GEN_EDIT_STATE_INSTANCE, Godot.Core.SceneState.get_connection_binds, Godot.Core.SceneState.get_connection_count, Godot.Core.SceneState.get_connection_flags, Godot.Core.SceneState.get_connection_method, Godot.Core.SceneState.get_connection_signal, Godot.Core.SceneState.get_connection_source, Godot.Core.SceneState.get_connection_target, Godot.Core.SceneState.get_node_count, Godot.Core.SceneState.get_node_groups, Godot.Core.SceneState.get_node_index, Godot.Core.SceneState.get_node_instance, Godot.Core.SceneState.get_node_instance_placeholder, Godot.Core.SceneState.get_node_name, Godot.Core.SceneState.get_node_owner_path, Godot.Core.SceneState.get_node_path, Godot.Core.SceneState.get_node_property_count, Godot.Core.SceneState.get_node_property_name, Godot.Core.SceneState.get_node_property_value, Godot.Core.SceneState.get_node_type, Godot.Core.SceneState.is_node_instance_placeholder) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _GEN_EDIT_STATE_DISABLED :: Int _GEN_EDIT_STATE_DISABLED = 0 _GEN_EDIT_STATE_MAIN :: Int _GEN_EDIT_STATE_MAIN = 2 _GEN_EDIT_STATE_INSTANCE :: Int _GEN_EDIT_STATE_INSTANCE = 1 {-# NOINLINE bindSceneState_get_connection_binds #-} -- | Returns the list of bound parameters for the signal at @idx@. bindSceneState_get_connection_binds :: MethodBind bindSceneState_get_connection_binds = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_connection_binds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of bound parameters for the signal at @idx@. get_connection_binds :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO Array get_connection_binds cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_connection_binds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_connection_binds" '[Int] (IO Array) where nodeMethod = Godot.Core.SceneState.get_connection_binds {-# NOINLINE bindSceneState_get_connection_count #-} -- | Returns the number of signal connections in the scene. -- The @idx@ argument used to query connection metadata in other @get_connection_*@ methods in the interval @@0, get_connection_count() - 1@@. bindSceneState_get_connection_count :: MethodBind bindSceneState_get_connection_count = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_connection_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of signal connections in the scene. -- The @idx@ argument used to query connection metadata in other @get_connection_*@ methods in the interval @@0, get_connection_count() - 1@@. get_connection_count :: (SceneState :< cls, Object :< cls) => cls -> IO Int get_connection_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_connection_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_connection_count" '[] (IO Int) where nodeMethod = Godot.Core.SceneState.get_connection_count {-# NOINLINE bindSceneState_get_connection_flags #-} -- | Returns the connection flags for the signal at @idx@. See @enum Object.ConnectFlags@ constants. bindSceneState_get_connection_flags :: MethodBind bindSceneState_get_connection_flags = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_connection_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the connection flags for the signal at @idx@. See @enum Object.ConnectFlags@ constants. get_connection_flags :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO Int get_connection_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_connection_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_connection_flags" '[Int] (IO Int) where nodeMethod = Godot.Core.SceneState.get_connection_flags {-# NOINLINE bindSceneState_get_connection_method #-} -- | Returns the method connected to the signal at @idx@. bindSceneState_get_connection_method :: MethodBind bindSceneState_get_connection_method = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_connection_method" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the method connected to the signal at @idx@. get_connection_method :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO GodotString get_connection_method cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_connection_method (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_connection_method" '[Int] (IO GodotString) where nodeMethod = Godot.Core.SceneState.get_connection_method {-# NOINLINE bindSceneState_get_connection_signal #-} -- | Returns the name of the signal at @idx@. bindSceneState_get_connection_signal :: MethodBind bindSceneState_get_connection_signal = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_connection_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the signal at @idx@. get_connection_signal :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO GodotString get_connection_signal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_connection_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_connection_signal" '[Int] (IO GodotString) where nodeMethod = Godot.Core.SceneState.get_connection_signal {-# NOINLINE bindSceneState_get_connection_source #-} -- | Returns the path to the node that owns the signal at @idx@, relative to the root node. bindSceneState_get_connection_source :: MethodBind bindSceneState_get_connection_source = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_connection_source" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to the node that owns the signal at @idx@, relative to the root node. get_connection_source :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO NodePath get_connection_source cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_connection_source (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_connection_source" '[Int] (IO NodePath) where nodeMethod = Godot.Core.SceneState.get_connection_source {-# NOINLINE bindSceneState_get_connection_target #-} -- | Returns the path to the node that owns the method connected to the signal at @idx@, relative to the root node. bindSceneState_get_connection_target :: MethodBind bindSceneState_get_connection_target = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_connection_target" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to the node that owns the method connected to the signal at @idx@, relative to the root node. get_connection_target :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO NodePath get_connection_target cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_connection_target (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_connection_target" '[Int] (IO NodePath) where nodeMethod = Godot.Core.SceneState.get_connection_target {-# NOINLINE bindSceneState_get_node_count #-} -- | Returns the number of nodes in the scene. -- The @idx@ argument used to query node data in other @get_node_*@ methods in the interval @@0, get_node_count() - 1@@. bindSceneState_get_node_count :: MethodBind bindSceneState_get_node_count = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of nodes in the scene. -- The @idx@ argument used to query node data in other @get_node_*@ methods in the interval @@0, get_node_count() - 1@@. get_node_count :: (SceneState :< cls, Object :< cls) => cls -> IO Int get_node_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_count" '[] (IO Int) where nodeMethod = Godot.Core.SceneState.get_node_count {-# NOINLINE bindSceneState_get_node_groups #-} -- | Returns the list of group names associated with the node at @idx@. bindSceneState_get_node_groups :: MethodBind bindSceneState_get_node_groups = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_groups" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of group names associated with the node at @idx@. get_node_groups :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO PoolStringArray get_node_groups cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_groups (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_groups" '[Int] (IO PoolStringArray) where nodeMethod = Godot.Core.SceneState.get_node_groups {-# NOINLINE bindSceneState_get_node_index #-} -- | Returns the node's index, which is its position relative to its siblings. This is only relevant and saved in scenes for cases where new nodes are added to an instanced or inherited scene among siblings from the base scene. Despite the name, this index is not related to the @idx@ argument used here and in other methods. bindSceneState_get_node_index :: MethodBind bindSceneState_get_node_index = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the node's index, which is its position relative to its siblings. This is only relevant and saved in scenes for cases where new nodes are added to an instanced or inherited scene among siblings from the base scene. Despite the name, this index is not related to the @idx@ argument used here and in other methods. get_node_index :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO Int get_node_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_index" '[Int] (IO Int) where nodeMethod = Godot.Core.SceneState.get_node_index {-# NOINLINE bindSceneState_get_node_instance #-} -- | Returns a @PackedScene@ for the node at @idx@ (i.e. the whole branch starting at this node, with its child nodes and resources), or @null@ if the node is not an instance. bindSceneState_get_node_instance :: MethodBind bindSceneState_get_node_instance = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @PackedScene@ for the node at @idx@ (i.e. the whole branch starting at this node, with its child nodes and resources), or @null@ if the node is not an instance. get_node_instance :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO PackedScene get_node_instance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_instance" '[Int] (IO PackedScene) where nodeMethod = Godot.Core.SceneState.get_node_instance {-# NOINLINE bindSceneState_get_node_instance_placeholder #-} -- | Returns the path to the represented scene file if the node at @idx@ is an @InstancePlaceholder@. bindSceneState_get_node_instance_placeholder :: MethodBind bindSceneState_get_node_instance_placeholder = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_instance_placeholder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to the represented scene file if the node at @idx@ is an @InstancePlaceholder@. get_node_instance_placeholder :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO GodotString get_node_instance_placeholder cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_instance_placeholder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_instance_placeholder" '[Int] (IO GodotString) where nodeMethod = Godot.Core.SceneState.get_node_instance_placeholder {-# NOINLINE bindSceneState_get_node_name #-} -- | Returns the name of the node at @idx@. bindSceneState_get_node_name :: MethodBind bindSceneState_get_node_name = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the node at @idx@. get_node_name :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO GodotString get_node_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.SceneState.get_node_name {-# NOINLINE bindSceneState_get_node_owner_path #-} -- | Returns the path to the owner of the node at @idx@, relative to the root node. bindSceneState_get_node_owner_path :: MethodBind bindSceneState_get_node_owner_path = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_owner_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to the owner of the node at @idx@, relative to the root node. get_node_owner_path :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO NodePath get_node_owner_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_owner_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_owner_path" '[Int] (IO NodePath) where nodeMethod = Godot.Core.SceneState.get_node_owner_path {-# NOINLINE bindSceneState_get_node_path #-} -- | Returns the path to the node at @idx@. -- If @for_parent@ is @true@, returns the path of the @idx@ node's parent instead. bindSceneState_get_node_path :: MethodBind bindSceneState_get_node_path = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to the node at @idx@. -- If @for_parent@ is @true@, returns the path of the @idx@ node's parent instead. get_node_path :: (SceneState :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO NodePath get_node_path cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_path" '[Int, Maybe Bool] (IO NodePath) where nodeMethod = Godot.Core.SceneState.get_node_path {-# NOINLINE bindSceneState_get_node_property_count #-} -- | Returns the number of exported or overridden properties for the node at @idx@. -- The @prop_idx@ argument used to query node property data in other @get_node_property_*@ methods in the interval @@0, get_node_property_count() - 1@@. bindSceneState_get_node_property_count :: MethodBind bindSceneState_get_node_property_count = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_property_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of exported or overridden properties for the node at @idx@. -- The @prop_idx@ argument used to query node property data in other @get_node_property_*@ methods in the interval @@0, get_node_property_count() - 1@@. get_node_property_count :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO Int get_node_property_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_property_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_property_count" '[Int] (IO Int) where nodeMethod = Godot.Core.SceneState.get_node_property_count {-# NOINLINE bindSceneState_get_node_property_name #-} -- | Returns the name of the property at @prop_idx@ for the node at @idx@. bindSceneState_get_node_property_name :: MethodBind bindSceneState_get_node_property_name = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_property_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the property at @prop_idx@ for the node at @idx@. get_node_property_name :: (SceneState :< cls, Object :< cls) => cls -> Int -> Int -> IO GodotString get_node_property_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_property_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_property_name" '[Int, Int] (IO GodotString) where nodeMethod = Godot.Core.SceneState.get_node_property_name {-# NOINLINE bindSceneState_get_node_property_value #-} -- | Returns the value of the property at @prop_idx@ for the node at @idx@. bindSceneState_get_node_property_value :: MethodBind bindSceneState_get_node_property_value = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_property_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the property at @prop_idx@ for the node at @idx@. get_node_property_value :: (SceneState :< cls, Object :< cls) => cls -> Int -> Int -> IO GodotVariant get_node_property_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_property_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_property_value" '[Int, Int] (IO GodotVariant) where nodeMethod = Godot.Core.SceneState.get_node_property_value {-# NOINLINE bindSceneState_get_node_type #-} -- | Returns the type of the node at @idx@. bindSceneState_get_node_type :: MethodBind bindSceneState_get_node_type = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "get_node_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the type of the node at @idx@. get_node_type :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO GodotString get_node_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_get_node_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "get_node_type" '[Int] (IO GodotString) where nodeMethod = Godot.Core.SceneState.get_node_type {-# NOINLINE bindSceneState_is_node_instance_placeholder #-} -- | Returns @true@ if the node at @idx@ is an @InstancePlaceholder@. bindSceneState_is_node_instance_placeholder :: MethodBind bindSceneState_is_node_instance_placeholder = unsafePerformIO $ withCString "SceneState" $ \ clsNamePtr -> withCString "is_node_instance_placeholder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node at @idx@ is an @InstancePlaceholder@. is_node_instance_placeholder :: (SceneState :< cls, Object :< cls) => cls -> Int -> IO Bool is_node_instance_placeholder cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneState_is_node_instance_placeholder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneState "is_node_instance_placeholder" '[Int] (IO Bool) where nodeMethod = Godot.Core.SceneState.is_node_instance_placeholder ================================================ FILE: src/Godot/Core/SceneTree.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SceneTree (Godot.Core.SceneTree._STRETCH_ASPECT_KEEP, Godot.Core.SceneTree._STRETCH_ASPECT_IGNORE, Godot.Core.SceneTree._GROUP_CALL_REALTIME, Godot.Core.SceneTree._GROUP_CALL_UNIQUE, Godot.Core.SceneTree._STRETCH_MODE_DISABLED, Godot.Core.SceneTree._STRETCH_ASPECT_KEEP_HEIGHT, Godot.Core.SceneTree._STRETCH_MODE_2D, Godot.Core.SceneTree._GROUP_CALL_REVERSE, Godot.Core.SceneTree._STRETCH_ASPECT_KEEP_WIDTH, Godot.Core.SceneTree._STRETCH_MODE_VIEWPORT, Godot.Core.SceneTree._GROUP_CALL_DEFAULT, Godot.Core.SceneTree._STRETCH_ASPECT_EXPAND, Godot.Core.SceneTree.sig_connected_to_server, Godot.Core.SceneTree.sig_connection_failed, Godot.Core.SceneTree.sig_files_dropped, Godot.Core.SceneTree.sig_global_menu_action, Godot.Core.SceneTree.sig_idle_frame, Godot.Core.SceneTree.sig_network_peer_connected, Godot.Core.SceneTree.sig_network_peer_disconnected, Godot.Core.SceneTree.sig_node_added, Godot.Core.SceneTree.sig_node_configuration_warning_changed, Godot.Core.SceneTree.sig_node_removed, Godot.Core.SceneTree.sig_node_renamed, Godot.Core.SceneTree.sig_physics_frame, Godot.Core.SceneTree.sig_screen_resized, Godot.Core.SceneTree.sig_server_disconnected, Godot.Core.SceneTree.sig_tree_changed, Godot.Core.SceneTree._change_scene, Godot.Core.SceneTree._connected_to_server, Godot.Core.SceneTree._connection_failed, Godot.Core.SceneTree._network_peer_connected, Godot.Core.SceneTree._network_peer_disconnected, Godot.Core.SceneTree._server_disconnected, Godot.Core.SceneTree.call_group, Godot.Core.SceneTree.call_group_flags, Godot.Core.SceneTree.change_scene, Godot.Core.SceneTree.change_scene_to, Godot.Core.SceneTree.create_timer, Godot.Core.SceneTree.get_current_scene, Godot.Core.SceneTree.get_edited_scene_root, Godot.Core.SceneTree.get_frame, Godot.Core.SceneTree.get_multiplayer, Godot.Core.SceneTree.get_network_connected_peers, Godot.Core.SceneTree.get_network_peer, Godot.Core.SceneTree.get_network_unique_id, Godot.Core.SceneTree.get_node_count, Godot.Core.SceneTree.get_nodes_in_group, Godot.Core.SceneTree.get_root, Godot.Core.SceneTree.get_rpc_sender_id, Godot.Core.SceneTree.has_group, Godot.Core.SceneTree.has_network_peer, Godot.Core.SceneTree.is_debugging_collisions_hint, Godot.Core.SceneTree.is_debugging_navigation_hint, Godot.Core.SceneTree.is_input_handled, Godot.Core.SceneTree.is_multiplayer_poll_enabled, Godot.Core.SceneTree.is_network_server, Godot.Core.SceneTree.is_paused, Godot.Core.SceneTree.is_refusing_new_network_connections, Godot.Core.SceneTree.is_using_font_oversampling, Godot.Core.SceneTree.notify_group, Godot.Core.SceneTree.notify_group_flags, Godot.Core.SceneTree.queue_delete, Godot.Core.SceneTree.quit, Godot.Core.SceneTree.reload_current_scene, Godot.Core.SceneTree.set_auto_accept_quit, Godot.Core.SceneTree.set_current_scene, Godot.Core.SceneTree.set_debug_collisions_hint, Godot.Core.SceneTree.set_debug_navigation_hint, Godot.Core.SceneTree.set_edited_scene_root, Godot.Core.SceneTree.set_group, Godot.Core.SceneTree.set_group_flags, Godot.Core.SceneTree.set_input_as_handled, Godot.Core.SceneTree.set_multiplayer, Godot.Core.SceneTree.set_multiplayer_poll_enabled, Godot.Core.SceneTree.set_network_peer, Godot.Core.SceneTree.set_pause, Godot.Core.SceneTree.set_quit_on_go_back, Godot.Core.SceneTree.set_refuse_new_network_connections, Godot.Core.SceneTree.set_screen_stretch, Godot.Core.SceneTree.set_use_font_oversampling) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.MainLoop() _STRETCH_ASPECT_KEEP :: Int _STRETCH_ASPECT_KEEP = 1 _STRETCH_ASPECT_IGNORE :: Int _STRETCH_ASPECT_IGNORE = 0 _GROUP_CALL_REALTIME :: Int _GROUP_CALL_REALTIME = 2 _GROUP_CALL_UNIQUE :: Int _GROUP_CALL_UNIQUE = 4 _STRETCH_MODE_DISABLED :: Int _STRETCH_MODE_DISABLED = 0 _STRETCH_ASPECT_KEEP_HEIGHT :: Int _STRETCH_ASPECT_KEEP_HEIGHT = 3 _STRETCH_MODE_2D :: Int _STRETCH_MODE_2D = 1 _GROUP_CALL_REVERSE :: Int _GROUP_CALL_REVERSE = 1 _STRETCH_ASPECT_KEEP_WIDTH :: Int _STRETCH_ASPECT_KEEP_WIDTH = 2 _STRETCH_MODE_VIEWPORT :: Int _STRETCH_MODE_VIEWPORT = 2 _GROUP_CALL_DEFAULT :: Int _GROUP_CALL_DEFAULT = 0 _STRETCH_ASPECT_EXPAND :: Int _STRETCH_ASPECT_EXPAND = 4 -- | Emitted whenever this @SceneTree@'s @network_peer@ successfully connected to a server. Only emitted on clients. sig_connected_to_server :: Godot.Internal.Dispatch.Signal SceneTree sig_connected_to_server = Godot.Internal.Dispatch.Signal "connected_to_server" instance NodeSignal SceneTree "connected_to_server" '[] -- | Emitted whenever this @SceneTree@'s @network_peer@ fails to establish a connection to a server. Only emitted on clients. sig_connection_failed :: Godot.Internal.Dispatch.Signal SceneTree sig_connection_failed = Godot.Internal.Dispatch.Signal "connection_failed" instance NodeSignal SceneTree "connection_failed" '[] -- | Emitted when files are dragged from the OS file manager and dropped in the game window. The arguments are a list of file paths and the identifier of the screen where the drag originated. sig_files_dropped :: Godot.Internal.Dispatch.Signal SceneTree sig_files_dropped = Godot.Internal.Dispatch.Signal "files_dropped" instance NodeSignal SceneTree "files_dropped" '[PoolStringArray, Int] -- | Emitted whenever global menu item is clicked. sig_global_menu_action :: Godot.Internal.Dispatch.Signal SceneTree sig_global_menu_action = Godot.Internal.Dispatch.Signal "global_menu_action" instance NodeSignal SceneTree "global_menu_action" '[(), ()] -- | Emitted immediately before @method Node._process@ is called on every node in the @SceneTree@. sig_idle_frame :: Godot.Internal.Dispatch.Signal SceneTree sig_idle_frame = Godot.Internal.Dispatch.Signal "idle_frame" instance NodeSignal SceneTree "idle_frame" '[] -- | Emitted whenever this @SceneTree@'s @network_peer@ connects with a new peer. ID is the peer ID of the new peer. Clients get notified when other clients connect to the same server. Upon connecting to a server, a client also receives this signal for the server (with ID being 1). sig_network_peer_connected :: Godot.Internal.Dispatch.Signal SceneTree sig_network_peer_connected = Godot.Internal.Dispatch.Signal "network_peer_connected" instance NodeSignal SceneTree "network_peer_connected" '[Int] -- | Emitted whenever this @SceneTree@'s @network_peer@ disconnects from a peer. Clients get notified when other clients disconnect from the same server. sig_network_peer_disconnected :: Godot.Internal.Dispatch.Signal SceneTree sig_network_peer_disconnected = Godot.Internal.Dispatch.Signal "network_peer_disconnected" instance NodeSignal SceneTree "network_peer_disconnected" '[Int] -- | Emitted whenever a node is added to the @SceneTree@. sig_node_added :: Godot.Internal.Dispatch.Signal SceneTree sig_node_added = Godot.Internal.Dispatch.Signal "node_added" instance NodeSignal SceneTree "node_added" '[Node] -- | Emitted when a node's configuration changed. Only emitted in @tool@ mode. sig_node_configuration_warning_changed :: Godot.Internal.Dispatch.Signal SceneTree sig_node_configuration_warning_changed = Godot.Internal.Dispatch.Signal "node_configuration_warning_changed" instance NodeSignal SceneTree "node_configuration_warning_changed" '[Node] -- | Emitted whenever a node is removed from the @SceneTree@. sig_node_removed :: Godot.Internal.Dispatch.Signal SceneTree sig_node_removed = Godot.Internal.Dispatch.Signal "node_removed" instance NodeSignal SceneTree "node_removed" '[Node] -- | Emitted whenever a node is renamed. sig_node_renamed :: Godot.Internal.Dispatch.Signal SceneTree sig_node_renamed = Godot.Internal.Dispatch.Signal "node_renamed" instance NodeSignal SceneTree "node_renamed" '[Node] -- | Emitted immediately before @method Node._physics_process@ is called on every node in the @SceneTree@. sig_physics_frame :: Godot.Internal.Dispatch.Signal SceneTree sig_physics_frame = Godot.Internal.Dispatch.Signal "physics_frame" instance NodeSignal SceneTree "physics_frame" '[] -- | Emitted when the screen resolution (fullscreen) or window size (windowed) changes. sig_screen_resized :: Godot.Internal.Dispatch.Signal SceneTree sig_screen_resized = Godot.Internal.Dispatch.Signal "screen_resized" instance NodeSignal SceneTree "screen_resized" '[] -- | Emitted whenever this @SceneTree@'s @network_peer@ disconnected from server. Only emitted on clients. sig_server_disconnected :: Godot.Internal.Dispatch.Signal SceneTree sig_server_disconnected = Godot.Internal.Dispatch.Signal "server_disconnected" instance NodeSignal SceneTree "server_disconnected" '[] -- | Emitted whenever the @SceneTree@ hierarchy changed (children being moved or renamed, etc.). sig_tree_changed :: Godot.Internal.Dispatch.Signal SceneTree sig_tree_changed = Godot.Internal.Dispatch.Signal "tree_changed" instance NodeSignal SceneTree "tree_changed" '[] instance NodeProperty SceneTree "current_scene" Node 'False where nodeProperty = (get_current_scene, wrapDroppingSetter set_current_scene, Nothing) instance NodeProperty SceneTree "debug_collisions_hint" Bool 'False where nodeProperty = (is_debugging_collisions_hint, wrapDroppingSetter set_debug_collisions_hint, Nothing) instance NodeProperty SceneTree "debug_navigation_hint" Bool 'False where nodeProperty = (is_debugging_navigation_hint, wrapDroppingSetter set_debug_navigation_hint, Nothing) instance NodeProperty SceneTree "edited_scene_root" Node 'False where nodeProperty = (get_edited_scene_root, wrapDroppingSetter set_edited_scene_root, Nothing) instance NodeProperty SceneTree "multiplayer" MultiplayerAPI 'False where nodeProperty = (get_multiplayer, wrapDroppingSetter set_multiplayer, Nothing) instance NodeProperty SceneTree "multiplayer_poll" Bool 'False where nodeProperty = (is_multiplayer_poll_enabled, wrapDroppingSetter set_multiplayer_poll_enabled, Nothing) instance NodeProperty SceneTree "network_peer" NetworkedMultiplayerPeer 'False where nodeProperty = (get_network_peer, wrapDroppingSetter set_network_peer, Nothing) instance NodeProperty SceneTree "paused" Bool 'False where nodeProperty = (is_paused, wrapDroppingSetter set_pause, Nothing) instance NodeProperty SceneTree "refuse_new_network_connections" Bool 'False where nodeProperty = (is_refusing_new_network_connections, wrapDroppingSetter set_refuse_new_network_connections, Nothing) instance NodeProperty SceneTree "root" Viewport 'True where nodeProperty = (get_root, (), Nothing) instance NodeProperty SceneTree "use_font_oversampling" Bool 'False where nodeProperty = (is_using_font_oversampling, wrapDroppingSetter set_use_font_oversampling, Nothing) {-# NOINLINE bindSceneTree__change_scene #-} bindSceneTree__change_scene :: MethodBind bindSceneTree__change_scene = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "_change_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _change_scene :: (SceneTree :< cls, Object :< cls) => cls -> Node -> IO () _change_scene cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree__change_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "_change_scene" '[Node] (IO ()) where nodeMethod = Godot.Core.SceneTree._change_scene {-# NOINLINE bindSceneTree__connected_to_server #-} bindSceneTree__connected_to_server :: MethodBind bindSceneTree__connected_to_server = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "_connected_to_server" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _connected_to_server :: (SceneTree :< cls, Object :< cls) => cls -> IO () _connected_to_server cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree__connected_to_server (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "_connected_to_server" '[] (IO ()) where nodeMethod = Godot.Core.SceneTree._connected_to_server {-# NOINLINE bindSceneTree__connection_failed #-} bindSceneTree__connection_failed :: MethodBind bindSceneTree__connection_failed = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "_connection_failed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _connection_failed :: (SceneTree :< cls, Object :< cls) => cls -> IO () _connection_failed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree__connection_failed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "_connection_failed" '[] (IO ()) where nodeMethod = Godot.Core.SceneTree._connection_failed {-# NOINLINE bindSceneTree__network_peer_connected #-} bindSceneTree__network_peer_connected :: MethodBind bindSceneTree__network_peer_connected = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "_network_peer_connected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _network_peer_connected :: (SceneTree :< cls, Object :< cls) => cls -> Int -> IO () _network_peer_connected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree__network_peer_connected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "_network_peer_connected" '[Int] (IO ()) where nodeMethod = Godot.Core.SceneTree._network_peer_connected {-# NOINLINE bindSceneTree__network_peer_disconnected #-} bindSceneTree__network_peer_disconnected :: MethodBind bindSceneTree__network_peer_disconnected = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "_network_peer_disconnected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _network_peer_disconnected :: (SceneTree :< cls, Object :< cls) => cls -> Int -> IO () _network_peer_disconnected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree__network_peer_disconnected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "_network_peer_disconnected" '[Int] (IO ()) where nodeMethod = Godot.Core.SceneTree._network_peer_disconnected {-# NOINLINE bindSceneTree__server_disconnected #-} bindSceneTree__server_disconnected :: MethodBind bindSceneTree__server_disconnected = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "_server_disconnected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _server_disconnected :: (SceneTree :< cls, Object :< cls) => cls -> IO () _server_disconnected cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree__server_disconnected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "_server_disconnected" '[] (IO ()) where nodeMethod = Godot.Core.SceneTree._server_disconnected {-# NOINLINE bindSceneTree_call_group #-} -- | Calls @method@ on each member of the given group. bindSceneTree_call_group :: MethodBind bindSceneTree_call_group = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "call_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls @method@ on each member of the given group. call_group :: (SceneTree :< cls, Object :< cls) => cls -> GodotString -> GodotString -> [Variant 'GodotTy] -> IO GodotVariant call_group cls arg1 arg2 varargs = withVariantArray ([toVariant arg1, toVariant arg2] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_call_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "call_group" '[GodotString, GodotString, [Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.SceneTree.call_group {-# NOINLINE bindSceneTree_call_group_flags #-} -- | Calls @method@ on each member of the given group, respecting the given @enum GroupCallFlags@. bindSceneTree_call_group_flags :: MethodBind bindSceneTree_call_group_flags = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "call_group_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls @method@ on each member of the given group, respecting the given @enum GroupCallFlags@. call_group_flags :: (SceneTree :< cls, Object :< cls) => cls -> Int -> GodotString -> GodotString -> [Variant 'GodotTy] -> IO GodotVariant call_group_flags cls arg1 arg2 arg3 varargs = withVariantArray ([toVariant arg1, toVariant arg2, toVariant arg3] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_call_group_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "call_group_flags" '[Int, GodotString, GodotString, [Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.SceneTree.call_group_flags {-# NOINLINE bindSceneTree_change_scene #-} -- | Changes the running scene to the one at the given @path@, after loading it into a @PackedScene@ and creating a new instance. -- Returns @OK@ on success, @ERR_CANT_OPEN@ if the @path@ cannot be loaded into a @PackedScene@, or @ERR_CANT_CREATE@ if that scene cannot be instantiated. bindSceneTree_change_scene :: MethodBind bindSceneTree_change_scene = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "change_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the running scene to the one at the given @path@, after loading it into a @PackedScene@ and creating a new instance. -- Returns @OK@ on success, @ERR_CANT_OPEN@ if the @path@ cannot be loaded into a @PackedScene@, or @ERR_CANT_CREATE@ if that scene cannot be instantiated. change_scene :: (SceneTree :< cls, Object :< cls) => cls -> GodotString -> IO Int change_scene cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_change_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "change_scene" '[GodotString] (IO Int) where nodeMethod = Godot.Core.SceneTree.change_scene {-# NOINLINE bindSceneTree_change_scene_to #-} -- | Changes the running scene to a new instance of the given @PackedScene@. -- Returns @OK@ on success or @ERR_CANT_CREATE@ if the scene cannot be instantiated. bindSceneTree_change_scene_to :: MethodBind bindSceneTree_change_scene_to = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "change_scene_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the running scene to a new instance of the given @PackedScene@. -- Returns @OK@ on success or @ERR_CANT_CREATE@ if the scene cannot be instantiated. change_scene_to :: (SceneTree :< cls, Object :< cls) => cls -> PackedScene -> IO Int change_scene_to cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_change_scene_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "change_scene_to" '[PackedScene] (IO Int) where nodeMethod = Godot.Core.SceneTree.change_scene_to {-# NOINLINE bindSceneTree_create_timer #-} -- | Returns a @SceneTreeTimer@ which will @signal SceneTreeTimer.timeout@ after the given time in seconds elapsed in this @SceneTree@. If @pause_mode_process@ is set to @false@, pausing the @SceneTree@ will also pause the timer. -- Commonly used to create a one-shot delay timer as in the following example: -- -- @ -- -- func some_function(): -- print("start") -- yield(get_tree().create_timer(1.0), "timeout") -- print("end") -- -- @ bindSceneTree_create_timer :: MethodBind bindSceneTree_create_timer = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "create_timer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @SceneTreeTimer@ which will @signal SceneTreeTimer.timeout@ after the given time in seconds elapsed in this @SceneTree@. If @pause_mode_process@ is set to @false@, pausing the @SceneTree@ will also pause the timer. -- Commonly used to create a one-shot delay timer as in the following example: -- -- @ -- -- func some_function(): -- print("start") -- yield(get_tree().create_timer(1.0), "timeout") -- print("end") -- -- @ create_timer :: (SceneTree :< cls, Object :< cls) => cls -> Float -> Maybe Bool -> IO SceneTreeTimer create_timer cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_create_timer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "create_timer" '[Float, Maybe Bool] (IO SceneTreeTimer) where nodeMethod = Godot.Core.SceneTree.create_timer {-# NOINLINE bindSceneTree_get_current_scene #-} -- | The current scene. bindSceneTree_get_current_scene :: MethodBind bindSceneTree_get_current_scene = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_current_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current scene. get_current_scene :: (SceneTree :< cls, Object :< cls) => cls -> IO Node get_current_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_current_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_current_scene" '[] (IO Node) where nodeMethod = Godot.Core.SceneTree.get_current_scene {-# NOINLINE bindSceneTree_get_edited_scene_root #-} -- | The root of the edited scene. bindSceneTree_get_edited_scene_root :: MethodBind bindSceneTree_get_edited_scene_root = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_edited_scene_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The root of the edited scene. get_edited_scene_root :: (SceneTree :< cls, Object :< cls) => cls -> IO Node get_edited_scene_root cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_edited_scene_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_edited_scene_root" '[] (IO Node) where nodeMethod = Godot.Core.SceneTree.get_edited_scene_root {-# NOINLINE bindSceneTree_get_frame #-} -- | Returns the current frame number, i.e. the total frame count since the application started. bindSceneTree_get_frame :: MethodBind bindSceneTree_get_frame = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current frame number, i.e. the total frame count since the application started. get_frame :: (SceneTree :< cls, Object :< cls) => cls -> IO Int get_frame cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_frame" '[] (IO Int) where nodeMethod = Godot.Core.SceneTree.get_frame {-# NOINLINE bindSceneTree_get_multiplayer #-} -- | The default @MultiplayerAPI@ instance for this @SceneTree@. bindSceneTree_get_multiplayer :: MethodBind bindSceneTree_get_multiplayer = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_multiplayer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The default @MultiplayerAPI@ instance for this @SceneTree@. get_multiplayer :: (SceneTree :< cls, Object :< cls) => cls -> IO MultiplayerAPI get_multiplayer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_multiplayer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_multiplayer" '[] (IO MultiplayerAPI) where nodeMethod = Godot.Core.SceneTree.get_multiplayer {-# NOINLINE bindSceneTree_get_network_connected_peers #-} -- | Returns the peer IDs of all connected peers of this @SceneTree@'s @network_peer@. bindSceneTree_get_network_connected_peers :: MethodBind bindSceneTree_get_network_connected_peers = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_network_connected_peers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the peer IDs of all connected peers of this @SceneTree@'s @network_peer@. get_network_connected_peers :: (SceneTree :< cls, Object :< cls) => cls -> IO PoolIntArray get_network_connected_peers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_network_connected_peers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_network_connected_peers" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.SceneTree.get_network_connected_peers {-# NOINLINE bindSceneTree_get_network_peer #-} -- | The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the @SceneTree@ will become a network server (check with @method is_network_server@) and will set the root node's network mode to master, or it will become a regular peer with the root node set to puppet. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to @SceneTree@'s signals. bindSceneTree_get_network_peer :: MethodBind bindSceneTree_get_network_peer = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_network_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the @SceneTree@ will become a network server (check with @method is_network_server@) and will set the root node's network mode to master, or it will become a regular peer with the root node set to puppet. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to @SceneTree@'s signals. get_network_peer :: (SceneTree :< cls, Object :< cls) => cls -> IO NetworkedMultiplayerPeer get_network_peer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_network_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_network_peer" '[] (IO NetworkedMultiplayerPeer) where nodeMethod = Godot.Core.SceneTree.get_network_peer {-# NOINLINE bindSceneTree_get_network_unique_id #-} -- | Returns the unique peer ID of this @SceneTree@'s @network_peer@. bindSceneTree_get_network_unique_id :: MethodBind bindSceneTree_get_network_unique_id = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_network_unique_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the unique peer ID of this @SceneTree@'s @network_peer@. get_network_unique_id :: (SceneTree :< cls, Object :< cls) => cls -> IO Int get_network_unique_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_network_unique_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_network_unique_id" '[] (IO Int) where nodeMethod = Godot.Core.SceneTree.get_network_unique_id {-# NOINLINE bindSceneTree_get_node_count #-} -- | Returns the number of nodes in this @SceneTree@. bindSceneTree_get_node_count :: MethodBind bindSceneTree_get_node_count = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_node_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of nodes in this @SceneTree@. get_node_count :: (SceneTree :< cls, Object :< cls) => cls -> IO Int get_node_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_node_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_node_count" '[] (IO Int) where nodeMethod = Godot.Core.SceneTree.get_node_count {-# NOINLINE bindSceneTree_get_nodes_in_group #-} -- | Returns a list of all nodes assigned to the given group. bindSceneTree_get_nodes_in_group :: MethodBind bindSceneTree_get_nodes_in_group = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_nodes_in_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of all nodes assigned to the given group. get_nodes_in_group :: (SceneTree :< cls, Object :< cls) => cls -> GodotString -> IO Array get_nodes_in_group cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_nodes_in_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_nodes_in_group" '[GodotString] (IO Array) where nodeMethod = Godot.Core.SceneTree.get_nodes_in_group {-# NOINLINE bindSceneTree_get_root #-} -- | The @SceneTree@'s root @Viewport@. bindSceneTree_get_root :: MethodBind bindSceneTree_get_root = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @SceneTree@'s root @Viewport@. get_root :: (SceneTree :< cls, Object :< cls) => cls -> IO Viewport get_root cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_root" '[] (IO Viewport) where nodeMethod = Godot.Core.SceneTree.get_root {-# NOINLINE bindSceneTree_get_rpc_sender_id #-} -- | Returns the sender's peer ID for the most recently received RPC call. bindSceneTree_get_rpc_sender_id :: MethodBind bindSceneTree_get_rpc_sender_id = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "get_rpc_sender_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the sender's peer ID for the most recently received RPC call. get_rpc_sender_id :: (SceneTree :< cls, Object :< cls) => cls -> IO Int get_rpc_sender_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_get_rpc_sender_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "get_rpc_sender_id" '[] (IO Int) where nodeMethod = Godot.Core.SceneTree.get_rpc_sender_id {-# NOINLINE bindSceneTree_has_group #-} -- | Returns @true@ if the given group exists. bindSceneTree_has_group :: MethodBind bindSceneTree_has_group = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "has_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given group exists. has_group :: (SceneTree :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_group cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_has_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "has_group" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.SceneTree.has_group {-# NOINLINE bindSceneTree_has_network_peer #-} -- | Returns @true@ if there is a @network_peer@ set. bindSceneTree_has_network_peer :: MethodBind bindSceneTree_has_network_peer = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "has_network_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if there is a @network_peer@ set. has_network_peer :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool has_network_peer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_has_network_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "has_network_peer" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.has_network_peer {-# NOINLINE bindSceneTree_is_debugging_collisions_hint #-} -- | If @true@, collision shapes will be visible when running the game from the editor for debugging purposes. bindSceneTree_is_debugging_collisions_hint :: MethodBind bindSceneTree_is_debugging_collisions_hint = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "is_debugging_collisions_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision shapes will be visible when running the game from the editor for debugging purposes. is_debugging_collisions_hint :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool is_debugging_collisions_hint cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_is_debugging_collisions_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "is_debugging_collisions_hint" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.is_debugging_collisions_hint {-# NOINLINE bindSceneTree_is_debugging_navigation_hint #-} -- | If @true@, navigation polygons will be visible when running the game from the editor for debugging purposes. bindSceneTree_is_debugging_navigation_hint :: MethodBind bindSceneTree_is_debugging_navigation_hint = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "is_debugging_navigation_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, navigation polygons will be visible when running the game from the editor for debugging purposes. is_debugging_navigation_hint :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool is_debugging_navigation_hint cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_is_debugging_navigation_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "is_debugging_navigation_hint" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.is_debugging_navigation_hint {-# NOINLINE bindSceneTree_is_input_handled #-} -- | Returns @true@ if the most recent @InputEvent@ was marked as handled with @method set_input_as_handled@. bindSceneTree_is_input_handled :: MethodBind bindSceneTree_is_input_handled = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "is_input_handled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the most recent @InputEvent@ was marked as handled with @method set_input_as_handled@. is_input_handled :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool is_input_handled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_is_input_handled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "is_input_handled" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.is_input_handled {-# NOINLINE bindSceneTree_is_multiplayer_poll_enabled #-} -- | If @true@ (default value), enables automatic polling of the @MultiplayerAPI@ for this SceneTree during @signal idle_frame@. -- If @false@, you need to manually call @method MultiplayerAPI.poll@ to process network packets and deliver RPCs/RSETs. This allows running RPCs/RSETs in a different loop (e.g. physics, thread, specific time step) and for manual @Mutex@ protection when accessing the @MultiplayerAPI@ from threads. bindSceneTree_is_multiplayer_poll_enabled :: MethodBind bindSceneTree_is_multiplayer_poll_enabled = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "is_multiplayer_poll_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@ (default value), enables automatic polling of the @MultiplayerAPI@ for this SceneTree during @signal idle_frame@. -- If @false@, you need to manually call @method MultiplayerAPI.poll@ to process network packets and deliver RPCs/RSETs. This allows running RPCs/RSETs in a different loop (e.g. physics, thread, specific time step) and for manual @Mutex@ protection when accessing the @MultiplayerAPI@ from threads. is_multiplayer_poll_enabled :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool is_multiplayer_poll_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_is_multiplayer_poll_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "is_multiplayer_poll_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.is_multiplayer_poll_enabled {-# NOINLINE bindSceneTree_is_network_server #-} -- | Returns @true@ if this @SceneTree@'s @network_peer@ is in server mode (listening for connections). bindSceneTree_is_network_server :: MethodBind bindSceneTree_is_network_server = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "is_network_server" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this @SceneTree@'s @network_peer@ is in server mode (listening for connections). is_network_server :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool is_network_server cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_is_network_server (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "is_network_server" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.is_network_server {-# NOINLINE bindSceneTree_is_paused #-} -- | If @true@, the @SceneTree@ is paused. Doing so will have the following behavior: -- - 2D and 3D physics will be stopped. -- - @method Node._process@, @method Node._physics_process@ and @method Node._input@ will not be called anymore in nodes. bindSceneTree_is_paused :: MethodBind bindSceneTree_is_paused = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "is_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @SceneTree@ is paused. Doing so will have the following behavior: -- - 2D and 3D physics will be stopped. -- - @method Node._process@, @method Node._physics_process@ and @method Node._input@ will not be called anymore in nodes. is_paused :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool is_paused cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_is_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "is_paused" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.is_paused {-# NOINLINE bindSceneTree_is_refusing_new_network_connections #-} -- | If @true@, the @SceneTree@'s @network_peer@ refuses new incoming connections. bindSceneTree_is_refusing_new_network_connections :: MethodBind bindSceneTree_is_refusing_new_network_connections = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "is_refusing_new_network_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @SceneTree@'s @network_peer@ refuses new incoming connections. is_refusing_new_network_connections :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool is_refusing_new_network_connections cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_is_refusing_new_network_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "is_refusing_new_network_connections" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.is_refusing_new_network_connections {-# NOINLINE bindSceneTree_is_using_font_oversampling #-} -- | If @true@, font oversampling is used. bindSceneTree_is_using_font_oversampling :: MethodBind bindSceneTree_is_using_font_oversampling = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "is_using_font_oversampling" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, font oversampling is used. is_using_font_oversampling :: (SceneTree :< cls, Object :< cls) => cls -> IO Bool is_using_font_oversampling cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_is_using_font_oversampling (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "is_using_font_oversampling" '[] (IO Bool) where nodeMethod = Godot.Core.SceneTree.is_using_font_oversampling {-# NOINLINE bindSceneTree_notify_group #-} -- | Sends the given notification to all members of the @group@. bindSceneTree_notify_group :: MethodBind bindSceneTree_notify_group = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "notify_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends the given notification to all members of the @group@. notify_group :: (SceneTree :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () notify_group cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_notify_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "notify_group" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.SceneTree.notify_group {-# NOINLINE bindSceneTree_notify_group_flags #-} -- | Sends the given notification to all members of the @group@, respecting the given @enum GroupCallFlags@. bindSceneTree_notify_group_flags :: MethodBind bindSceneTree_notify_group_flags = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "notify_group_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends the given notification to all members of the @group@, respecting the given @enum GroupCallFlags@. notify_group_flags :: (SceneTree :< cls, Object :< cls) => cls -> Int -> GodotString -> Int -> IO () notify_group_flags cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_notify_group_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "notify_group_flags" '[Int, GodotString, Int] (IO ()) where nodeMethod = Godot.Core.SceneTree.notify_group_flags {-# NOINLINE bindSceneTree_queue_delete #-} -- | Queues the given object for deletion, delaying the call to @method Object.free@ to after the current frame. bindSceneTree_queue_delete :: MethodBind bindSceneTree_queue_delete = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "queue_delete" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Queues the given object for deletion, delaying the call to @method Object.free@ to after the current frame. queue_delete :: (SceneTree :< cls, Object :< cls) => cls -> Object -> IO () queue_delete cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_queue_delete (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "queue_delete" '[Object] (IO ()) where nodeMethod = Godot.Core.SceneTree.queue_delete {-# NOINLINE bindSceneTree_quit #-} -- | Quits the application. A process @exit_code@ can optionally be passed as an argument. If this argument is @0@ or greater, it will override the @OS.exit_code@ defined before quitting the application. bindSceneTree_quit :: MethodBind bindSceneTree_quit = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "quit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Quits the application. A process @exit_code@ can optionally be passed as an argument. If this argument is @0@ or greater, it will override the @OS.exit_code@ defined before quitting the application. quit :: (SceneTree :< cls, Object :< cls) => cls -> Maybe Int -> IO () quit cls arg1 = withVariantArray [maybe (VariantInt (-1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_quit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "quit" '[Maybe Int] (IO ()) where nodeMethod = Godot.Core.SceneTree.quit {-# NOINLINE bindSceneTree_reload_current_scene #-} -- | Reloads the currently active scene. -- Returns @OK@ on success, @ERR_UNCONFIGURED@ if no @current_scene@ was defined yet, @ERR_CANT_OPEN@ if @current_scene@ cannot be loaded into a @PackedScene@, or @ERR_CANT_CREATE@ if the scene cannot be instantiated. bindSceneTree_reload_current_scene :: MethodBind bindSceneTree_reload_current_scene = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "reload_current_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reloads the currently active scene. -- Returns @OK@ on success, @ERR_UNCONFIGURED@ if no @current_scene@ was defined yet, @ERR_CANT_OPEN@ if @current_scene@ cannot be loaded into a @PackedScene@, or @ERR_CANT_CREATE@ if the scene cannot be instantiated. reload_current_scene :: (SceneTree :< cls, Object :< cls) => cls -> IO Int reload_current_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_reload_current_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "reload_current_scene" '[] (IO Int) where nodeMethod = Godot.Core.SceneTree.reload_current_scene {-# NOINLINE bindSceneTree_set_auto_accept_quit #-} -- | If @true@, the application automatically accepts quitting. Enabled by default. -- For mobile platforms, see @method set_quit_on_go_back@. bindSceneTree_set_auto_accept_quit :: MethodBind bindSceneTree_set_auto_accept_quit = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_auto_accept_quit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the application automatically accepts quitting. Enabled by default. -- For mobile platforms, see @method set_quit_on_go_back@. set_auto_accept_quit :: (SceneTree :< cls, Object :< cls) => cls -> Bool -> IO () set_auto_accept_quit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_auto_accept_quit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_auto_accept_quit" '[Bool] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_auto_accept_quit {-# NOINLINE bindSceneTree_set_current_scene #-} -- | The current scene. bindSceneTree_set_current_scene :: MethodBind bindSceneTree_set_current_scene = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_current_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current scene. set_current_scene :: (SceneTree :< cls, Object :< cls) => cls -> Node -> IO () set_current_scene cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_current_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_current_scene" '[Node] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_current_scene {-# NOINLINE bindSceneTree_set_debug_collisions_hint #-} -- | If @true@, collision shapes will be visible when running the game from the editor for debugging purposes. bindSceneTree_set_debug_collisions_hint :: MethodBind bindSceneTree_set_debug_collisions_hint = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_debug_collisions_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, collision shapes will be visible when running the game from the editor for debugging purposes. set_debug_collisions_hint :: (SceneTree :< cls, Object :< cls) => cls -> Bool -> IO () set_debug_collisions_hint cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_debug_collisions_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_debug_collisions_hint" '[Bool] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_debug_collisions_hint {-# NOINLINE bindSceneTree_set_debug_navigation_hint #-} -- | If @true@, navigation polygons will be visible when running the game from the editor for debugging purposes. bindSceneTree_set_debug_navigation_hint :: MethodBind bindSceneTree_set_debug_navigation_hint = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_debug_navigation_hint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, navigation polygons will be visible when running the game from the editor for debugging purposes. set_debug_navigation_hint :: (SceneTree :< cls, Object :< cls) => cls -> Bool -> IO () set_debug_navigation_hint cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_debug_navigation_hint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_debug_navigation_hint" '[Bool] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_debug_navigation_hint {-# NOINLINE bindSceneTree_set_edited_scene_root #-} -- | The root of the edited scene. bindSceneTree_set_edited_scene_root :: MethodBind bindSceneTree_set_edited_scene_root = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_edited_scene_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The root of the edited scene. set_edited_scene_root :: (SceneTree :< cls, Object :< cls) => cls -> Node -> IO () set_edited_scene_root cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_edited_scene_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_edited_scene_root" '[Node] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_edited_scene_root {-# NOINLINE bindSceneTree_set_group #-} -- | Sets the given @property@ to @value@ on all members of the given group. bindSceneTree_set_group :: MethodBind bindSceneTree_set_group = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given @property@ to @value@ on all members of the given group. set_group :: (SceneTree :< cls, Object :< cls) => cls -> GodotString -> GodotString -> GodotVariant -> IO () set_group cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_group" '[GodotString, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_group {-# NOINLINE bindSceneTree_set_group_flags #-} -- | Sets the given @property@ to @value@ on all members of the given group, respecting the given @enum GroupCallFlags@. bindSceneTree_set_group_flags :: MethodBind bindSceneTree_set_group_flags = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_group_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given @property@ to @value@ on all members of the given group, respecting the given @enum GroupCallFlags@. set_group_flags :: (SceneTree :< cls, Object :< cls) => cls -> Int -> GodotString -> GodotString -> GodotVariant -> IO () set_group_flags cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_group_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_group_flags" '[Int, GodotString, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_group_flags {-# NOINLINE bindSceneTree_set_input_as_handled #-} -- | Marks the most recent @InputEvent@ as handled. bindSceneTree_set_input_as_handled :: MethodBind bindSceneTree_set_input_as_handled = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_input_as_handled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Marks the most recent @InputEvent@ as handled. set_input_as_handled :: (SceneTree :< cls, Object :< cls) => cls -> IO () set_input_as_handled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_input_as_handled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_input_as_handled" '[] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_input_as_handled {-# NOINLINE bindSceneTree_set_multiplayer #-} -- | The default @MultiplayerAPI@ instance for this @SceneTree@. bindSceneTree_set_multiplayer :: MethodBind bindSceneTree_set_multiplayer = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_multiplayer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The default @MultiplayerAPI@ instance for this @SceneTree@. set_multiplayer :: (SceneTree :< cls, Object :< cls) => cls -> MultiplayerAPI -> IO () set_multiplayer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_multiplayer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_multiplayer" '[MultiplayerAPI] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_multiplayer {-# NOINLINE bindSceneTree_set_multiplayer_poll_enabled #-} -- | If @true@ (default value), enables automatic polling of the @MultiplayerAPI@ for this SceneTree during @signal idle_frame@. -- If @false@, you need to manually call @method MultiplayerAPI.poll@ to process network packets and deliver RPCs/RSETs. This allows running RPCs/RSETs in a different loop (e.g. physics, thread, specific time step) and for manual @Mutex@ protection when accessing the @MultiplayerAPI@ from threads. bindSceneTree_set_multiplayer_poll_enabled :: MethodBind bindSceneTree_set_multiplayer_poll_enabled = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_multiplayer_poll_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@ (default value), enables automatic polling of the @MultiplayerAPI@ for this SceneTree during @signal idle_frame@. -- If @false@, you need to manually call @method MultiplayerAPI.poll@ to process network packets and deliver RPCs/RSETs. This allows running RPCs/RSETs in a different loop (e.g. physics, thread, specific time step) and for manual @Mutex@ protection when accessing the @MultiplayerAPI@ from threads. set_multiplayer_poll_enabled :: (SceneTree :< cls, Object :< cls) => cls -> Bool -> IO () set_multiplayer_poll_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_multiplayer_poll_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_multiplayer_poll_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_multiplayer_poll_enabled {-# NOINLINE bindSceneTree_set_network_peer #-} -- | The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the @SceneTree@ will become a network server (check with @method is_network_server@) and will set the root node's network mode to master, or it will become a regular peer with the root node set to puppet. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to @SceneTree@'s signals. bindSceneTree_set_network_peer :: MethodBind bindSceneTree_set_network_peer = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_network_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the @SceneTree@ will become a network server (check with @method is_network_server@) and will set the root node's network mode to master, or it will become a regular peer with the root node set to puppet. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to @SceneTree@'s signals. set_network_peer :: (SceneTree :< cls, Object :< cls) => cls -> NetworkedMultiplayerPeer -> IO () set_network_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_network_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_network_peer" '[NetworkedMultiplayerPeer] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_network_peer {-# NOINLINE bindSceneTree_set_pause #-} -- | If @true@, the @SceneTree@ is paused. Doing so will have the following behavior: -- - 2D and 3D physics will be stopped. -- - @method Node._process@, @method Node._physics_process@ and @method Node._input@ will not be called anymore in nodes. bindSceneTree_set_pause :: MethodBind bindSceneTree_set_pause = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_pause" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @SceneTree@ is paused. Doing so will have the following behavior: -- - 2D and 3D physics will be stopped. -- - @method Node._process@, @method Node._physics_process@ and @method Node._input@ will not be called anymore in nodes. set_pause :: (SceneTree :< cls, Object :< cls) => cls -> Bool -> IO () set_pause cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_pause (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_pause" '[Bool] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_pause {-# NOINLINE bindSceneTree_set_quit_on_go_back #-} -- | If @true@, the application quits automatically on going back (e.g. on Android). Enabled by default. -- To handle 'Go Back' button when this option is disabled, use @MainLoop.NOTIFICATION_WM_GO_BACK_REQUEST@. bindSceneTree_set_quit_on_go_back :: MethodBind bindSceneTree_set_quit_on_go_back = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_quit_on_go_back" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the application quits automatically on going back (e.g. on Android). Enabled by default. -- To handle 'Go Back' button when this option is disabled, use @MainLoop.NOTIFICATION_WM_GO_BACK_REQUEST@. set_quit_on_go_back :: (SceneTree :< cls, Object :< cls) => cls -> Bool -> IO () set_quit_on_go_back cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_quit_on_go_back (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_quit_on_go_back" '[Bool] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_quit_on_go_back {-# NOINLINE bindSceneTree_set_refuse_new_network_connections #-} -- | If @true@, the @SceneTree@'s @network_peer@ refuses new incoming connections. bindSceneTree_set_refuse_new_network_connections :: MethodBind bindSceneTree_set_refuse_new_network_connections = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_refuse_new_network_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @SceneTree@'s @network_peer@ refuses new incoming connections. set_refuse_new_network_connections :: (SceneTree :< cls, Object :< cls) => cls -> Bool -> IO () set_refuse_new_network_connections cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_refuse_new_network_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_refuse_new_network_connections" '[Bool] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_refuse_new_network_connections {-# NOINLINE bindSceneTree_set_screen_stretch #-} -- | Configures screen stretching to the given @enum StretchMode@, @enum StretchAspect@, minimum size and @shrink@ ratio. bindSceneTree_set_screen_stretch :: MethodBind bindSceneTree_set_screen_stretch = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_screen_stretch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Configures screen stretching to the given @enum StretchMode@, @enum StretchAspect@, minimum size and @shrink@ ratio. set_screen_stretch :: (SceneTree :< cls, Object :< cls) => cls -> Int -> Int -> Vector2 -> Maybe Float -> IO () set_screen_stretch cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantReal (1)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_screen_stretch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_screen_stretch" '[Int, Int, Vector2, Maybe Float] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_screen_stretch {-# NOINLINE bindSceneTree_set_use_font_oversampling #-} -- | If @true@, font oversampling is used. bindSceneTree_set_use_font_oversampling :: MethodBind bindSceneTree_set_use_font_oversampling = unsafePerformIO $ withCString "SceneTree" $ \ clsNamePtr -> withCString "set_use_font_oversampling" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, font oversampling is used. set_use_font_oversampling :: (SceneTree :< cls, Object :< cls) => cls -> Bool -> IO () set_use_font_oversampling cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTree_set_use_font_oversampling (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTree "set_use_font_oversampling" '[Bool] (IO ()) where nodeMethod = Godot.Core.SceneTree.set_use_font_oversampling ================================================ FILE: src/Godot/Core/SceneTreeTimer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SceneTreeTimer (Godot.Core.SceneTreeTimer.sig_timeout, Godot.Core.SceneTreeTimer.get_time_left, Godot.Core.SceneTreeTimer.set_time_left) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() -- | Emitted when the timer reaches 0. sig_timeout :: Godot.Internal.Dispatch.Signal SceneTreeTimer sig_timeout = Godot.Internal.Dispatch.Signal "timeout" instance NodeSignal SceneTreeTimer "timeout" '[] instance NodeProperty SceneTreeTimer "time_left" Float 'False where nodeProperty = (get_time_left, wrapDroppingSetter set_time_left, Nothing) {-# NOINLINE bindSceneTreeTimer_get_time_left #-} -- | The time remaining. bindSceneTreeTimer_get_time_left :: MethodBind bindSceneTreeTimer_get_time_left = unsafePerformIO $ withCString "SceneTreeTimer" $ \ clsNamePtr -> withCString "get_time_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The time remaining. get_time_left :: (SceneTreeTimer :< cls, Object :< cls) => cls -> IO Float get_time_left cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTreeTimer_get_time_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTreeTimer "get_time_left" '[] (IO Float) where nodeMethod = Godot.Core.SceneTreeTimer.get_time_left {-# NOINLINE bindSceneTreeTimer_set_time_left #-} -- | The time remaining. bindSceneTreeTimer_set_time_left :: MethodBind bindSceneTreeTimer_set_time_left = unsafePerformIO $ withCString "SceneTreeTimer" $ \ clsNamePtr -> withCString "set_time_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The time remaining. set_time_left :: (SceneTreeTimer :< cls, Object :< cls) => cls -> Float -> IO () set_time_left cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSceneTreeTimer_set_time_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SceneTreeTimer "set_time_left" '[Float] (IO ()) where nodeMethod = Godot.Core.SceneTreeTimer.set_time_left ================================================ FILE: src/Godot/Core/Script.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Script (Godot.Core.Script.can_instance, Godot.Core.Script.get_base_script, Godot.Core.Script.get_instance_base_type, Godot.Core.Script.get_property_default_value, Godot.Core.Script.get_script_constant_map, Godot.Core.Script.get_script_method_list, Godot.Core.Script.get_script_property_list, Godot.Core.Script.get_script_signal_list, Godot.Core.Script.get_source_code, Godot.Core.Script.has_script_signal, Godot.Core.Script.has_source_code, Godot.Core.Script.instance_has, Godot.Core.Script.is_tool, Godot.Core.Script.reload, Godot.Core.Script.set_source_code) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty Script "source_code" GodotString 'False where nodeProperty = (get_source_code, wrapDroppingSetter set_source_code, Nothing) {-# NOINLINE bindScript_can_instance #-} -- | Returns @true@ if the script can be instanced. bindScript_can_instance :: MethodBind bindScript_can_instance = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "can_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the script can be instanced. can_instance :: (Script :< cls, Object :< cls) => cls -> IO Bool can_instance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_can_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "can_instance" '[] (IO Bool) where nodeMethod = Godot.Core.Script.can_instance {-# NOINLINE bindScript_get_base_script #-} -- | Returns the script directly inherited by this script. bindScript_get_base_script :: MethodBind bindScript_get_base_script = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "get_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the script directly inherited by this script. get_base_script :: (Script :< cls, Object :< cls) => cls -> IO Script get_base_script cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_get_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "get_base_script" '[] (IO Script) where nodeMethod = Godot.Core.Script.get_base_script {-# NOINLINE bindScript_get_instance_base_type #-} -- | Returns the script's base type. bindScript_get_instance_base_type :: MethodBind bindScript_get_instance_base_type = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "get_instance_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the script's base type. get_instance_base_type :: (Script :< cls, Object :< cls) => cls -> IO GodotString get_instance_base_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_get_instance_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "get_instance_base_type" '[] (IO GodotString) where nodeMethod = Godot.Core.Script.get_instance_base_type {-# NOINLINE bindScript_get_property_default_value #-} -- | Returns the default value of the specified property. bindScript_get_property_default_value :: MethodBind bindScript_get_property_default_value = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "get_property_default_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the default value of the specified property. get_property_default_value :: (Script :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get_property_default_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScript_get_property_default_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "get_property_default_value" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.Script.get_property_default_value {-# NOINLINE bindScript_get_script_constant_map #-} -- | Returns a dictionary containing constant names and their values. bindScript_get_script_constant_map :: MethodBind bindScript_get_script_constant_map = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "get_script_constant_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a dictionary containing constant names and their values. get_script_constant_map :: (Script :< cls, Object :< cls) => cls -> IO Dictionary get_script_constant_map cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_get_script_constant_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "get_script_constant_map" '[] (IO Dictionary) where nodeMethod = Godot.Core.Script.get_script_constant_map {-# NOINLINE bindScript_get_script_method_list #-} -- | Returns the list of methods in this @Script@. bindScript_get_script_method_list :: MethodBind bindScript_get_script_method_list = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "get_script_method_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of methods in this @Script@. get_script_method_list :: (Script :< cls, Object :< cls) => cls -> IO Array get_script_method_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_get_script_method_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "get_script_method_list" '[] (IO Array) where nodeMethod = Godot.Core.Script.get_script_method_list {-# NOINLINE bindScript_get_script_property_list #-} -- | Returns the list of properties in this @Script@. bindScript_get_script_property_list :: MethodBind bindScript_get_script_property_list = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "get_script_property_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of properties in this @Script@. get_script_property_list :: (Script :< cls, Object :< cls) => cls -> IO Array get_script_property_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_get_script_property_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "get_script_property_list" '[] (IO Array) where nodeMethod = Godot.Core.Script.get_script_property_list {-# NOINLINE bindScript_get_script_signal_list #-} -- | Returns the list of user signals defined in this @Script@. bindScript_get_script_signal_list :: MethodBind bindScript_get_script_signal_list = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "get_script_signal_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of user signals defined in this @Script@. get_script_signal_list :: (Script :< cls, Object :< cls) => cls -> IO Array get_script_signal_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_get_script_signal_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "get_script_signal_list" '[] (IO Array) where nodeMethod = Godot.Core.Script.get_script_signal_list {-# NOINLINE bindScript_get_source_code #-} -- | The script source code or an empty string if source code is not available. When set, does not reload the class implementation automatically. bindScript_get_source_code :: MethodBind bindScript_get_source_code = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "get_source_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The script source code or an empty string if source code is not available. When set, does not reload the class implementation automatically. get_source_code :: (Script :< cls, Object :< cls) => cls -> IO GodotString get_source_code cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_get_source_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "get_source_code" '[] (IO GodotString) where nodeMethod = Godot.Core.Script.get_source_code {-# NOINLINE bindScript_has_script_signal #-} -- | Returns @true@ if the script, or a base class, defines a signal with the given name. bindScript_has_script_signal :: MethodBind bindScript_has_script_signal = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "has_script_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the script, or a base class, defines a signal with the given name. has_script_signal :: (Script :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_script_signal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScript_has_script_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "has_script_signal" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Script.has_script_signal {-# NOINLINE bindScript_has_source_code #-} -- | Returns @true@ if the script contains non-empty source code. bindScript_has_source_code :: MethodBind bindScript_has_source_code = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "has_source_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the script contains non-empty source code. has_source_code :: (Script :< cls, Object :< cls) => cls -> IO Bool has_source_code cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_has_source_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "has_source_code" '[] (IO Bool) where nodeMethod = Godot.Core.Script.has_source_code {-# NOINLINE bindScript_instance_has #-} -- | Returns @true@ if @base_object@ is an instance of this script. bindScript_instance_has :: MethodBind bindScript_instance_has = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "instance_has" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @base_object@ is an instance of this script. instance_has :: (Script :< cls, Object :< cls) => cls -> Object -> IO Bool instance_has cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScript_instance_has (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "instance_has" '[Object] (IO Bool) where nodeMethod = Godot.Core.Script.instance_has {-# NOINLINE bindScript_is_tool #-} -- | Returns @true@ if the script is a tool script. A tool script can run in the editor. bindScript_is_tool :: MethodBind bindScript_is_tool = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "is_tool" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the script is a tool script. A tool script can run in the editor. is_tool :: (Script :< cls, Object :< cls) => cls -> IO Bool is_tool cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScript_is_tool (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "is_tool" '[] (IO Bool) where nodeMethod = Godot.Core.Script.is_tool {-# NOINLINE bindScript_reload #-} -- | Reloads the script's class implementation. Returns an error code. bindScript_reload :: MethodBind bindScript_reload = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "reload" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reloads the script's class implementation. Returns an error code. reload :: (Script :< cls, Object :< cls) => cls -> Maybe Bool -> IO Int reload cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScript_reload (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "reload" '[Maybe Bool] (IO Int) where nodeMethod = Godot.Core.Script.reload {-# NOINLINE bindScript_set_source_code #-} -- | The script source code or an empty string if source code is not available. When set, does not reload the class implementation automatically. bindScript_set_source_code :: MethodBind bindScript_set_source_code = unsafePerformIO $ withCString "Script" $ \ clsNamePtr -> withCString "set_source_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The script source code or an empty string if source code is not available. When set, does not reload the class implementation automatically. set_source_code :: (Script :< cls, Object :< cls) => cls -> GodotString -> IO () set_source_code cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScript_set_source_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Script "set_source_code" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Script.set_source_code ================================================ FILE: src/Godot/Core/ScrollBar.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ScrollBar (Godot.Core.ScrollBar.sig_scrolling, Godot.Core.ScrollBar._drag_node_exit, Godot.Core.ScrollBar._drag_node_input, Godot.Core.ScrollBar._gui_input, Godot.Core.ScrollBar.get_custom_step, Godot.Core.ScrollBar.set_custom_step) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Range() -- | Emitted when the scrollbar is being scrolled. sig_scrolling :: Godot.Internal.Dispatch.Signal ScrollBar sig_scrolling = Godot.Internal.Dispatch.Signal "scrolling" instance NodeSignal ScrollBar "scrolling" '[] instance NodeProperty ScrollBar "custom_step" Float 'False where nodeProperty = (get_custom_step, wrapDroppingSetter set_custom_step, Nothing) {-# NOINLINE bindScrollBar__drag_node_exit #-} bindScrollBar__drag_node_exit :: MethodBind bindScrollBar__drag_node_exit = unsafePerformIO $ withCString "ScrollBar" $ \ clsNamePtr -> withCString "_drag_node_exit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _drag_node_exit :: (ScrollBar :< cls, Object :< cls) => cls -> IO () _drag_node_exit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollBar__drag_node_exit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollBar "_drag_node_exit" '[] (IO ()) where nodeMethod = Godot.Core.ScrollBar._drag_node_exit {-# NOINLINE bindScrollBar__drag_node_input #-} bindScrollBar__drag_node_input :: MethodBind bindScrollBar__drag_node_input = unsafePerformIO $ withCString "ScrollBar" $ \ clsNamePtr -> withCString "_drag_node_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _drag_node_input :: (ScrollBar :< cls, Object :< cls) => cls -> InputEvent -> IO () _drag_node_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollBar__drag_node_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollBar "_drag_node_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ScrollBar._drag_node_input {-# NOINLINE bindScrollBar__gui_input #-} bindScrollBar__gui_input :: MethodBind bindScrollBar__gui_input = unsafePerformIO $ withCString "ScrollBar" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (ScrollBar :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollBar__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollBar "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ScrollBar._gui_input {-# NOINLINE bindScrollBar_get_custom_step #-} -- | Overrides the step used when clicking increment and decrement buttons or when using arrow keys when the @ScrollBar@ is focused. bindScrollBar_get_custom_step :: MethodBind bindScrollBar_get_custom_step = unsafePerformIO $ withCString "ScrollBar" $ \ clsNamePtr -> withCString "get_custom_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the step used when clicking increment and decrement buttons or when using arrow keys when the @ScrollBar@ is focused. get_custom_step :: (ScrollBar :< cls, Object :< cls) => cls -> IO Float get_custom_step cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollBar_get_custom_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollBar "get_custom_step" '[] (IO Float) where nodeMethod = Godot.Core.ScrollBar.get_custom_step {-# NOINLINE bindScrollBar_set_custom_step #-} -- | Overrides the step used when clicking increment and decrement buttons or when using arrow keys when the @ScrollBar@ is focused. bindScrollBar_set_custom_step :: MethodBind bindScrollBar_set_custom_step = unsafePerformIO $ withCString "ScrollBar" $ \ clsNamePtr -> withCString "set_custom_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Overrides the step used when clicking increment and decrement buttons or when using arrow keys when the @ScrollBar@ is focused. set_custom_step :: (ScrollBar :< cls, Object :< cls) => cls -> Float -> IO () set_custom_step cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollBar_set_custom_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollBar "set_custom_step" '[Float] (IO ()) where nodeMethod = Godot.Core.ScrollBar.set_custom_step ================================================ FILE: src/Godot/Core/ScrollContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ScrollContainer (Godot.Core.ScrollContainer.sig_scroll_ended, Godot.Core.ScrollContainer.sig_scroll_started, Godot.Core.ScrollContainer._ensure_focused_visible, Godot.Core.ScrollContainer._gui_input, Godot.Core.ScrollContainer._scroll_moved, Godot.Core.ScrollContainer._update_scrollbar_position, Godot.Core.ScrollContainer.get_deadzone, Godot.Core.ScrollContainer.get_h_scroll, Godot.Core.ScrollContainer.get_h_scrollbar, Godot.Core.ScrollContainer.get_v_scroll, Godot.Core.ScrollContainer.get_v_scrollbar, Godot.Core.ScrollContainer.is_following_focus, Godot.Core.ScrollContainer.is_h_scroll_enabled, Godot.Core.ScrollContainer.is_v_scroll_enabled, Godot.Core.ScrollContainer.set_deadzone, Godot.Core.ScrollContainer.set_enable_h_scroll, Godot.Core.ScrollContainer.set_enable_v_scroll, Godot.Core.ScrollContainer.set_follow_focus, Godot.Core.ScrollContainer.set_h_scroll, Godot.Core.ScrollContainer.set_v_scroll) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() -- | Emitted when scrolling stops. sig_scroll_ended :: Godot.Internal.Dispatch.Signal ScrollContainer sig_scroll_ended = Godot.Internal.Dispatch.Signal "scroll_ended" instance NodeSignal ScrollContainer "scroll_ended" '[] -- | Emitted when scrolling is started. sig_scroll_started :: Godot.Internal.Dispatch.Signal ScrollContainer sig_scroll_started = Godot.Internal.Dispatch.Signal "scroll_started" instance NodeSignal ScrollContainer "scroll_started" '[] instance NodeProperty ScrollContainer "follow_focus" Bool 'False where nodeProperty = (is_following_focus, wrapDroppingSetter set_follow_focus, Nothing) instance NodeProperty ScrollContainer "scroll_deadzone" Int 'False where nodeProperty = (get_deadzone, wrapDroppingSetter set_deadzone, Nothing) instance NodeProperty ScrollContainer "scroll_horizontal" Int 'False where nodeProperty = (get_h_scroll, wrapDroppingSetter set_h_scroll, Nothing) instance NodeProperty ScrollContainer "scroll_horizontal_enabled" Bool 'False where nodeProperty = (is_h_scroll_enabled, wrapDroppingSetter set_enable_h_scroll, Nothing) instance NodeProperty ScrollContainer "scroll_vertical" Int 'False where nodeProperty = (get_v_scroll, wrapDroppingSetter set_v_scroll, Nothing) instance NodeProperty ScrollContainer "scroll_vertical_enabled" Bool 'False where nodeProperty = (is_v_scroll_enabled, wrapDroppingSetter set_enable_v_scroll, Nothing) {-# NOINLINE bindScrollContainer__ensure_focused_visible #-} bindScrollContainer__ensure_focused_visible :: MethodBind bindScrollContainer__ensure_focused_visible = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "_ensure_focused_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _ensure_focused_visible :: (ScrollContainer :< cls, Object :< cls) => cls -> Control -> IO () _ensure_focused_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer__ensure_focused_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "_ensure_focused_visible" '[Control] (IO ()) where nodeMethod = Godot.Core.ScrollContainer._ensure_focused_visible {-# NOINLINE bindScrollContainer__gui_input #-} bindScrollContainer__gui_input :: MethodBind bindScrollContainer__gui_input = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (ScrollContainer :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ScrollContainer._gui_input {-# NOINLINE bindScrollContainer__scroll_moved #-} bindScrollContainer__scroll_moved :: MethodBind bindScrollContainer__scroll_moved = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "_scroll_moved" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _scroll_moved :: (ScrollContainer :< cls, Object :< cls) => cls -> Float -> IO () _scroll_moved cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer__scroll_moved (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "_scroll_moved" '[Float] (IO ()) where nodeMethod = Godot.Core.ScrollContainer._scroll_moved {-# NOINLINE bindScrollContainer__update_scrollbar_position #-} bindScrollContainer__update_scrollbar_position :: MethodBind bindScrollContainer__update_scrollbar_position = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "_update_scrollbar_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_scrollbar_position :: (ScrollContainer :< cls, Object :< cls) => cls -> IO () _update_scrollbar_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer__update_scrollbar_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "_update_scrollbar_position" '[] (IO ()) where nodeMethod = Godot.Core.ScrollContainer._update_scrollbar_position {-# NOINLINE bindScrollContainer_get_deadzone #-} bindScrollContainer_get_deadzone :: MethodBind bindScrollContainer_get_deadzone = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "get_deadzone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_deadzone :: (ScrollContainer :< cls, Object :< cls) => cls -> IO Int get_deadzone cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_get_deadzone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "get_deadzone" '[] (IO Int) where nodeMethod = Godot.Core.ScrollContainer.get_deadzone {-# NOINLINE bindScrollContainer_get_h_scroll #-} -- | The current horizontal scroll value. bindScrollContainer_get_h_scroll :: MethodBind bindScrollContainer_get_h_scroll = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "get_h_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current horizontal scroll value. get_h_scroll :: (ScrollContainer :< cls, Object :< cls) => cls -> IO Int get_h_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_get_h_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "get_h_scroll" '[] (IO Int) where nodeMethod = Godot.Core.ScrollContainer.get_h_scroll {-# NOINLINE bindScrollContainer_get_h_scrollbar #-} -- | Returns the horizontal scrollbar @HScrollBar@ of this @ScrollContainer@. bindScrollContainer_get_h_scrollbar :: MethodBind bindScrollContainer_get_h_scrollbar = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "get_h_scrollbar" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the horizontal scrollbar @HScrollBar@ of this @ScrollContainer@. get_h_scrollbar :: (ScrollContainer :< cls, Object :< cls) => cls -> IO HScrollBar get_h_scrollbar cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_get_h_scrollbar (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "get_h_scrollbar" '[] (IO HScrollBar) where nodeMethod = Godot.Core.ScrollContainer.get_h_scrollbar {-# NOINLINE bindScrollContainer_get_v_scroll #-} -- | The current vertical scroll value. bindScrollContainer_get_v_scroll :: MethodBind bindScrollContainer_get_v_scroll = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "get_v_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current vertical scroll value. get_v_scroll :: (ScrollContainer :< cls, Object :< cls) => cls -> IO Int get_v_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_get_v_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "get_v_scroll" '[] (IO Int) where nodeMethod = Godot.Core.ScrollContainer.get_v_scroll {-# NOINLINE bindScrollContainer_get_v_scrollbar #-} -- | Returns the vertical scrollbar @VScrollBar@ of this @ScrollContainer@. bindScrollContainer_get_v_scrollbar :: MethodBind bindScrollContainer_get_v_scrollbar = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "get_v_scrollbar" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the vertical scrollbar @VScrollBar@ of this @ScrollContainer@. get_v_scrollbar :: (ScrollContainer :< cls, Object :< cls) => cls -> IO VScrollBar get_v_scrollbar cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_get_v_scrollbar (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "get_v_scrollbar" '[] (IO VScrollBar) where nodeMethod = Godot.Core.ScrollContainer.get_v_scrollbar {-# NOINLINE bindScrollContainer_is_following_focus #-} -- | If @true@, the ScrollContainer will automatically scroll to focused children (including indirect children) to make sure they are fully visible. bindScrollContainer_is_following_focus :: MethodBind bindScrollContainer_is_following_focus = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "is_following_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the ScrollContainer will automatically scroll to focused children (including indirect children) to make sure they are fully visible. is_following_focus :: (ScrollContainer :< cls, Object :< cls) => cls -> IO Bool is_following_focus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_is_following_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "is_following_focus" '[] (IO Bool) where nodeMethod = Godot.Core.ScrollContainer.is_following_focus {-# NOINLINE bindScrollContainer_is_h_scroll_enabled #-} -- | If @true@, enables horizontal scrolling. bindScrollContainer_is_h_scroll_enabled :: MethodBind bindScrollContainer_is_h_scroll_enabled = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "is_h_scroll_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables horizontal scrolling. is_h_scroll_enabled :: (ScrollContainer :< cls, Object :< cls) => cls -> IO Bool is_h_scroll_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_is_h_scroll_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "is_h_scroll_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ScrollContainer.is_h_scroll_enabled {-# NOINLINE bindScrollContainer_is_v_scroll_enabled #-} -- | If @true@, enables vertical scrolling. bindScrollContainer_is_v_scroll_enabled :: MethodBind bindScrollContainer_is_v_scroll_enabled = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "is_v_scroll_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables vertical scrolling. is_v_scroll_enabled :: (ScrollContainer :< cls, Object :< cls) => cls -> IO Bool is_v_scroll_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_is_v_scroll_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "is_v_scroll_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ScrollContainer.is_v_scroll_enabled {-# NOINLINE bindScrollContainer_set_deadzone #-} bindScrollContainer_set_deadzone :: MethodBind bindScrollContainer_set_deadzone = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "set_deadzone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_deadzone :: (ScrollContainer :< cls, Object :< cls) => cls -> Int -> IO () set_deadzone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_set_deadzone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "set_deadzone" '[Int] (IO ()) where nodeMethod = Godot.Core.ScrollContainer.set_deadzone {-# NOINLINE bindScrollContainer_set_enable_h_scroll #-} -- | If @true@, enables horizontal scrolling. bindScrollContainer_set_enable_h_scroll :: MethodBind bindScrollContainer_set_enable_h_scroll = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "set_enable_h_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables horizontal scrolling. set_enable_h_scroll :: (ScrollContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_enable_h_scroll cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_set_enable_h_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "set_enable_h_scroll" '[Bool] (IO ()) where nodeMethod = Godot.Core.ScrollContainer.set_enable_h_scroll {-# NOINLINE bindScrollContainer_set_enable_v_scroll #-} -- | If @true@, enables vertical scrolling. bindScrollContainer_set_enable_v_scroll :: MethodBind bindScrollContainer_set_enable_v_scroll = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "set_enable_v_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables vertical scrolling. set_enable_v_scroll :: (ScrollContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_enable_v_scroll cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_set_enable_v_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "set_enable_v_scroll" '[Bool] (IO ()) where nodeMethod = Godot.Core.ScrollContainer.set_enable_v_scroll {-# NOINLINE bindScrollContainer_set_follow_focus #-} -- | If @true@, the ScrollContainer will automatically scroll to focused children (including indirect children) to make sure they are fully visible. bindScrollContainer_set_follow_focus :: MethodBind bindScrollContainer_set_follow_focus = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "set_follow_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the ScrollContainer will automatically scroll to focused children (including indirect children) to make sure they are fully visible. set_follow_focus :: (ScrollContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_follow_focus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_set_follow_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "set_follow_focus" '[Bool] (IO ()) where nodeMethod = Godot.Core.ScrollContainer.set_follow_focus {-# NOINLINE bindScrollContainer_set_h_scroll #-} -- | The current horizontal scroll value. bindScrollContainer_set_h_scroll :: MethodBind bindScrollContainer_set_h_scroll = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "set_h_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current horizontal scroll value. set_h_scroll :: (ScrollContainer :< cls, Object :< cls) => cls -> Int -> IO () set_h_scroll cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_set_h_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "set_h_scroll" '[Int] (IO ()) where nodeMethod = Godot.Core.ScrollContainer.set_h_scroll {-# NOINLINE bindScrollContainer_set_v_scroll #-} -- | The current vertical scroll value. bindScrollContainer_set_v_scroll :: MethodBind bindScrollContainer_set_v_scroll = unsafePerformIO $ withCString "ScrollContainer" $ \ clsNamePtr -> withCString "set_v_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current vertical scroll value. set_v_scroll :: (ScrollContainer :< cls, Object :< cls) => cls -> Int -> IO () set_v_scroll cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScrollContainer_set_v_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScrollContainer "set_v_scroll" '[Int] (IO ()) where nodeMethod = Godot.Core.ScrollContainer.set_v_scroll ================================================ FILE: src/Godot/Core/SegmentShape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SegmentShape2D (Godot.Core.SegmentShape2D.get_a, Godot.Core.SegmentShape2D.get_b, Godot.Core.SegmentShape2D.set_a, Godot.Core.SegmentShape2D.set_b) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape2D() instance NodeProperty SegmentShape2D "a" Vector2 'False where nodeProperty = (get_a, wrapDroppingSetter set_a, Nothing) instance NodeProperty SegmentShape2D "b" Vector2 'False where nodeProperty = (get_b, wrapDroppingSetter set_b, Nothing) {-# NOINLINE bindSegmentShape2D_get_a #-} -- | The segment's first point position. bindSegmentShape2D_get_a :: MethodBind bindSegmentShape2D_get_a = unsafePerformIO $ withCString "SegmentShape2D" $ \ clsNamePtr -> withCString "get_a" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The segment's first point position. get_a :: (SegmentShape2D :< cls, Object :< cls) => cls -> IO Vector2 get_a cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSegmentShape2D_get_a (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SegmentShape2D "get_a" '[] (IO Vector2) where nodeMethod = Godot.Core.SegmentShape2D.get_a {-# NOINLINE bindSegmentShape2D_get_b #-} -- | The segment's second point position. bindSegmentShape2D_get_b :: MethodBind bindSegmentShape2D_get_b = unsafePerformIO $ withCString "SegmentShape2D" $ \ clsNamePtr -> withCString "get_b" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The segment's second point position. get_b :: (SegmentShape2D :< cls, Object :< cls) => cls -> IO Vector2 get_b cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSegmentShape2D_get_b (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SegmentShape2D "get_b" '[] (IO Vector2) where nodeMethod = Godot.Core.SegmentShape2D.get_b {-# NOINLINE bindSegmentShape2D_set_a #-} -- | The segment's first point position. bindSegmentShape2D_set_a :: MethodBind bindSegmentShape2D_set_a = unsafePerformIO $ withCString "SegmentShape2D" $ \ clsNamePtr -> withCString "set_a" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The segment's first point position. set_a :: (SegmentShape2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_a cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSegmentShape2D_set_a (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SegmentShape2D "set_a" '[Vector2] (IO ()) where nodeMethod = Godot.Core.SegmentShape2D.set_a {-# NOINLINE bindSegmentShape2D_set_b #-} -- | The segment's second point position. bindSegmentShape2D_set_b :: MethodBind bindSegmentShape2D_set_b = unsafePerformIO $ withCString "SegmentShape2D" $ \ clsNamePtr -> withCString "set_b" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The segment's second point position. set_b :: (SegmentShape2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_b cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSegmentShape2D_set_b (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SegmentShape2D "set_b" '[Vector2] (IO ()) where nodeMethod = Godot.Core.SegmentShape2D.set_b ================================================ FILE: src/Godot/Core/Semaphore.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Semaphore (Godot.Core.Semaphore.post, Godot.Core.Semaphore.wait) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindSemaphore_post #-} -- | Lowers the @Semaphore@, allowing one more thread in. Returns @OK@ on success, @ERR_BUSY@ otherwise. bindSemaphore_post :: MethodBind bindSemaphore_post = unsafePerformIO $ withCString "_Semaphore" $ \ clsNamePtr -> withCString "post" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Lowers the @Semaphore@, allowing one more thread in. Returns @OK@ on success, @ERR_BUSY@ otherwise. post :: (Semaphore :< cls, Object :< cls) => cls -> IO Int post cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSemaphore_post (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Semaphore "post" '[] (IO Int) where nodeMethod = Godot.Core.Semaphore.post {-# NOINLINE bindSemaphore_wait #-} -- | Tries to wait for the @Semaphore@, if its value is zero, blocks until non-zero. Returns @OK@ on success, @ERR_BUSY@ otherwise. bindSemaphore_wait :: MethodBind bindSemaphore_wait = unsafePerformIO $ withCString "_Semaphore" $ \ clsNamePtr -> withCString "wait" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tries to wait for the @Semaphore@, if its value is zero, blocks until non-zero. Returns @OK@ on success, @ERR_BUSY@ otherwise. wait :: (Semaphore :< cls, Object :< cls) => cls -> IO Int wait cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSemaphore_wait (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Semaphore "wait" '[] (IO Int) where nodeMethod = Godot.Core.Semaphore.wait ================================================ FILE: src/Godot/Core/Separator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Separator () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() ================================================ FILE: src/Godot/Core/Shader.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Shader (Godot.Core.Shader._MODE_CANVAS_ITEM, Godot.Core.Shader._MODE_PARTICLES, Godot.Core.Shader._MODE_SPATIAL, Godot.Core.Shader.get_code, Godot.Core.Shader.get_default_texture_param, Godot.Core.Shader.get_mode, Godot.Core.Shader.has_param, Godot.Core.Shader.set_code, Godot.Core.Shader.set_default_texture_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _MODE_CANVAS_ITEM :: Int _MODE_CANVAS_ITEM = 1 _MODE_PARTICLES :: Int _MODE_PARTICLES = 2 _MODE_SPATIAL :: Int _MODE_SPATIAL = 0 instance NodeProperty Shader "code" GodotString 'False where nodeProperty = (get_code, wrapDroppingSetter set_code, Nothing) {-# NOINLINE bindShader_get_code #-} -- | Returns the shader's code as the user has written it, not the full generated code used internally. bindShader_get_code :: MethodBind bindShader_get_code = unsafePerformIO $ withCString "Shader" $ \ clsNamePtr -> withCString "get_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shader's code as the user has written it, not the full generated code used internally. get_code :: (Shader :< cls, Object :< cls) => cls -> IO GodotString get_code cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShader_get_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shader "get_code" '[] (IO GodotString) where nodeMethod = Godot.Core.Shader.get_code {-# NOINLINE bindShader_get_default_texture_param #-} -- | Returns the texture that is set as default for the specified parameter. -- __Note:__ @param@ must match the name of the uniform in the code exactly. bindShader_get_default_texture_param :: MethodBind bindShader_get_default_texture_param = unsafePerformIO $ withCString "Shader" $ \ clsNamePtr -> withCString "get_default_texture_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the texture that is set as default for the specified parameter. -- __Note:__ @param@ must match the name of the uniform in the code exactly. get_default_texture_param :: (Shader :< cls, Object :< cls) => cls -> GodotString -> IO Texture get_default_texture_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShader_get_default_texture_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shader "get_default_texture_param" '[GodotString] (IO Texture) where nodeMethod = Godot.Core.Shader.get_default_texture_param {-# NOINLINE bindShader_get_mode #-} -- | Returns the shader mode for the shader, either @MODE_CANVAS_ITEM@, @MODE_SPATIAL@ or @MODE_PARTICLES@. bindShader_get_mode :: MethodBind bindShader_get_mode = unsafePerformIO $ withCString "Shader" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shader mode for the shader, either @MODE_CANVAS_ITEM@, @MODE_SPATIAL@ or @MODE_PARTICLES@. get_mode :: (Shader :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShader_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shader "get_mode" '[] (IO Int) where nodeMethod = Godot.Core.Shader.get_mode {-# NOINLINE bindShader_has_param #-} -- | Returns @true@ if the shader has this param defined as a uniform in its code. -- __Note:__ @param@ must match the name of the uniform in the code exactly. bindShader_has_param :: MethodBind bindShader_has_param = unsafePerformIO $ withCString "Shader" $ \ clsNamePtr -> withCString "has_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the shader has this param defined as a uniform in its code. -- __Note:__ @param@ must match the name of the uniform in the code exactly. has_param :: (Shader :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShader_has_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shader "has_param" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.Shader.has_param {-# NOINLINE bindShader_set_code #-} -- | Returns the shader's code as the user has written it, not the full generated code used internally. bindShader_set_code :: MethodBind bindShader_set_code = unsafePerformIO $ withCString "Shader" $ \ clsNamePtr -> withCString "set_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shader's code as the user has written it, not the full generated code used internally. set_code :: (Shader :< cls, Object :< cls) => cls -> GodotString -> IO () set_code cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShader_set_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shader "set_code" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Shader.set_code {-# NOINLINE bindShader_set_default_texture_param #-} -- | Sets the default texture to be used with a texture uniform. The default is used if a texture is not set in the @ShaderMaterial@. -- __Note:__ @param@ must match the name of the uniform in the code exactly. bindShader_set_default_texture_param :: MethodBind bindShader_set_default_texture_param = unsafePerformIO $ withCString "Shader" $ \ clsNamePtr -> withCString "set_default_texture_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the default texture to be used with a texture uniform. The default is used if a texture is not set in the @ShaderMaterial@. -- __Note:__ @param@ must match the name of the uniform in the code exactly. set_default_texture_param :: (Shader :< cls, Object :< cls) => cls -> GodotString -> Texture -> IO () set_default_texture_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindShader_set_default_texture_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shader "set_default_texture_param" '[GodotString, Texture] (IO ()) where nodeMethod = Godot.Core.Shader.set_default_texture_param ================================================ FILE: src/Godot/Core/ShaderMaterial.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ShaderMaterial (Godot.Core.ShaderMaterial._shader_changed, Godot.Core.ShaderMaterial.get_shader, Godot.Core.ShaderMaterial.get_shader_param, Godot.Core.ShaderMaterial.property_can_revert, Godot.Core.ShaderMaterial.property_get_revert, Godot.Core.ShaderMaterial.set_shader, Godot.Core.ShaderMaterial.set_shader_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Material() instance NodeProperty ShaderMaterial "shader" Shader 'False where nodeProperty = (get_shader, wrapDroppingSetter set_shader, Nothing) {-# NOINLINE bindShaderMaterial__shader_changed #-} bindShaderMaterial__shader_changed :: MethodBind bindShaderMaterial__shader_changed = unsafePerformIO $ withCString "ShaderMaterial" $ \ clsNamePtr -> withCString "_shader_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _shader_changed :: (ShaderMaterial :< cls, Object :< cls) => cls -> IO () _shader_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShaderMaterial__shader_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShaderMaterial "_shader_changed" '[] (IO ()) where nodeMethod = Godot.Core.ShaderMaterial._shader_changed {-# NOINLINE bindShaderMaterial_get_shader #-} -- | The @Shader@ program used to render this material. bindShaderMaterial_get_shader :: MethodBind bindShaderMaterial_get_shader = unsafePerformIO $ withCString "ShaderMaterial" $ \ clsNamePtr -> withCString "get_shader" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Shader@ program used to render this material. get_shader :: (ShaderMaterial :< cls, Object :< cls) => cls -> IO Shader get_shader cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShaderMaterial_get_shader (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShaderMaterial "get_shader" '[] (IO Shader) where nodeMethod = Godot.Core.ShaderMaterial.get_shader {-# NOINLINE bindShaderMaterial_get_shader_param #-} -- | Returns the current value set for this material of a uniform in the shader. bindShaderMaterial_get_shader_param :: MethodBind bindShaderMaterial_get_shader_param = unsafePerformIO $ withCString "ShaderMaterial" $ \ clsNamePtr -> withCString "get_shader_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current value set for this material of a uniform in the shader. get_shader_param :: (ShaderMaterial :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get_shader_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShaderMaterial_get_shader_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShaderMaterial "get_shader_param" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.ShaderMaterial.get_shader_param {-# NOINLINE bindShaderMaterial_property_can_revert #-} -- | Returns @true@ if the property identified by @name@ can be reverted to a default value. bindShaderMaterial_property_can_revert :: MethodBind bindShaderMaterial_property_can_revert = unsafePerformIO $ withCString "ShaderMaterial" $ \ clsNamePtr -> withCString "property_can_revert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the property identified by @name@ can be reverted to a default value. property_can_revert :: (ShaderMaterial :< cls, Object :< cls) => cls -> GodotString -> IO Bool property_can_revert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShaderMaterial_property_can_revert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShaderMaterial "property_can_revert" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.ShaderMaterial.property_can_revert {-# NOINLINE bindShaderMaterial_property_get_revert #-} -- | Returns the default value of the material property with given @name@. bindShaderMaterial_property_get_revert :: MethodBind bindShaderMaterial_property_get_revert = unsafePerformIO $ withCString "ShaderMaterial" $ \ clsNamePtr -> withCString "property_get_revert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the default value of the material property with given @name@. property_get_revert :: (ShaderMaterial :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant property_get_revert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShaderMaterial_property_get_revert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShaderMaterial "property_get_revert" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.ShaderMaterial.property_get_revert {-# NOINLINE bindShaderMaterial_set_shader #-} -- | The @Shader@ program used to render this material. bindShaderMaterial_set_shader :: MethodBind bindShaderMaterial_set_shader = unsafePerformIO $ withCString "ShaderMaterial" $ \ clsNamePtr -> withCString "set_shader" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Shader@ program used to render this material. set_shader :: (ShaderMaterial :< cls, Object :< cls) => cls -> Shader -> IO () set_shader cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShaderMaterial_set_shader (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShaderMaterial "set_shader" '[Shader] (IO ()) where nodeMethod = Godot.Core.ShaderMaterial.set_shader {-# NOINLINE bindShaderMaterial_set_shader_param #-} -- | Changes the value set for this material of a uniform in the shader. __Note:__ @param@ must match the name of the uniform in the code exactly. bindShaderMaterial_set_shader_param :: MethodBind bindShaderMaterial_set_shader_param = unsafePerformIO $ withCString "ShaderMaterial" $ \ clsNamePtr -> withCString "set_shader_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the value set for this material of a uniform in the shader. __Note:__ @param@ must match the name of the uniform in the code exactly. set_shader_param :: (ShaderMaterial :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set_shader_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindShaderMaterial_set_shader_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShaderMaterial "set_shader_param" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.ShaderMaterial.set_shader_param ================================================ FILE: src/Godot/Core/Shape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Shape (Godot.Core.Shape.get_margin, Godot.Core.Shape.set_margin) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty Shape "margin" Float 'False where nodeProperty = (get_margin, wrapDroppingSetter set_margin, Nothing) {-# NOINLINE bindShape_get_margin #-} -- | The collision margin for the shape. bindShape_get_margin :: MethodBind bindShape_get_margin = unsafePerformIO $ withCString "Shape" $ \ clsNamePtr -> withCString "get_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision margin for the shape. get_margin :: (Shape :< cls, Object :< cls) => cls -> IO Float get_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShape_get_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shape "get_margin" '[] (IO Float) where nodeMethod = Godot.Core.Shape.get_margin {-# NOINLINE bindShape_set_margin #-} -- | The collision margin for the shape. bindShape_set_margin :: MethodBind bindShape_set_margin = unsafePerformIO $ withCString "Shape" $ \ clsNamePtr -> withCString "set_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision margin for the shape. set_margin :: (Shape :< cls, Object :< cls) => cls -> Float -> IO () set_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShape_set_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shape "set_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.Shape.set_margin ================================================ FILE: src/Godot/Core/Shape2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Shape2D (Godot.Core.Shape2D.collide, Godot.Core.Shape2D.collide_and_get_contacts, Godot.Core.Shape2D.collide_with_motion, Godot.Core.Shape2D.collide_with_motion_and_get_contacts, Godot.Core.Shape2D.get_custom_solver_bias, Godot.Core.Shape2D.set_custom_solver_bias) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty Shape2D "custom_solver_bias" Float 'False where nodeProperty = (get_custom_solver_bias, wrapDroppingSetter set_custom_solver_bias, Nothing) {-# NOINLINE bindShape2D_collide #-} -- | Returns @true@ if this shape is colliding with another. -- This method needs the transformation matrix for this shape (@local_xform@), the shape to check collisions with (@with_shape@), and the transformation matrix of that shape (@shape_xform@). bindShape2D_collide :: MethodBind bindShape2D_collide = unsafePerformIO $ withCString "Shape2D" $ \ clsNamePtr -> withCString "collide" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this shape is colliding with another. -- This method needs the transformation matrix for this shape (@local_xform@), the shape to check collisions with (@with_shape@), and the transformation matrix of that shape (@shape_xform@). collide :: (Shape2D :< cls, Object :< cls) => cls -> Transform2d -> Shape2D -> Transform2d -> IO Bool collide cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindShape2D_collide (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shape2D "collide" '[Transform2d, Shape2D, Transform2d] (IO Bool) where nodeMethod = Godot.Core.Shape2D.collide {-# NOINLINE bindShape2D_collide_and_get_contacts #-} -- | Returns a list of the points where this shape touches another. If there are no collisions the list is empty. -- This method needs the transformation matrix for this shape (@local_xform@), the shape to check collisions with (@with_shape@), and the transformation matrix of that shape (@shape_xform@). bindShape2D_collide_and_get_contacts :: MethodBind bindShape2D_collide_and_get_contacts = unsafePerformIO $ withCString "Shape2D" $ \ clsNamePtr -> withCString "collide_and_get_contacts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of the points where this shape touches another. If there are no collisions the list is empty. -- This method needs the transformation matrix for this shape (@local_xform@), the shape to check collisions with (@with_shape@), and the transformation matrix of that shape (@shape_xform@). collide_and_get_contacts :: (Shape2D :< cls, Object :< cls) => cls -> Transform2d -> Shape2D -> Transform2d -> IO Array collide_and_get_contacts cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindShape2D_collide_and_get_contacts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shape2D "collide_and_get_contacts" '[Transform2d, Shape2D, Transform2d] (IO Array) where nodeMethod = Godot.Core.Shape2D.collide_and_get_contacts {-# NOINLINE bindShape2D_collide_with_motion #-} -- | Returns whether this shape would collide with another, if a given movement was applied. -- This method needs the transformation matrix for this shape (@local_xform@), the movement to test on this shape (@local_motion@), the shape to check collisions with (@with_shape@), the transformation matrix of that shape (@shape_xform@), and the movement to test onto the other object (@shape_motion@). bindShape2D_collide_with_motion :: MethodBind bindShape2D_collide_with_motion = unsafePerformIO $ withCString "Shape2D" $ \ clsNamePtr -> withCString "collide_with_motion" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether this shape would collide with another, if a given movement was applied. -- This method needs the transformation matrix for this shape (@local_xform@), the movement to test on this shape (@local_motion@), the shape to check collisions with (@with_shape@), the transformation matrix of that shape (@shape_xform@), and the movement to test onto the other object (@shape_motion@). collide_with_motion :: (Shape2D :< cls, Object :< cls) => cls -> Transform2d -> Vector2 -> Shape2D -> Transform2d -> Vector2 -> IO Bool collide_with_motion cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindShape2D_collide_with_motion (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shape2D "collide_with_motion" '[Transform2d, Vector2, Shape2D, Transform2d, Vector2] (IO Bool) where nodeMethod = Godot.Core.Shape2D.collide_with_motion {-# NOINLINE bindShape2D_collide_with_motion_and_get_contacts #-} -- | Returns a list of the points where this shape would touch another, if a given movement was applied. If there are no collisions the list is empty. -- This method needs the transformation matrix for this shape (@local_xform@), the movement to test on this shape (@local_motion@), the shape to check collisions with (@with_shape@), the transformation matrix of that shape (@shape_xform@), and the movement to test onto the other object (@shape_motion@). bindShape2D_collide_with_motion_and_get_contacts :: MethodBind bindShape2D_collide_with_motion_and_get_contacts = unsafePerformIO $ withCString "Shape2D" $ \ clsNamePtr -> withCString "collide_with_motion_and_get_contacts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of the points where this shape would touch another, if a given movement was applied. If there are no collisions the list is empty. -- This method needs the transformation matrix for this shape (@local_xform@), the movement to test on this shape (@local_motion@), the shape to check collisions with (@with_shape@), the transformation matrix of that shape (@shape_xform@), and the movement to test onto the other object (@shape_motion@). collide_with_motion_and_get_contacts :: (Shape2D :< cls, Object :< cls) => cls -> Transform2d -> Vector2 -> Shape2D -> Transform2d -> Vector2 -> IO Array collide_with_motion_and_get_contacts cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindShape2D_collide_with_motion_and_get_contacts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shape2D "collide_with_motion_and_get_contacts" '[Transform2d, Vector2, Shape2D, Transform2d, Vector2] (IO Array) where nodeMethod = Godot.Core.Shape2D.collide_with_motion_and_get_contacts {-# NOINLINE bindShape2D_get_custom_solver_bias #-} -- | The shape's custom solver bias. bindShape2D_get_custom_solver_bias :: MethodBind bindShape2D_get_custom_solver_bias = unsafePerformIO $ withCString "Shape2D" $ \ clsNamePtr -> withCString "get_custom_solver_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shape's custom solver bias. get_custom_solver_bias :: (Shape2D :< cls, Object :< cls) => cls -> IO Float get_custom_solver_bias cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShape2D_get_custom_solver_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shape2D "get_custom_solver_bias" '[] (IO Float) where nodeMethod = Godot.Core.Shape2D.get_custom_solver_bias {-# NOINLINE bindShape2D_set_custom_solver_bias #-} -- | The shape's custom solver bias. bindShape2D_set_custom_solver_bias :: MethodBind bindShape2D_set_custom_solver_bias = unsafePerformIO $ withCString "Shape2D" $ \ clsNamePtr -> withCString "set_custom_solver_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shape's custom solver bias. set_custom_solver_bias :: (Shape2D :< cls, Object :< cls) => cls -> Float -> IO () set_custom_solver_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShape2D_set_custom_solver_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Shape2D "set_custom_solver_bias" '[Float] (IO ()) where nodeMethod = Godot.Core.Shape2D.set_custom_solver_bias ================================================ FILE: src/Godot/Core/ShortCut.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ShortCut (Godot.Core.ShortCut.get_as_text, Godot.Core.ShortCut.get_shortcut, Godot.Core.ShortCut.is_shortcut, Godot.Core.ShortCut.is_valid, Godot.Core.ShortCut.set_shortcut) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty ShortCut "shortcut" InputEvent 'False where nodeProperty = (get_shortcut, wrapDroppingSetter set_shortcut, Nothing) {-# NOINLINE bindShortCut_get_as_text #-} -- | Returns the shortcut's @InputEvent@ as a @String@. bindShortCut_get_as_text :: MethodBind bindShortCut_get_as_text = unsafePerformIO $ withCString "ShortCut" $ \ clsNamePtr -> withCString "get_as_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shortcut's @InputEvent@ as a @String@. get_as_text :: (ShortCut :< cls, Object :< cls) => cls -> IO GodotString get_as_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShortCut_get_as_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShortCut "get_as_text" '[] (IO GodotString) where nodeMethod = Godot.Core.ShortCut.get_as_text {-# NOINLINE bindShortCut_get_shortcut #-} -- | The shortcut's @InputEvent@. -- Generally the @InputEvent@ is a keyboard key, though it can be any @InputEvent@. bindShortCut_get_shortcut :: MethodBind bindShortCut_get_shortcut = unsafePerformIO $ withCString "ShortCut" $ \ clsNamePtr -> withCString "get_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shortcut's @InputEvent@. -- Generally the @InputEvent@ is a keyboard key, though it can be any @InputEvent@. get_shortcut :: (ShortCut :< cls, Object :< cls) => cls -> IO InputEvent get_shortcut cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShortCut_get_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShortCut "get_shortcut" '[] (IO InputEvent) where nodeMethod = Godot.Core.ShortCut.get_shortcut {-# NOINLINE bindShortCut_is_shortcut #-} -- | Returns @true@ if the shortcut's @InputEvent@ equals @event@. bindShortCut_is_shortcut :: MethodBind bindShortCut_is_shortcut = unsafePerformIO $ withCString "ShortCut" $ \ clsNamePtr -> withCString "is_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the shortcut's @InputEvent@ equals @event@. is_shortcut :: (ShortCut :< cls, Object :< cls) => cls -> InputEvent -> IO Bool is_shortcut cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShortCut_is_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShortCut "is_shortcut" '[InputEvent] (IO Bool) where nodeMethod = Godot.Core.ShortCut.is_shortcut {-# NOINLINE bindShortCut_is_valid #-} -- | If @true@, this shortcut is valid. bindShortCut_is_valid :: MethodBind bindShortCut_is_valid = unsafePerformIO $ withCString "ShortCut" $ \ clsNamePtr -> withCString "is_valid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this shortcut is valid. is_valid :: (ShortCut :< cls, Object :< cls) => cls -> IO Bool is_valid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindShortCut_is_valid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShortCut "is_valid" '[] (IO Bool) where nodeMethod = Godot.Core.ShortCut.is_valid {-# NOINLINE bindShortCut_set_shortcut #-} -- | The shortcut's @InputEvent@. -- Generally the @InputEvent@ is a keyboard key, though it can be any @InputEvent@. bindShortCut_set_shortcut :: MethodBind bindShortCut_set_shortcut = unsafePerformIO $ withCString "ShortCut" $ \ clsNamePtr -> withCString "set_shortcut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shortcut's @InputEvent@. -- Generally the @InputEvent@ is a keyboard key, though it can be any @InputEvent@. set_shortcut :: (ShortCut :< cls, Object :< cls) => cls -> InputEvent -> IO () set_shortcut cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindShortCut_set_shortcut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ShortCut "set_shortcut" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ShortCut.set_shortcut ================================================ FILE: src/Godot/Core/Skeleton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Skeleton (Godot.Core.Skeleton._NOTIFICATION_UPDATE_SKELETON, Godot.Core.Skeleton.add_bone, Godot.Core.Skeleton.bind_child_node_to_bone, Godot.Core.Skeleton.clear_bones, Godot.Core.Skeleton.find_bone, Godot.Core.Skeleton.get_bone_count, Godot.Core.Skeleton.get_bone_custom_pose, Godot.Core.Skeleton.get_bone_global_pose, Godot.Core.Skeleton.get_bone_name, Godot.Core.Skeleton.get_bone_parent, Godot.Core.Skeleton.get_bone_pose, Godot.Core.Skeleton.get_bone_rest, Godot.Core.Skeleton.get_bound_child_nodes_to_bone, Godot.Core.Skeleton.is_bone_rest_disabled, Godot.Core.Skeleton.localize_rests, Godot.Core.Skeleton.physical_bones_add_collision_exception, Godot.Core.Skeleton.physical_bones_remove_collision_exception, Godot.Core.Skeleton.physical_bones_start_simulation, Godot.Core.Skeleton.physical_bones_stop_simulation, Godot.Core.Skeleton.register_skin, Godot.Core.Skeleton.set_bone_custom_pose, Godot.Core.Skeleton.set_bone_disable_rest, Godot.Core.Skeleton.set_bone_global_pose_override, Godot.Core.Skeleton.set_bone_parent, Godot.Core.Skeleton.set_bone_pose, Godot.Core.Skeleton.set_bone_rest, Godot.Core.Skeleton.unbind_child_node_from_bone, Godot.Core.Skeleton.unparent_bone_and_rest) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() _NOTIFICATION_UPDATE_SKELETON :: Int _NOTIFICATION_UPDATE_SKELETON = 50 {-# NOINLINE bindSkeleton_add_bone #-} -- | Adds a bone, with name @name@. @method get_bone_count@ will become the bone index. bindSkeleton_add_bone :: MethodBind bindSkeleton_add_bone = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "add_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a bone, with name @name@. @method get_bone_count@ will become the bone index. add_bone :: (Skeleton :< cls, Object :< cls) => cls -> GodotString -> IO () add_bone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_add_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "add_bone" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Skeleton.add_bone {-# NOINLINE bindSkeleton_bind_child_node_to_bone #-} -- | @i@Deprecated soon.@/i@ bindSkeleton_bind_child_node_to_bone :: MethodBind bindSkeleton_bind_child_node_to_bone = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "bind_child_node_to_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @i@Deprecated soon.@/i@ bind_child_node_to_bone :: (Skeleton :< cls, Object :< cls) => cls -> Int -> Node -> IO () bind_child_node_to_bone cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_bind_child_node_to_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "bind_child_node_to_bone" '[Int, Node] (IO ()) where nodeMethod = Godot.Core.Skeleton.bind_child_node_to_bone {-# NOINLINE bindSkeleton_clear_bones #-} -- | Clear all the bones in this skeleton. bindSkeleton_clear_bones :: MethodBind bindSkeleton_clear_bones = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "clear_bones" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear all the bones in this skeleton. clear_bones :: (Skeleton :< cls, Object :< cls) => cls -> IO () clear_bones cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_clear_bones (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "clear_bones" '[] (IO ()) where nodeMethod = Godot.Core.Skeleton.clear_bones {-# NOINLINE bindSkeleton_find_bone #-} -- | Returns the bone index that matches @name@ as its name. bindSkeleton_find_bone :: MethodBind bindSkeleton_find_bone = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "find_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the bone index that matches @name@ as its name. find_bone :: (Skeleton :< cls, Object :< cls) => cls -> GodotString -> IO Int find_bone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_find_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "find_bone" '[GodotString] (IO Int) where nodeMethod = Godot.Core.Skeleton.find_bone {-# NOINLINE bindSkeleton_get_bone_count #-} -- | Returns the amount of bones in the skeleton. bindSkeleton_get_bone_count :: MethodBind bindSkeleton_get_bone_count = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "get_bone_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of bones in the skeleton. get_bone_count :: (Skeleton :< cls, Object :< cls) => cls -> IO Int get_bone_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_get_bone_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "get_bone_count" '[] (IO Int) where nodeMethod = Godot.Core.Skeleton.get_bone_count {-# NOINLINE bindSkeleton_get_bone_custom_pose #-} -- | Returns the custom pose of the specified bone. Custom pose is applied on top of the rest pose. bindSkeleton_get_bone_custom_pose :: MethodBind bindSkeleton_get_bone_custom_pose = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "get_bone_custom_pose" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the custom pose of the specified bone. Custom pose is applied on top of the rest pose. get_bone_custom_pose :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO Transform get_bone_custom_pose cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_get_bone_custom_pose (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "get_bone_custom_pose" '[Int] (IO Transform) where nodeMethod = Godot.Core.Skeleton.get_bone_custom_pose {-# NOINLINE bindSkeleton_get_bone_global_pose #-} -- | Returns the overall transform of the specified bone, with respect to the skeleton. Being relative to the skeleton frame, this is not the actual "global" transform of the bone. bindSkeleton_get_bone_global_pose :: MethodBind bindSkeleton_get_bone_global_pose = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "get_bone_global_pose" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the overall transform of the specified bone, with respect to the skeleton. Being relative to the skeleton frame, this is not the actual "global" transform of the bone. get_bone_global_pose :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO Transform get_bone_global_pose cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_get_bone_global_pose (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "get_bone_global_pose" '[Int] (IO Transform) where nodeMethod = Godot.Core.Skeleton.get_bone_global_pose {-# NOINLINE bindSkeleton_get_bone_name #-} -- | Returns the name of the bone at index @index@. bindSkeleton_get_bone_name :: MethodBind bindSkeleton_get_bone_name = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "get_bone_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the bone at index @index@. get_bone_name :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO GodotString get_bone_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_get_bone_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "get_bone_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.Skeleton.get_bone_name {-# NOINLINE bindSkeleton_get_bone_parent #-} -- | Returns the bone index which is the parent of the bone at @bone_idx@. If -1, then bone has no parent. -- __Note:__ The parent bone returned will always be less than @bone_idx@. bindSkeleton_get_bone_parent :: MethodBind bindSkeleton_get_bone_parent = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "get_bone_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the bone index which is the parent of the bone at @bone_idx@. If -1, then bone has no parent. -- __Note:__ The parent bone returned will always be less than @bone_idx@. get_bone_parent :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO Int get_bone_parent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_get_bone_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "get_bone_parent" '[Int] (IO Int) where nodeMethod = Godot.Core.Skeleton.get_bone_parent {-# NOINLINE bindSkeleton_get_bone_pose #-} -- | Returns the pose transform of the specified bone. Pose is applied on top of the custom pose, which is applied on top the rest pose. bindSkeleton_get_bone_pose :: MethodBind bindSkeleton_get_bone_pose = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "get_bone_pose" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the pose transform of the specified bone. Pose is applied on top of the custom pose, which is applied on top the rest pose. get_bone_pose :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO Transform get_bone_pose cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_get_bone_pose (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "get_bone_pose" '[Int] (IO Transform) where nodeMethod = Godot.Core.Skeleton.get_bone_pose {-# NOINLINE bindSkeleton_get_bone_rest #-} -- | Returns the rest transform for a bone @bone_idx@. bindSkeleton_get_bone_rest :: MethodBind bindSkeleton_get_bone_rest = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "get_bone_rest" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the rest transform for a bone @bone_idx@. get_bone_rest :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO Transform get_bone_rest cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_get_bone_rest (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "get_bone_rest" '[Int] (IO Transform) where nodeMethod = Godot.Core.Skeleton.get_bone_rest {-# NOINLINE bindSkeleton_get_bound_child_nodes_to_bone #-} -- | @i@Deprecated soon.@/i@ bindSkeleton_get_bound_child_nodes_to_bone :: MethodBind bindSkeleton_get_bound_child_nodes_to_bone = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "get_bound_child_nodes_to_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @i@Deprecated soon.@/i@ get_bound_child_nodes_to_bone :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO Array get_bound_child_nodes_to_bone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_get_bound_child_nodes_to_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "get_bound_child_nodes_to_bone" '[Int] (IO Array) where nodeMethod = Godot.Core.Skeleton.get_bound_child_nodes_to_bone {-# NOINLINE bindSkeleton_is_bone_rest_disabled #-} bindSkeleton_is_bone_rest_disabled :: MethodBind bindSkeleton_is_bone_rest_disabled = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "is_bone_rest_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_bone_rest_disabled :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO Bool is_bone_rest_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_is_bone_rest_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "is_bone_rest_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.Skeleton.is_bone_rest_disabled {-# NOINLINE bindSkeleton_localize_rests #-} bindSkeleton_localize_rests :: MethodBind bindSkeleton_localize_rests = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "localize_rests" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr localize_rests :: (Skeleton :< cls, Object :< cls) => cls -> IO () localize_rests cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_localize_rests (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "localize_rests" '[] (IO ()) where nodeMethod = Godot.Core.Skeleton.localize_rests {-# NOINLINE bindSkeleton_physical_bones_add_collision_exception #-} bindSkeleton_physical_bones_add_collision_exception :: MethodBind bindSkeleton_physical_bones_add_collision_exception = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "physical_bones_add_collision_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr physical_bones_add_collision_exception :: (Skeleton :< cls, Object :< cls) => cls -> Rid -> IO () physical_bones_add_collision_exception cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_physical_bones_add_collision_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "physical_bones_add_collision_exception" '[Rid] (IO ()) where nodeMethod = Godot.Core.Skeleton.physical_bones_add_collision_exception {-# NOINLINE bindSkeleton_physical_bones_remove_collision_exception #-} bindSkeleton_physical_bones_remove_collision_exception :: MethodBind bindSkeleton_physical_bones_remove_collision_exception = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "physical_bones_remove_collision_exception" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr physical_bones_remove_collision_exception :: (Skeleton :< cls, Object :< cls) => cls -> Rid -> IO () physical_bones_remove_collision_exception cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_physical_bones_remove_collision_exception (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "physical_bones_remove_collision_exception" '[Rid] (IO ()) where nodeMethod = Godot.Core.Skeleton.physical_bones_remove_collision_exception {-# NOINLINE bindSkeleton_physical_bones_start_simulation #-} bindSkeleton_physical_bones_start_simulation :: MethodBind bindSkeleton_physical_bones_start_simulation = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "physical_bones_start_simulation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr physical_bones_start_simulation :: (Skeleton :< cls, Object :< cls) => cls -> Maybe Array -> IO () physical_bones_start_simulation cls arg1 = withVariantArray [defaultedVariant VariantArray V.empty arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_physical_bones_start_simulation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "physical_bones_start_simulation" '[Maybe Array] (IO ()) where nodeMethod = Godot.Core.Skeleton.physical_bones_start_simulation {-# NOINLINE bindSkeleton_physical_bones_stop_simulation #-} bindSkeleton_physical_bones_stop_simulation :: MethodBind bindSkeleton_physical_bones_stop_simulation = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "physical_bones_stop_simulation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr physical_bones_stop_simulation :: (Skeleton :< cls, Object :< cls) => cls -> IO () physical_bones_stop_simulation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_physical_bones_stop_simulation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "physical_bones_stop_simulation" '[] (IO ()) where nodeMethod = Godot.Core.Skeleton.physical_bones_stop_simulation {-# NOINLINE bindSkeleton_register_skin #-} bindSkeleton_register_skin :: MethodBind bindSkeleton_register_skin = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "register_skin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr register_skin :: (Skeleton :< cls, Object :< cls) => cls -> Skin -> IO SkinReference register_skin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_register_skin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "register_skin" '[Skin] (IO SkinReference) where nodeMethod = Godot.Core.Skeleton.register_skin {-# NOINLINE bindSkeleton_set_bone_custom_pose #-} bindSkeleton_set_bone_custom_pose :: MethodBind bindSkeleton_set_bone_custom_pose = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "set_bone_custom_pose" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bone_custom_pose :: (Skeleton :< cls, Object :< cls) => cls -> Int -> Transform -> IO () set_bone_custom_pose cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_set_bone_custom_pose (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "set_bone_custom_pose" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.Skeleton.set_bone_custom_pose {-# NOINLINE bindSkeleton_set_bone_disable_rest #-} bindSkeleton_set_bone_disable_rest :: MethodBind bindSkeleton_set_bone_disable_rest = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "set_bone_disable_rest" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bone_disable_rest :: (Skeleton :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_bone_disable_rest cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_set_bone_disable_rest (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "set_bone_disable_rest" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Skeleton.set_bone_disable_rest {-# NOINLINE bindSkeleton_set_bone_global_pose_override #-} bindSkeleton_set_bone_global_pose_override :: MethodBind bindSkeleton_set_bone_global_pose_override = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "set_bone_global_pose_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bone_global_pose_override :: (Skeleton :< cls, Object :< cls) => cls -> Int -> Transform -> Float -> Maybe Bool -> IO () set_bone_global_pose_override cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_set_bone_global_pose_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "set_bone_global_pose_override" '[Int, Transform, Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Skeleton.set_bone_global_pose_override {-# NOINLINE bindSkeleton_set_bone_parent #-} -- | Sets the bone index @parent_idx@ as the parent of the bone at @bone_idx@. If -1, then bone has no parent. -- __Note:__ @parent_idx@ must be less than @bone_idx@. bindSkeleton_set_bone_parent :: MethodBind bindSkeleton_set_bone_parent = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "set_bone_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the bone index @parent_idx@ as the parent of the bone at @bone_idx@. If -1, then bone has no parent. -- __Note:__ @parent_idx@ must be less than @bone_idx@. set_bone_parent :: (Skeleton :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_bone_parent cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_set_bone_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "set_bone_parent" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Skeleton.set_bone_parent {-# NOINLINE bindSkeleton_set_bone_pose #-} -- | Sets the pose transform for bone @bone_idx@. bindSkeleton_set_bone_pose :: MethodBind bindSkeleton_set_bone_pose = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "set_bone_pose" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the pose transform for bone @bone_idx@. set_bone_pose :: (Skeleton :< cls, Object :< cls) => cls -> Int -> Transform -> IO () set_bone_pose cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_set_bone_pose (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "set_bone_pose" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.Skeleton.set_bone_pose {-# NOINLINE bindSkeleton_set_bone_rest #-} -- | Sets the rest transform for bone @bone_idx@. bindSkeleton_set_bone_rest :: MethodBind bindSkeleton_set_bone_rest = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "set_bone_rest" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the rest transform for bone @bone_idx@. set_bone_rest :: (Skeleton :< cls, Object :< cls) => cls -> Int -> Transform -> IO () set_bone_rest cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_set_bone_rest (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "set_bone_rest" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.Skeleton.set_bone_rest {-# NOINLINE bindSkeleton_unbind_child_node_from_bone #-} -- | @i@Deprecated soon.@/i@ bindSkeleton_unbind_child_node_from_bone :: MethodBind bindSkeleton_unbind_child_node_from_bone = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "unbind_child_node_from_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @i@Deprecated soon.@/i@ unbind_child_node_from_bone :: (Skeleton :< cls, Object :< cls) => cls -> Int -> Node -> IO () unbind_child_node_from_bone cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_unbind_child_node_from_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "unbind_child_node_from_bone" '[Int, Node] (IO ()) where nodeMethod = Godot.Core.Skeleton.unbind_child_node_from_bone {-# NOINLINE bindSkeleton_unparent_bone_and_rest #-} bindSkeleton_unparent_bone_and_rest :: MethodBind bindSkeleton_unparent_bone_and_rest = unsafePerformIO $ withCString "Skeleton" $ \ clsNamePtr -> withCString "unparent_bone_and_rest" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr unparent_bone_and_rest :: (Skeleton :< cls, Object :< cls) => cls -> Int -> IO () unparent_bone_and_rest cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton_unparent_bone_and_rest (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton "unparent_bone_and_rest" '[Int] (IO ()) where nodeMethod = Godot.Core.Skeleton.unparent_bone_and_rest ================================================ FILE: src/Godot/Core/Skeleton2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Skeleton2D (Godot.Core.Skeleton2D.sig_bone_setup_changed, Godot.Core.Skeleton2D._update_bone_setup, Godot.Core.Skeleton2D._update_transform, Godot.Core.Skeleton2D.get_bone, Godot.Core.Skeleton2D.get_bone_count, Godot.Core.Skeleton2D.get_skeleton) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() sig_bone_setup_changed :: Godot.Internal.Dispatch.Signal Skeleton2D sig_bone_setup_changed = Godot.Internal.Dispatch.Signal "bone_setup_changed" instance NodeSignal Skeleton2D "bone_setup_changed" '[] {-# NOINLINE bindSkeleton2D__update_bone_setup #-} bindSkeleton2D__update_bone_setup :: MethodBind bindSkeleton2D__update_bone_setup = unsafePerformIO $ withCString "Skeleton2D" $ \ clsNamePtr -> withCString "_update_bone_setup" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_bone_setup :: (Skeleton2D :< cls, Object :< cls) => cls -> IO () _update_bone_setup cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton2D__update_bone_setup (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton2D "_update_bone_setup" '[] (IO ()) where nodeMethod = Godot.Core.Skeleton2D._update_bone_setup {-# NOINLINE bindSkeleton2D__update_transform #-} bindSkeleton2D__update_transform :: MethodBind bindSkeleton2D__update_transform = unsafePerformIO $ withCString "Skeleton2D" $ \ clsNamePtr -> withCString "_update_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_transform :: (Skeleton2D :< cls, Object :< cls) => cls -> IO () _update_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton2D__update_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton2D "_update_transform" '[] (IO ()) where nodeMethod = Godot.Core.Skeleton2D._update_transform {-# NOINLINE bindSkeleton2D_get_bone #-} -- | Returns a @Bone2D@ from the node hierarchy parented by Skeleton2D. The object to return is identified by the parameter @idx@. Bones are indexed by descending the node hierarchy from top to bottom, adding the children of each branch before moving to the next sibling. bindSkeleton2D_get_bone :: MethodBind bindSkeleton2D_get_bone = unsafePerformIO $ withCString "Skeleton2D" $ \ clsNamePtr -> withCString "get_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @Bone2D@ from the node hierarchy parented by Skeleton2D. The object to return is identified by the parameter @idx@. Bones are indexed by descending the node hierarchy from top to bottom, adding the children of each branch before moving to the next sibling. get_bone :: (Skeleton2D :< cls, Object :< cls) => cls -> Int -> IO Bone2D get_bone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton2D_get_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton2D "get_bone" '[Int] (IO Bone2D) where nodeMethod = Godot.Core.Skeleton2D.get_bone {-# NOINLINE bindSkeleton2D_get_bone_count #-} -- | Returns the number of @Bone2D@ nodes in the node hierarchy parented by Skeleton2D. bindSkeleton2D_get_bone_count :: MethodBind bindSkeleton2D_get_bone_count = unsafePerformIO $ withCString "Skeleton2D" $ \ clsNamePtr -> withCString "get_bone_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of @Bone2D@ nodes in the node hierarchy parented by Skeleton2D. get_bone_count :: (Skeleton2D :< cls, Object :< cls) => cls -> IO Int get_bone_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton2D_get_bone_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton2D "get_bone_count" '[] (IO Int) where nodeMethod = Godot.Core.Skeleton2D.get_bone_count {-# NOINLINE bindSkeleton2D_get_skeleton #-} -- | Returns the @RID@ of a Skeleton2D instance. bindSkeleton2D_get_skeleton :: MethodBind bindSkeleton2D_get_skeleton = unsafePerformIO $ withCString "Skeleton2D" $ \ clsNamePtr -> withCString "get_skeleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @RID@ of a Skeleton2D instance. get_skeleton :: (Skeleton2D :< cls, Object :< cls) => cls -> IO Rid get_skeleton cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeleton2D_get_skeleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skeleton2D "get_skeleton" '[] (IO Rid) where nodeMethod = Godot.Core.Skeleton2D.get_skeleton ================================================ FILE: src/Godot/Core/SkeletonIK.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SkeletonIK (Godot.Core.SkeletonIK.get_interpolation, Godot.Core.SkeletonIK.get_magnet_position, Godot.Core.SkeletonIK.get_max_iterations, Godot.Core.SkeletonIK.get_min_distance, Godot.Core.SkeletonIK.get_parent_skeleton, Godot.Core.SkeletonIK.get_root_bone, Godot.Core.SkeletonIK.get_target_node, Godot.Core.SkeletonIK.get_target_transform, Godot.Core.SkeletonIK.get_tip_bone, Godot.Core.SkeletonIK.is_override_tip_basis, Godot.Core.SkeletonIK.is_running, Godot.Core.SkeletonIK.is_using_magnet, Godot.Core.SkeletonIK.set_interpolation, Godot.Core.SkeletonIK.set_magnet_position, Godot.Core.SkeletonIK.set_max_iterations, Godot.Core.SkeletonIK.set_min_distance, Godot.Core.SkeletonIK.set_override_tip_basis, Godot.Core.SkeletonIK.set_root_bone, Godot.Core.SkeletonIK.set_target_node, Godot.Core.SkeletonIK.set_target_transform, Godot.Core.SkeletonIK.set_tip_bone, Godot.Core.SkeletonIK.set_use_magnet, Godot.Core.SkeletonIK.start, Godot.Core.SkeletonIK.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() instance NodeProperty SkeletonIK "interpolation" Float 'False where nodeProperty = (get_interpolation, wrapDroppingSetter set_interpolation, Nothing) instance NodeProperty SkeletonIK "magnet" Vector3 'False where nodeProperty = (get_magnet_position, wrapDroppingSetter set_magnet_position, Nothing) instance NodeProperty SkeletonIK "max_iterations" Int 'False where nodeProperty = (get_max_iterations, wrapDroppingSetter set_max_iterations, Nothing) instance NodeProperty SkeletonIK "min_distance" Float 'False where nodeProperty = (get_min_distance, wrapDroppingSetter set_min_distance, Nothing) instance NodeProperty SkeletonIK "override_tip_basis" Bool 'False where nodeProperty = (is_override_tip_basis, wrapDroppingSetter set_override_tip_basis, Nothing) instance NodeProperty SkeletonIK "root_bone" GodotString 'False where nodeProperty = (get_root_bone, wrapDroppingSetter set_root_bone, Nothing) instance NodeProperty SkeletonIK "target" Transform 'False where nodeProperty = (get_target_transform, wrapDroppingSetter set_target_transform, Nothing) instance NodeProperty SkeletonIK "target_node" NodePath 'False where nodeProperty = (get_target_node, wrapDroppingSetter set_target_node, Nothing) instance NodeProperty SkeletonIK "tip_bone" GodotString 'False where nodeProperty = (get_tip_bone, wrapDroppingSetter set_tip_bone, Nothing) instance NodeProperty SkeletonIK "use_magnet" Bool 'False where nodeProperty = (is_using_magnet, wrapDroppingSetter set_use_magnet, Nothing) {-# NOINLINE bindSkeletonIK_get_interpolation #-} bindSkeletonIK_get_interpolation :: MethodBind bindSkeletonIK_get_interpolation = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_interpolation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_interpolation :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Float get_interpolation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_interpolation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_interpolation" '[] (IO Float) where nodeMethod = Godot.Core.SkeletonIK.get_interpolation {-# NOINLINE bindSkeletonIK_get_magnet_position #-} bindSkeletonIK_get_magnet_position :: MethodBind bindSkeletonIK_get_magnet_position = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_magnet_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_magnet_position :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Vector3 get_magnet_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_magnet_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_magnet_position" '[] (IO Vector3) where nodeMethod = Godot.Core.SkeletonIK.get_magnet_position {-# NOINLINE bindSkeletonIK_get_max_iterations #-} bindSkeletonIK_get_max_iterations :: MethodBind bindSkeletonIK_get_max_iterations = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_max_iterations" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_max_iterations :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Int get_max_iterations cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_max_iterations (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_max_iterations" '[] (IO Int) where nodeMethod = Godot.Core.SkeletonIK.get_max_iterations {-# NOINLINE bindSkeletonIK_get_min_distance #-} bindSkeletonIK_get_min_distance :: MethodBind bindSkeletonIK_get_min_distance = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_min_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_min_distance :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Float get_min_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_min_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_min_distance" '[] (IO Float) where nodeMethod = Godot.Core.SkeletonIK.get_min_distance {-# NOINLINE bindSkeletonIK_get_parent_skeleton #-} bindSkeletonIK_get_parent_skeleton :: MethodBind bindSkeletonIK_get_parent_skeleton = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_parent_skeleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_parent_skeleton :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Skeleton get_parent_skeleton cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_parent_skeleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_parent_skeleton" '[] (IO Skeleton) where nodeMethod = Godot.Core.SkeletonIK.get_parent_skeleton {-# NOINLINE bindSkeletonIK_get_root_bone #-} bindSkeletonIK_get_root_bone :: MethodBind bindSkeletonIK_get_root_bone = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_root_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_root_bone :: (SkeletonIK :< cls, Object :< cls) => cls -> IO GodotString get_root_bone cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_root_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_root_bone" '[] (IO GodotString) where nodeMethod = Godot.Core.SkeletonIK.get_root_bone {-# NOINLINE bindSkeletonIK_get_target_node #-} bindSkeletonIK_get_target_node :: MethodBind bindSkeletonIK_get_target_node = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_target_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_target_node :: (SkeletonIK :< cls, Object :< cls) => cls -> IO NodePath get_target_node cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_target_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_target_node" '[] (IO NodePath) where nodeMethod = Godot.Core.SkeletonIK.get_target_node {-# NOINLINE bindSkeletonIK_get_target_transform #-} bindSkeletonIK_get_target_transform :: MethodBind bindSkeletonIK_get_target_transform = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_target_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_target_transform :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Transform get_target_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_target_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_target_transform" '[] (IO Transform) where nodeMethod = Godot.Core.SkeletonIK.get_target_transform {-# NOINLINE bindSkeletonIK_get_tip_bone #-} bindSkeletonIK_get_tip_bone :: MethodBind bindSkeletonIK_get_tip_bone = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "get_tip_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_tip_bone :: (SkeletonIK :< cls, Object :< cls) => cls -> IO GodotString get_tip_bone cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_get_tip_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "get_tip_bone" '[] (IO GodotString) where nodeMethod = Godot.Core.SkeletonIK.get_tip_bone {-# NOINLINE bindSkeletonIK_is_override_tip_basis #-} bindSkeletonIK_is_override_tip_basis :: MethodBind bindSkeletonIK_is_override_tip_basis = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "is_override_tip_basis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_override_tip_basis :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Bool is_override_tip_basis cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_is_override_tip_basis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "is_override_tip_basis" '[] (IO Bool) where nodeMethod = Godot.Core.SkeletonIK.is_override_tip_basis {-# NOINLINE bindSkeletonIK_is_running #-} bindSkeletonIK_is_running :: MethodBind bindSkeletonIK_is_running = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "is_running" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_running :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Bool is_running cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_is_running (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "is_running" '[] (IO Bool) where nodeMethod = Godot.Core.SkeletonIK.is_running {-# NOINLINE bindSkeletonIK_is_using_magnet #-} bindSkeletonIK_is_using_magnet :: MethodBind bindSkeletonIK_is_using_magnet = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "is_using_magnet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_using_magnet :: (SkeletonIK :< cls, Object :< cls) => cls -> IO Bool is_using_magnet cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_is_using_magnet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "is_using_magnet" '[] (IO Bool) where nodeMethod = Godot.Core.SkeletonIK.is_using_magnet {-# NOINLINE bindSkeletonIK_set_interpolation #-} bindSkeletonIK_set_interpolation :: MethodBind bindSkeletonIK_set_interpolation = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_interpolation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_interpolation :: (SkeletonIK :< cls, Object :< cls) => cls -> Float -> IO () set_interpolation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_interpolation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_interpolation" '[Float] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_interpolation {-# NOINLINE bindSkeletonIK_set_magnet_position #-} bindSkeletonIK_set_magnet_position :: MethodBind bindSkeletonIK_set_magnet_position = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_magnet_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_magnet_position :: (SkeletonIK :< cls, Object :< cls) => cls -> Vector3 -> IO () set_magnet_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_magnet_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_magnet_position" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_magnet_position {-# NOINLINE bindSkeletonIK_set_max_iterations #-} bindSkeletonIK_set_max_iterations :: MethodBind bindSkeletonIK_set_max_iterations = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_max_iterations" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_max_iterations :: (SkeletonIK :< cls, Object :< cls) => cls -> Int -> IO () set_max_iterations cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_max_iterations (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_max_iterations" '[Int] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_max_iterations {-# NOINLINE bindSkeletonIK_set_min_distance #-} bindSkeletonIK_set_min_distance :: MethodBind bindSkeletonIK_set_min_distance = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_min_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_min_distance :: (SkeletonIK :< cls, Object :< cls) => cls -> Float -> IO () set_min_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_min_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_min_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_min_distance {-# NOINLINE bindSkeletonIK_set_override_tip_basis #-} bindSkeletonIK_set_override_tip_basis :: MethodBind bindSkeletonIK_set_override_tip_basis = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_override_tip_basis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_override_tip_basis :: (SkeletonIK :< cls, Object :< cls) => cls -> Bool -> IO () set_override_tip_basis cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_override_tip_basis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_override_tip_basis" '[Bool] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_override_tip_basis {-# NOINLINE bindSkeletonIK_set_root_bone #-} bindSkeletonIK_set_root_bone :: MethodBind bindSkeletonIK_set_root_bone = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_root_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_root_bone :: (SkeletonIK :< cls, Object :< cls) => cls -> GodotString -> IO () set_root_bone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_root_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_root_bone" '[GodotString] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_root_bone {-# NOINLINE bindSkeletonIK_set_target_node #-} bindSkeletonIK_set_target_node :: MethodBind bindSkeletonIK_set_target_node = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_target_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_target_node :: (SkeletonIK :< cls, Object :< cls) => cls -> NodePath -> IO () set_target_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_target_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_target_node" '[NodePath] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_target_node {-# NOINLINE bindSkeletonIK_set_target_transform #-} bindSkeletonIK_set_target_transform :: MethodBind bindSkeletonIK_set_target_transform = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_target_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_target_transform :: (SkeletonIK :< cls, Object :< cls) => cls -> Transform -> IO () set_target_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_target_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_target_transform" '[Transform] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_target_transform {-# NOINLINE bindSkeletonIK_set_tip_bone #-} bindSkeletonIK_set_tip_bone :: MethodBind bindSkeletonIK_set_tip_bone = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_tip_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_tip_bone :: (SkeletonIK :< cls, Object :< cls) => cls -> GodotString -> IO () set_tip_bone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_tip_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_tip_bone" '[GodotString] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_tip_bone {-# NOINLINE bindSkeletonIK_set_use_magnet #-} bindSkeletonIK_set_use_magnet :: MethodBind bindSkeletonIK_set_use_magnet = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "set_use_magnet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_use_magnet :: (SkeletonIK :< cls, Object :< cls) => cls -> Bool -> IO () set_use_magnet cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_set_use_magnet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "set_use_magnet" '[Bool] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.set_use_magnet {-# NOINLINE bindSkeletonIK_start #-} bindSkeletonIK_start :: MethodBind bindSkeletonIK_start = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr start :: (SkeletonIK :< cls, Object :< cls) => cls -> Maybe Bool -> IO () start cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "start" '[Maybe Bool] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.start {-# NOINLINE bindSkeletonIK_stop #-} bindSkeletonIK_stop :: MethodBind bindSkeletonIK_stop = unsafePerformIO $ withCString "SkeletonIK" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr stop :: (SkeletonIK :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkeletonIK_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkeletonIK "stop" '[] (IO ()) where nodeMethod = Godot.Core.SkeletonIK.stop ================================================ FILE: src/Godot/Core/Skin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Skin (Godot.Core.Skin.add_bind, Godot.Core.Skin.clear_binds, Godot.Core.Skin.get_bind_bone, Godot.Core.Skin.get_bind_count, Godot.Core.Skin.get_bind_pose, Godot.Core.Skin.set_bind_bone, Godot.Core.Skin.set_bind_count, Godot.Core.Skin.set_bind_pose) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindSkin_add_bind #-} bindSkin_add_bind :: MethodBind bindSkin_add_bind = unsafePerformIO $ withCString "Skin" $ \ clsNamePtr -> withCString "add_bind" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_bind :: (Skin :< cls, Object :< cls) => cls -> Int -> Transform -> IO () add_bind cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkin_add_bind (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skin "add_bind" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.Skin.add_bind {-# NOINLINE bindSkin_clear_binds #-} bindSkin_clear_binds :: MethodBind bindSkin_clear_binds = unsafePerformIO $ withCString "Skin" $ \ clsNamePtr -> withCString "clear_binds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear_binds :: (Skin :< cls, Object :< cls) => cls -> IO () clear_binds cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkin_clear_binds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skin "clear_binds" '[] (IO ()) where nodeMethod = Godot.Core.Skin.clear_binds {-# NOINLINE bindSkin_get_bind_bone #-} bindSkin_get_bind_bone :: MethodBind bindSkin_get_bind_bone = unsafePerformIO $ withCString "Skin" $ \ clsNamePtr -> withCString "get_bind_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bind_bone :: (Skin :< cls, Object :< cls) => cls -> Int -> IO Int get_bind_bone cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkin_get_bind_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skin "get_bind_bone" '[Int] (IO Int) where nodeMethod = Godot.Core.Skin.get_bind_bone {-# NOINLINE bindSkin_get_bind_count #-} bindSkin_get_bind_count :: MethodBind bindSkin_get_bind_count = unsafePerformIO $ withCString "Skin" $ \ clsNamePtr -> withCString "get_bind_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bind_count :: (Skin :< cls, Object :< cls) => cls -> IO Int get_bind_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkin_get_bind_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skin "get_bind_count" '[] (IO Int) where nodeMethod = Godot.Core.Skin.get_bind_count {-# NOINLINE bindSkin_get_bind_pose #-} bindSkin_get_bind_pose :: MethodBind bindSkin_get_bind_pose = unsafePerformIO $ withCString "Skin" $ \ clsNamePtr -> withCString "get_bind_pose" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bind_pose :: (Skin :< cls, Object :< cls) => cls -> Int -> IO Transform get_bind_pose cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkin_get_bind_pose (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skin "get_bind_pose" '[Int] (IO Transform) where nodeMethod = Godot.Core.Skin.get_bind_pose {-# NOINLINE bindSkin_set_bind_bone #-} bindSkin_set_bind_bone :: MethodBind bindSkin_set_bind_bone = unsafePerformIO $ withCString "Skin" $ \ clsNamePtr -> withCString "set_bind_bone" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bind_bone :: (Skin :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_bind_bone cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkin_set_bind_bone (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skin "set_bind_bone" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Skin.set_bind_bone {-# NOINLINE bindSkin_set_bind_count #-} bindSkin_set_bind_count :: MethodBind bindSkin_set_bind_count = unsafePerformIO $ withCString "Skin" $ \ clsNamePtr -> withCString "set_bind_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bind_count :: (Skin :< cls, Object :< cls) => cls -> Int -> IO () set_bind_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSkin_set_bind_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skin "set_bind_count" '[Int] (IO ()) where nodeMethod = Godot.Core.Skin.set_bind_count {-# NOINLINE bindSkin_set_bind_pose #-} bindSkin_set_bind_pose :: MethodBind bindSkin_set_bind_pose = unsafePerformIO $ withCString "Skin" $ \ clsNamePtr -> withCString "set_bind_pose" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bind_pose :: (Skin :< cls, Object :< cls) => cls -> Int -> Transform -> IO () set_bind_pose cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSkin_set_bind_pose (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Skin "set_bind_pose" '[Int, Transform] (IO ()) where nodeMethod = Godot.Core.Skin.set_bind_pose ================================================ FILE: src/Godot/Core/SkinReference.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SkinReference (Godot.Core.SkinReference._skin_changed, Godot.Core.SkinReference.get_skeleton, Godot.Core.SkinReference.get_skin) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindSkinReference__skin_changed #-} bindSkinReference__skin_changed :: MethodBind bindSkinReference__skin_changed = unsafePerformIO $ withCString "SkinReference" $ \ clsNamePtr -> withCString "_skin_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _skin_changed :: (SkinReference :< cls, Object :< cls) => cls -> IO () _skin_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkinReference__skin_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkinReference "_skin_changed" '[] (IO ()) where nodeMethod = Godot.Core.SkinReference._skin_changed {-# NOINLINE bindSkinReference_get_skeleton #-} bindSkinReference_get_skeleton :: MethodBind bindSkinReference_get_skeleton = unsafePerformIO $ withCString "SkinReference" $ \ clsNamePtr -> withCString "get_skeleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_skeleton :: (SkinReference :< cls, Object :< cls) => cls -> IO Rid get_skeleton cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkinReference_get_skeleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkinReference "get_skeleton" '[] (IO Rid) where nodeMethod = Godot.Core.SkinReference.get_skeleton {-# NOINLINE bindSkinReference_get_skin #-} bindSkinReference_get_skin :: MethodBind bindSkinReference_get_skin = unsafePerformIO $ withCString "SkinReference" $ \ clsNamePtr -> withCString "get_skin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_skin :: (SkinReference :< cls, Object :< cls) => cls -> IO Skin get_skin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSkinReference_get_skin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SkinReference "get_skin" '[] (IO Skin) where nodeMethod = Godot.Core.SkinReference.get_skin ================================================ FILE: src/Godot/Core/Sky.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Sky (Godot.Core.Sky._RADIANCE_SIZE_128, Godot.Core.Sky._RADIANCE_SIZE_2048, Godot.Core.Sky._RADIANCE_SIZE_512, Godot.Core.Sky._RADIANCE_SIZE_1024, Godot.Core.Sky._RADIANCE_SIZE_64, Godot.Core.Sky._RADIANCE_SIZE_32, Godot.Core.Sky._RADIANCE_SIZE_256, Godot.Core.Sky._RADIANCE_SIZE_MAX, Godot.Core.Sky.get_radiance_size, Godot.Core.Sky.set_radiance_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _RADIANCE_SIZE_128 :: Int _RADIANCE_SIZE_128 = 2 _RADIANCE_SIZE_2048 :: Int _RADIANCE_SIZE_2048 = 6 _RADIANCE_SIZE_512 :: Int _RADIANCE_SIZE_512 = 4 _RADIANCE_SIZE_1024 :: Int _RADIANCE_SIZE_1024 = 5 _RADIANCE_SIZE_64 :: Int _RADIANCE_SIZE_64 = 1 _RADIANCE_SIZE_32 :: Int _RADIANCE_SIZE_32 = 0 _RADIANCE_SIZE_256 :: Int _RADIANCE_SIZE_256 = 3 _RADIANCE_SIZE_MAX :: Int _RADIANCE_SIZE_MAX = 7 instance NodeProperty Sky "radiance_size" Int 'False where nodeProperty = (get_radiance_size, wrapDroppingSetter set_radiance_size, Nothing) {-# NOINLINE bindSky_get_radiance_size #-} -- | The @Sky@'s radiance map size. The higher the radiance map size, the more detailed the lighting from the @Sky@ will be. -- See @enum RadianceSize@ constants for values. -- __Note:__ Some hardware will have trouble with higher radiance sizes, especially @RADIANCE_SIZE_512@ and above. Only use such high values on high-end hardware. bindSky_get_radiance_size :: MethodBind bindSky_get_radiance_size = unsafePerformIO $ withCString "Sky" $ \ clsNamePtr -> withCString "get_radiance_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@'s radiance map size. The higher the radiance map size, the more detailed the lighting from the @Sky@ will be. -- See @enum RadianceSize@ constants for values. -- __Note:__ Some hardware will have trouble with higher radiance sizes, especially @RADIANCE_SIZE_512@ and above. Only use such high values on high-end hardware. get_radiance_size :: (Sky :< cls, Object :< cls) => cls -> IO Int get_radiance_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSky_get_radiance_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sky "get_radiance_size" '[] (IO Int) where nodeMethod = Godot.Core.Sky.get_radiance_size {-# NOINLINE bindSky_set_radiance_size #-} -- | The @Sky@'s radiance map size. The higher the radiance map size, the more detailed the lighting from the @Sky@ will be. -- See @enum RadianceSize@ constants for values. -- __Note:__ Some hardware will have trouble with higher radiance sizes, especially @RADIANCE_SIZE_512@ and above. Only use such high values on high-end hardware. bindSky_set_radiance_size :: MethodBind bindSky_set_radiance_size = unsafePerformIO $ withCString "Sky" $ \ clsNamePtr -> withCString "set_radiance_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Sky@'s radiance map size. The higher the radiance map size, the more detailed the lighting from the @Sky@ will be. -- See @enum RadianceSize@ constants for values. -- __Note:__ Some hardware will have trouble with higher radiance sizes, especially @RADIANCE_SIZE_512@ and above. Only use such high values on high-end hardware. set_radiance_size :: (Sky :< cls, Object :< cls) => cls -> Int -> IO () set_radiance_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSky_set_radiance_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sky "set_radiance_size" '[Int] (IO ()) where nodeMethod = Godot.Core.Sky.set_radiance_size ================================================ FILE: src/Godot/Core/Slider.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Slider (Godot.Core.Slider._gui_input, Godot.Core.Slider.get_ticks, Godot.Core.Slider.get_ticks_on_borders, Godot.Core.Slider.is_editable, Godot.Core.Slider.is_scrollable, Godot.Core.Slider.set_editable, Godot.Core.Slider.set_scrollable, Godot.Core.Slider.set_ticks, Godot.Core.Slider.set_ticks_on_borders) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Range() instance NodeProperty Slider "editable" Bool 'False where nodeProperty = (is_editable, wrapDroppingSetter set_editable, Nothing) instance NodeProperty Slider "scrollable" Bool 'False where nodeProperty = (is_scrollable, wrapDroppingSetter set_scrollable, Nothing) instance NodeProperty Slider "tick_count" Int 'False where nodeProperty = (get_ticks, wrapDroppingSetter set_ticks, Nothing) instance NodeProperty Slider "ticks_on_borders" Bool 'False where nodeProperty = (get_ticks_on_borders, wrapDroppingSetter set_ticks_on_borders, Nothing) {-# NOINLINE bindSlider__gui_input #-} bindSlider__gui_input :: MethodBind bindSlider__gui_input = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (Slider :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSlider__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Slider._gui_input {-# NOINLINE bindSlider_get_ticks #-} -- | Number of ticks displayed on the slider, including border ticks. Ticks are uniformly-distributed value markers. bindSlider_get_ticks :: MethodBind bindSlider_get_ticks = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "get_ticks" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of ticks displayed on the slider, including border ticks. Ticks are uniformly-distributed value markers. get_ticks :: (Slider :< cls, Object :< cls) => cls -> IO Int get_ticks cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSlider_get_ticks (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "get_ticks" '[] (IO Int) where nodeMethod = Godot.Core.Slider.get_ticks {-# NOINLINE bindSlider_get_ticks_on_borders #-} -- | If @true@, the slider will display ticks for minimum and maximum values. bindSlider_get_ticks_on_borders :: MethodBind bindSlider_get_ticks_on_borders = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "get_ticks_on_borders" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the slider will display ticks for minimum and maximum values. get_ticks_on_borders :: (Slider :< cls, Object :< cls) => cls -> IO Bool get_ticks_on_borders cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSlider_get_ticks_on_borders (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "get_ticks_on_borders" '[] (IO Bool) where nodeMethod = Godot.Core.Slider.get_ticks_on_borders {-# NOINLINE bindSlider_is_editable #-} -- | If @true@, the slider can be interacted with. If @false@, the value can be changed only by code. bindSlider_is_editable :: MethodBind bindSlider_is_editable = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "is_editable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the slider can be interacted with. If @false@, the value can be changed only by code. is_editable :: (Slider :< cls, Object :< cls) => cls -> IO Bool is_editable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSlider_is_editable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "is_editable" '[] (IO Bool) where nodeMethod = Godot.Core.Slider.is_editable {-# NOINLINE bindSlider_is_scrollable #-} -- | If @true@, the value can be changed using the mouse wheel. bindSlider_is_scrollable :: MethodBind bindSlider_is_scrollable = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "is_scrollable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the value can be changed using the mouse wheel. is_scrollable :: (Slider :< cls, Object :< cls) => cls -> IO Bool is_scrollable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSlider_is_scrollable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "is_scrollable" '[] (IO Bool) where nodeMethod = Godot.Core.Slider.is_scrollable {-# NOINLINE bindSlider_set_editable #-} -- | If @true@, the slider can be interacted with. If @false@, the value can be changed only by code. bindSlider_set_editable :: MethodBind bindSlider_set_editable = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "set_editable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the slider can be interacted with. If @false@, the value can be changed only by code. set_editable :: (Slider :< cls, Object :< cls) => cls -> Bool -> IO () set_editable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSlider_set_editable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "set_editable" '[Bool] (IO ()) where nodeMethod = Godot.Core.Slider.set_editable {-# NOINLINE bindSlider_set_scrollable #-} -- | If @true@, the value can be changed using the mouse wheel. bindSlider_set_scrollable :: MethodBind bindSlider_set_scrollable = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "set_scrollable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the value can be changed using the mouse wheel. set_scrollable :: (Slider :< cls, Object :< cls) => cls -> Bool -> IO () set_scrollable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSlider_set_scrollable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "set_scrollable" '[Bool] (IO ()) where nodeMethod = Godot.Core.Slider.set_scrollable {-# NOINLINE bindSlider_set_ticks #-} -- | Number of ticks displayed on the slider, including border ticks. Ticks are uniformly-distributed value markers. bindSlider_set_ticks :: MethodBind bindSlider_set_ticks = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "set_ticks" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of ticks displayed on the slider, including border ticks. Ticks are uniformly-distributed value markers. set_ticks :: (Slider :< cls, Object :< cls) => cls -> Int -> IO () set_ticks cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSlider_set_ticks (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "set_ticks" '[Int] (IO ()) where nodeMethod = Godot.Core.Slider.set_ticks {-# NOINLINE bindSlider_set_ticks_on_borders #-} -- | If @true@, the slider will display ticks for minimum and maximum values. bindSlider_set_ticks_on_borders :: MethodBind bindSlider_set_ticks_on_borders = unsafePerformIO $ withCString "Slider" $ \ clsNamePtr -> withCString "set_ticks_on_borders" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the slider will display ticks for minimum and maximum values. set_ticks_on_borders :: (Slider :< cls, Object :< cls) => cls -> Bool -> IO () set_ticks_on_borders cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSlider_set_ticks_on_borders (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Slider "set_ticks_on_borders" '[Bool] (IO ()) where nodeMethod = Godot.Core.Slider.set_ticks_on_borders ================================================ FILE: src/Godot/Core/SliderJoint.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SliderJoint (Godot.Core.SliderJoint._PARAM_ANGULAR_LIMIT_LOWER, Godot.Core.SliderJoint._PARAM_LINEAR_ORTHOGONAL_RESTITUTION, Godot.Core.SliderJoint._PARAM_ANGULAR_MOTION_DAMPING, Godot.Core.SliderJoint._PARAM_LINEAR_LIMIT_RESTITUTION, Godot.Core.SliderJoint._PARAM_LINEAR_MOTION_RESTITUTION, Godot.Core.SliderJoint._PARAM_ANGULAR_ORTHOGONAL_DAMPING, Godot.Core.SliderJoint._PARAM_ANGULAR_ORTHOGONAL_SOFTNESS, Godot.Core.SliderJoint._PARAM_LINEAR_ORTHOGONAL_SOFTNESS, Godot.Core.SliderJoint._PARAM_LINEAR_LIMIT_SOFTNESS, Godot.Core.SliderJoint._PARAM_ANGULAR_LIMIT_RESTITUTION, Godot.Core.SliderJoint._PARAM_LINEAR_LIMIT_LOWER, Godot.Core.SliderJoint._PARAM_LINEAR_MOTION_SOFTNESS, Godot.Core.SliderJoint._PARAM_MAX, Godot.Core.SliderJoint._PARAM_ANGULAR_LIMIT_DAMPING, Godot.Core.SliderJoint._PARAM_ANGULAR_LIMIT_SOFTNESS, Godot.Core.SliderJoint._PARAM_LINEAR_LIMIT_UPPER, Godot.Core.SliderJoint._PARAM_ANGULAR_LIMIT_UPPER, Godot.Core.SliderJoint._PARAM_LINEAR_LIMIT_DAMPING, Godot.Core.SliderJoint._PARAM_ANGULAR_MOTION_RESTITUTION, Godot.Core.SliderJoint._PARAM_LINEAR_ORTHOGONAL_DAMPING, Godot.Core.SliderJoint._PARAM_ANGULAR_ORTHOGONAL_RESTITUTION, Godot.Core.SliderJoint._PARAM_LINEAR_MOTION_DAMPING, Godot.Core.SliderJoint._PARAM_ANGULAR_MOTION_SOFTNESS, Godot.Core.SliderJoint._get_lower_limit_angular, Godot.Core.SliderJoint._get_upper_limit_angular, Godot.Core.SliderJoint._set_lower_limit_angular, Godot.Core.SliderJoint._set_upper_limit_angular, Godot.Core.SliderJoint.get_param, Godot.Core.SliderJoint.set_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Joint() _PARAM_ANGULAR_LIMIT_LOWER :: Int _PARAM_ANGULAR_LIMIT_LOWER = 12 _PARAM_LINEAR_ORTHOGONAL_RESTITUTION :: Int _PARAM_LINEAR_ORTHOGONAL_RESTITUTION = 9 _PARAM_ANGULAR_MOTION_DAMPING :: Int _PARAM_ANGULAR_MOTION_DAMPING = 18 _PARAM_LINEAR_LIMIT_RESTITUTION :: Int _PARAM_LINEAR_LIMIT_RESTITUTION = 3 _PARAM_LINEAR_MOTION_RESTITUTION :: Int _PARAM_LINEAR_MOTION_RESTITUTION = 6 _PARAM_ANGULAR_ORTHOGONAL_DAMPING :: Int _PARAM_ANGULAR_ORTHOGONAL_DAMPING = 21 _PARAM_ANGULAR_ORTHOGONAL_SOFTNESS :: Int _PARAM_ANGULAR_ORTHOGONAL_SOFTNESS = 19 _PARAM_LINEAR_ORTHOGONAL_SOFTNESS :: Int _PARAM_LINEAR_ORTHOGONAL_SOFTNESS = 8 _PARAM_LINEAR_LIMIT_SOFTNESS :: Int _PARAM_LINEAR_LIMIT_SOFTNESS = 2 _PARAM_ANGULAR_LIMIT_RESTITUTION :: Int _PARAM_ANGULAR_LIMIT_RESTITUTION = 14 _PARAM_LINEAR_LIMIT_LOWER :: Int _PARAM_LINEAR_LIMIT_LOWER = 1 _PARAM_LINEAR_MOTION_SOFTNESS :: Int _PARAM_LINEAR_MOTION_SOFTNESS = 5 _PARAM_MAX :: Int _PARAM_MAX = 22 _PARAM_ANGULAR_LIMIT_DAMPING :: Int _PARAM_ANGULAR_LIMIT_DAMPING = 15 _PARAM_ANGULAR_LIMIT_SOFTNESS :: Int _PARAM_ANGULAR_LIMIT_SOFTNESS = 13 _PARAM_LINEAR_LIMIT_UPPER :: Int _PARAM_LINEAR_LIMIT_UPPER = 0 _PARAM_ANGULAR_LIMIT_UPPER :: Int _PARAM_ANGULAR_LIMIT_UPPER = 11 _PARAM_LINEAR_LIMIT_DAMPING :: Int _PARAM_LINEAR_LIMIT_DAMPING = 4 _PARAM_ANGULAR_MOTION_RESTITUTION :: Int _PARAM_ANGULAR_MOTION_RESTITUTION = 17 _PARAM_LINEAR_ORTHOGONAL_DAMPING :: Int _PARAM_LINEAR_ORTHOGONAL_DAMPING = 10 _PARAM_ANGULAR_ORTHOGONAL_RESTITUTION :: Int _PARAM_ANGULAR_ORTHOGONAL_RESTITUTION = 20 _PARAM_LINEAR_MOTION_DAMPING :: Int _PARAM_LINEAR_MOTION_DAMPING = 7 _PARAM_ANGULAR_MOTION_SOFTNESS :: Int _PARAM_ANGULAR_MOTION_SOFTNESS = 16 instance NodeProperty SliderJoint "angular_limit/damping" Float 'False where nodeProperty = (wrapIndexedGetter 15 get_param, wrapIndexedSetter 15 set_param, Nothing) instance NodeProperty SliderJoint "angular_limit/lower_angle" Float 'False where nodeProperty = (_get_lower_limit_angular, wrapDroppingSetter _set_lower_limit_angular, Nothing) instance NodeProperty SliderJoint "angular_limit/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 14 get_param, wrapIndexedSetter 14 set_param, Nothing) instance NodeProperty SliderJoint "angular_limit/softness" Float 'False where nodeProperty = (wrapIndexedGetter 13 get_param, wrapIndexedSetter 13 set_param, Nothing) instance NodeProperty SliderJoint "angular_limit/upper_angle" Float 'False where nodeProperty = (_get_upper_limit_angular, wrapDroppingSetter _set_upper_limit_angular, Nothing) instance NodeProperty SliderJoint "angular_motion/damping" Float 'False where nodeProperty = (wrapIndexedGetter 18 get_param, wrapIndexedSetter 18 set_param, Nothing) instance NodeProperty SliderJoint "angular_motion/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 17 get_param, wrapIndexedSetter 17 set_param, Nothing) instance NodeProperty SliderJoint "angular_motion/softness" Float 'False where nodeProperty = (wrapIndexedGetter 16 get_param, wrapIndexedSetter 16 set_param, Nothing) instance NodeProperty SliderJoint "angular_ortho/damping" Float 'False where nodeProperty = (wrapIndexedGetter 21 get_param, wrapIndexedSetter 21 set_param, Nothing) instance NodeProperty SliderJoint "angular_ortho/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 20 get_param, wrapIndexedSetter 20 set_param, Nothing) instance NodeProperty SliderJoint "angular_ortho/softness" Float 'False where nodeProperty = (wrapIndexedGetter 19 get_param, wrapIndexedSetter 19 set_param, Nothing) instance NodeProperty SliderJoint "linear_limit/damping" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param, wrapIndexedSetter 4 set_param, Nothing) instance NodeProperty SliderJoint "linear_limit/lower_distance" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_param, wrapIndexedSetter 1 set_param, Nothing) instance NodeProperty SliderJoint "linear_limit/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param, wrapIndexedSetter 3 set_param, Nothing) instance NodeProperty SliderJoint "linear_limit/softness" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_param, wrapIndexedSetter 2 set_param, Nothing) instance NodeProperty SliderJoint "linear_limit/upper_distance" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_param, wrapIndexedSetter 0 set_param, Nothing) instance NodeProperty SliderJoint "linear_motion/damping" Float 'False where nodeProperty = (wrapIndexedGetter 7 get_param, wrapIndexedSetter 7 set_param, Nothing) instance NodeProperty SliderJoint "linear_motion/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param, wrapIndexedSetter 6 set_param, Nothing) instance NodeProperty SliderJoint "linear_motion/softness" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param, wrapIndexedSetter 5 set_param, Nothing) instance NodeProperty SliderJoint "linear_ortho/damping" Float 'False where nodeProperty = (wrapIndexedGetter 10 get_param, wrapIndexedSetter 10 set_param, Nothing) instance NodeProperty SliderJoint "linear_ortho/restitution" Float 'False where nodeProperty = (wrapIndexedGetter 9 get_param, wrapIndexedSetter 9 set_param, Nothing) instance NodeProperty SliderJoint "linear_ortho/softness" Float 'False where nodeProperty = (wrapIndexedGetter 8 get_param, wrapIndexedSetter 8 set_param, Nothing) {-# NOINLINE bindSliderJoint__get_lower_limit_angular #-} -- | The lower limit of rotation in the slider. bindSliderJoint__get_lower_limit_angular :: MethodBind bindSliderJoint__get_lower_limit_angular = unsafePerformIO $ withCString "SliderJoint" $ \ clsNamePtr -> withCString "_get_lower_limit_angular" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The lower limit of rotation in the slider. _get_lower_limit_angular :: (SliderJoint :< cls, Object :< cls) => cls -> IO Float _get_lower_limit_angular cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSliderJoint__get_lower_limit_angular (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SliderJoint "_get_lower_limit_angular" '[] (IO Float) where nodeMethod = Godot.Core.SliderJoint._get_lower_limit_angular {-# NOINLINE bindSliderJoint__get_upper_limit_angular #-} -- | The upper limit of rotation in the slider. bindSliderJoint__get_upper_limit_angular :: MethodBind bindSliderJoint__get_upper_limit_angular = unsafePerformIO $ withCString "SliderJoint" $ \ clsNamePtr -> withCString "_get_upper_limit_angular" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The upper limit of rotation in the slider. _get_upper_limit_angular :: (SliderJoint :< cls, Object :< cls) => cls -> IO Float _get_upper_limit_angular cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSliderJoint__get_upper_limit_angular (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SliderJoint "_get_upper_limit_angular" '[] (IO Float) where nodeMethod = Godot.Core.SliderJoint._get_upper_limit_angular {-# NOINLINE bindSliderJoint__set_lower_limit_angular #-} -- | The lower limit of rotation in the slider. bindSliderJoint__set_lower_limit_angular :: MethodBind bindSliderJoint__set_lower_limit_angular = unsafePerformIO $ withCString "SliderJoint" $ \ clsNamePtr -> withCString "_set_lower_limit_angular" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The lower limit of rotation in the slider. _set_lower_limit_angular :: (SliderJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_lower_limit_angular cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSliderJoint__set_lower_limit_angular (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SliderJoint "_set_lower_limit_angular" '[Float] (IO ()) where nodeMethod = Godot.Core.SliderJoint._set_lower_limit_angular {-# NOINLINE bindSliderJoint__set_upper_limit_angular #-} -- | The upper limit of rotation in the slider. bindSliderJoint__set_upper_limit_angular :: MethodBind bindSliderJoint__set_upper_limit_angular = unsafePerformIO $ withCString "SliderJoint" $ \ clsNamePtr -> withCString "_set_upper_limit_angular" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The upper limit of rotation in the slider. _set_upper_limit_angular :: (SliderJoint :< cls, Object :< cls) => cls -> Float -> IO () _set_upper_limit_angular cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSliderJoint__set_upper_limit_angular (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SliderJoint "_set_upper_limit_angular" '[Float] (IO ()) where nodeMethod = Godot.Core.SliderJoint._set_upper_limit_angular {-# NOINLINE bindSliderJoint_get_param #-} -- | The amount of damping of the rotation when the limit is surpassed. -- A lower damping value allows a rotation initiated by body A to travel to body B slower. bindSliderJoint_get_param :: MethodBind bindSliderJoint_get_param = unsafePerformIO $ withCString "SliderJoint" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of damping of the rotation when the limit is surpassed. -- A lower damping value allows a rotation initiated by body A to travel to body B slower. get_param :: (SliderJoint :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSliderJoint_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SliderJoint "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.SliderJoint.get_param {-# NOINLINE bindSliderJoint_set_param #-} -- | The amount of damping of the rotation when the limit is surpassed. -- A lower damping value allows a rotation initiated by body A to travel to body B slower. bindSliderJoint_set_param :: MethodBind bindSliderJoint_set_param = unsafePerformIO $ withCString "SliderJoint" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of damping of the rotation when the limit is surpassed. -- A lower damping value allows a rotation initiated by body A to travel to body B slower. set_param :: (SliderJoint :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSliderJoint_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SliderJoint "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.SliderJoint.set_param ================================================ FILE: src/Godot/Core/SoftBody.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SoftBody (Godot.Core.SoftBody._draw_soft_mesh, Godot.Core.SoftBody.add_collision_exception_with, Godot.Core.SoftBody.get_areaAngular_stiffness, Godot.Core.SoftBody.get_collision_exceptions, Godot.Core.SoftBody.get_collision_layer, Godot.Core.SoftBody.get_collision_layer_bit, Godot.Core.SoftBody.get_collision_mask, Godot.Core.SoftBody.get_collision_mask_bit, Godot.Core.SoftBody.get_damping_coefficient, Godot.Core.SoftBody.get_drag_coefficient, Godot.Core.SoftBody.get_linear_stiffness, Godot.Core.SoftBody.get_parent_collision_ignore, Godot.Core.SoftBody.get_pose_matching_coefficient, Godot.Core.SoftBody.get_pressure_coefficient, Godot.Core.SoftBody.get_simulation_precision, Godot.Core.SoftBody.get_total_mass, Godot.Core.SoftBody.get_volume_stiffness, Godot.Core.SoftBody.is_ray_pickable, Godot.Core.SoftBody.remove_collision_exception_with, Godot.Core.SoftBody.set_areaAngular_stiffness, Godot.Core.SoftBody.set_collision_layer, Godot.Core.SoftBody.set_collision_layer_bit, Godot.Core.SoftBody.set_collision_mask, Godot.Core.SoftBody.set_collision_mask_bit, Godot.Core.SoftBody.set_damping_coefficient, Godot.Core.SoftBody.set_drag_coefficient, Godot.Core.SoftBody.set_linear_stiffness, Godot.Core.SoftBody.set_parent_collision_ignore, Godot.Core.SoftBody.set_pose_matching_coefficient, Godot.Core.SoftBody.set_pressure_coefficient, Godot.Core.SoftBody.set_ray_pickable, Godot.Core.SoftBody.set_simulation_precision, Godot.Core.SoftBody.set_total_mass, Godot.Core.SoftBody.set_volume_stiffness) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.MeshInstance() instance NodeProperty SoftBody "areaAngular_stiffness" Float 'False where nodeProperty = (get_areaAngular_stiffness, wrapDroppingSetter set_areaAngular_stiffness, Nothing) instance NodeProperty SoftBody "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty SoftBody "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty SoftBody "damping_coefficient" Float 'False where nodeProperty = (get_damping_coefficient, wrapDroppingSetter set_damping_coefficient, Nothing) instance NodeProperty SoftBody "drag_coefficient" Float 'False where nodeProperty = (get_drag_coefficient, wrapDroppingSetter set_drag_coefficient, Nothing) instance NodeProperty SoftBody "linear_stiffness" Float 'False where nodeProperty = (get_linear_stiffness, wrapDroppingSetter set_linear_stiffness, Nothing) instance NodeProperty SoftBody "parent_collision_ignore" NodePath 'False where nodeProperty = (get_parent_collision_ignore, wrapDroppingSetter set_parent_collision_ignore, Nothing) instance NodeProperty SoftBody "pose_matching_coefficient" Float 'False where nodeProperty = (get_pose_matching_coefficient, wrapDroppingSetter set_pose_matching_coefficient, Nothing) instance NodeProperty SoftBody "pressure_coefficient" Float 'False where nodeProperty = (get_pressure_coefficient, wrapDroppingSetter set_pressure_coefficient, Nothing) instance NodeProperty SoftBody "ray_pickable" Bool 'False where nodeProperty = (is_ray_pickable, wrapDroppingSetter set_ray_pickable, Nothing) instance NodeProperty SoftBody "simulation_precision" Int 'False where nodeProperty = (get_simulation_precision, wrapDroppingSetter set_simulation_precision, Nothing) instance NodeProperty SoftBody "total_mass" Float 'False where nodeProperty = (get_total_mass, wrapDroppingSetter set_total_mass, Nothing) instance NodeProperty SoftBody "volume_stiffness" Float 'False where nodeProperty = (get_volume_stiffness, wrapDroppingSetter set_volume_stiffness, Nothing) {-# NOINLINE bindSoftBody__draw_soft_mesh #-} bindSoftBody__draw_soft_mesh :: MethodBind bindSoftBody__draw_soft_mesh = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "_draw_soft_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _draw_soft_mesh :: (SoftBody :< cls, Object :< cls) => cls -> IO () _draw_soft_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody__draw_soft_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "_draw_soft_mesh" '[] (IO ()) where nodeMethod = Godot.Core.SoftBody._draw_soft_mesh {-# NOINLINE bindSoftBody_add_collision_exception_with #-} -- | Adds a body to the list of bodies that this body can't collide with. bindSoftBody_add_collision_exception_with :: MethodBind bindSoftBody_add_collision_exception_with = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "add_collision_exception_with" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a body to the list of bodies that this body can't collide with. add_collision_exception_with :: (SoftBody :< cls, Object :< cls) => cls -> Node -> IO () add_collision_exception_with cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_add_collision_exception_with (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "add_collision_exception_with" '[Node] (IO ()) where nodeMethod = Godot.Core.SoftBody.add_collision_exception_with {-# NOINLINE bindSoftBody_get_areaAngular_stiffness #-} bindSoftBody_get_areaAngular_stiffness :: MethodBind bindSoftBody_get_areaAngular_stiffness = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_areaAngular_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_areaAngular_stiffness :: (SoftBody :< cls, Object :< cls) => cls -> IO Float get_areaAngular_stiffness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_areaAngular_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_areaAngular_stiffness" '[] (IO Float) where nodeMethod = Godot.Core.SoftBody.get_areaAngular_stiffness {-# NOINLINE bindSoftBody_get_collision_exceptions #-} -- | Returns an array of nodes that were added as collision exceptions for this body. bindSoftBody_get_collision_exceptions :: MethodBind bindSoftBody_get_collision_exceptions = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_collision_exceptions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of nodes that were added as collision exceptions for this body. get_collision_exceptions :: (SoftBody :< cls, Object :< cls) => cls -> IO Array get_collision_exceptions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_collision_exceptions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_collision_exceptions" '[] (IO Array) where nodeMethod = Godot.Core.SoftBody.get_collision_exceptions {-# NOINLINE bindSoftBody_get_collision_layer #-} -- | The physics layers this SoftBody is in. -- 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 collision_mask property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindSoftBody_get_collision_layer :: MethodBind bindSoftBody_get_collision_layer = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this SoftBody is in. -- 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 collision_mask property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_layer :: (SoftBody :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.SoftBody.get_collision_layer {-# NOINLINE bindSoftBody_get_collision_layer_bit #-} -- | Returns an individual bit on the collision mask. bindSoftBody_get_collision_layer_bit :: MethodBind bindSoftBody_get_collision_layer_bit = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the collision mask. get_collision_layer_bit :: (SoftBody :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_layer_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_collision_layer_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.SoftBody.get_collision_layer_bit {-# NOINLINE bindSoftBody_get_collision_mask #-} -- | The physics layers this SoftBody scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindSoftBody_get_collision_mask :: MethodBind bindSoftBody_get_collision_mask = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this SoftBody scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (SoftBody :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.SoftBody.get_collision_mask {-# NOINLINE bindSoftBody_get_collision_mask_bit #-} -- | Returns an individual bit on the collision mask. bindSoftBody_get_collision_mask_bit :: MethodBind bindSoftBody_get_collision_mask_bit = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an individual bit on the collision mask. get_collision_mask_bit :: (SoftBody :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.SoftBody.get_collision_mask_bit {-# NOINLINE bindSoftBody_get_damping_coefficient #-} bindSoftBody_get_damping_coefficient :: MethodBind bindSoftBody_get_damping_coefficient = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_damping_coefficient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_damping_coefficient :: (SoftBody :< cls, Object :< cls) => cls -> IO Float get_damping_coefficient cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_damping_coefficient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_damping_coefficient" '[] (IO Float) where nodeMethod = Godot.Core.SoftBody.get_damping_coefficient {-# NOINLINE bindSoftBody_get_drag_coefficient #-} bindSoftBody_get_drag_coefficient :: MethodBind bindSoftBody_get_drag_coefficient = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_drag_coefficient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_drag_coefficient :: (SoftBody :< cls, Object :< cls) => cls -> IO Float get_drag_coefficient cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_drag_coefficient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_drag_coefficient" '[] (IO Float) where nodeMethod = Godot.Core.SoftBody.get_drag_coefficient {-# NOINLINE bindSoftBody_get_linear_stiffness #-} bindSoftBody_get_linear_stiffness :: MethodBind bindSoftBody_get_linear_stiffness = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_linear_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_linear_stiffness :: (SoftBody :< cls, Object :< cls) => cls -> IO Float get_linear_stiffness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_linear_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_linear_stiffness" '[] (IO Float) where nodeMethod = Godot.Core.SoftBody.get_linear_stiffness {-# NOINLINE bindSoftBody_get_parent_collision_ignore #-} -- | @NodePath@ to a @CollisionObject@ this SoftBody should avoid clipping. bindSoftBody_get_parent_collision_ignore :: MethodBind bindSoftBody_get_parent_collision_ignore = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_parent_collision_ignore" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @NodePath@ to a @CollisionObject@ this SoftBody should avoid clipping. get_parent_collision_ignore :: (SoftBody :< cls, Object :< cls) => cls -> IO NodePath get_parent_collision_ignore cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_parent_collision_ignore (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_parent_collision_ignore" '[] (IO NodePath) where nodeMethod = Godot.Core.SoftBody.get_parent_collision_ignore {-# NOINLINE bindSoftBody_get_pose_matching_coefficient #-} bindSoftBody_get_pose_matching_coefficient :: MethodBind bindSoftBody_get_pose_matching_coefficient = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_pose_matching_coefficient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_pose_matching_coefficient :: (SoftBody :< cls, Object :< cls) => cls -> IO Float get_pose_matching_coefficient cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_pose_matching_coefficient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_pose_matching_coefficient" '[] (IO Float) where nodeMethod = Godot.Core.SoftBody.get_pose_matching_coefficient {-# NOINLINE bindSoftBody_get_pressure_coefficient #-} bindSoftBody_get_pressure_coefficient :: MethodBind bindSoftBody_get_pressure_coefficient = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_pressure_coefficient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_pressure_coefficient :: (SoftBody :< cls, Object :< cls) => cls -> IO Float get_pressure_coefficient cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_pressure_coefficient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_pressure_coefficient" '[] (IO Float) where nodeMethod = Godot.Core.SoftBody.get_pressure_coefficient {-# NOINLINE bindSoftBody_get_simulation_precision #-} -- | Increasing this value will improve the resulting simulation, but can affect performance. Use with care. bindSoftBody_get_simulation_precision :: MethodBind bindSoftBody_get_simulation_precision = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_simulation_precision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Increasing this value will improve the resulting simulation, but can affect performance. Use with care. get_simulation_precision :: (SoftBody :< cls, Object :< cls) => cls -> IO Int get_simulation_precision cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_simulation_precision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_simulation_precision" '[] (IO Int) where nodeMethod = Godot.Core.SoftBody.get_simulation_precision {-# NOINLINE bindSoftBody_get_total_mass #-} -- | The SoftBody's mass. bindSoftBody_get_total_mass :: MethodBind bindSoftBody_get_total_mass = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_total_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The SoftBody's mass. get_total_mass :: (SoftBody :< cls, Object :< cls) => cls -> IO Float get_total_mass cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_total_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_total_mass" '[] (IO Float) where nodeMethod = Godot.Core.SoftBody.get_total_mass {-# NOINLINE bindSoftBody_get_volume_stiffness #-} bindSoftBody_get_volume_stiffness :: MethodBind bindSoftBody_get_volume_stiffness = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "get_volume_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_volume_stiffness :: (SoftBody :< cls, Object :< cls) => cls -> IO Float get_volume_stiffness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_get_volume_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "get_volume_stiffness" '[] (IO Float) where nodeMethod = Godot.Core.SoftBody.get_volume_stiffness {-# NOINLINE bindSoftBody_is_ray_pickable #-} -- | If @true@, the @SoftBody@ will respond to @RayCast@s. bindSoftBody_is_ray_pickable :: MethodBind bindSoftBody_is_ray_pickable = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "is_ray_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @SoftBody@ will respond to @RayCast@s. is_ray_pickable :: (SoftBody :< cls, Object :< cls) => cls -> IO Bool is_ray_pickable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_is_ray_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "is_ray_pickable" '[] (IO Bool) where nodeMethod = Godot.Core.SoftBody.is_ray_pickable {-# NOINLINE bindSoftBody_remove_collision_exception_with #-} -- | Removes a body from the list of bodies that this body can't collide with. bindSoftBody_remove_collision_exception_with :: MethodBind bindSoftBody_remove_collision_exception_with = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "remove_collision_exception_with" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a body from the list of bodies that this body can't collide with. remove_collision_exception_with :: (SoftBody :< cls, Object :< cls) => cls -> Node -> IO () remove_collision_exception_with cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_remove_collision_exception_with (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "remove_collision_exception_with" '[Node] (IO ()) where nodeMethod = Godot.Core.SoftBody.remove_collision_exception_with {-# NOINLINE bindSoftBody_set_areaAngular_stiffness #-} bindSoftBody_set_areaAngular_stiffness :: MethodBind bindSoftBody_set_areaAngular_stiffness = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_areaAngular_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_areaAngular_stiffness :: (SoftBody :< cls, Object :< cls) => cls -> Float -> IO () set_areaAngular_stiffness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_areaAngular_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_areaAngular_stiffness" '[Float] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_areaAngular_stiffness {-# NOINLINE bindSoftBody_set_collision_layer #-} -- | The physics layers this SoftBody is in. -- 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 collision_mask property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindSoftBody_set_collision_layer :: MethodBind bindSoftBody_set_collision_layer = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this SoftBody is in. -- 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 collision_mask property. -- 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 @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_layer :: (SoftBody :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_collision_layer {-# NOINLINE bindSoftBody_set_collision_layer_bit #-} -- | Sets individual bits on the layer mask. Use this if you only need to change one layer's value. bindSoftBody_set_collision_layer_bit :: MethodBind bindSoftBody_set_collision_layer_bit = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets individual bits on the layer mask. Use this if you only need to change one layer's value. set_collision_layer_bit :: (SoftBody :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_layer_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_collision_layer_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_collision_layer_bit {-# NOINLINE bindSoftBody_set_collision_mask #-} -- | The physics layers this SoftBody scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindSoftBody_set_collision_mask :: MethodBind bindSoftBody_set_collision_mask = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics layers this SoftBody scans for collisions. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (SoftBody :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_collision_mask {-# NOINLINE bindSoftBody_set_collision_mask_bit #-} -- | Sets individual bits on the collision mask. Use this if you only need to change one layer's value. bindSoftBody_set_collision_mask_bit :: MethodBind bindSoftBody_set_collision_mask_bit = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets individual bits on the collision mask. Use this if you only need to change one layer's value. set_collision_mask_bit :: (SoftBody :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_collision_mask_bit {-# NOINLINE bindSoftBody_set_damping_coefficient #-} bindSoftBody_set_damping_coefficient :: MethodBind bindSoftBody_set_damping_coefficient = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_damping_coefficient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_damping_coefficient :: (SoftBody :< cls, Object :< cls) => cls -> Float -> IO () set_damping_coefficient cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_damping_coefficient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_damping_coefficient" '[Float] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_damping_coefficient {-# NOINLINE bindSoftBody_set_drag_coefficient #-} bindSoftBody_set_drag_coefficient :: MethodBind bindSoftBody_set_drag_coefficient = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_drag_coefficient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_drag_coefficient :: (SoftBody :< cls, Object :< cls) => cls -> Float -> IO () set_drag_coefficient cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_drag_coefficient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_drag_coefficient" '[Float] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_drag_coefficient {-# NOINLINE bindSoftBody_set_linear_stiffness #-} bindSoftBody_set_linear_stiffness :: MethodBind bindSoftBody_set_linear_stiffness = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_linear_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_linear_stiffness :: (SoftBody :< cls, Object :< cls) => cls -> Float -> IO () set_linear_stiffness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_linear_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_linear_stiffness" '[Float] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_linear_stiffness {-# NOINLINE bindSoftBody_set_parent_collision_ignore #-} -- | @NodePath@ to a @CollisionObject@ this SoftBody should avoid clipping. bindSoftBody_set_parent_collision_ignore :: MethodBind bindSoftBody_set_parent_collision_ignore = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_parent_collision_ignore" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @NodePath@ to a @CollisionObject@ this SoftBody should avoid clipping. set_parent_collision_ignore :: (SoftBody :< cls, Object :< cls) => cls -> NodePath -> IO () set_parent_collision_ignore cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_parent_collision_ignore (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_parent_collision_ignore" '[NodePath] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_parent_collision_ignore {-# NOINLINE bindSoftBody_set_pose_matching_coefficient #-} bindSoftBody_set_pose_matching_coefficient :: MethodBind bindSoftBody_set_pose_matching_coefficient = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_pose_matching_coefficient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_pose_matching_coefficient :: (SoftBody :< cls, Object :< cls) => cls -> Float -> IO () set_pose_matching_coefficient cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_pose_matching_coefficient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_pose_matching_coefficient" '[Float] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_pose_matching_coefficient {-# NOINLINE bindSoftBody_set_pressure_coefficient #-} bindSoftBody_set_pressure_coefficient :: MethodBind bindSoftBody_set_pressure_coefficient = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_pressure_coefficient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_pressure_coefficient :: (SoftBody :< cls, Object :< cls) => cls -> Float -> IO () set_pressure_coefficient cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_pressure_coefficient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_pressure_coefficient" '[Float] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_pressure_coefficient {-# NOINLINE bindSoftBody_set_ray_pickable #-} -- | If @true@, the @SoftBody@ will respond to @RayCast@s. bindSoftBody_set_ray_pickable :: MethodBind bindSoftBody_set_ray_pickable = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_ray_pickable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @SoftBody@ will respond to @RayCast@s. set_ray_pickable :: (SoftBody :< cls, Object :< cls) => cls -> Bool -> IO () set_ray_pickable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_ray_pickable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_ray_pickable" '[Bool] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_ray_pickable {-# NOINLINE bindSoftBody_set_simulation_precision #-} -- | Increasing this value will improve the resulting simulation, but can affect performance. Use with care. bindSoftBody_set_simulation_precision :: MethodBind bindSoftBody_set_simulation_precision = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_simulation_precision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Increasing this value will improve the resulting simulation, but can affect performance. Use with care. set_simulation_precision :: (SoftBody :< cls, Object :< cls) => cls -> Int -> IO () set_simulation_precision cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_simulation_precision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_simulation_precision" '[Int] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_simulation_precision {-# NOINLINE bindSoftBody_set_total_mass #-} -- | The SoftBody's mass. bindSoftBody_set_total_mass :: MethodBind bindSoftBody_set_total_mass = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_total_mass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The SoftBody's mass. set_total_mass :: (SoftBody :< cls, Object :< cls) => cls -> Float -> IO () set_total_mass cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_total_mass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_total_mass" '[Float] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_total_mass {-# NOINLINE bindSoftBody_set_volume_stiffness #-} bindSoftBody_set_volume_stiffness :: MethodBind bindSoftBody_set_volume_stiffness = unsafePerformIO $ withCString "SoftBody" $ \ clsNamePtr -> withCString "set_volume_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_volume_stiffness :: (SoftBody :< cls, Object :< cls) => cls -> Float -> IO () set_volume_stiffness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSoftBody_set_volume_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SoftBody "set_volume_stiffness" '[Float] (IO ()) where nodeMethod = Godot.Core.SoftBody.set_volume_stiffness ================================================ FILE: src/Godot/Core/Spatial.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Spatial (Godot.Core.Spatial._NOTIFICATION_ENTER_WORLD, Godot.Core.Spatial._NOTIFICATION_EXIT_WORLD, Godot.Core.Spatial._NOTIFICATION_TRANSFORM_CHANGED, Godot.Core.Spatial._NOTIFICATION_VISIBILITY_CHANGED, Godot.Core.Spatial.sig_visibility_changed, Godot.Core.Spatial._update_gizmo, Godot.Core.Spatial.force_update_transform, Godot.Core.Spatial.get_gizmo, Godot.Core.Spatial.get_global_transform, Godot.Core.Spatial.get_parent_spatial, Godot.Core.Spatial.get_rotation, Godot.Core.Spatial.get_rotation_degrees, Godot.Core.Spatial.get_scale, Godot.Core.Spatial.get_transform, Godot.Core.Spatial.get_translation, Godot.Core.Spatial.get_world, Godot.Core.Spatial.global_rotate, Godot.Core.Spatial.global_scale, Godot.Core.Spatial.global_translate, Godot.Core.Spatial.hide, Godot.Core.Spatial.is_local_transform_notification_enabled, Godot.Core.Spatial.is_scale_disabled, Godot.Core.Spatial.is_set_as_toplevel, Godot.Core.Spatial.is_transform_notification_enabled, Godot.Core.Spatial.is_visible, Godot.Core.Spatial.is_visible_in_tree, Godot.Core.Spatial.look_at, Godot.Core.Spatial.look_at_from_position, Godot.Core.Spatial.orthonormalize, Godot.Core.Spatial.rotate, Godot.Core.Spatial.rotate_object_local, Godot.Core.Spatial.rotate_x, Godot.Core.Spatial.rotate_y, Godot.Core.Spatial.rotate_z, Godot.Core.Spatial.scale_object_local, Godot.Core.Spatial.set_as_toplevel, Godot.Core.Spatial.set_disable_scale, Godot.Core.Spatial.set_gizmo, Godot.Core.Spatial.set_global_transform, Godot.Core.Spatial.set_identity, Godot.Core.Spatial.set_ignore_transform_notification, Godot.Core.Spatial.set_notify_local_transform, Godot.Core.Spatial.set_notify_transform, Godot.Core.Spatial.set_rotation, Godot.Core.Spatial.set_rotation_degrees, Godot.Core.Spatial.set_scale, Godot.Core.Spatial.set_transform, Godot.Core.Spatial.set_translation, Godot.Core.Spatial.set_visible, Godot.Core.Spatial.show, Godot.Core.Spatial.to_global, Godot.Core.Spatial.to_local, Godot.Core.Spatial.translate, Godot.Core.Spatial.translate_object_local, Godot.Core.Spatial.update_gizmo) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _NOTIFICATION_ENTER_WORLD :: Int _NOTIFICATION_ENTER_WORLD = 41 _NOTIFICATION_EXIT_WORLD :: Int _NOTIFICATION_EXIT_WORLD = 42 _NOTIFICATION_TRANSFORM_CHANGED :: Int _NOTIFICATION_TRANSFORM_CHANGED = 2000 _NOTIFICATION_VISIBILITY_CHANGED :: Int _NOTIFICATION_VISIBILITY_CHANGED = 43 -- | Emitted when node visibility changes. sig_visibility_changed :: Godot.Internal.Dispatch.Signal Spatial sig_visibility_changed = Godot.Internal.Dispatch.Signal "visibility_changed" instance NodeSignal Spatial "visibility_changed" '[] instance NodeProperty Spatial "gizmo" SpatialGizmo 'False where nodeProperty = (get_gizmo, wrapDroppingSetter set_gizmo, Nothing) instance NodeProperty Spatial "global_transform" Transform 'False where nodeProperty = (get_global_transform, wrapDroppingSetter set_global_transform, Nothing) instance NodeProperty Spatial "rotation" Vector3 'False where nodeProperty = (get_rotation, wrapDroppingSetter set_rotation, Nothing) instance NodeProperty Spatial "rotation_degrees" Vector3 'False where nodeProperty = (get_rotation_degrees, wrapDroppingSetter set_rotation_degrees, Nothing) instance NodeProperty Spatial "scale" Vector3 'False where nodeProperty = (get_scale, wrapDroppingSetter set_scale, Nothing) instance NodeProperty Spatial "transform" Transform 'False where nodeProperty = (get_transform, wrapDroppingSetter set_transform, Nothing) instance NodeProperty Spatial "translation" Vector3 'False where nodeProperty = (get_translation, wrapDroppingSetter set_translation, Nothing) instance NodeProperty Spatial "visible" Bool 'False where nodeProperty = (is_visible, wrapDroppingSetter set_visible, Nothing) {-# NOINLINE bindSpatial__update_gizmo #-} bindSpatial__update_gizmo :: MethodBind bindSpatial__update_gizmo = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "_update_gizmo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_gizmo :: (Spatial :< cls, Object :< cls) => cls -> IO () _update_gizmo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial__update_gizmo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "_update_gizmo" '[] (IO ()) where nodeMethod = Godot.Core.Spatial._update_gizmo {-# NOINLINE bindSpatial_force_update_transform #-} -- | Forces the transform to update. Transform changes in physics are not instant for performance reasons. Transforms are accumulated and then set. Use this if you need an up-to-date transform when doing physics operations. bindSpatial_force_update_transform :: MethodBind bindSpatial_force_update_transform = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "force_update_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Forces the transform to update. Transform changes in physics are not instant for performance reasons. Transforms are accumulated and then set. Use this if you need an up-to-date transform when doing physics operations. force_update_transform :: (Spatial :< cls, Object :< cls) => cls -> IO () force_update_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_force_update_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "force_update_transform" '[] (IO ()) where nodeMethod = Godot.Core.Spatial.force_update_transform {-# NOINLINE bindSpatial_get_gizmo #-} -- | The @SpatialGizmo@ for this node. Used for example in @EditorSpatialGizmo@ as custom visualization and editing handles in Editor. bindSpatial_get_gizmo :: MethodBind bindSpatial_get_gizmo = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_gizmo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @SpatialGizmo@ for this node. Used for example in @EditorSpatialGizmo@ as custom visualization and editing handles in Editor. get_gizmo :: (Spatial :< cls, Object :< cls) => cls -> IO SpatialGizmo get_gizmo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_gizmo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_gizmo" '[] (IO SpatialGizmo) where nodeMethod = Godot.Core.Spatial.get_gizmo {-# NOINLINE bindSpatial_get_global_transform #-} -- | World space (global) @Transform@ of this node. bindSpatial_get_global_transform :: MethodBind bindSpatial_get_global_transform = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_global_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | World space (global) @Transform@ of this node. get_global_transform :: (Spatial :< cls, Object :< cls) => cls -> IO Transform get_global_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_global_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_global_transform" '[] (IO Transform) where nodeMethod = Godot.Core.Spatial.get_global_transform {-# NOINLINE bindSpatial_get_parent_spatial #-} -- | Returns the parent @Spatial@, or an empty @Object@ if no parent exists or parent is not of type @Spatial@. bindSpatial_get_parent_spatial :: MethodBind bindSpatial_get_parent_spatial = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_parent_spatial" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parent @Spatial@, or an empty @Object@ if no parent exists or parent is not of type @Spatial@. get_parent_spatial :: (Spatial :< cls, Object :< cls) => cls -> IO Spatial get_parent_spatial cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_parent_spatial (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_parent_spatial" '[] (IO Spatial) where nodeMethod = Godot.Core.Spatial.get_parent_spatial {-# NOINLINE bindSpatial_get_rotation #-} -- | Rotation part of the local transformation in radians, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle). -- __Note:__ In the mathematical sense, rotation is a matrix and not a vector. The three Euler angles, which are the three independent parameters of the Euler-angle parametrization of the rotation matrix, are stored in a @Vector3@ data structure not because the rotation is a vector, but only because @Vector3@ exists as a convenient data-structure to store 3 floating-point numbers. Therefore, applying affine operations on the rotation "vector" is not meaningful. bindSpatial_get_rotation :: MethodBind bindSpatial_get_rotation = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotation part of the local transformation in radians, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle). -- __Note:__ In the mathematical sense, rotation is a matrix and not a vector. The three Euler angles, which are the three independent parameters of the Euler-angle parametrization of the rotation matrix, are stored in a @Vector3@ data structure not because the rotation is a vector, but only because @Vector3@ exists as a convenient data-structure to store 3 floating-point numbers. Therefore, applying affine operations on the rotation "vector" is not meaningful. get_rotation :: (Spatial :< cls, Object :< cls) => cls -> IO Vector3 get_rotation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_rotation" '[] (IO Vector3) where nodeMethod = Godot.Core.Spatial.get_rotation {-# NOINLINE bindSpatial_get_rotation_degrees #-} -- | Rotation part of the local transformation in degrees, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle). bindSpatial_get_rotation_degrees :: MethodBind bindSpatial_get_rotation_degrees = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotation part of the local transformation in degrees, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle). get_rotation_degrees :: (Spatial :< cls, Object :< cls) => cls -> IO Vector3 get_rotation_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_rotation_degrees" '[] (IO Vector3) where nodeMethod = Godot.Core.Spatial.get_rotation_degrees {-# NOINLINE bindSpatial_get_scale #-} -- | Scale part of the local transformation. bindSpatial_get_scale :: MethodBind bindSpatial_get_scale = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scale part of the local transformation. get_scale :: (Spatial :< cls, Object :< cls) => cls -> IO Vector3 get_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_scale" '[] (IO Vector3) where nodeMethod = Godot.Core.Spatial.get_scale {-# NOINLINE bindSpatial_get_transform #-} -- | Local space @Transform@ of this node, with respect to the parent node. bindSpatial_get_transform :: MethodBind bindSpatial_get_transform = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Local space @Transform@ of this node, with respect to the parent node. get_transform :: (Spatial :< cls, Object :< cls) => cls -> IO Transform get_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_transform" '[] (IO Transform) where nodeMethod = Godot.Core.Spatial.get_transform {-# NOINLINE bindSpatial_get_translation #-} -- | Local translation of this node. bindSpatial_get_translation :: MethodBind bindSpatial_get_translation = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_translation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Local translation of this node. get_translation :: (Spatial :< cls, Object :< cls) => cls -> IO Vector3 get_translation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_translation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_translation" '[] (IO Vector3) where nodeMethod = Godot.Core.Spatial.get_translation {-# NOINLINE bindSpatial_get_world #-} -- | Returns the current @World@ resource this @Spatial@ node is registered to. bindSpatial_get_world :: MethodBind bindSpatial_get_world = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "get_world" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current @World@ resource this @Spatial@ node is registered to. get_world :: (Spatial :< cls, Object :< cls) => cls -> IO World get_world cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_get_world (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "get_world" '[] (IO World) where nodeMethod = Godot.Core.Spatial.get_world {-# NOINLINE bindSpatial_global_rotate #-} -- | Rotates the global (world) transformation around axis, a unit @Vector3@, by specified angle in radians. The rotation axis is in global coordinate system. bindSpatial_global_rotate :: MethodBind bindSpatial_global_rotate = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "global_rotate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotates the global (world) transformation around axis, a unit @Vector3@, by specified angle in radians. The rotation axis is in global coordinate system. global_rotate :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> Float -> IO () global_rotate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_global_rotate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "global_rotate" '[Vector3, Float] (IO ()) where nodeMethod = Godot.Core.Spatial.global_rotate {-# NOINLINE bindSpatial_global_scale #-} -- | Scales the global (world) transformation by the given @Vector3@ scale factors. bindSpatial_global_scale :: MethodBind bindSpatial_global_scale = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "global_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scales the global (world) transformation by the given @Vector3@ scale factors. global_scale :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () global_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_global_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "global_scale" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.global_scale {-# NOINLINE bindSpatial_global_translate #-} -- | Moves the global (world) transformation by @Vector3@ offset. The offset is in global coordinate system. bindSpatial_global_translate :: MethodBind bindSpatial_global_translate = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "global_translate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the global (world) transformation by @Vector3@ offset. The offset is in global coordinate system. global_translate :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () global_translate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_global_translate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "global_translate" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.global_translate {-# NOINLINE bindSpatial_hide #-} -- | Disables rendering of this node. Changes @visible@ to @false@. bindSpatial_hide :: MethodBind bindSpatial_hide = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "hide" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables rendering of this node. Changes @visible@ to @false@. hide :: (Spatial :< cls, Object :< cls) => cls -> IO () hide cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_hide (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "hide" '[] (IO ()) where nodeMethod = Godot.Core.Spatial.hide {-# NOINLINE bindSpatial_is_local_transform_notification_enabled #-} -- | Returns whether node notifies about its local transformation changes. @Spatial@ will not propagate this by default. bindSpatial_is_local_transform_notification_enabled :: MethodBind bindSpatial_is_local_transform_notification_enabled = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "is_local_transform_notification_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether node notifies about its local transformation changes. @Spatial@ will not propagate this by default. is_local_transform_notification_enabled :: (Spatial :< cls, Object :< cls) => cls -> IO Bool is_local_transform_notification_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_is_local_transform_notification_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "is_local_transform_notification_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Spatial.is_local_transform_notification_enabled {-# NOINLINE bindSpatial_is_scale_disabled #-} -- | Returns whether this node uses a scale of @(1, 1, 1)@ or its local transformation scale. bindSpatial_is_scale_disabled :: MethodBind bindSpatial_is_scale_disabled = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "is_scale_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether this node uses a scale of @(1, 1, 1)@ or its local transformation scale. is_scale_disabled :: (Spatial :< cls, Object :< cls) => cls -> IO Bool is_scale_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_is_scale_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "is_scale_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.Spatial.is_scale_disabled {-# NOINLINE bindSpatial_is_set_as_toplevel #-} -- | Returns whether this node is set as Toplevel, that is whether it ignores its parent nodes transformations. bindSpatial_is_set_as_toplevel :: MethodBind bindSpatial_is_set_as_toplevel = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "is_set_as_toplevel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether this node is set as Toplevel, that is whether it ignores its parent nodes transformations. is_set_as_toplevel :: (Spatial :< cls, Object :< cls) => cls -> IO Bool is_set_as_toplevel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_is_set_as_toplevel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "is_set_as_toplevel" '[] (IO Bool) where nodeMethod = Godot.Core.Spatial.is_set_as_toplevel {-# NOINLINE bindSpatial_is_transform_notification_enabled #-} -- | Returns whether the node notifies about its global and local transformation changes. @Spatial@ will not propagate this by default. bindSpatial_is_transform_notification_enabled :: MethodBind bindSpatial_is_transform_notification_enabled = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "is_transform_notification_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the node notifies about its global and local transformation changes. @Spatial@ will not propagate this by default. is_transform_notification_enabled :: (Spatial :< cls, Object :< cls) => cls -> IO Bool is_transform_notification_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_is_transform_notification_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "is_transform_notification_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Spatial.is_transform_notification_enabled {-# NOINLINE bindSpatial_is_visible #-} -- | If @true@, this node is drawn. The node is only visible if all of its antecedents are visible as well (in other words, @method is_visible_in_tree@ must return @true@). bindSpatial_is_visible :: MethodBind bindSpatial_is_visible = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "is_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this node is drawn. The node is only visible if all of its antecedents are visible as well (in other words, @method is_visible_in_tree@ must return @true@). is_visible :: (Spatial :< cls, Object :< cls) => cls -> IO Bool is_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_is_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "is_visible" '[] (IO Bool) where nodeMethod = Godot.Core.Spatial.is_visible {-# NOINLINE bindSpatial_is_visible_in_tree #-} -- | Returns @true@ if the node is present in the @SceneTree@, its @visible@ property is @true@ and all its antecedents are also visible. If any antecedent is hidden, this node will not be visible in the scene tree. bindSpatial_is_visible_in_tree :: MethodBind bindSpatial_is_visible_in_tree = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "is_visible_in_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the node is present in the @SceneTree@, its @visible@ property is @true@ and all its antecedents are also visible. If any antecedent is hidden, this node will not be visible in the scene tree. is_visible_in_tree :: (Spatial :< cls, Object :< cls) => cls -> IO Bool is_visible_in_tree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_is_visible_in_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "is_visible_in_tree" '[] (IO Bool) where nodeMethod = Godot.Core.Spatial.is_visible_in_tree {-# NOINLINE bindSpatial_look_at #-} -- | Rotates itself so that the local -Z axis points towards the @target@ position. -- The transform will first be rotated around the given @up@ vector, and then fully aligned to the target by a further rotation around an axis perpendicular to both the @target@ and @up@ vectors. -- Operations take place in global space. bindSpatial_look_at :: MethodBind bindSpatial_look_at = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "look_at" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotates itself so that the local -Z axis points towards the @target@ position. -- The transform will first be rotated around the given @up@ vector, and then fully aligned to the target by a further rotation around an axis perpendicular to both the @target@ and @up@ vectors. -- Operations take place in global space. look_at :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> IO () look_at cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_look_at (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "look_at" '[Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.look_at {-# NOINLINE bindSpatial_look_at_from_position #-} -- | Moves the node to the specified @position@, and then rotates itself to point toward the @target@ as per @method look_at@. Operations take place in global space. bindSpatial_look_at_from_position :: MethodBind bindSpatial_look_at_from_position = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "look_at_from_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the node to the specified @position@, and then rotates itself to point toward the @target@ as per @method look_at@. Operations take place in global space. look_at_from_position :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Vector3 -> IO () look_at_from_position cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_look_at_from_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "look_at_from_position" '[Vector3, Vector3, Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.look_at_from_position {-# NOINLINE bindSpatial_orthonormalize #-} -- | Resets this node's transformations (like scale, skew and taper) preserving its rotation and translation by performing Gram-Schmidt orthonormalization on this node's @Transform@. bindSpatial_orthonormalize :: MethodBind bindSpatial_orthonormalize = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "orthonormalize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resets this node's transformations (like scale, skew and taper) preserving its rotation and translation by performing Gram-Schmidt orthonormalization on this node's @Transform@. orthonormalize :: (Spatial :< cls, Object :< cls) => cls -> IO () orthonormalize cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_orthonormalize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "orthonormalize" '[] (IO ()) where nodeMethod = Godot.Core.Spatial.orthonormalize {-# NOINLINE bindSpatial_rotate #-} -- | Rotates the local transformation around axis, a unit @Vector3@, by specified angle in radians. bindSpatial_rotate :: MethodBind bindSpatial_rotate = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "rotate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotates the local transformation around axis, a unit @Vector3@, by specified angle in radians. rotate :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> Float -> IO () rotate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_rotate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "rotate" '[Vector3, Float] (IO ()) where nodeMethod = Godot.Core.Spatial.rotate {-# NOINLINE bindSpatial_rotate_object_local #-} -- | Rotates the local transformation around axis, a unit @Vector3@, by specified angle in radians. The rotation axis is in object-local coordinate system. bindSpatial_rotate_object_local :: MethodBind bindSpatial_rotate_object_local = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "rotate_object_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotates the local transformation around axis, a unit @Vector3@, by specified angle in radians. The rotation axis is in object-local coordinate system. rotate_object_local :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> Float -> IO () rotate_object_local cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_rotate_object_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "rotate_object_local" '[Vector3, Float] (IO ()) where nodeMethod = Godot.Core.Spatial.rotate_object_local {-# NOINLINE bindSpatial_rotate_x #-} -- | Rotates the local transformation around the X axis by angle in radians. bindSpatial_rotate_x :: MethodBind bindSpatial_rotate_x = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "rotate_x" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotates the local transformation around the X axis by angle in radians. rotate_x :: (Spatial :< cls, Object :< cls) => cls -> Float -> IO () rotate_x cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_rotate_x (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "rotate_x" '[Float] (IO ()) where nodeMethod = Godot.Core.Spatial.rotate_x {-# NOINLINE bindSpatial_rotate_y #-} -- | Rotates the local transformation around the Y axis by angle in radians. bindSpatial_rotate_y :: MethodBind bindSpatial_rotate_y = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "rotate_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotates the local transformation around the Y axis by angle in radians. rotate_y :: (Spatial :< cls, Object :< cls) => cls -> Float -> IO () rotate_y cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_rotate_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "rotate_y" '[Float] (IO ()) where nodeMethod = Godot.Core.Spatial.rotate_y {-# NOINLINE bindSpatial_rotate_z #-} -- | Rotates the local transformation around the Z axis by angle in radians. bindSpatial_rotate_z :: MethodBind bindSpatial_rotate_z = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "rotate_z" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotates the local transformation around the Z axis by angle in radians. rotate_z :: (Spatial :< cls, Object :< cls) => cls -> Float -> IO () rotate_z cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_rotate_z (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "rotate_z" '[Float] (IO ()) where nodeMethod = Godot.Core.Spatial.rotate_z {-# NOINLINE bindSpatial_scale_object_local #-} -- | Scales the local transformation by given 3D scale factors in object-local coordinate system. bindSpatial_scale_object_local :: MethodBind bindSpatial_scale_object_local = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "scale_object_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scales the local transformation by given 3D scale factors in object-local coordinate system. scale_object_local :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () scale_object_local cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_scale_object_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "scale_object_local" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.scale_object_local {-# NOINLINE bindSpatial_set_as_toplevel #-} -- | Makes the node ignore its parents transformations. Node transformations are only in global space. bindSpatial_set_as_toplevel :: MethodBind bindSpatial_set_as_toplevel = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_as_toplevel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Makes the node ignore its parents transformations. Node transformations are only in global space. set_as_toplevel :: (Spatial :< cls, Object :< cls) => cls -> Bool -> IO () set_as_toplevel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_as_toplevel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_as_toplevel" '[Bool] (IO ()) where nodeMethod = Godot.Core.Spatial.set_as_toplevel {-# NOINLINE bindSpatial_set_disable_scale #-} -- | Sets whether the node uses a scale of @(1, 1, 1)@ or its local transformation scale. Changes to the local transformation scale are preserved. bindSpatial_set_disable_scale :: MethodBind bindSpatial_set_disable_scale = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_disable_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the node uses a scale of @(1, 1, 1)@ or its local transformation scale. Changes to the local transformation scale are preserved. set_disable_scale :: (Spatial :< cls, Object :< cls) => cls -> Bool -> IO () set_disable_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_disable_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_disable_scale" '[Bool] (IO ()) where nodeMethod = Godot.Core.Spatial.set_disable_scale {-# NOINLINE bindSpatial_set_gizmo #-} -- | The @SpatialGizmo@ for this node. Used for example in @EditorSpatialGizmo@ as custom visualization and editing handles in Editor. bindSpatial_set_gizmo :: MethodBind bindSpatial_set_gizmo = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_gizmo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @SpatialGizmo@ for this node. Used for example in @EditorSpatialGizmo@ as custom visualization and editing handles in Editor. set_gizmo :: (Spatial :< cls, Object :< cls) => cls -> SpatialGizmo -> IO () set_gizmo cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_gizmo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_gizmo" '[SpatialGizmo] (IO ()) where nodeMethod = Godot.Core.Spatial.set_gizmo {-# NOINLINE bindSpatial_set_global_transform #-} -- | World space (global) @Transform@ of this node. bindSpatial_set_global_transform :: MethodBind bindSpatial_set_global_transform = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_global_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | World space (global) @Transform@ of this node. set_global_transform :: (Spatial :< cls, Object :< cls) => cls -> Transform -> IO () set_global_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_global_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_global_transform" '[Transform] (IO ()) where nodeMethod = Godot.Core.Spatial.set_global_transform {-# NOINLINE bindSpatial_set_identity #-} -- | Reset all transformations for this node (sets its @Transform@ to the identity matrix). bindSpatial_set_identity :: MethodBind bindSpatial_set_identity = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_identity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reset all transformations for this node (sets its @Transform@ to the identity matrix). set_identity :: (Spatial :< cls, Object :< cls) => cls -> IO () set_identity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_identity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_identity" '[] (IO ()) where nodeMethod = Godot.Core.Spatial.set_identity {-# NOINLINE bindSpatial_set_ignore_transform_notification #-} -- | Sets whether the node ignores notification that its transformation (global or local) changed. bindSpatial_set_ignore_transform_notification :: MethodBind bindSpatial_set_ignore_transform_notification = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_ignore_transform_notification" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the node ignores notification that its transformation (global or local) changed. set_ignore_transform_notification :: (Spatial :< cls, Object :< cls) => cls -> Bool -> IO () set_ignore_transform_notification cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_ignore_transform_notification (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_ignore_transform_notification" '[Bool] (IO ()) where nodeMethod = Godot.Core.Spatial.set_ignore_transform_notification {-# NOINLINE bindSpatial_set_notify_local_transform #-} -- | Sets whether the node notifies about its local transformation changes. @Spatial@ will not propagate this by default. bindSpatial_set_notify_local_transform :: MethodBind bindSpatial_set_notify_local_transform = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_notify_local_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the node notifies about its local transformation changes. @Spatial@ will not propagate this by default. set_notify_local_transform :: (Spatial :< cls, Object :< cls) => cls -> Bool -> IO () set_notify_local_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_notify_local_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_notify_local_transform" '[Bool] (IO ()) where nodeMethod = Godot.Core.Spatial.set_notify_local_transform {-# NOINLINE bindSpatial_set_notify_transform #-} -- | Sets whether the node notifies about its global and local transformation changes. @Spatial@ will not propagate this by default. bindSpatial_set_notify_transform :: MethodBind bindSpatial_set_notify_transform = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_notify_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether the node notifies about its global and local transformation changes. @Spatial@ will not propagate this by default. set_notify_transform :: (Spatial :< cls, Object :< cls) => cls -> Bool -> IO () set_notify_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_notify_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_notify_transform" '[Bool] (IO ()) where nodeMethod = Godot.Core.Spatial.set_notify_transform {-# NOINLINE bindSpatial_set_rotation #-} -- | Rotation part of the local transformation in radians, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle). -- __Note:__ In the mathematical sense, rotation is a matrix and not a vector. The three Euler angles, which are the three independent parameters of the Euler-angle parametrization of the rotation matrix, are stored in a @Vector3@ data structure not because the rotation is a vector, but only because @Vector3@ exists as a convenient data-structure to store 3 floating-point numbers. Therefore, applying affine operations on the rotation "vector" is not meaningful. bindSpatial_set_rotation :: MethodBind bindSpatial_set_rotation = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_rotation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotation part of the local transformation in radians, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle). -- __Note:__ In the mathematical sense, rotation is a matrix and not a vector. The three Euler angles, which are the three independent parameters of the Euler-angle parametrization of the rotation matrix, are stored in a @Vector3@ data structure not because the rotation is a vector, but only because @Vector3@ exists as a convenient data-structure to store 3 floating-point numbers. Therefore, applying affine operations on the rotation "vector" is not meaningful. set_rotation :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_rotation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_rotation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_rotation" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.set_rotation {-# NOINLINE bindSpatial_set_rotation_degrees #-} -- | Rotation part of the local transformation in degrees, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle). bindSpatial_set_rotation_degrees :: MethodBind bindSpatial_set_rotation_degrees = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_rotation_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Rotation part of the local transformation in degrees, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle). set_rotation_degrees :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_rotation_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_rotation_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_rotation_degrees" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.set_rotation_degrees {-# NOINLINE bindSpatial_set_scale #-} -- | Scale part of the local transformation. bindSpatial_set_scale :: MethodBind bindSpatial_set_scale = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scale part of the local transformation. set_scale :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_scale" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.set_scale {-# NOINLINE bindSpatial_set_transform #-} -- | Local space @Transform@ of this node, with respect to the parent node. bindSpatial_set_transform :: MethodBind bindSpatial_set_transform = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Local space @Transform@ of this node, with respect to the parent node. set_transform :: (Spatial :< cls, Object :< cls) => cls -> Transform -> IO () set_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_transform" '[Transform] (IO ()) where nodeMethod = Godot.Core.Spatial.set_transform {-# NOINLINE bindSpatial_set_translation #-} -- | Local translation of this node. bindSpatial_set_translation :: MethodBind bindSpatial_set_translation = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_translation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Local translation of this node. set_translation :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_translation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_translation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_translation" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.set_translation {-# NOINLINE bindSpatial_set_visible #-} -- | If @true@, this node is drawn. The node is only visible if all of its antecedents are visible as well (in other words, @method is_visible_in_tree@ must return @true@). bindSpatial_set_visible :: MethodBind bindSpatial_set_visible = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "set_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this node is drawn. The node is only visible if all of its antecedents are visible as well (in other words, @method is_visible_in_tree@ must return @true@). set_visible :: (Spatial :< cls, Object :< cls) => cls -> Bool -> IO () set_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_set_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "set_visible" '[Bool] (IO ()) where nodeMethod = Godot.Core.Spatial.set_visible {-# NOINLINE bindSpatial_show #-} -- | Enables rendering of this node. Changes @visible@ to @true@. bindSpatial_show :: MethodBind bindSpatial_show = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "show" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables rendering of this node. Changes @visible@ to @true@. show :: (Spatial :< cls, Object :< cls) => cls -> IO () show cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_show (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "show" '[] (IO ()) where nodeMethod = Godot.Core.Spatial.show {-# NOINLINE bindSpatial_to_global #-} -- | Transforms @local_point@ from this node's local space to world space. bindSpatial_to_global :: MethodBind bindSpatial_to_global = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "to_global" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Transforms @local_point@ from this node's local space to world space. to_global :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO Vector3 to_global cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_to_global (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "to_global" '[Vector3] (IO Vector3) where nodeMethod = Godot.Core.Spatial.to_global {-# NOINLINE bindSpatial_to_local #-} -- | Transforms @global_point@ from world space to this node's local space. bindSpatial_to_local :: MethodBind bindSpatial_to_local = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "to_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Transforms @global_point@ from world space to this node's local space. to_local :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO Vector3 to_local cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_to_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "to_local" '[Vector3] (IO Vector3) where nodeMethod = Godot.Core.Spatial.to_local {-# NOINLINE bindSpatial_translate #-} -- | Changes the node's position by the given offset @Vector3@. -- Note that the translation @offset@ is affected by the node's scale, so if scaled by e.g. @(10, 1, 1)@, a translation by an offset of @(2, 0, 0)@ would actually add 20 (@2 * 10@) to the X coordinate. bindSpatial_translate :: MethodBind bindSpatial_translate = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "translate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the node's position by the given offset @Vector3@. -- Note that the translation @offset@ is affected by the node's scale, so if scaled by e.g. @(10, 1, 1)@, a translation by an offset of @(2, 0, 0)@ would actually add 20 (@2 * 10@) to the X coordinate. translate :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () translate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_translate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "translate" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.translate {-# NOINLINE bindSpatial_translate_object_local #-} -- | Changes the node's position by the given offset @Vector3@ in local space. bindSpatial_translate_object_local :: MethodBind bindSpatial_translate_object_local = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "translate_object_local" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the node's position by the given offset @Vector3@ in local space. translate_object_local :: (Spatial :< cls, Object :< cls) => cls -> Vector3 -> IO () translate_object_local cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_translate_object_local (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "translate_object_local" '[Vector3] (IO ()) where nodeMethod = Godot.Core.Spatial.translate_object_local {-# NOINLINE bindSpatial_update_gizmo #-} -- | Updates the @SpatialGizmo@ of this node. bindSpatial_update_gizmo :: MethodBind bindSpatial_update_gizmo = unsafePerformIO $ withCString "Spatial" $ \ clsNamePtr -> withCString "update_gizmo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the @SpatialGizmo@ of this node. update_gizmo :: (Spatial :< cls, Object :< cls) => cls -> IO () update_gizmo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatial_update_gizmo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Spatial "update_gizmo" '[] (IO ()) where nodeMethod = Godot.Core.Spatial.update_gizmo ================================================ FILE: src/Godot/Core/SpatialGizmo.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SpatialGizmo () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() ================================================ FILE: src/Godot/Core/SpatialMaterial.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SpatialMaterial (Godot.Core.SpatialMaterial._DIFFUSE_BURLEY, Godot.Core.SpatialMaterial._DEPTH_DRAW_ALWAYS, Godot.Core.SpatialMaterial._FLAG_DISABLE_DEPTH_TEST, Godot.Core.SpatialMaterial._TEXTURE_MAX, Godot.Core.SpatialMaterial._DISTANCE_FADE_PIXEL_DITHER, Godot.Core.SpatialMaterial._FLAG_DONT_RECEIVE_SHADOWS, Godot.Core.SpatialMaterial._TEXTURE_METALLIC, Godot.Core.SpatialMaterial._FEATURE_MAX, Godot.Core.SpatialMaterial._TEXTURE_DETAIL_ALBEDO, Godot.Core.SpatialMaterial._TEXTURE_CHANNEL_RED, Godot.Core.SpatialMaterial._SPECULAR_TOON, Godot.Core.SpatialMaterial._FEATURE_EMISSION, Godot.Core.SpatialMaterial._TEXTURE_CHANNEL_BLUE, Godot.Core.SpatialMaterial._TEXTURE_AMBIENT_OCCLUSION, Godot.Core.SpatialMaterial._TEXTURE_DETAIL_MASK, Godot.Core.SpatialMaterial._FEATURE_DETAIL, Godot.Core.SpatialMaterial._SPECULAR_SCHLICK_GGX, Godot.Core.SpatialMaterial._FEATURE_SUBSURACE_SCATTERING, Godot.Core.SpatialMaterial._FEATURE_DEPTH_MAPPING, Godot.Core.SpatialMaterial._TEXTURE_REFRACTION, Godot.Core.SpatialMaterial._FEATURE_TRANSPARENT, Godot.Core.SpatialMaterial._FEATURE_TRANSMISSION, Godot.Core.SpatialMaterial._FLAG_TRIPLANAR_USE_WORLD, Godot.Core.SpatialMaterial._DEPTH_DRAW_ALPHA_OPAQUE_PREPASS, Godot.Core.SpatialMaterial._FLAG_USE_ALPHA_SCISSOR, Godot.Core.SpatialMaterial._DIFFUSE_LAMBERT, Godot.Core.SpatialMaterial._DETAIL_UV_2, Godot.Core.SpatialMaterial._DIFFUSE_LAMBERT_WRAP, Godot.Core.SpatialMaterial._BLEND_MODE_ADD, Godot.Core.SpatialMaterial._BILLBOARD_ENABLED, Godot.Core.SpatialMaterial._TEXTURE_NORMAL, Godot.Core.SpatialMaterial._FEATURE_NORMAL_MAPPING, Godot.Core.SpatialMaterial._TEXTURE_TRANSMISSION, Godot.Core.SpatialMaterial._FLAG_ALBEDO_FROM_VERTEX_COLOR, Godot.Core.SpatialMaterial._FEATURE_REFRACTION, Godot.Core.SpatialMaterial._BLEND_MODE_MIX, Godot.Core.SpatialMaterial._BILLBOARD_FIXED_Y, Godot.Core.SpatialMaterial._TEXTURE_FLOWMAP, Godot.Core.SpatialMaterial._TEXTURE_RIM, Godot.Core.SpatialMaterial._FEATURE_AMBIENT_OCCLUSION, Godot.Core.SpatialMaterial._DISTANCE_FADE_OBJECT_DITHER, Godot.Core.SpatialMaterial._FLAG_BILLBOARD_KEEP_SCALE, Godot.Core.SpatialMaterial._DEPTH_DRAW_OPAQUE_ONLY, Godot.Core.SpatialMaterial._FLAG_USE_POINT_SIZE, Godot.Core.SpatialMaterial._CULL_DISABLED, Godot.Core.SpatialMaterial._FEATURE_ANISOTROPY, Godot.Core.SpatialMaterial._TEXTURE_ROUGHNESS, Godot.Core.SpatialMaterial._EMISSION_OP_ADD, Godot.Core.SpatialMaterial._FLAG_MAX, Godot.Core.SpatialMaterial._FLAG_FIXED_SIZE, Godot.Core.SpatialMaterial._FLAG_UNSHADED, Godot.Core.SpatialMaterial._FLAG_ENSURE_CORRECT_NORMALS, Godot.Core.SpatialMaterial._TEXTURE_CHANNEL_GREEN, Godot.Core.SpatialMaterial._SPECULAR_BLINN, Godot.Core.SpatialMaterial._CULL_BACK, Godot.Core.SpatialMaterial._EMISSION_OP_MULTIPLY, Godot.Core.SpatialMaterial._FLAG_SRGB_VERTEX_COLOR, Godot.Core.SpatialMaterial._FLAG_EMISSION_ON_UV2, Godot.Core.SpatialMaterial._FLAG_AO_ON_UV2, Godot.Core.SpatialMaterial._TEXTURE_DEPTH, Godot.Core.SpatialMaterial._DIFFUSE_OREN_NAYAR, Godot.Core.SpatialMaterial._FLAG_UV1_USE_TRIPLANAR, Godot.Core.SpatialMaterial._DEPTH_DRAW_DISABLED, Godot.Core.SpatialMaterial._TEXTURE_DETAIL_NORMAL, Godot.Core.SpatialMaterial._FEATURE_RIM, Godot.Core.SpatialMaterial._DISTANCE_FADE_DISABLED, Godot.Core.SpatialMaterial._SPECULAR_DISABLED, Godot.Core.SpatialMaterial._CULL_FRONT, Godot.Core.SpatialMaterial._TEXTURE_SUBSURFACE_SCATTERING, Godot.Core.SpatialMaterial._TEXTURE_CLEARCOAT, Godot.Core.SpatialMaterial._TEXTURE_CHANNEL_ALPHA, Godot.Core.SpatialMaterial._FEATURE_CLEARCOAT, Godot.Core.SpatialMaterial._FLAG_ALBEDO_TEXTURE_FORCE_SRGB, Godot.Core.SpatialMaterial._DIFFUSE_TOON, Godot.Core.SpatialMaterial._DETAIL_UV_1, Godot.Core.SpatialMaterial._FLAG_USE_SHADOW_TO_OPACITY, Godot.Core.SpatialMaterial._BILLBOARD_DISABLED, Godot.Core.SpatialMaterial._BLEND_MODE_MUL, Godot.Core.SpatialMaterial._FLAG_USE_VERTEX_LIGHTING, Godot.Core.SpatialMaterial._FLAG_UV2_USE_TRIPLANAR, Godot.Core.SpatialMaterial._BLEND_MODE_SUB, Godot.Core.SpatialMaterial._SPECULAR_PHONG, Godot.Core.SpatialMaterial._DISTANCE_FADE_PIXEL_ALPHA, Godot.Core.SpatialMaterial._FLAG_DISABLE_AMBIENT_LIGHT, Godot.Core.SpatialMaterial._BILLBOARD_PARTICLES, Godot.Core.SpatialMaterial._TEXTURE_EMISSION, Godot.Core.SpatialMaterial._TEXTURE_CHANNEL_GRAYSCALE, Godot.Core.SpatialMaterial._TEXTURE_ALBEDO, Godot.Core.SpatialMaterial.get_albedo, Godot.Core.SpatialMaterial.get_alpha_scissor_threshold, Godot.Core.SpatialMaterial.get_anisotropy, Godot.Core.SpatialMaterial.get_ao_light_affect, Godot.Core.SpatialMaterial.get_ao_texture_channel, Godot.Core.SpatialMaterial.get_billboard_mode, Godot.Core.SpatialMaterial.get_blend_mode, Godot.Core.SpatialMaterial.get_clearcoat, Godot.Core.SpatialMaterial.get_clearcoat_gloss, Godot.Core.SpatialMaterial.get_cull_mode, Godot.Core.SpatialMaterial.get_depth_deep_parallax_flip_binormal, Godot.Core.SpatialMaterial.get_depth_deep_parallax_flip_tangent, Godot.Core.SpatialMaterial.get_depth_deep_parallax_max_layers, Godot.Core.SpatialMaterial.get_depth_deep_parallax_min_layers, Godot.Core.SpatialMaterial.get_depth_draw_mode, Godot.Core.SpatialMaterial.get_depth_scale, Godot.Core.SpatialMaterial.get_detail_blend_mode, Godot.Core.SpatialMaterial.get_detail_uv, Godot.Core.SpatialMaterial.get_diffuse_mode, Godot.Core.SpatialMaterial.get_distance_fade, Godot.Core.SpatialMaterial.get_distance_fade_max_distance, Godot.Core.SpatialMaterial.get_distance_fade_min_distance, Godot.Core.SpatialMaterial.get_emission, Godot.Core.SpatialMaterial.get_emission_energy, Godot.Core.SpatialMaterial.get_emission_operator, Godot.Core.SpatialMaterial.get_feature, Godot.Core.SpatialMaterial.get_flag, Godot.Core.SpatialMaterial.get_grow, Godot.Core.SpatialMaterial.get_line_width, Godot.Core.SpatialMaterial.get_metallic, Godot.Core.SpatialMaterial.get_metallic_texture_channel, Godot.Core.SpatialMaterial.get_normal_scale, Godot.Core.SpatialMaterial.get_particles_anim_h_frames, Godot.Core.SpatialMaterial.get_particles_anim_loop, Godot.Core.SpatialMaterial.get_particles_anim_v_frames, Godot.Core.SpatialMaterial.get_point_size, Godot.Core.SpatialMaterial.get_proximity_fade_distance, Godot.Core.SpatialMaterial.get_refraction, Godot.Core.SpatialMaterial.get_refraction_texture_channel, Godot.Core.SpatialMaterial.get_rim, Godot.Core.SpatialMaterial.get_rim_tint, Godot.Core.SpatialMaterial.get_roughness, Godot.Core.SpatialMaterial.get_roughness_texture_channel, Godot.Core.SpatialMaterial.get_specular, Godot.Core.SpatialMaterial.get_specular_mode, Godot.Core.SpatialMaterial.get_subsurface_scattering_strength, Godot.Core.SpatialMaterial.get_texture, Godot.Core.SpatialMaterial.get_transmission, Godot.Core.SpatialMaterial.get_uv1_offset, Godot.Core.SpatialMaterial.get_uv1_scale, Godot.Core.SpatialMaterial.get_uv1_triplanar_blend_sharpness, Godot.Core.SpatialMaterial.get_uv2_offset, Godot.Core.SpatialMaterial.get_uv2_scale, Godot.Core.SpatialMaterial.get_uv2_triplanar_blend_sharpness, Godot.Core.SpatialMaterial.is_depth_deep_parallax_enabled, Godot.Core.SpatialMaterial.is_grow_enabled, Godot.Core.SpatialMaterial.is_proximity_fade_enabled, Godot.Core.SpatialMaterial.set_albedo, Godot.Core.SpatialMaterial.set_alpha_scissor_threshold, Godot.Core.SpatialMaterial.set_anisotropy, Godot.Core.SpatialMaterial.set_ao_light_affect, Godot.Core.SpatialMaterial.set_ao_texture_channel, Godot.Core.SpatialMaterial.set_billboard_mode, Godot.Core.SpatialMaterial.set_blend_mode, Godot.Core.SpatialMaterial.set_clearcoat, Godot.Core.SpatialMaterial.set_clearcoat_gloss, Godot.Core.SpatialMaterial.set_cull_mode, Godot.Core.SpatialMaterial.set_depth_deep_parallax, Godot.Core.SpatialMaterial.set_depth_deep_parallax_flip_binormal, Godot.Core.SpatialMaterial.set_depth_deep_parallax_flip_tangent, Godot.Core.SpatialMaterial.set_depth_deep_parallax_max_layers, Godot.Core.SpatialMaterial.set_depth_deep_parallax_min_layers, Godot.Core.SpatialMaterial.set_depth_draw_mode, Godot.Core.SpatialMaterial.set_depth_scale, Godot.Core.SpatialMaterial.set_detail_blend_mode, Godot.Core.SpatialMaterial.set_detail_uv, Godot.Core.SpatialMaterial.set_diffuse_mode, Godot.Core.SpatialMaterial.set_distance_fade, Godot.Core.SpatialMaterial.set_distance_fade_max_distance, Godot.Core.SpatialMaterial.set_distance_fade_min_distance, Godot.Core.SpatialMaterial.set_emission, Godot.Core.SpatialMaterial.set_emission_energy, Godot.Core.SpatialMaterial.set_emission_operator, Godot.Core.SpatialMaterial.set_feature, Godot.Core.SpatialMaterial.set_flag, Godot.Core.SpatialMaterial.set_grow, Godot.Core.SpatialMaterial.set_grow_enabled, Godot.Core.SpatialMaterial.set_line_width, Godot.Core.SpatialMaterial.set_metallic, Godot.Core.SpatialMaterial.set_metallic_texture_channel, Godot.Core.SpatialMaterial.set_normal_scale, Godot.Core.SpatialMaterial.set_particles_anim_h_frames, Godot.Core.SpatialMaterial.set_particles_anim_loop, Godot.Core.SpatialMaterial.set_particles_anim_v_frames, Godot.Core.SpatialMaterial.set_point_size, Godot.Core.SpatialMaterial.set_proximity_fade, Godot.Core.SpatialMaterial.set_proximity_fade_distance, Godot.Core.SpatialMaterial.set_refraction, Godot.Core.SpatialMaterial.set_refraction_texture_channel, Godot.Core.SpatialMaterial.set_rim, Godot.Core.SpatialMaterial.set_rim_tint, Godot.Core.SpatialMaterial.set_roughness, Godot.Core.SpatialMaterial.set_roughness_texture_channel, Godot.Core.SpatialMaterial.set_specular, Godot.Core.SpatialMaterial.set_specular_mode, Godot.Core.SpatialMaterial.set_subsurface_scattering_strength, Godot.Core.SpatialMaterial.set_texture, Godot.Core.SpatialMaterial.set_transmission, Godot.Core.SpatialMaterial.set_uv1_offset, Godot.Core.SpatialMaterial.set_uv1_scale, Godot.Core.SpatialMaterial.set_uv1_triplanar_blend_sharpness, Godot.Core.SpatialMaterial.set_uv2_offset, Godot.Core.SpatialMaterial.set_uv2_scale, Godot.Core.SpatialMaterial.set_uv2_triplanar_blend_sharpness) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Material() _DIFFUSE_BURLEY :: Int _DIFFUSE_BURLEY = 0 _DEPTH_DRAW_ALWAYS :: Int _DEPTH_DRAW_ALWAYS = 1 _FLAG_DISABLE_DEPTH_TEST :: Int _FLAG_DISABLE_DEPTH_TEST = 2 _TEXTURE_MAX :: Int _TEXTURE_MAX = 16 _DISTANCE_FADE_PIXEL_DITHER :: Int _DISTANCE_FADE_PIXEL_DITHER = 2 _FLAG_DONT_RECEIVE_SHADOWS :: Int _FLAG_DONT_RECEIVE_SHADOWS = 15 _TEXTURE_METALLIC :: Int _TEXTURE_METALLIC = 1 _FEATURE_MAX :: Int _FEATURE_MAX = 12 _TEXTURE_DETAIL_ALBEDO :: Int _TEXTURE_DETAIL_ALBEDO = 14 _TEXTURE_CHANNEL_RED :: Int _TEXTURE_CHANNEL_RED = 0 _SPECULAR_TOON :: Int _SPECULAR_TOON = 3 _FEATURE_EMISSION :: Int _FEATURE_EMISSION = 1 _TEXTURE_CHANNEL_BLUE :: Int _TEXTURE_CHANNEL_BLUE = 2 _TEXTURE_AMBIENT_OCCLUSION :: Int _TEXTURE_AMBIENT_OCCLUSION = 8 _TEXTURE_DETAIL_MASK :: Int _TEXTURE_DETAIL_MASK = 13 _FEATURE_DETAIL :: Int _FEATURE_DETAIL = 11 _SPECULAR_SCHLICK_GGX :: Int _SPECULAR_SCHLICK_GGX = 0 _FEATURE_SUBSURACE_SCATTERING :: Int _FEATURE_SUBSURACE_SCATTERING = 8 _FEATURE_DEPTH_MAPPING :: Int _FEATURE_DEPTH_MAPPING = 7 _TEXTURE_REFRACTION :: Int _TEXTURE_REFRACTION = 12 _FEATURE_TRANSPARENT :: Int _FEATURE_TRANSPARENT = 0 _FEATURE_TRANSMISSION :: Int _FEATURE_TRANSMISSION = 9 _FLAG_TRIPLANAR_USE_WORLD :: Int _FLAG_TRIPLANAR_USE_WORLD = 10 _DEPTH_DRAW_ALPHA_OPAQUE_PREPASS :: Int _DEPTH_DRAW_ALPHA_OPAQUE_PREPASS = 3 _FLAG_USE_ALPHA_SCISSOR :: Int _FLAG_USE_ALPHA_SCISSOR = 13 _DIFFUSE_LAMBERT :: Int _DIFFUSE_LAMBERT = 1 _DETAIL_UV_2 :: Int _DETAIL_UV_2 = 1 _DIFFUSE_LAMBERT_WRAP :: Int _DIFFUSE_LAMBERT_WRAP = 2 _BLEND_MODE_ADD :: Int _BLEND_MODE_ADD = 1 _BILLBOARD_ENABLED :: Int _BILLBOARD_ENABLED = 1 _TEXTURE_NORMAL :: Int _TEXTURE_NORMAL = 4 _FEATURE_NORMAL_MAPPING :: Int _FEATURE_NORMAL_MAPPING = 2 _TEXTURE_TRANSMISSION :: Int _TEXTURE_TRANSMISSION = 11 _FLAG_ALBEDO_FROM_VERTEX_COLOR :: Int _FLAG_ALBEDO_FROM_VERTEX_COLOR = 3 _FEATURE_REFRACTION :: Int _FEATURE_REFRACTION = 10 _BLEND_MODE_MIX :: Int _BLEND_MODE_MIX = 0 _BILLBOARD_FIXED_Y :: Int _BILLBOARD_FIXED_Y = 2 _TEXTURE_FLOWMAP :: Int _TEXTURE_FLOWMAP = 7 _TEXTURE_RIM :: Int _TEXTURE_RIM = 5 _FEATURE_AMBIENT_OCCLUSION :: Int _FEATURE_AMBIENT_OCCLUSION = 6 _DISTANCE_FADE_OBJECT_DITHER :: Int _DISTANCE_FADE_OBJECT_DITHER = 3 _FLAG_BILLBOARD_KEEP_SCALE :: Int _FLAG_BILLBOARD_KEEP_SCALE = 7 _DEPTH_DRAW_OPAQUE_ONLY :: Int _DEPTH_DRAW_OPAQUE_ONLY = 0 _FLAG_USE_POINT_SIZE :: Int _FLAG_USE_POINT_SIZE = 5 _CULL_DISABLED :: Int _CULL_DISABLED = 2 _FEATURE_ANISOTROPY :: Int _FEATURE_ANISOTROPY = 5 _TEXTURE_ROUGHNESS :: Int _TEXTURE_ROUGHNESS = 2 _EMISSION_OP_ADD :: Int _EMISSION_OP_ADD = 0 _FLAG_MAX :: Int _FLAG_MAX = 19 _FLAG_FIXED_SIZE :: Int _FLAG_FIXED_SIZE = 6 _FLAG_UNSHADED :: Int _FLAG_UNSHADED = 0 _FLAG_ENSURE_CORRECT_NORMALS :: Int _FLAG_ENSURE_CORRECT_NORMALS = 16 _TEXTURE_CHANNEL_GREEN :: Int _TEXTURE_CHANNEL_GREEN = 1 _SPECULAR_BLINN :: Int _SPECULAR_BLINN = 1 _CULL_BACK :: Int _CULL_BACK = 0 _EMISSION_OP_MULTIPLY :: Int _EMISSION_OP_MULTIPLY = 1 _FLAG_SRGB_VERTEX_COLOR :: Int _FLAG_SRGB_VERTEX_COLOR = 4 _FLAG_EMISSION_ON_UV2 :: Int _FLAG_EMISSION_ON_UV2 = 12 _FLAG_AO_ON_UV2 :: Int _FLAG_AO_ON_UV2 = 11 _TEXTURE_DEPTH :: Int _TEXTURE_DEPTH = 9 _DIFFUSE_OREN_NAYAR :: Int _DIFFUSE_OREN_NAYAR = 3 _FLAG_UV1_USE_TRIPLANAR :: Int _FLAG_UV1_USE_TRIPLANAR = 8 _DEPTH_DRAW_DISABLED :: Int _DEPTH_DRAW_DISABLED = 2 _TEXTURE_DETAIL_NORMAL :: Int _TEXTURE_DETAIL_NORMAL = 15 _FEATURE_RIM :: Int _FEATURE_RIM = 3 _DISTANCE_FADE_DISABLED :: Int _DISTANCE_FADE_DISABLED = 0 _SPECULAR_DISABLED :: Int _SPECULAR_DISABLED = 4 _CULL_FRONT :: Int _CULL_FRONT = 1 _TEXTURE_SUBSURFACE_SCATTERING :: Int _TEXTURE_SUBSURFACE_SCATTERING = 10 _TEXTURE_CLEARCOAT :: Int _TEXTURE_CLEARCOAT = 6 _TEXTURE_CHANNEL_ALPHA :: Int _TEXTURE_CHANNEL_ALPHA = 3 _FEATURE_CLEARCOAT :: Int _FEATURE_CLEARCOAT = 4 _FLAG_ALBEDO_TEXTURE_FORCE_SRGB :: Int _FLAG_ALBEDO_TEXTURE_FORCE_SRGB = 14 _DIFFUSE_TOON :: Int _DIFFUSE_TOON = 4 _DETAIL_UV_1 :: Int _DETAIL_UV_1 = 0 _FLAG_USE_SHADOW_TO_OPACITY :: Int _FLAG_USE_SHADOW_TO_OPACITY = 18 _BILLBOARD_DISABLED :: Int _BILLBOARD_DISABLED = 0 _BLEND_MODE_MUL :: Int _BLEND_MODE_MUL = 3 _FLAG_USE_VERTEX_LIGHTING :: Int _FLAG_USE_VERTEX_LIGHTING = 1 _FLAG_UV2_USE_TRIPLANAR :: Int _FLAG_UV2_USE_TRIPLANAR = 9 _BLEND_MODE_SUB :: Int _BLEND_MODE_SUB = 2 _SPECULAR_PHONG :: Int _SPECULAR_PHONG = 2 _DISTANCE_FADE_PIXEL_ALPHA :: Int _DISTANCE_FADE_PIXEL_ALPHA = 1 _FLAG_DISABLE_AMBIENT_LIGHT :: Int _FLAG_DISABLE_AMBIENT_LIGHT = 17 _BILLBOARD_PARTICLES :: Int _BILLBOARD_PARTICLES = 3 _TEXTURE_EMISSION :: Int _TEXTURE_EMISSION = 3 _TEXTURE_CHANNEL_GRAYSCALE :: Int _TEXTURE_CHANNEL_GRAYSCALE = 4 _TEXTURE_ALBEDO :: Int _TEXTURE_ALBEDO = 0 instance NodeProperty SpatialMaterial "albedo_color" Color 'False where nodeProperty = (get_albedo, wrapDroppingSetter set_albedo, Nothing) instance NodeProperty SpatialMaterial "albedo_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 0 get_texture, wrapIndexedSetter 0 set_texture, Nothing) instance NodeProperty SpatialMaterial "anisotropy" Float 'False where nodeProperty = (get_anisotropy, wrapDroppingSetter set_anisotropy, Nothing) instance NodeProperty SpatialMaterial "anisotropy_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 5 get_feature, wrapIndexedSetter 5 set_feature, Nothing) instance NodeProperty SpatialMaterial "anisotropy_flowmap" Texture 'False where nodeProperty = (wrapIndexedGetter 7 get_texture, wrapIndexedSetter 7 set_texture, Nothing) instance NodeProperty SpatialMaterial "ao_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 6 get_feature, wrapIndexedSetter 6 set_feature, Nothing) instance NodeProperty SpatialMaterial "ao_light_affect" Float 'False where nodeProperty = (get_ao_light_affect, wrapDroppingSetter set_ao_light_affect, Nothing) instance NodeProperty SpatialMaterial "ao_on_uv2" Bool 'False where nodeProperty = (wrapIndexedGetter 11 get_flag, wrapIndexedSetter 11 set_flag, Nothing) instance NodeProperty SpatialMaterial "ao_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 8 get_texture, wrapIndexedSetter 8 set_texture, Nothing) instance NodeProperty SpatialMaterial "ao_texture_channel" Int 'False where nodeProperty = (get_ao_texture_channel, wrapDroppingSetter set_ao_texture_channel, Nothing) instance NodeProperty SpatialMaterial "clearcoat" Float 'False where nodeProperty = (get_clearcoat, wrapDroppingSetter set_clearcoat, Nothing) instance NodeProperty SpatialMaterial "clearcoat_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 4 get_feature, wrapIndexedSetter 4 set_feature, Nothing) instance NodeProperty SpatialMaterial "clearcoat_gloss" Float 'False where nodeProperty = (get_clearcoat_gloss, wrapDroppingSetter set_clearcoat_gloss, Nothing) instance NodeProperty SpatialMaterial "clearcoat_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 6 get_texture, wrapIndexedSetter 6 set_texture, Nothing) instance NodeProperty SpatialMaterial "depth_deep_parallax" Bool 'False where nodeProperty = (is_depth_deep_parallax_enabled, wrapDroppingSetter set_depth_deep_parallax, Nothing) instance NodeProperty SpatialMaterial "depth_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 7 get_feature, wrapIndexedSetter 7 set_feature, Nothing) instance NodeProperty SpatialMaterial "depth_flip_binormal" Bool 'False where nodeProperty = (get_depth_deep_parallax_flip_binormal, wrapDroppingSetter set_depth_deep_parallax_flip_binormal, Nothing) instance NodeProperty SpatialMaterial "depth_flip_tangent" Bool 'False where nodeProperty = (get_depth_deep_parallax_flip_tangent, wrapDroppingSetter set_depth_deep_parallax_flip_tangent, Nothing) instance NodeProperty SpatialMaterial "depth_max_layers" Int 'False where nodeProperty = (get_depth_deep_parallax_max_layers, wrapDroppingSetter set_depth_deep_parallax_max_layers, Nothing) instance NodeProperty SpatialMaterial "depth_min_layers" Int 'False where nodeProperty = (get_depth_deep_parallax_min_layers, wrapDroppingSetter set_depth_deep_parallax_min_layers, Nothing) instance NodeProperty SpatialMaterial "depth_scale" Float 'False where nodeProperty = (get_depth_scale, wrapDroppingSetter set_depth_scale, Nothing) instance NodeProperty SpatialMaterial "depth_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 9 get_texture, wrapIndexedSetter 9 set_texture, Nothing) instance NodeProperty SpatialMaterial "detail_albedo" Texture 'False where nodeProperty = (wrapIndexedGetter 14 get_texture, wrapIndexedSetter 14 set_texture, Nothing) instance NodeProperty SpatialMaterial "detail_blend_mode" Int 'False where nodeProperty = (get_detail_blend_mode, wrapDroppingSetter set_detail_blend_mode, Nothing) instance NodeProperty SpatialMaterial "detail_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 11 get_feature, wrapIndexedSetter 11 set_feature, Nothing) instance NodeProperty SpatialMaterial "detail_mask" Texture 'False where nodeProperty = (wrapIndexedGetter 13 get_texture, wrapIndexedSetter 13 set_texture, Nothing) instance NodeProperty SpatialMaterial "detail_normal" Texture 'False where nodeProperty = (wrapIndexedGetter 15 get_texture, wrapIndexedSetter 15 set_texture, Nothing) instance NodeProperty SpatialMaterial "detail_uv_layer" Int 'False where nodeProperty = (get_detail_uv, wrapDroppingSetter set_detail_uv, Nothing) instance NodeProperty SpatialMaterial "distance_fade_max_distance" Float 'False where nodeProperty = (get_distance_fade_max_distance, wrapDroppingSetter set_distance_fade_max_distance, Nothing) instance NodeProperty SpatialMaterial "distance_fade_min_distance" Float 'False where nodeProperty = (get_distance_fade_min_distance, wrapDroppingSetter set_distance_fade_min_distance, Nothing) instance NodeProperty SpatialMaterial "distance_fade_mode" Int 'False where nodeProperty = (get_distance_fade, wrapDroppingSetter set_distance_fade, Nothing) instance NodeProperty SpatialMaterial "emission" Color 'False where nodeProperty = (get_emission, wrapDroppingSetter set_emission, Nothing) instance NodeProperty SpatialMaterial "emission_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_feature, wrapIndexedSetter 1 set_feature, Nothing) instance NodeProperty SpatialMaterial "emission_energy" Float 'False where nodeProperty = (get_emission_energy, wrapDroppingSetter set_emission_energy, Nothing) instance NodeProperty SpatialMaterial "emission_on_uv2" Bool 'False where nodeProperty = (wrapIndexedGetter 12 get_flag, wrapIndexedSetter 12 set_flag, Nothing) instance NodeProperty SpatialMaterial "emission_operator" Int 'False where nodeProperty = (get_emission_operator, wrapDroppingSetter set_emission_operator, Nothing) instance NodeProperty SpatialMaterial "emission_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 3 get_texture, wrapIndexedSetter 3 set_texture, Nothing) instance NodeProperty SpatialMaterial "flags_albedo_tex_force_srgb" Bool 'False where nodeProperty = (wrapIndexedGetter 14 get_flag, wrapIndexedSetter 14 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_disable_ambient_light" Bool 'False where nodeProperty = (wrapIndexedGetter 17 get_flag, wrapIndexedSetter 17 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_do_not_receive_shadows" Bool 'False where nodeProperty = (wrapIndexedGetter 15 get_flag, wrapIndexedSetter 15 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_ensure_correct_normals" Bool 'False where nodeProperty = (wrapIndexedGetter 16 get_flag, wrapIndexedSetter 16 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_fixed_size" Bool 'False where nodeProperty = (wrapIndexedGetter 6 get_flag, wrapIndexedSetter 6 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_no_depth_test" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_flag, wrapIndexedSetter 2 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_transparent" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_feature, wrapIndexedSetter 0 set_feature, Nothing) instance NodeProperty SpatialMaterial "flags_unshaded" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_flag, wrapIndexedSetter 0 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_use_point_size" Bool 'False where nodeProperty = (wrapIndexedGetter 5 get_flag, wrapIndexedSetter 5 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_use_shadow_to_opacity" Bool 'False where nodeProperty = (wrapIndexedGetter 18 get_flag, wrapIndexedSetter 18 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_vertex_lighting" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_flag, wrapIndexedSetter 1 set_flag, Nothing) instance NodeProperty SpatialMaterial "flags_world_triplanar" Bool 'False where nodeProperty = (wrapIndexedGetter 10 get_flag, wrapIndexedSetter 10 set_flag, Nothing) instance NodeProperty SpatialMaterial "metallic" Float 'False where nodeProperty = (get_metallic, wrapDroppingSetter set_metallic, Nothing) instance NodeProperty SpatialMaterial "metallic_specular" Float 'False where nodeProperty = (get_specular, wrapDroppingSetter set_specular, Nothing) instance NodeProperty SpatialMaterial "metallic_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 1 get_texture, wrapIndexedSetter 1 set_texture, Nothing) instance NodeProperty SpatialMaterial "metallic_texture_channel" Int 'False where nodeProperty = (get_metallic_texture_channel, wrapDroppingSetter set_metallic_texture_channel, Nothing) instance NodeProperty SpatialMaterial "normal_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_feature, wrapIndexedSetter 2 set_feature, Nothing) instance NodeProperty SpatialMaterial "normal_scale" Float 'False where nodeProperty = (get_normal_scale, wrapDroppingSetter set_normal_scale, Nothing) instance NodeProperty SpatialMaterial "normal_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 4 get_texture, wrapIndexedSetter 4 set_texture, Nothing) instance NodeProperty SpatialMaterial "params_alpha_scissor_threshold" Float 'False where nodeProperty = (get_alpha_scissor_threshold, wrapDroppingSetter set_alpha_scissor_threshold, Nothing) instance NodeProperty SpatialMaterial "params_billboard_keep_scale" Bool 'False where nodeProperty = (wrapIndexedGetter 7 get_flag, wrapIndexedSetter 7 set_flag, Nothing) instance NodeProperty SpatialMaterial "params_billboard_mode" Int 'False where nodeProperty = (get_billboard_mode, wrapDroppingSetter set_billboard_mode, Nothing) instance NodeProperty SpatialMaterial "params_blend_mode" Int 'False where nodeProperty = (get_blend_mode, wrapDroppingSetter set_blend_mode, Nothing) instance NodeProperty SpatialMaterial "params_cull_mode" Int 'False where nodeProperty = (get_cull_mode, wrapDroppingSetter set_cull_mode, Nothing) instance NodeProperty SpatialMaterial "params_depth_draw_mode" Int 'False where nodeProperty = (get_depth_draw_mode, wrapDroppingSetter set_depth_draw_mode, Nothing) instance NodeProperty SpatialMaterial "params_diffuse_mode" Int 'False where nodeProperty = (get_diffuse_mode, wrapDroppingSetter set_diffuse_mode, Nothing) instance NodeProperty SpatialMaterial "params_grow" Bool 'False where nodeProperty = (is_grow_enabled, wrapDroppingSetter set_grow_enabled, Nothing) instance NodeProperty SpatialMaterial "params_grow_amount" Float 'False where nodeProperty = (get_grow, wrapDroppingSetter set_grow, Nothing) instance NodeProperty SpatialMaterial "params_line_width" Float 'False where nodeProperty = (get_line_width, wrapDroppingSetter set_line_width, Nothing) instance NodeProperty SpatialMaterial "params_point_size" Float 'False where nodeProperty = (get_point_size, wrapDroppingSetter set_point_size, Nothing) instance NodeProperty SpatialMaterial "params_specular_mode" Int 'False where nodeProperty = (get_specular_mode, wrapDroppingSetter set_specular_mode, Nothing) instance NodeProperty SpatialMaterial "params_use_alpha_scissor" Bool 'False where nodeProperty = (wrapIndexedGetter 13 get_flag, wrapIndexedSetter 13 set_flag, Nothing) instance NodeProperty SpatialMaterial "particles_anim_h_frames" Int 'False where nodeProperty = (get_particles_anim_h_frames, wrapDroppingSetter set_particles_anim_h_frames, Nothing) instance NodeProperty SpatialMaterial "particles_anim_loop" Bool 'False where nodeProperty = (get_particles_anim_loop, wrapDroppingSetter set_particles_anim_loop, Nothing) instance NodeProperty SpatialMaterial "particles_anim_v_frames" Int 'False where nodeProperty = (get_particles_anim_v_frames, wrapDroppingSetter set_particles_anim_v_frames, Nothing) instance NodeProperty SpatialMaterial "proximity_fade_distance" Float 'False where nodeProperty = (get_proximity_fade_distance, wrapDroppingSetter set_proximity_fade_distance, Nothing) instance NodeProperty SpatialMaterial "proximity_fade_enable" Bool 'False where nodeProperty = (is_proximity_fade_enabled, wrapDroppingSetter set_proximity_fade, Nothing) instance NodeProperty SpatialMaterial "refraction_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 10 get_feature, wrapIndexedSetter 10 set_feature, Nothing) instance NodeProperty SpatialMaterial "refraction_scale" Float 'False where nodeProperty = (get_refraction, wrapDroppingSetter set_refraction, Nothing) instance NodeProperty SpatialMaterial "refraction_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 12 get_texture, wrapIndexedSetter 12 set_texture, Nothing) instance NodeProperty SpatialMaterial "refraction_texture_channel" Int 'False where nodeProperty = (get_refraction_texture_channel, wrapDroppingSetter set_refraction_texture_channel, Nothing) instance NodeProperty SpatialMaterial "rim" Float 'False where nodeProperty = (get_rim, wrapDroppingSetter set_rim, Nothing) instance NodeProperty SpatialMaterial "rim_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 3 get_feature, wrapIndexedSetter 3 set_feature, Nothing) instance NodeProperty SpatialMaterial "rim_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 5 get_texture, wrapIndexedSetter 5 set_texture, Nothing) instance NodeProperty SpatialMaterial "rim_tint" Float 'False where nodeProperty = (get_rim_tint, wrapDroppingSetter set_rim_tint, Nothing) instance NodeProperty SpatialMaterial "roughness" Float 'False where nodeProperty = (get_roughness, wrapDroppingSetter set_roughness, Nothing) instance NodeProperty SpatialMaterial "roughness_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 2 get_texture, wrapIndexedSetter 2 set_texture, Nothing) instance NodeProperty SpatialMaterial "roughness_texture_channel" Int 'False where nodeProperty = (get_roughness_texture_channel, wrapDroppingSetter set_roughness_texture_channel, Nothing) instance NodeProperty SpatialMaterial "subsurf_scatter_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 8 get_feature, wrapIndexedSetter 8 set_feature, Nothing) instance NodeProperty SpatialMaterial "subsurf_scatter_strength" Float 'False where nodeProperty = (get_subsurface_scattering_strength, wrapDroppingSetter set_subsurface_scattering_strength, Nothing) instance NodeProperty SpatialMaterial "subsurf_scatter_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 10 get_texture, wrapIndexedSetter 10 set_texture, Nothing) instance NodeProperty SpatialMaterial "transmission" Color 'False where nodeProperty = (get_transmission, wrapDroppingSetter set_transmission, Nothing) instance NodeProperty SpatialMaterial "transmission_enabled" Bool 'False where nodeProperty = (wrapIndexedGetter 9 get_feature, wrapIndexedSetter 9 set_feature, Nothing) instance NodeProperty SpatialMaterial "transmission_texture" Texture 'False where nodeProperty = (wrapIndexedGetter 11 get_texture, wrapIndexedSetter 11 set_texture, Nothing) instance NodeProperty SpatialMaterial "uv1_offset" Vector3 'False where nodeProperty = (get_uv1_offset, wrapDroppingSetter set_uv1_offset, Nothing) instance NodeProperty SpatialMaterial "uv1_scale" Vector3 'False where nodeProperty = (get_uv1_scale, wrapDroppingSetter set_uv1_scale, Nothing) instance NodeProperty SpatialMaterial "uv1_triplanar" Bool 'False where nodeProperty = (wrapIndexedGetter 8 get_flag, wrapIndexedSetter 8 set_flag, Nothing) instance NodeProperty SpatialMaterial "uv1_triplanar_sharpness" Float 'False where nodeProperty = (get_uv1_triplanar_blend_sharpness, wrapDroppingSetter set_uv1_triplanar_blend_sharpness, Nothing) instance NodeProperty SpatialMaterial "uv2_offset" Vector3 'False where nodeProperty = (get_uv2_offset, wrapDroppingSetter set_uv2_offset, Nothing) instance NodeProperty SpatialMaterial "uv2_scale" Vector3 'False where nodeProperty = (get_uv2_scale, wrapDroppingSetter set_uv2_scale, Nothing) instance NodeProperty SpatialMaterial "uv2_triplanar" Bool 'False where nodeProperty = (wrapIndexedGetter 9 get_flag, wrapIndexedSetter 9 set_flag, Nothing) instance NodeProperty SpatialMaterial "uv2_triplanar_sharpness" Float 'False where nodeProperty = (get_uv2_triplanar_blend_sharpness, wrapDroppingSetter set_uv2_triplanar_blend_sharpness, Nothing) instance NodeProperty SpatialMaterial "vertex_color_is_srgb" Bool 'False where nodeProperty = (wrapIndexedGetter 4 get_flag, wrapIndexedSetter 4 set_flag, Nothing) instance NodeProperty SpatialMaterial "vertex_color_use_as_albedo" Bool 'False where nodeProperty = (wrapIndexedGetter 3 get_flag, wrapIndexedSetter 3 set_flag, Nothing) {-# NOINLINE bindSpatialMaterial_get_albedo #-} -- | The material's base color. bindSpatialMaterial_get_albedo :: MethodBind bindSpatialMaterial_get_albedo = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_albedo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The material's base color. get_albedo :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Color get_albedo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_albedo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_albedo" '[] (IO Color) where nodeMethod = Godot.Core.SpatialMaterial.get_albedo {-# NOINLINE bindSpatialMaterial_get_alpha_scissor_threshold #-} -- | Threshold at which the alpha scissor will discard values. bindSpatialMaterial_get_alpha_scissor_threshold :: MethodBind bindSpatialMaterial_get_alpha_scissor_threshold = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_alpha_scissor_threshold" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Threshold at which the alpha scissor will discard values. get_alpha_scissor_threshold :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_alpha_scissor_threshold cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_alpha_scissor_threshold (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_alpha_scissor_threshold" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_alpha_scissor_threshold {-# NOINLINE bindSpatialMaterial_get_anisotropy #-} -- | The strength of the anisotropy effect. bindSpatialMaterial_get_anisotropy :: MethodBind bindSpatialMaterial_get_anisotropy = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_anisotropy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The strength of the anisotropy effect. get_anisotropy :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_anisotropy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_anisotropy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_anisotropy" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_anisotropy {-# NOINLINE bindSpatialMaterial_get_ao_light_affect #-} -- | Amount that ambient occlusion affects lighting from lights. If @0@, ambient occlusion only affects ambient light. If @1@, ambient occlusion affects lights just as much as it affects ambient light. This can be used to impact the strength of the ambient occlusion effect, but typically looks unrealistic. bindSpatialMaterial_get_ao_light_affect :: MethodBind bindSpatialMaterial_get_ao_light_affect = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_ao_light_affect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount that ambient occlusion affects lighting from lights. If @0@, ambient occlusion only affects ambient light. If @1@, ambient occlusion affects lights just as much as it affects ambient light. This can be used to impact the strength of the ambient occlusion effect, but typically looks unrealistic. get_ao_light_affect :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_ao_light_affect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_ao_light_affect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_ao_light_affect" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_ao_light_affect {-# NOINLINE bindSpatialMaterial_get_ao_texture_channel #-} -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. bindSpatialMaterial_get_ao_texture_channel :: MethodBind bindSpatialMaterial_get_ao_texture_channel = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_ao_texture_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. get_ao_texture_channel :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_ao_texture_channel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_ao_texture_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_ao_texture_channel" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_ao_texture_channel {-# NOINLINE bindSpatialMaterial_get_billboard_mode #-} -- | Controls how the object faces the camera. See @enum BillboardMode@. bindSpatialMaterial_get_billboard_mode :: MethodBind bindSpatialMaterial_get_billboard_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_billboard_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how the object faces the camera. See @enum BillboardMode@. get_billboard_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_billboard_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_billboard_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_billboard_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_billboard_mode {-# NOINLINE bindSpatialMaterial_get_blend_mode #-} -- | The material's blend mode. -- __Note:__ Values other than @Mix@ force the object into the transparent pipeline. See @enum BlendMode@. bindSpatialMaterial_get_blend_mode :: MethodBind bindSpatialMaterial_get_blend_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The material's blend mode. -- __Note:__ Values other than @Mix@ force the object into the transparent pipeline. See @enum BlendMode@. get_blend_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_blend_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_blend_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_blend_mode {-# NOINLINE bindSpatialMaterial_get_clearcoat #-} -- | Sets the strength of the clearcoat effect. Setting to @0@ looks the same as disabling the clearcoat effect. bindSpatialMaterial_get_clearcoat :: MethodBind bindSpatialMaterial_get_clearcoat = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_clearcoat" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the strength of the clearcoat effect. Setting to @0@ looks the same as disabling the clearcoat effect. get_clearcoat :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_clearcoat cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_clearcoat (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_clearcoat" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_clearcoat {-# NOINLINE bindSpatialMaterial_get_clearcoat_gloss #-} -- | Sets the roughness of the clearcoat pass. A higher value results in a smoother clearcoat while a lower value results in a rougher clearcoat. bindSpatialMaterial_get_clearcoat_gloss :: MethodBind bindSpatialMaterial_get_clearcoat_gloss = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_clearcoat_gloss" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the roughness of the clearcoat pass. A higher value results in a smoother clearcoat while a lower value results in a rougher clearcoat. get_clearcoat_gloss :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_clearcoat_gloss cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_clearcoat_gloss (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_clearcoat_gloss" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_clearcoat_gloss {-# NOINLINE bindSpatialMaterial_get_cull_mode #-} -- | Which side of the object is not drawn when backfaces are rendered. See @enum CullMode@. bindSpatialMaterial_get_cull_mode :: MethodBind bindSpatialMaterial_get_cull_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_cull_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Which side of the object is not drawn when backfaces are rendered. See @enum CullMode@. get_cull_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_cull_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_cull_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_cull_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_cull_mode {-# NOINLINE bindSpatialMaterial_get_depth_deep_parallax_flip_binormal #-} -- | If @true@, direction of the binormal is flipped before using in the depth effect. This may be necessary if you have encoded your binormals in a way that is conflicting with the depth effect. bindSpatialMaterial_get_depth_deep_parallax_flip_binormal :: MethodBind bindSpatialMaterial_get_depth_deep_parallax_flip_binormal = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_depth_deep_parallax_flip_binormal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, direction of the binormal is flipped before using in the depth effect. This may be necessary if you have encoded your binormals in a way that is conflicting with the depth effect. get_depth_deep_parallax_flip_binormal :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Bool get_depth_deep_parallax_flip_binormal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_depth_deep_parallax_flip_binormal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_depth_deep_parallax_flip_binormal" '[] (IO Bool) where nodeMethod = Godot.Core.SpatialMaterial.get_depth_deep_parallax_flip_binormal {-# NOINLINE bindSpatialMaterial_get_depth_deep_parallax_flip_tangent #-} -- | If @true@, direction of the tangent is flipped before using in the depth effect. This may be necessary if you have encoded your tangents in a way that is conflicting with the depth effect. bindSpatialMaterial_get_depth_deep_parallax_flip_tangent :: MethodBind bindSpatialMaterial_get_depth_deep_parallax_flip_tangent = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_depth_deep_parallax_flip_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, direction of the tangent is flipped before using in the depth effect. This may be necessary if you have encoded your tangents in a way that is conflicting with the depth effect. get_depth_deep_parallax_flip_tangent :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Bool get_depth_deep_parallax_flip_tangent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_depth_deep_parallax_flip_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_depth_deep_parallax_flip_tangent" '[] (IO Bool) where nodeMethod = Godot.Core.SpatialMaterial.get_depth_deep_parallax_flip_tangent {-# NOINLINE bindSpatialMaterial_get_depth_deep_parallax_max_layers #-} -- | Number of layers to use when using @depth_deep_parallax@ and the view direction is perpendicular to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. bindSpatialMaterial_get_depth_deep_parallax_max_layers :: MethodBind bindSpatialMaterial_get_depth_deep_parallax_max_layers = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_depth_deep_parallax_max_layers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of layers to use when using @depth_deep_parallax@ and the view direction is perpendicular to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. get_depth_deep_parallax_max_layers :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_depth_deep_parallax_max_layers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_depth_deep_parallax_max_layers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_depth_deep_parallax_max_layers" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_depth_deep_parallax_max_layers {-# NOINLINE bindSpatialMaterial_get_depth_deep_parallax_min_layers #-} -- | Number of layers to use when using @depth_deep_parallax@ and the view direction is parallel to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. bindSpatialMaterial_get_depth_deep_parallax_min_layers :: MethodBind bindSpatialMaterial_get_depth_deep_parallax_min_layers = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_depth_deep_parallax_min_layers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of layers to use when using @depth_deep_parallax@ and the view direction is parallel to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. get_depth_deep_parallax_min_layers :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_depth_deep_parallax_min_layers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_depth_deep_parallax_min_layers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_depth_deep_parallax_min_layers" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_depth_deep_parallax_min_layers {-# NOINLINE bindSpatialMaterial_get_depth_draw_mode #-} -- | Determines when depth rendering takes place. See @enum DepthDrawMode@. See also @flags_transparent@. bindSpatialMaterial_get_depth_draw_mode :: MethodBind bindSpatialMaterial_get_depth_draw_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_depth_draw_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines when depth rendering takes place. See @enum DepthDrawMode@. See also @flags_transparent@. get_depth_draw_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_depth_draw_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_depth_draw_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_depth_draw_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_depth_draw_mode {-# NOINLINE bindSpatialMaterial_get_depth_scale #-} -- | Scales the depth offset effect. A higher number will create a larger depth. bindSpatialMaterial_get_depth_scale :: MethodBind bindSpatialMaterial_get_depth_scale = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_depth_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scales the depth offset effect. A higher number will create a larger depth. get_depth_scale :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_depth_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_depth_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_depth_scale" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_depth_scale {-# NOINLINE bindSpatialMaterial_get_detail_blend_mode #-} -- | Specifies how the @detail_albedo@ should blend with the current @ALBEDO@. See @enum BlendMode@ for options. bindSpatialMaterial_get_detail_blend_mode :: MethodBind bindSpatialMaterial_get_detail_blend_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_detail_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies how the @detail_albedo@ should blend with the current @ALBEDO@. See @enum BlendMode@ for options. get_detail_blend_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_detail_blend_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_detail_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_detail_blend_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_detail_blend_mode {-# NOINLINE bindSpatialMaterial_get_detail_uv #-} -- | Specifies whether to use @UV@ or @UV2@ for the detail layer. See @enum DetailUV@ for options. bindSpatialMaterial_get_detail_uv :: MethodBind bindSpatialMaterial_get_detail_uv = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_detail_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies whether to use @UV@ or @UV2@ for the detail layer. See @enum DetailUV@ for options. get_detail_uv :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_detail_uv cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_detail_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_detail_uv" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_detail_uv {-# NOINLINE bindSpatialMaterial_get_diffuse_mode #-} -- | The algorithm used for diffuse light scattering. See @enum DiffuseMode@. bindSpatialMaterial_get_diffuse_mode :: MethodBind bindSpatialMaterial_get_diffuse_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_diffuse_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The algorithm used for diffuse light scattering. See @enum DiffuseMode@. get_diffuse_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_diffuse_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_diffuse_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_diffuse_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_diffuse_mode {-# NOINLINE bindSpatialMaterial_get_distance_fade #-} -- | Specifies which type of fade to use. Can be any of the @enum DistanceFadeMode@s. bindSpatialMaterial_get_distance_fade :: MethodBind bindSpatialMaterial_get_distance_fade = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_distance_fade" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies which type of fade to use. Can be any of the @enum DistanceFadeMode@s. get_distance_fade :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_distance_fade cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_distance_fade (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_distance_fade" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_distance_fade {-# NOINLINE bindSpatialMaterial_get_distance_fade_max_distance #-} -- | Distance at which the object fades fully and is no longer visible. bindSpatialMaterial_get_distance_fade_max_distance :: MethodBind bindSpatialMaterial_get_distance_fade_max_distance = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_distance_fade_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance at which the object fades fully and is no longer visible. get_distance_fade_max_distance :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_distance_fade_max_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_distance_fade_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_distance_fade_max_distance" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_distance_fade_max_distance {-# NOINLINE bindSpatialMaterial_get_distance_fade_min_distance #-} -- | Distance at which the object starts to fade. If the object is less than this distance away it will appear normal. bindSpatialMaterial_get_distance_fade_min_distance :: MethodBind bindSpatialMaterial_get_distance_fade_min_distance = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_distance_fade_min_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance at which the object starts to fade. If the object is less than this distance away it will appear normal. get_distance_fade_min_distance :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_distance_fade_min_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_distance_fade_min_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_distance_fade_min_distance" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_distance_fade_min_distance {-# NOINLINE bindSpatialMaterial_get_emission #-} -- | The emitted light's color. See @emission_enabled@. bindSpatialMaterial_get_emission :: MethodBind bindSpatialMaterial_get_emission = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_emission" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The emitted light's color. See @emission_enabled@. get_emission :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Color get_emission cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_emission (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_emission" '[] (IO Color) where nodeMethod = Godot.Core.SpatialMaterial.get_emission {-# NOINLINE bindSpatialMaterial_get_emission_energy #-} -- | The emitted light's strength. See @emission_enabled@. bindSpatialMaterial_get_emission_energy :: MethodBind bindSpatialMaterial_get_emission_energy = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_emission_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The emitted light's strength. See @emission_enabled@. get_emission_energy :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_emission_energy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_emission_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_emission_energy" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_emission_energy {-# NOINLINE bindSpatialMaterial_get_emission_operator #-} -- | Sets how @emission@ interacts with @emission_texture@. Can either add or multiply. See @enum EmissionOperator@ for options. bindSpatialMaterial_get_emission_operator :: MethodBind bindSpatialMaterial_get_emission_operator = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_emission_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets how @emission@ interacts with @emission_texture@. Can either add or multiply. See @enum EmissionOperator@ for options. get_emission_operator :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_emission_operator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_emission_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_emission_operator" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_emission_operator {-# NOINLINE bindSpatialMaterial_get_feature #-} -- | Returns @true@, if the specified @enum Feature@ is enabled. bindSpatialMaterial_get_feature :: MethodBind bindSpatialMaterial_get_feature = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_feature" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@, if the specified @enum Feature@ is enabled. get_feature :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO Bool get_feature cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_feature (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_feature" '[Int] (IO Bool) where nodeMethod = Godot.Core.SpatialMaterial.get_feature {-# NOINLINE bindSpatialMaterial_get_flag #-} -- | Returns @true@, if the specified flag is enabled. See @enum Flags@ enumerator for options. bindSpatialMaterial_get_flag :: MethodBind bindSpatialMaterial_get_flag = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@, if the specified flag is enabled. See @enum Flags@ enumerator for options. get_flag :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO Bool get_flag cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_flag" '[Int] (IO Bool) where nodeMethod = Godot.Core.SpatialMaterial.get_flag {-# NOINLINE bindSpatialMaterial_get_grow #-} -- | Grows object vertices in the direction of their normals. bindSpatialMaterial_get_grow :: MethodBind bindSpatialMaterial_get_grow = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_grow" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Grows object vertices in the direction of their normals. get_grow :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_grow cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_grow (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_grow" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_grow {-# NOINLINE bindSpatialMaterial_get_line_width #-} -- | Currently unimplemented in Godot. bindSpatialMaterial_get_line_width :: MethodBind bindSpatialMaterial_get_line_width = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_line_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Currently unimplemented in Godot. get_line_width :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_line_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_line_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_line_width" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_line_width {-# NOINLINE bindSpatialMaterial_get_metallic #-} -- | A high value makes the material appear more like a metal. Non-metals use their albedo as the diffuse color and add diffuse to the specular reflection. With non-metals, the reflection appears on top of the albedo color. Metals use their albedo as a multiplier to the specular reflection and set the diffuse color to black resulting in a tinted reflection. Materials work better when fully metal or fully non-metal, values between @0@ and @1@ should only be used for blending between metal and non-metal sections. To alter the amount of reflection use @roughness@. bindSpatialMaterial_get_metallic :: MethodBind bindSpatialMaterial_get_metallic = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_metallic" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A high value makes the material appear more like a metal. Non-metals use their albedo as the diffuse color and add diffuse to the specular reflection. With non-metals, the reflection appears on top of the albedo color. Metals use their albedo as a multiplier to the specular reflection and set the diffuse color to black resulting in a tinted reflection. Materials work better when fully metal or fully non-metal, values between @0@ and @1@ should only be used for blending between metal and non-metal sections. To alter the amount of reflection use @roughness@. get_metallic :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_metallic cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_metallic (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_metallic" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_metallic {-# NOINLINE bindSpatialMaterial_get_metallic_texture_channel #-} -- | Specifies the channel of the @metallic_texture@ in which the metallic information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. bindSpatialMaterial_get_metallic_texture_channel :: MethodBind bindSpatialMaterial_get_metallic_texture_channel = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_metallic_texture_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the channel of the @metallic_texture@ in which the metallic information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. get_metallic_texture_channel :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_metallic_texture_channel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_metallic_texture_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_metallic_texture_channel" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_metallic_texture_channel {-# NOINLINE bindSpatialMaterial_get_normal_scale #-} -- | The strength of the normal map's effect. bindSpatialMaterial_get_normal_scale :: MethodBind bindSpatialMaterial_get_normal_scale = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_normal_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The strength of the normal map's effect. get_normal_scale :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_normal_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_normal_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_normal_scale" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_normal_scale {-# NOINLINE bindSpatialMaterial_get_particles_anim_h_frames #-} -- | The number of horizontal frames in the particle sprite sheet. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. bindSpatialMaterial_get_particles_anim_h_frames :: MethodBind bindSpatialMaterial_get_particles_anim_h_frames = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_particles_anim_h_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of horizontal frames in the particle sprite sheet. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. get_particles_anim_h_frames :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_particles_anim_h_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_particles_anim_h_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_particles_anim_h_frames" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_particles_anim_h_frames {-# NOINLINE bindSpatialMaterial_get_particles_anim_loop #-} -- | If @true@, particle animations are looped. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. bindSpatialMaterial_get_particles_anim_loop :: MethodBind bindSpatialMaterial_get_particles_anim_loop = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_particles_anim_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particle animations are looped. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. get_particles_anim_loop :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Bool get_particles_anim_loop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_particles_anim_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_particles_anim_loop" '[] (IO Bool) where nodeMethod = Godot.Core.SpatialMaterial.get_particles_anim_loop {-# NOINLINE bindSpatialMaterial_get_particles_anim_v_frames #-} -- | The number of vertical frames in the particle sprite sheet. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. bindSpatialMaterial_get_particles_anim_v_frames :: MethodBind bindSpatialMaterial_get_particles_anim_v_frames = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_particles_anim_v_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of vertical frames in the particle sprite sheet. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. get_particles_anim_v_frames :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_particles_anim_v_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_particles_anim_v_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_particles_anim_v_frames" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_particles_anim_v_frames {-# NOINLINE bindSpatialMaterial_get_point_size #-} -- | The point size in pixels. See @flags_use_point_size@. bindSpatialMaterial_get_point_size :: MethodBind bindSpatialMaterial_get_point_size = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_point_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The point size in pixels. See @flags_use_point_size@. get_point_size :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_point_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_point_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_point_size" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_point_size {-# NOINLINE bindSpatialMaterial_get_proximity_fade_distance #-} -- | Distance over which the fade effect takes place. The larger the distance the longer it takes for an object to fade. bindSpatialMaterial_get_proximity_fade_distance :: MethodBind bindSpatialMaterial_get_proximity_fade_distance = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_proximity_fade_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance over which the fade effect takes place. The larger the distance the longer it takes for an object to fade. get_proximity_fade_distance :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_proximity_fade_distance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_proximity_fade_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_proximity_fade_distance" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_proximity_fade_distance {-# NOINLINE bindSpatialMaterial_get_refraction #-} -- | The strength of the refraction effect. bindSpatialMaterial_get_refraction :: MethodBind bindSpatialMaterial_get_refraction = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_refraction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The strength of the refraction effect. get_refraction :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_refraction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_refraction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_refraction" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_refraction {-# NOINLINE bindSpatialMaterial_get_refraction_texture_channel #-} -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. bindSpatialMaterial_get_refraction_texture_channel :: MethodBind bindSpatialMaterial_get_refraction_texture_channel = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_refraction_texture_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. get_refraction_texture_channel :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_refraction_texture_channel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_refraction_texture_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_refraction_texture_channel" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_refraction_texture_channel {-# NOINLINE bindSpatialMaterial_get_rim #-} -- | Sets the strength of the rim lighting effect. bindSpatialMaterial_get_rim :: MethodBind bindSpatialMaterial_get_rim = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_rim" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the strength of the rim lighting effect. get_rim :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_rim cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_rim (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_rim" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_rim {-# NOINLINE bindSpatialMaterial_get_rim_tint #-} -- | The amount of to blend light and albedo color when rendering rim effect. If @0@ the light color is used, while @1@ means albedo color is used. An intermediate value generally works best. bindSpatialMaterial_get_rim_tint :: MethodBind bindSpatialMaterial_get_rim_tint = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_rim_tint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of to blend light and albedo color when rendering rim effect. If @0@ the light color is used, while @1@ means albedo color is used. An intermediate value generally works best. get_rim_tint :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_rim_tint cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_rim_tint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_rim_tint" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_rim_tint {-# NOINLINE bindSpatialMaterial_get_roughness #-} -- | Surface reflection. A value of @0@ represents a perfect mirror while a value of @1@ completely blurs the reflection. See also @metallic@. bindSpatialMaterial_get_roughness :: MethodBind bindSpatialMaterial_get_roughness = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_roughness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Surface reflection. A value of @0@ represents a perfect mirror while a value of @1@ completely blurs the reflection. See also @metallic@. get_roughness :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_roughness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_roughness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_roughness" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_roughness {-# NOINLINE bindSpatialMaterial_get_roughness_texture_channel #-} -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. bindSpatialMaterial_get_roughness_texture_channel :: MethodBind bindSpatialMaterial_get_roughness_texture_channel = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_roughness_texture_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. get_roughness_texture_channel :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_roughness_texture_channel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_roughness_texture_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_roughness_texture_channel" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_roughness_texture_channel {-# NOINLINE bindSpatialMaterial_get_specular #-} -- | Sets the size of the specular lobe. The specular lobe is the bright spot that is reflected from light sources. -- __Note:__ unlike @metallic@, this is not energy-conserving, so it should be left at @0.5@ in most cases. See also @roughness@. bindSpatialMaterial_get_specular :: MethodBind bindSpatialMaterial_get_specular = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_specular" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the specular lobe. The specular lobe is the bright spot that is reflected from light sources. -- __Note:__ unlike @metallic@, this is not energy-conserving, so it should be left at @0.5@ in most cases. See also @roughness@. get_specular :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_specular cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_specular (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_specular" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_specular {-# NOINLINE bindSpatialMaterial_get_specular_mode #-} -- | The method for rendering the specular blob. See @enum SpecularMode@. bindSpatialMaterial_get_specular_mode :: MethodBind bindSpatialMaterial_get_specular_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_specular_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The method for rendering the specular blob. See @enum SpecularMode@. get_specular_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Int get_specular_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_specular_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_specular_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpatialMaterial.get_specular_mode {-# NOINLINE bindSpatialMaterial_get_subsurface_scattering_strength #-} -- | The strength of the subsurface scattering effect. bindSpatialMaterial_get_subsurface_scattering_strength :: MethodBind bindSpatialMaterial_get_subsurface_scattering_strength = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_subsurface_scattering_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The strength of the subsurface scattering effect. get_subsurface_scattering_strength :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_subsurface_scattering_strength cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_subsurface_scattering_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_subsurface_scattering_strength" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_subsurface_scattering_strength {-# NOINLINE bindSpatialMaterial_get_texture #-} -- | Returns the @Texture@ associated with the specified @enum TextureParam@. bindSpatialMaterial_get_texture :: MethodBind bindSpatialMaterial_get_texture = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Texture@ associated with the specified @enum TextureParam@. get_texture :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO Texture get_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_texture" '[Int] (IO Texture) where nodeMethod = Godot.Core.SpatialMaterial.get_texture {-# NOINLINE bindSpatialMaterial_get_transmission #-} -- | The color used by the transmission effect. Represents the light passing through an object. bindSpatialMaterial_get_transmission :: MethodBind bindSpatialMaterial_get_transmission = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_transmission" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color used by the transmission effect. Represents the light passing through an object. get_transmission :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Color get_transmission cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_transmission (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_transmission" '[] (IO Color) where nodeMethod = Godot.Core.SpatialMaterial.get_transmission {-# NOINLINE bindSpatialMaterial_get_uv1_offset #-} -- | How much to offset the @UV@ coordinates. This amount will be added to @UV@ in the vertex function. This can be used to offset a texture. bindSpatialMaterial_get_uv1_offset :: MethodBind bindSpatialMaterial_get_uv1_offset = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_uv1_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much to offset the @UV@ coordinates. This amount will be added to @UV@ in the vertex function. This can be used to offset a texture. get_uv1_offset :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Vector3 get_uv1_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_uv1_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_uv1_offset" '[] (IO Vector3) where nodeMethod = Godot.Core.SpatialMaterial.get_uv1_offset {-# NOINLINE bindSpatialMaterial_get_uv1_scale #-} -- | How much to scale the @UV@ coordinates. This is multiplied by @UV@ in the vertex function. bindSpatialMaterial_get_uv1_scale :: MethodBind bindSpatialMaterial_get_uv1_scale = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_uv1_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much to scale the @UV@ coordinates. This is multiplied by @UV@ in the vertex function. get_uv1_scale :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Vector3 get_uv1_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_uv1_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_uv1_scale" '[] (IO Vector3) where nodeMethod = Godot.Core.SpatialMaterial.get_uv1_scale {-# NOINLINE bindSpatialMaterial_get_uv1_triplanar_blend_sharpness #-} -- | A lower number blends the texture more softly while a higher number blends the texture more sharply. bindSpatialMaterial_get_uv1_triplanar_blend_sharpness :: MethodBind bindSpatialMaterial_get_uv1_triplanar_blend_sharpness = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_uv1_triplanar_blend_sharpness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A lower number blends the texture more softly while a higher number blends the texture more sharply. get_uv1_triplanar_blend_sharpness :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_uv1_triplanar_blend_sharpness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_uv1_triplanar_blend_sharpness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_uv1_triplanar_blend_sharpness" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_uv1_triplanar_blend_sharpness {-# NOINLINE bindSpatialMaterial_get_uv2_offset #-} -- | How much to offset the @UV2@ coordinates. This amount will be added to @UV2@ in the vertex function. This can be used to offset a texture. bindSpatialMaterial_get_uv2_offset :: MethodBind bindSpatialMaterial_get_uv2_offset = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_uv2_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much to offset the @UV2@ coordinates. This amount will be added to @UV2@ in the vertex function. This can be used to offset a texture. get_uv2_offset :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Vector3 get_uv2_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_uv2_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_uv2_offset" '[] (IO Vector3) where nodeMethod = Godot.Core.SpatialMaterial.get_uv2_offset {-# NOINLINE bindSpatialMaterial_get_uv2_scale #-} -- | How much to scale the @UV2@ coordinates. This is multiplied by @UV2@ in the vertex function. bindSpatialMaterial_get_uv2_scale :: MethodBind bindSpatialMaterial_get_uv2_scale = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_uv2_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much to scale the @UV2@ coordinates. This is multiplied by @UV2@ in the vertex function. get_uv2_scale :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Vector3 get_uv2_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_uv2_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_uv2_scale" '[] (IO Vector3) where nodeMethod = Godot.Core.SpatialMaterial.get_uv2_scale {-# NOINLINE bindSpatialMaterial_get_uv2_triplanar_blend_sharpness #-} -- | A lower number blends the texture more softly while a higher number blends the texture more sharply. bindSpatialMaterial_get_uv2_triplanar_blend_sharpness :: MethodBind bindSpatialMaterial_get_uv2_triplanar_blend_sharpness = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "get_uv2_triplanar_blend_sharpness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A lower number blends the texture more softly while a higher number blends the texture more sharply. get_uv2_triplanar_blend_sharpness :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Float get_uv2_triplanar_blend_sharpness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_get_uv2_triplanar_blend_sharpness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "get_uv2_triplanar_blend_sharpness" '[] (IO Float) where nodeMethod = Godot.Core.SpatialMaterial.get_uv2_triplanar_blend_sharpness {-# NOINLINE bindSpatialMaterial_is_depth_deep_parallax_enabled #-} -- | If @true@, the shader will read depth texture at multiple points along the view ray to determine occlusion and parrallax. This can be very performance demanding, but results in more realistic looking depth mapping. bindSpatialMaterial_is_depth_deep_parallax_enabled :: MethodBind bindSpatialMaterial_is_depth_deep_parallax_enabled = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "is_depth_deep_parallax_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the shader will read depth texture at multiple points along the view ray to determine occlusion and parrallax. This can be very performance demanding, but results in more realistic looking depth mapping. is_depth_deep_parallax_enabled :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Bool is_depth_deep_parallax_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_is_depth_deep_parallax_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "is_depth_deep_parallax_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.SpatialMaterial.is_depth_deep_parallax_enabled {-# NOINLINE bindSpatialMaterial_is_grow_enabled #-} -- | If @true@, enables the vertex grow setting. See @params_grow_amount@. bindSpatialMaterial_is_grow_enabled :: MethodBind bindSpatialMaterial_is_grow_enabled = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "is_grow_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the vertex grow setting. See @params_grow_amount@. is_grow_enabled :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Bool is_grow_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_is_grow_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "is_grow_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.SpatialMaterial.is_grow_enabled {-# NOINLINE bindSpatialMaterial_is_proximity_fade_enabled #-} -- | If @true@, the proximity fade effect is enabled. The proximity fade effect fades out each pixel based on its distance to another object. bindSpatialMaterial_is_proximity_fade_enabled :: MethodBind bindSpatialMaterial_is_proximity_fade_enabled = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "is_proximity_fade_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the proximity fade effect is enabled. The proximity fade effect fades out each pixel based on its distance to another object. is_proximity_fade_enabled :: (SpatialMaterial :< cls, Object :< cls) => cls -> IO Bool is_proximity_fade_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_is_proximity_fade_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "is_proximity_fade_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.SpatialMaterial.is_proximity_fade_enabled {-# NOINLINE bindSpatialMaterial_set_albedo #-} -- | The material's base color. bindSpatialMaterial_set_albedo :: MethodBind bindSpatialMaterial_set_albedo = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_albedo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The material's base color. set_albedo :: (SpatialMaterial :< cls, Object :< cls) => cls -> Color -> IO () set_albedo cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_albedo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_albedo" '[Color] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_albedo {-# NOINLINE bindSpatialMaterial_set_alpha_scissor_threshold #-} -- | Threshold at which the alpha scissor will discard values. bindSpatialMaterial_set_alpha_scissor_threshold :: MethodBind bindSpatialMaterial_set_alpha_scissor_threshold = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_alpha_scissor_threshold" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Threshold at which the alpha scissor will discard values. set_alpha_scissor_threshold :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_alpha_scissor_threshold cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_alpha_scissor_threshold (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_alpha_scissor_threshold" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_alpha_scissor_threshold {-# NOINLINE bindSpatialMaterial_set_anisotropy #-} -- | The strength of the anisotropy effect. bindSpatialMaterial_set_anisotropy :: MethodBind bindSpatialMaterial_set_anisotropy = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_anisotropy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The strength of the anisotropy effect. set_anisotropy :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_anisotropy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_anisotropy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_anisotropy" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_anisotropy {-# NOINLINE bindSpatialMaterial_set_ao_light_affect #-} -- | Amount that ambient occlusion affects lighting from lights. If @0@, ambient occlusion only affects ambient light. If @1@, ambient occlusion affects lights just as much as it affects ambient light. This can be used to impact the strength of the ambient occlusion effect, but typically looks unrealistic. bindSpatialMaterial_set_ao_light_affect :: MethodBind bindSpatialMaterial_set_ao_light_affect = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_ao_light_affect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount that ambient occlusion affects lighting from lights. If @0@, ambient occlusion only affects ambient light. If @1@, ambient occlusion affects lights just as much as it affects ambient light. This can be used to impact the strength of the ambient occlusion effect, but typically looks unrealistic. set_ao_light_affect :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_ao_light_affect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_ao_light_affect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_ao_light_affect" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_ao_light_affect {-# NOINLINE bindSpatialMaterial_set_ao_texture_channel #-} -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. bindSpatialMaterial_set_ao_texture_channel :: MethodBind bindSpatialMaterial_set_ao_texture_channel = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_ao_texture_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. set_ao_texture_channel :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_ao_texture_channel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_ao_texture_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_ao_texture_channel" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_ao_texture_channel {-# NOINLINE bindSpatialMaterial_set_billboard_mode #-} -- | Controls how the object faces the camera. See @enum BillboardMode@. bindSpatialMaterial_set_billboard_mode :: MethodBind bindSpatialMaterial_set_billboard_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_billboard_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how the object faces the camera. See @enum BillboardMode@. set_billboard_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_billboard_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_billboard_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_billboard_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_billboard_mode {-# NOINLINE bindSpatialMaterial_set_blend_mode #-} -- | The material's blend mode. -- __Note:__ Values other than @Mix@ force the object into the transparent pipeline. See @enum BlendMode@. bindSpatialMaterial_set_blend_mode :: MethodBind bindSpatialMaterial_set_blend_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The material's blend mode. -- __Note:__ Values other than @Mix@ force the object into the transparent pipeline. See @enum BlendMode@. set_blend_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_blend_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_blend_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_blend_mode {-# NOINLINE bindSpatialMaterial_set_clearcoat #-} -- | Sets the strength of the clearcoat effect. Setting to @0@ looks the same as disabling the clearcoat effect. bindSpatialMaterial_set_clearcoat :: MethodBind bindSpatialMaterial_set_clearcoat = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_clearcoat" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the strength of the clearcoat effect. Setting to @0@ looks the same as disabling the clearcoat effect. set_clearcoat :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_clearcoat cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_clearcoat (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_clearcoat" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_clearcoat {-# NOINLINE bindSpatialMaterial_set_clearcoat_gloss #-} -- | Sets the roughness of the clearcoat pass. A higher value results in a smoother clearcoat while a lower value results in a rougher clearcoat. bindSpatialMaterial_set_clearcoat_gloss :: MethodBind bindSpatialMaterial_set_clearcoat_gloss = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_clearcoat_gloss" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the roughness of the clearcoat pass. A higher value results in a smoother clearcoat while a lower value results in a rougher clearcoat. set_clearcoat_gloss :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_clearcoat_gloss cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_clearcoat_gloss (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_clearcoat_gloss" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_clearcoat_gloss {-# NOINLINE bindSpatialMaterial_set_cull_mode #-} -- | Which side of the object is not drawn when backfaces are rendered. See @enum CullMode@. bindSpatialMaterial_set_cull_mode :: MethodBind bindSpatialMaterial_set_cull_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_cull_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Which side of the object is not drawn when backfaces are rendered. See @enum CullMode@. set_cull_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_cull_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_cull_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_cull_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_cull_mode {-# NOINLINE bindSpatialMaterial_set_depth_deep_parallax #-} -- | If @true@, the shader will read depth texture at multiple points along the view ray to determine occlusion and parrallax. This can be very performance demanding, but results in more realistic looking depth mapping. bindSpatialMaterial_set_depth_deep_parallax :: MethodBind bindSpatialMaterial_set_depth_deep_parallax = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_depth_deep_parallax" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the shader will read depth texture at multiple points along the view ray to determine occlusion and parrallax. This can be very performance demanding, but results in more realistic looking depth mapping. set_depth_deep_parallax :: (SpatialMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_depth_deep_parallax cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_depth_deep_parallax (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_depth_deep_parallax" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_depth_deep_parallax {-# NOINLINE bindSpatialMaterial_set_depth_deep_parallax_flip_binormal #-} -- | If @true@, direction of the binormal is flipped before using in the depth effect. This may be necessary if you have encoded your binormals in a way that is conflicting with the depth effect. bindSpatialMaterial_set_depth_deep_parallax_flip_binormal :: MethodBind bindSpatialMaterial_set_depth_deep_parallax_flip_binormal = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_depth_deep_parallax_flip_binormal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, direction of the binormal is flipped before using in the depth effect. This may be necessary if you have encoded your binormals in a way that is conflicting with the depth effect. set_depth_deep_parallax_flip_binormal :: (SpatialMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_depth_deep_parallax_flip_binormal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_depth_deep_parallax_flip_binormal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_depth_deep_parallax_flip_binormal" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_depth_deep_parallax_flip_binormal {-# NOINLINE bindSpatialMaterial_set_depth_deep_parallax_flip_tangent #-} -- | If @true@, direction of the tangent is flipped before using in the depth effect. This may be necessary if you have encoded your tangents in a way that is conflicting with the depth effect. bindSpatialMaterial_set_depth_deep_parallax_flip_tangent :: MethodBind bindSpatialMaterial_set_depth_deep_parallax_flip_tangent = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_depth_deep_parallax_flip_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, direction of the tangent is flipped before using in the depth effect. This may be necessary if you have encoded your tangents in a way that is conflicting with the depth effect. set_depth_deep_parallax_flip_tangent :: (SpatialMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_depth_deep_parallax_flip_tangent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_depth_deep_parallax_flip_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_depth_deep_parallax_flip_tangent" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_depth_deep_parallax_flip_tangent {-# NOINLINE bindSpatialMaterial_set_depth_deep_parallax_max_layers #-} -- | Number of layers to use when using @depth_deep_parallax@ and the view direction is perpendicular to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. bindSpatialMaterial_set_depth_deep_parallax_max_layers :: MethodBind bindSpatialMaterial_set_depth_deep_parallax_max_layers = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_depth_deep_parallax_max_layers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of layers to use when using @depth_deep_parallax@ and the view direction is perpendicular to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. set_depth_deep_parallax_max_layers :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_depth_deep_parallax_max_layers cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_depth_deep_parallax_max_layers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_depth_deep_parallax_max_layers" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_depth_deep_parallax_max_layers {-# NOINLINE bindSpatialMaterial_set_depth_deep_parallax_min_layers #-} -- | Number of layers to use when using @depth_deep_parallax@ and the view direction is parallel to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. bindSpatialMaterial_set_depth_deep_parallax_min_layers :: MethodBind bindSpatialMaterial_set_depth_deep_parallax_min_layers = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_depth_deep_parallax_min_layers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of layers to use when using @depth_deep_parallax@ and the view direction is parallel to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. set_depth_deep_parallax_min_layers :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_depth_deep_parallax_min_layers cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_depth_deep_parallax_min_layers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_depth_deep_parallax_min_layers" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_depth_deep_parallax_min_layers {-# NOINLINE bindSpatialMaterial_set_depth_draw_mode #-} -- | Determines when depth rendering takes place. See @enum DepthDrawMode@. See also @flags_transparent@. bindSpatialMaterial_set_depth_draw_mode :: MethodBind bindSpatialMaterial_set_depth_draw_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_depth_draw_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines when depth rendering takes place. See @enum DepthDrawMode@. See also @flags_transparent@. set_depth_draw_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_depth_draw_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_depth_draw_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_depth_draw_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_depth_draw_mode {-# NOINLINE bindSpatialMaterial_set_depth_scale #-} -- | Scales the depth offset effect. A higher number will create a larger depth. bindSpatialMaterial_set_depth_scale :: MethodBind bindSpatialMaterial_set_depth_scale = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_depth_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scales the depth offset effect. A higher number will create a larger depth. set_depth_scale :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_depth_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_depth_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_depth_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_depth_scale {-# NOINLINE bindSpatialMaterial_set_detail_blend_mode #-} -- | Specifies how the @detail_albedo@ should blend with the current @ALBEDO@. See @enum BlendMode@ for options. bindSpatialMaterial_set_detail_blend_mode :: MethodBind bindSpatialMaterial_set_detail_blend_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_detail_blend_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies how the @detail_albedo@ should blend with the current @ALBEDO@. See @enum BlendMode@ for options. set_detail_blend_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_detail_blend_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_detail_blend_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_detail_blend_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_detail_blend_mode {-# NOINLINE bindSpatialMaterial_set_detail_uv #-} -- | Specifies whether to use @UV@ or @UV2@ for the detail layer. See @enum DetailUV@ for options. bindSpatialMaterial_set_detail_uv :: MethodBind bindSpatialMaterial_set_detail_uv = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_detail_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies whether to use @UV@ or @UV2@ for the detail layer. See @enum DetailUV@ for options. set_detail_uv :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_detail_uv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_detail_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_detail_uv" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_detail_uv {-# NOINLINE bindSpatialMaterial_set_diffuse_mode #-} -- | The algorithm used for diffuse light scattering. See @enum DiffuseMode@. bindSpatialMaterial_set_diffuse_mode :: MethodBind bindSpatialMaterial_set_diffuse_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_diffuse_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The algorithm used for diffuse light scattering. See @enum DiffuseMode@. set_diffuse_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_diffuse_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_diffuse_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_diffuse_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_diffuse_mode {-# NOINLINE bindSpatialMaterial_set_distance_fade #-} -- | Specifies which type of fade to use. Can be any of the @enum DistanceFadeMode@s. bindSpatialMaterial_set_distance_fade :: MethodBind bindSpatialMaterial_set_distance_fade = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_distance_fade" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies which type of fade to use. Can be any of the @enum DistanceFadeMode@s. set_distance_fade :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_distance_fade cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_distance_fade (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_distance_fade" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_distance_fade {-# NOINLINE bindSpatialMaterial_set_distance_fade_max_distance #-} -- | Distance at which the object fades fully and is no longer visible. bindSpatialMaterial_set_distance_fade_max_distance :: MethodBind bindSpatialMaterial_set_distance_fade_max_distance = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_distance_fade_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance at which the object fades fully and is no longer visible. set_distance_fade_max_distance :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_distance_fade_max_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_distance_fade_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_distance_fade_max_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_distance_fade_max_distance {-# NOINLINE bindSpatialMaterial_set_distance_fade_min_distance #-} -- | Distance at which the object starts to fade. If the object is less than this distance away it will appear normal. bindSpatialMaterial_set_distance_fade_min_distance :: MethodBind bindSpatialMaterial_set_distance_fade_min_distance = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_distance_fade_min_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance at which the object starts to fade. If the object is less than this distance away it will appear normal. set_distance_fade_min_distance :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_distance_fade_min_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_distance_fade_min_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_distance_fade_min_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_distance_fade_min_distance {-# NOINLINE bindSpatialMaterial_set_emission #-} -- | The emitted light's color. See @emission_enabled@. bindSpatialMaterial_set_emission :: MethodBind bindSpatialMaterial_set_emission = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_emission" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The emitted light's color. See @emission_enabled@. set_emission :: (SpatialMaterial :< cls, Object :< cls) => cls -> Color -> IO () set_emission cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_emission (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_emission" '[Color] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_emission {-# NOINLINE bindSpatialMaterial_set_emission_energy #-} -- | The emitted light's strength. See @emission_enabled@. bindSpatialMaterial_set_emission_energy :: MethodBind bindSpatialMaterial_set_emission_energy = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_emission_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The emitted light's strength. See @emission_enabled@. set_emission_energy :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_emission_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_emission_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_emission_energy" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_emission_energy {-# NOINLINE bindSpatialMaterial_set_emission_operator #-} -- | Sets how @emission@ interacts with @emission_texture@. Can either add or multiply. See @enum EmissionOperator@ for options. bindSpatialMaterial_set_emission_operator :: MethodBind bindSpatialMaterial_set_emission_operator = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_emission_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets how @emission@ interacts with @emission_texture@. Can either add or multiply. See @enum EmissionOperator@ for options. set_emission_operator :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_emission_operator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_emission_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_emission_operator" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_emission_operator {-# NOINLINE bindSpatialMaterial_set_feature #-} -- | If @true@, enables the specified @enum Feature@. Many features that are available in @SpatialMaterial@s need to be enabled before use. This way the cost for using the feature is only incurred when specified. Features can also be enabled by setting the corresponding member to @true@. bindSpatialMaterial_set_feature :: MethodBind bindSpatialMaterial_set_feature = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_feature" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the specified @enum Feature@. Many features that are available in @SpatialMaterial@s need to be enabled before use. This way the cost for using the feature is only incurred when specified. Features can also be enabled by setting the corresponding member to @true@. set_feature :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_feature cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_feature (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_feature" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_feature {-# NOINLINE bindSpatialMaterial_set_flag #-} -- | If @true@, enables the specified flag. Flags are optional behaviour that can be turned on and off. Only one flag can be enabled at a time with this function, the flag enumerators cannot be bit-masked together to enable or disable multiple flags at once. Flags can also be enabled by setting the corresponding member to @true@. See @enum Flags@ enumerator for options. bindSpatialMaterial_set_flag :: MethodBind bindSpatialMaterial_set_flag = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the specified flag. Flags are optional behaviour that can be turned on and off. Only one flag can be enabled at a time with this function, the flag enumerators cannot be bit-masked together to enable or disable multiple flags at once. Flags can also be enabled by setting the corresponding member to @true@. See @enum Flags@ enumerator for options. set_flag :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_flag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_flag" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_flag {-# NOINLINE bindSpatialMaterial_set_grow #-} -- | Grows object vertices in the direction of their normals. bindSpatialMaterial_set_grow :: MethodBind bindSpatialMaterial_set_grow = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_grow" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Grows object vertices in the direction of their normals. set_grow :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_grow cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_grow (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_grow" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_grow {-# NOINLINE bindSpatialMaterial_set_grow_enabled #-} -- | If @true@, enables the vertex grow setting. See @params_grow_amount@. bindSpatialMaterial_set_grow_enabled :: MethodBind bindSpatialMaterial_set_grow_enabled = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_grow_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables the vertex grow setting. See @params_grow_amount@. set_grow_enabled :: (SpatialMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_grow_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_grow_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_grow_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_grow_enabled {-# NOINLINE bindSpatialMaterial_set_line_width #-} -- | Currently unimplemented in Godot. bindSpatialMaterial_set_line_width :: MethodBind bindSpatialMaterial_set_line_width = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_line_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Currently unimplemented in Godot. set_line_width :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_line_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_line_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_line_width" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_line_width {-# NOINLINE bindSpatialMaterial_set_metallic #-} -- | A high value makes the material appear more like a metal. Non-metals use their albedo as the diffuse color and add diffuse to the specular reflection. With non-metals, the reflection appears on top of the albedo color. Metals use their albedo as a multiplier to the specular reflection and set the diffuse color to black resulting in a tinted reflection. Materials work better when fully metal or fully non-metal, values between @0@ and @1@ should only be used for blending between metal and non-metal sections. To alter the amount of reflection use @roughness@. bindSpatialMaterial_set_metallic :: MethodBind bindSpatialMaterial_set_metallic = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_metallic" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A high value makes the material appear more like a metal. Non-metals use their albedo as the diffuse color and add diffuse to the specular reflection. With non-metals, the reflection appears on top of the albedo color. Metals use their albedo as a multiplier to the specular reflection and set the diffuse color to black resulting in a tinted reflection. Materials work better when fully metal or fully non-metal, values between @0@ and @1@ should only be used for blending between metal and non-metal sections. To alter the amount of reflection use @roughness@. set_metallic :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_metallic cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_metallic (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_metallic" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_metallic {-# NOINLINE bindSpatialMaterial_set_metallic_texture_channel #-} -- | Specifies the channel of the @metallic_texture@ in which the metallic information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. bindSpatialMaterial_set_metallic_texture_channel :: MethodBind bindSpatialMaterial_set_metallic_texture_channel = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_metallic_texture_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the channel of the @metallic_texture@ in which the metallic information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. set_metallic_texture_channel :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_metallic_texture_channel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_metallic_texture_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_metallic_texture_channel" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_metallic_texture_channel {-# NOINLINE bindSpatialMaterial_set_normal_scale #-} -- | The strength of the normal map's effect. bindSpatialMaterial_set_normal_scale :: MethodBind bindSpatialMaterial_set_normal_scale = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_normal_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The strength of the normal map's effect. set_normal_scale :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_normal_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_normal_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_normal_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_normal_scale {-# NOINLINE bindSpatialMaterial_set_particles_anim_h_frames #-} -- | The number of horizontal frames in the particle sprite sheet. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. bindSpatialMaterial_set_particles_anim_h_frames :: MethodBind bindSpatialMaterial_set_particles_anim_h_frames = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_particles_anim_h_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of horizontal frames in the particle sprite sheet. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. set_particles_anim_h_frames :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_particles_anim_h_frames cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_particles_anim_h_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_particles_anim_h_frames" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_particles_anim_h_frames {-# NOINLINE bindSpatialMaterial_set_particles_anim_loop #-} -- | If @true@, particle animations are looped. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. bindSpatialMaterial_set_particles_anim_loop :: MethodBind bindSpatialMaterial_set_particles_anim_loop = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_particles_anim_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particle animations are looped. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. set_particles_anim_loop :: (SpatialMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_particles_anim_loop cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_particles_anim_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_particles_anim_loop" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_particles_anim_loop {-# NOINLINE bindSpatialMaterial_set_particles_anim_v_frames #-} -- | The number of vertical frames in the particle sprite sheet. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. bindSpatialMaterial_set_particles_anim_v_frames :: MethodBind bindSpatialMaterial_set_particles_anim_v_frames = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_particles_anim_v_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of vertical frames in the particle sprite sheet. Only enabled when using @BILLBOARD_PARTICLES@. See @params_billboard_mode@. set_particles_anim_v_frames :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_particles_anim_v_frames cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_particles_anim_v_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_particles_anim_v_frames" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_particles_anim_v_frames {-# NOINLINE bindSpatialMaterial_set_point_size #-} -- | The point size in pixels. See @flags_use_point_size@. bindSpatialMaterial_set_point_size :: MethodBind bindSpatialMaterial_set_point_size = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_point_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The point size in pixels. See @flags_use_point_size@. set_point_size :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_point_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_point_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_point_size" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_point_size {-# NOINLINE bindSpatialMaterial_set_proximity_fade #-} -- | If @true@, the proximity fade effect is enabled. The proximity fade effect fades out each pixel based on its distance to another object. bindSpatialMaterial_set_proximity_fade :: MethodBind bindSpatialMaterial_set_proximity_fade = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_proximity_fade" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the proximity fade effect is enabled. The proximity fade effect fades out each pixel based on its distance to another object. set_proximity_fade :: (SpatialMaterial :< cls, Object :< cls) => cls -> Bool -> IO () set_proximity_fade cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_proximity_fade (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_proximity_fade" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_proximity_fade {-# NOINLINE bindSpatialMaterial_set_proximity_fade_distance #-} -- | Distance over which the fade effect takes place. The larger the distance the longer it takes for an object to fade. bindSpatialMaterial_set_proximity_fade_distance :: MethodBind bindSpatialMaterial_set_proximity_fade_distance = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_proximity_fade_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Distance over which the fade effect takes place. The larger the distance the longer it takes for an object to fade. set_proximity_fade_distance :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_proximity_fade_distance cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_proximity_fade_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_proximity_fade_distance" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_proximity_fade_distance {-# NOINLINE bindSpatialMaterial_set_refraction #-} -- | The strength of the refraction effect. bindSpatialMaterial_set_refraction :: MethodBind bindSpatialMaterial_set_refraction = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_refraction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The strength of the refraction effect. set_refraction :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_refraction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_refraction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_refraction" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_refraction {-# NOINLINE bindSpatialMaterial_set_refraction_texture_channel #-} -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. bindSpatialMaterial_set_refraction_texture_channel :: MethodBind bindSpatialMaterial_set_refraction_texture_channel = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_refraction_texture_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. set_refraction_texture_channel :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_refraction_texture_channel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_refraction_texture_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_refraction_texture_channel" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_refraction_texture_channel {-# NOINLINE bindSpatialMaterial_set_rim #-} -- | Sets the strength of the rim lighting effect. bindSpatialMaterial_set_rim :: MethodBind bindSpatialMaterial_set_rim = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_rim" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the strength of the rim lighting effect. set_rim :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_rim cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_rim (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_rim" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_rim {-# NOINLINE bindSpatialMaterial_set_rim_tint #-} -- | The amount of to blend light and albedo color when rendering rim effect. If @0@ the light color is used, while @1@ means albedo color is used. An intermediate value generally works best. bindSpatialMaterial_set_rim_tint :: MethodBind bindSpatialMaterial_set_rim_tint = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_rim_tint" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The amount of to blend light and albedo color when rendering rim effect. If @0@ the light color is used, while @1@ means albedo color is used. An intermediate value generally works best. set_rim_tint :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_rim_tint cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_rim_tint (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_rim_tint" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_rim_tint {-# NOINLINE bindSpatialMaterial_set_roughness #-} -- | Surface reflection. A value of @0@ represents a perfect mirror while a value of @1@ completely blurs the reflection. See also @metallic@. bindSpatialMaterial_set_roughness :: MethodBind bindSpatialMaterial_set_roughness = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_roughness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Surface reflection. A value of @0@ represents a perfect mirror while a value of @1@ completely blurs the reflection. See also @metallic@. set_roughness :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_roughness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_roughness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_roughness" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_roughness {-# NOINLINE bindSpatialMaterial_set_roughness_texture_channel #-} -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. bindSpatialMaterial_set_roughness_texture_channel :: MethodBind bindSpatialMaterial_set_roughness_texture_channel = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_roughness_texture_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the channel of the @ao_texture@ in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use. set_roughness_texture_channel :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_roughness_texture_channel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_roughness_texture_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_roughness_texture_channel" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_roughness_texture_channel {-# NOINLINE bindSpatialMaterial_set_specular #-} -- | Sets the size of the specular lobe. The specular lobe is the bright spot that is reflected from light sources. -- __Note:__ unlike @metallic@, this is not energy-conserving, so it should be left at @0.5@ in most cases. See also @roughness@. bindSpatialMaterial_set_specular :: MethodBind bindSpatialMaterial_set_specular = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_specular" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the specular lobe. The specular lobe is the bright spot that is reflected from light sources. -- __Note:__ unlike @metallic@, this is not energy-conserving, so it should be left at @0.5@ in most cases. See also @roughness@. set_specular :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_specular cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_specular (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_specular" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_specular {-# NOINLINE bindSpatialMaterial_set_specular_mode #-} -- | The method for rendering the specular blob. See @enum SpecularMode@. bindSpatialMaterial_set_specular_mode :: MethodBind bindSpatialMaterial_set_specular_mode = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_specular_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The method for rendering the specular blob. See @enum SpecularMode@. set_specular_mode :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> IO () set_specular_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_specular_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_specular_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_specular_mode {-# NOINLINE bindSpatialMaterial_set_subsurface_scattering_strength #-} -- | The strength of the subsurface scattering effect. bindSpatialMaterial_set_subsurface_scattering_strength :: MethodBind bindSpatialMaterial_set_subsurface_scattering_strength = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_subsurface_scattering_strength" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The strength of the subsurface scattering effect. set_subsurface_scattering_strength :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_subsurface_scattering_strength cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_subsurface_scattering_strength (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_subsurface_scattering_strength" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_subsurface_scattering_strength {-# NOINLINE bindSpatialMaterial_set_texture #-} -- | Sets the @Texture@ to be used by the specified @enum TextureParam@. This function is called when setting members ending in @*_texture@. bindSpatialMaterial_set_texture :: MethodBind bindSpatialMaterial_set_texture = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Texture@ to be used by the specified @enum TextureParam@. This function is called when setting members ending in @*_texture@. set_texture :: (SpatialMaterial :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_texture cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_texture" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_texture {-# NOINLINE bindSpatialMaterial_set_transmission #-} -- | The color used by the transmission effect. Represents the light passing through an object. bindSpatialMaterial_set_transmission :: MethodBind bindSpatialMaterial_set_transmission = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_transmission" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color used by the transmission effect. Represents the light passing through an object. set_transmission :: (SpatialMaterial :< cls, Object :< cls) => cls -> Color -> IO () set_transmission cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_transmission (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_transmission" '[Color] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_transmission {-# NOINLINE bindSpatialMaterial_set_uv1_offset #-} -- | How much to offset the @UV@ coordinates. This amount will be added to @UV@ in the vertex function. This can be used to offset a texture. bindSpatialMaterial_set_uv1_offset :: MethodBind bindSpatialMaterial_set_uv1_offset = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_uv1_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much to offset the @UV@ coordinates. This amount will be added to @UV@ in the vertex function. This can be used to offset a texture. set_uv1_offset :: (SpatialMaterial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_uv1_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_uv1_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_uv1_offset" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_uv1_offset {-# NOINLINE bindSpatialMaterial_set_uv1_scale #-} -- | How much to scale the @UV@ coordinates. This is multiplied by @UV@ in the vertex function. bindSpatialMaterial_set_uv1_scale :: MethodBind bindSpatialMaterial_set_uv1_scale = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_uv1_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much to scale the @UV@ coordinates. This is multiplied by @UV@ in the vertex function. set_uv1_scale :: (SpatialMaterial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_uv1_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_uv1_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_uv1_scale" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_uv1_scale {-# NOINLINE bindSpatialMaterial_set_uv1_triplanar_blend_sharpness #-} -- | A lower number blends the texture more softly while a higher number blends the texture more sharply. bindSpatialMaterial_set_uv1_triplanar_blend_sharpness :: MethodBind bindSpatialMaterial_set_uv1_triplanar_blend_sharpness = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_uv1_triplanar_blend_sharpness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A lower number blends the texture more softly while a higher number blends the texture more sharply. set_uv1_triplanar_blend_sharpness :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_uv1_triplanar_blend_sharpness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_uv1_triplanar_blend_sharpness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_uv1_triplanar_blend_sharpness" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_uv1_triplanar_blend_sharpness {-# NOINLINE bindSpatialMaterial_set_uv2_offset #-} -- | How much to offset the @UV2@ coordinates. This amount will be added to @UV2@ in the vertex function. This can be used to offset a texture. bindSpatialMaterial_set_uv2_offset :: MethodBind bindSpatialMaterial_set_uv2_offset = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_uv2_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much to offset the @UV2@ coordinates. This amount will be added to @UV2@ in the vertex function. This can be used to offset a texture. set_uv2_offset :: (SpatialMaterial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_uv2_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_uv2_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_uv2_offset" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_uv2_offset {-# NOINLINE bindSpatialMaterial_set_uv2_scale #-} -- | How much to scale the @UV2@ coordinates. This is multiplied by @UV2@ in the vertex function. bindSpatialMaterial_set_uv2_scale :: MethodBind bindSpatialMaterial_set_uv2_scale = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_uv2_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | How much to scale the @UV2@ coordinates. This is multiplied by @UV2@ in the vertex function. set_uv2_scale :: (SpatialMaterial :< cls, Object :< cls) => cls -> Vector3 -> IO () set_uv2_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_uv2_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_uv2_scale" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_uv2_scale {-# NOINLINE bindSpatialMaterial_set_uv2_triplanar_blend_sharpness #-} -- | A lower number blends the texture more softly while a higher number blends the texture more sharply. bindSpatialMaterial_set_uv2_triplanar_blend_sharpness :: MethodBind bindSpatialMaterial_set_uv2_triplanar_blend_sharpness = unsafePerformIO $ withCString "SpatialMaterial" $ \ clsNamePtr -> withCString "set_uv2_triplanar_blend_sharpness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A lower number blends the texture more softly while a higher number blends the texture more sharply. set_uv2_triplanar_blend_sharpness :: (SpatialMaterial :< cls, Object :< cls) => cls -> Float -> IO () set_uv2_triplanar_blend_sharpness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialMaterial_set_uv2_triplanar_blend_sharpness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialMaterial "set_uv2_triplanar_blend_sharpness" '[Float] (IO ()) where nodeMethod = Godot.Core.SpatialMaterial.set_uv2_triplanar_blend_sharpness ================================================ FILE: src/Godot/Core/SpatialVelocityTracker.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SpatialVelocityTracker (Godot.Core.SpatialVelocityTracker.get_tracked_linear_velocity, Godot.Core.SpatialVelocityTracker.is_tracking_physics_step, Godot.Core.SpatialVelocityTracker.reset, Godot.Core.SpatialVelocityTracker.set_track_physics_step, Godot.Core.SpatialVelocityTracker.update_position) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty SpatialVelocityTracker "track_physics_step" Bool 'False where nodeProperty = (is_tracking_physics_step, wrapDroppingSetter set_track_physics_step, Nothing) {-# NOINLINE bindSpatialVelocityTracker_get_tracked_linear_velocity #-} bindSpatialVelocityTracker_get_tracked_linear_velocity :: MethodBind bindSpatialVelocityTracker_get_tracked_linear_velocity = unsafePerformIO $ withCString "SpatialVelocityTracker" $ \ clsNamePtr -> withCString "get_tracked_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_tracked_linear_velocity :: (SpatialVelocityTracker :< cls, Object :< cls) => cls -> IO Vector3 get_tracked_linear_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialVelocityTracker_get_tracked_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialVelocityTracker "get_tracked_linear_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.SpatialVelocityTracker.get_tracked_linear_velocity {-# NOINLINE bindSpatialVelocityTracker_is_tracking_physics_step #-} bindSpatialVelocityTracker_is_tracking_physics_step :: MethodBind bindSpatialVelocityTracker_is_tracking_physics_step = unsafePerformIO $ withCString "SpatialVelocityTracker" $ \ clsNamePtr -> withCString "is_tracking_physics_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_tracking_physics_step :: (SpatialVelocityTracker :< cls, Object :< cls) => cls -> IO Bool is_tracking_physics_step cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialVelocityTracker_is_tracking_physics_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialVelocityTracker "is_tracking_physics_step" '[] (IO Bool) where nodeMethod = Godot.Core.SpatialVelocityTracker.is_tracking_physics_step {-# NOINLINE bindSpatialVelocityTracker_reset #-} bindSpatialVelocityTracker_reset :: MethodBind bindSpatialVelocityTracker_reset = unsafePerformIO $ withCString "SpatialVelocityTracker" $ \ clsNamePtr -> withCString "reset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr reset :: (SpatialVelocityTracker :< cls, Object :< cls) => cls -> Vector3 -> IO () reset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialVelocityTracker_reset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialVelocityTracker "reset" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SpatialVelocityTracker.reset {-# NOINLINE bindSpatialVelocityTracker_set_track_physics_step #-} bindSpatialVelocityTracker_set_track_physics_step :: MethodBind bindSpatialVelocityTracker_set_track_physics_step = unsafePerformIO $ withCString "SpatialVelocityTracker" $ \ clsNamePtr -> withCString "set_track_physics_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_track_physics_step :: (SpatialVelocityTracker :< cls, Object :< cls) => cls -> Bool -> IO () set_track_physics_step cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialVelocityTracker_set_track_physics_step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialVelocityTracker "set_track_physics_step" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpatialVelocityTracker.set_track_physics_step {-# NOINLINE bindSpatialVelocityTracker_update_position #-} bindSpatialVelocityTracker_update_position :: MethodBind bindSpatialVelocityTracker_update_position = unsafePerformIO $ withCString "SpatialVelocityTracker" $ \ clsNamePtr -> withCString "update_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr update_position :: (SpatialVelocityTracker :< cls, Object :< cls) => cls -> Vector3 -> IO () update_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpatialVelocityTracker_update_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpatialVelocityTracker "update_position" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SpatialVelocityTracker.update_position ================================================ FILE: src/Godot/Core/SphereMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SphereMesh (Godot.Core.SphereMesh.get_height, Godot.Core.SphereMesh.get_is_hemisphere, Godot.Core.SphereMesh.get_radial_segments, Godot.Core.SphereMesh.get_radius, Godot.Core.SphereMesh.get_rings, Godot.Core.SphereMesh.set_height, Godot.Core.SphereMesh.set_is_hemisphere, Godot.Core.SphereMesh.set_radial_segments, Godot.Core.SphereMesh.set_radius, Godot.Core.SphereMesh.set_rings) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PrimitiveMesh() instance NodeProperty SphereMesh "height" Float 'False where nodeProperty = (get_height, wrapDroppingSetter set_height, Nothing) instance NodeProperty SphereMesh "is_hemisphere" Bool 'False where nodeProperty = (get_is_hemisphere, wrapDroppingSetter set_is_hemisphere, Nothing) instance NodeProperty SphereMesh "radial_segments" Int 'False where nodeProperty = (get_radial_segments, wrapDroppingSetter set_radial_segments, Nothing) instance NodeProperty SphereMesh "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) instance NodeProperty SphereMesh "rings" Int 'False where nodeProperty = (get_rings, wrapDroppingSetter set_rings, Nothing) {-# NOINLINE bindSphereMesh_get_height #-} -- | Full height of the sphere. bindSphereMesh_get_height :: MethodBind bindSphereMesh_get_height = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Full height of the sphere. get_height :: (SphereMesh :< cls, Object :< cls) => cls -> IO Float get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "get_height" '[] (IO Float) where nodeMethod = Godot.Core.SphereMesh.get_height {-# NOINLINE bindSphereMesh_get_is_hemisphere #-} -- | If @true@, a hemisphere is created rather than a full sphere. -- __Note:__ To get a regular hemisphere, the height and radius of the sphere must be equal. bindSphereMesh_get_is_hemisphere :: MethodBind bindSphereMesh_get_is_hemisphere = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "get_is_hemisphere" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a hemisphere is created rather than a full sphere. -- __Note:__ To get a regular hemisphere, the height and radius of the sphere must be equal. get_is_hemisphere :: (SphereMesh :< cls, Object :< cls) => cls -> IO Bool get_is_hemisphere cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_get_is_hemisphere (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "get_is_hemisphere" '[] (IO Bool) where nodeMethod = Godot.Core.SphereMesh.get_is_hemisphere {-# NOINLINE bindSphereMesh_get_radial_segments #-} -- | Number of radial segments on the sphere. bindSphereMesh_get_radial_segments :: MethodBind bindSphereMesh_get_radial_segments = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "get_radial_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of radial segments on the sphere. get_radial_segments :: (SphereMesh :< cls, Object :< cls) => cls -> IO Int get_radial_segments cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_get_radial_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "get_radial_segments" '[] (IO Int) where nodeMethod = Godot.Core.SphereMesh.get_radial_segments {-# NOINLINE bindSphereMesh_get_radius #-} -- | Radius of sphere. bindSphereMesh_get_radius :: MethodBind bindSphereMesh_get_radius = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Radius of sphere. get_radius :: (SphereMesh :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.SphereMesh.get_radius {-# NOINLINE bindSphereMesh_get_rings #-} -- | Number of segments along the height of the sphere. bindSphereMesh_get_rings :: MethodBind bindSphereMesh_get_rings = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "get_rings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of segments along the height of the sphere. get_rings :: (SphereMesh :< cls, Object :< cls) => cls -> IO Int get_rings cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_get_rings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "get_rings" '[] (IO Int) where nodeMethod = Godot.Core.SphereMesh.get_rings {-# NOINLINE bindSphereMesh_set_height #-} -- | Full height of the sphere. bindSphereMesh_set_height :: MethodBind bindSphereMesh_set_height = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Full height of the sphere. set_height :: (SphereMesh :< cls, Object :< cls) => cls -> Float -> IO () set_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "set_height" '[Float] (IO ()) where nodeMethod = Godot.Core.SphereMesh.set_height {-# NOINLINE bindSphereMesh_set_is_hemisphere #-} -- | If @true@, a hemisphere is created rather than a full sphere. -- __Note:__ To get a regular hemisphere, the height and radius of the sphere must be equal. bindSphereMesh_set_is_hemisphere :: MethodBind bindSphereMesh_set_is_hemisphere = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "set_is_hemisphere" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a hemisphere is created rather than a full sphere. -- __Note:__ To get a regular hemisphere, the height and radius of the sphere must be equal. set_is_hemisphere :: (SphereMesh :< cls, Object :< cls) => cls -> Bool -> IO () set_is_hemisphere cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_set_is_hemisphere (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "set_is_hemisphere" '[Bool] (IO ()) where nodeMethod = Godot.Core.SphereMesh.set_is_hemisphere {-# NOINLINE bindSphereMesh_set_radial_segments #-} -- | Number of radial segments on the sphere. bindSphereMesh_set_radial_segments :: MethodBind bindSphereMesh_set_radial_segments = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "set_radial_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of radial segments on the sphere. set_radial_segments :: (SphereMesh :< cls, Object :< cls) => cls -> Int -> IO () set_radial_segments cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_set_radial_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "set_radial_segments" '[Int] (IO ()) where nodeMethod = Godot.Core.SphereMesh.set_radial_segments {-# NOINLINE bindSphereMesh_set_radius #-} -- | Radius of sphere. bindSphereMesh_set_radius :: MethodBind bindSphereMesh_set_radius = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Radius of sphere. set_radius :: (SphereMesh :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.SphereMesh.set_radius {-# NOINLINE bindSphereMesh_set_rings #-} -- | Number of segments along the height of the sphere. bindSphereMesh_set_rings :: MethodBind bindSphereMesh_set_rings = unsafePerformIO $ withCString "SphereMesh" $ \ clsNamePtr -> withCString "set_rings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Number of segments along the height of the sphere. set_rings :: (SphereMesh :< cls, Object :< cls) => cls -> Int -> IO () set_rings cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSphereMesh_set_rings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereMesh "set_rings" '[Int] (IO ()) where nodeMethod = Godot.Core.SphereMesh.set_rings ================================================ FILE: src/Godot/Core/SphereShape.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SphereShape (Godot.Core.SphereShape.get_radius, Godot.Core.SphereShape.set_radius) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shape() instance NodeProperty SphereShape "radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) {-# NOINLINE bindSphereShape_get_radius #-} -- | The sphere's radius. The shape's diameter is double the radius. bindSphereShape_get_radius :: MethodBind bindSphereShape_get_radius = unsafePerformIO $ withCString "SphereShape" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sphere's radius. The shape's diameter is double the radius. get_radius :: (SphereShape :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSphereShape_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereShape "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.SphereShape.get_radius {-# NOINLINE bindSphereShape_set_radius #-} -- | The sphere's radius. The shape's diameter is double the radius. bindSphereShape_set_radius :: MethodBind bindSphereShape_set_radius = unsafePerformIO $ withCString "SphereShape" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The sphere's radius. The shape's diameter is double the radius. set_radius :: (SphereShape :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSphereShape_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SphereShape "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.SphereShape.set_radius ================================================ FILE: src/Godot/Core/SpinBox.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SpinBox (Godot.Core.SpinBox._gui_input, Godot.Core.SpinBox._line_edit_focus_exit, Godot.Core.SpinBox._line_edit_input, Godot.Core.SpinBox._range_click_timeout, Godot.Core.SpinBox._text_entered, Godot.Core.SpinBox.apply, Godot.Core.SpinBox.get_align, Godot.Core.SpinBox.get_line_edit, Godot.Core.SpinBox.get_prefix, Godot.Core.SpinBox.get_suffix, Godot.Core.SpinBox.is_editable, Godot.Core.SpinBox.set_align, Godot.Core.SpinBox.set_editable, Godot.Core.SpinBox.set_prefix, Godot.Core.SpinBox.set_suffix) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Range() instance NodeProperty SpinBox "align" Int 'False where nodeProperty = (get_align, wrapDroppingSetter set_align, Nothing) instance NodeProperty SpinBox "editable" Bool 'False where nodeProperty = (is_editable, wrapDroppingSetter set_editable, Nothing) instance NodeProperty SpinBox "prefix" GodotString 'False where nodeProperty = (get_prefix, wrapDroppingSetter set_prefix, Nothing) instance NodeProperty SpinBox "suffix" GodotString 'False where nodeProperty = (get_suffix, wrapDroppingSetter set_suffix, Nothing) {-# NOINLINE bindSpinBox__gui_input #-} bindSpinBox__gui_input :: MethodBind bindSpinBox__gui_input = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (SpinBox :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.SpinBox._gui_input {-# NOINLINE bindSpinBox__line_edit_focus_exit #-} bindSpinBox__line_edit_focus_exit :: MethodBind bindSpinBox__line_edit_focus_exit = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "_line_edit_focus_exit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _line_edit_focus_exit :: (SpinBox :< cls, Object :< cls) => cls -> IO () _line_edit_focus_exit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox__line_edit_focus_exit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "_line_edit_focus_exit" '[] (IO ()) where nodeMethod = Godot.Core.SpinBox._line_edit_focus_exit {-# NOINLINE bindSpinBox__line_edit_input #-} bindSpinBox__line_edit_input :: MethodBind bindSpinBox__line_edit_input = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "_line_edit_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _line_edit_input :: (SpinBox :< cls, Object :< cls) => cls -> InputEvent -> IO () _line_edit_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox__line_edit_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "_line_edit_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.SpinBox._line_edit_input {-# NOINLINE bindSpinBox__range_click_timeout #-} bindSpinBox__range_click_timeout :: MethodBind bindSpinBox__range_click_timeout = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "_range_click_timeout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _range_click_timeout :: (SpinBox :< cls, Object :< cls) => cls -> IO () _range_click_timeout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox__range_click_timeout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "_range_click_timeout" '[] (IO ()) where nodeMethod = Godot.Core.SpinBox._range_click_timeout {-# NOINLINE bindSpinBox__text_entered #-} bindSpinBox__text_entered :: MethodBind bindSpinBox__text_entered = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "_text_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _text_entered :: (SpinBox :< cls, Object :< cls) => cls -> GodotString -> IO () _text_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox__text_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "_text_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Core.SpinBox._text_entered {-# NOINLINE bindSpinBox_apply #-} -- | Applies the current value of this @SpinBox@. bindSpinBox_apply :: MethodBind bindSpinBox_apply = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "apply" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies the current value of this @SpinBox@. apply :: (SpinBox :< cls, Object :< cls) => cls -> IO () apply cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_apply (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "apply" '[] (IO ()) where nodeMethod = Godot.Core.SpinBox.apply {-# NOINLINE bindSpinBox_get_align #-} -- | Sets the text alignment of the @SpinBox@. bindSpinBox_get_align :: MethodBind bindSpinBox_get_align = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "get_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the text alignment of the @SpinBox@. get_align :: (SpinBox :< cls, Object :< cls) => cls -> IO Int get_align cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_get_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "get_align" '[] (IO Int) where nodeMethod = Godot.Core.SpinBox.get_align {-# NOINLINE bindSpinBox_get_line_edit #-} -- | Returns the @LineEdit@ instance from this @SpinBox@. You can use it to access properties and methods of @LineEdit@. bindSpinBox_get_line_edit :: MethodBind bindSpinBox_get_line_edit = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "get_line_edit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @LineEdit@ instance from this @SpinBox@. You can use it to access properties and methods of @LineEdit@. get_line_edit :: (SpinBox :< cls, Object :< cls) => cls -> IO LineEdit get_line_edit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_get_line_edit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "get_line_edit" '[] (IO LineEdit) where nodeMethod = Godot.Core.SpinBox.get_line_edit {-# NOINLINE bindSpinBox_get_prefix #-} -- | Adds the specified @prefix@ string before the numerical value of the @SpinBox@. bindSpinBox_get_prefix :: MethodBind bindSpinBox_get_prefix = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "get_prefix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the specified @prefix@ string before the numerical value of the @SpinBox@. get_prefix :: (SpinBox :< cls, Object :< cls) => cls -> IO GodotString get_prefix cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_get_prefix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "get_prefix" '[] (IO GodotString) where nodeMethod = Godot.Core.SpinBox.get_prefix {-# NOINLINE bindSpinBox_get_suffix #-} -- | Adds the specified @suffix@ string after the numerical value of the @SpinBox@. bindSpinBox_get_suffix :: MethodBind bindSpinBox_get_suffix = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "get_suffix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the specified @suffix@ string after the numerical value of the @SpinBox@. get_suffix :: (SpinBox :< cls, Object :< cls) => cls -> IO GodotString get_suffix cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_get_suffix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "get_suffix" '[] (IO GodotString) where nodeMethod = Godot.Core.SpinBox.get_suffix {-# NOINLINE bindSpinBox_is_editable #-} -- | If @true@, the @SpinBox@ will be editable. Otherwise, it will be read only. bindSpinBox_is_editable :: MethodBind bindSpinBox_is_editable = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "is_editable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @SpinBox@ will be editable. Otherwise, it will be read only. is_editable :: (SpinBox :< cls, Object :< cls) => cls -> IO Bool is_editable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_is_editable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "is_editable" '[] (IO Bool) where nodeMethod = Godot.Core.SpinBox.is_editable {-# NOINLINE bindSpinBox_set_align #-} -- | Sets the text alignment of the @SpinBox@. bindSpinBox_set_align :: MethodBind bindSpinBox_set_align = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "set_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the text alignment of the @SpinBox@. set_align :: (SpinBox :< cls, Object :< cls) => cls -> Int -> IO () set_align cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_set_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "set_align" '[Int] (IO ()) where nodeMethod = Godot.Core.SpinBox.set_align {-# NOINLINE bindSpinBox_set_editable #-} -- | If @true@, the @SpinBox@ will be editable. Otherwise, it will be read only. bindSpinBox_set_editable :: MethodBind bindSpinBox_set_editable = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "set_editable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @SpinBox@ will be editable. Otherwise, it will be read only. set_editable :: (SpinBox :< cls, Object :< cls) => cls -> Bool -> IO () set_editable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_set_editable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "set_editable" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpinBox.set_editable {-# NOINLINE bindSpinBox_set_prefix #-} -- | Adds the specified @prefix@ string before the numerical value of the @SpinBox@. bindSpinBox_set_prefix :: MethodBind bindSpinBox_set_prefix = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "set_prefix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the specified @prefix@ string before the numerical value of the @SpinBox@. set_prefix :: (SpinBox :< cls, Object :< cls) => cls -> GodotString -> IO () set_prefix cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_set_prefix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "set_prefix" '[GodotString] (IO ()) where nodeMethod = Godot.Core.SpinBox.set_prefix {-# NOINLINE bindSpinBox_set_suffix #-} -- | Adds the specified @suffix@ string after the numerical value of the @SpinBox@. bindSpinBox_set_suffix :: MethodBind bindSpinBox_set_suffix = unsafePerformIO $ withCString "SpinBox" $ \ clsNamePtr -> withCString "set_suffix" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the specified @suffix@ string after the numerical value of the @SpinBox@. set_suffix :: (SpinBox :< cls, Object :< cls) => cls -> GodotString -> IO () set_suffix cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpinBox_set_suffix (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpinBox "set_suffix" '[GodotString] (IO ()) where nodeMethod = Godot.Core.SpinBox.set_suffix ================================================ FILE: src/Godot/Core/SplitContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SplitContainer (Godot.Core.SplitContainer._DRAGGER_HIDDEN, Godot.Core.SplitContainer._DRAGGER_HIDDEN_COLLAPSED, Godot.Core.SplitContainer._DRAGGER_VISIBLE, Godot.Core.SplitContainer.sig_dragged, Godot.Core.SplitContainer._gui_input, Godot.Core.SplitContainer.clamp_split_offset, Godot.Core.SplitContainer.get_dragger_visibility, Godot.Core.SplitContainer.get_split_offset, Godot.Core.SplitContainer.is_collapsed, Godot.Core.SplitContainer.set_collapsed, Godot.Core.SplitContainer.set_dragger_visibility, Godot.Core.SplitContainer.set_split_offset) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() _DRAGGER_HIDDEN :: Int _DRAGGER_HIDDEN = 1 _DRAGGER_HIDDEN_COLLAPSED :: Int _DRAGGER_HIDDEN_COLLAPSED = 2 _DRAGGER_VISIBLE :: Int _DRAGGER_VISIBLE = 0 -- | Emitted when the dragger is dragged by user. sig_dragged :: Godot.Internal.Dispatch.Signal SplitContainer sig_dragged = Godot.Internal.Dispatch.Signal "dragged" instance NodeSignal SplitContainer "dragged" '[Int] instance NodeProperty SplitContainer "collapsed" Bool 'False where nodeProperty = (is_collapsed, wrapDroppingSetter set_collapsed, Nothing) instance NodeProperty SplitContainer "dragger_visibility" Int 'False where nodeProperty = (get_dragger_visibility, wrapDroppingSetter set_dragger_visibility, Nothing) instance NodeProperty SplitContainer "split_offset" Int 'False where nodeProperty = (get_split_offset, wrapDroppingSetter set_split_offset, Nothing) {-# NOINLINE bindSplitContainer__gui_input #-} bindSplitContainer__gui_input :: MethodBind bindSplitContainer__gui_input = unsafePerformIO $ withCString "SplitContainer" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (SplitContainer :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSplitContainer__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SplitContainer "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.SplitContainer._gui_input {-# NOINLINE bindSplitContainer_clamp_split_offset #-} -- | Clamps the @split_offset@ value to not go outside the currently possible minimal and maximum values. bindSplitContainer_clamp_split_offset :: MethodBind bindSplitContainer_clamp_split_offset = unsafePerformIO $ withCString "SplitContainer" $ \ clsNamePtr -> withCString "clamp_split_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clamps the @split_offset@ value to not go outside the currently possible minimal and maximum values. clamp_split_offset :: (SplitContainer :< cls, Object :< cls) => cls -> IO () clamp_split_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSplitContainer_clamp_split_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SplitContainer "clamp_split_offset" '[] (IO ()) where nodeMethod = Godot.Core.SplitContainer.clamp_split_offset {-# NOINLINE bindSplitContainer_get_dragger_visibility #-} -- | Determines the dragger's visibility. See @enum DraggerVisibility@ for details. bindSplitContainer_get_dragger_visibility :: MethodBind bindSplitContainer_get_dragger_visibility = unsafePerformIO $ withCString "SplitContainer" $ \ clsNamePtr -> withCString "get_dragger_visibility" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines the dragger's visibility. See @enum DraggerVisibility@ for details. get_dragger_visibility :: (SplitContainer :< cls, Object :< cls) => cls -> IO Int get_dragger_visibility cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSplitContainer_get_dragger_visibility (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SplitContainer "get_dragger_visibility" '[] (IO Int) where nodeMethod = Godot.Core.SplitContainer.get_dragger_visibility {-# NOINLINE bindSplitContainer_get_split_offset #-} -- | The initial offset of the splitting between the two @Control@s, with @0@ being at the end of the first @Control@. bindSplitContainer_get_split_offset :: MethodBind bindSplitContainer_get_split_offset = unsafePerformIO $ withCString "SplitContainer" $ \ clsNamePtr -> withCString "get_split_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The initial offset of the splitting between the two @Control@s, with @0@ being at the end of the first @Control@. get_split_offset :: (SplitContainer :< cls, Object :< cls) => cls -> IO Int get_split_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSplitContainer_get_split_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SplitContainer "get_split_offset" '[] (IO Int) where nodeMethod = Godot.Core.SplitContainer.get_split_offset {-# NOINLINE bindSplitContainer_is_collapsed #-} -- | If @true@, the area of the first @Control@ will be collapsed and the dragger will be disabled. bindSplitContainer_is_collapsed :: MethodBind bindSplitContainer_is_collapsed = unsafePerformIO $ withCString "SplitContainer" $ \ clsNamePtr -> withCString "is_collapsed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area of the first @Control@ will be collapsed and the dragger will be disabled. is_collapsed :: (SplitContainer :< cls, Object :< cls) => cls -> IO Bool is_collapsed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSplitContainer_is_collapsed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SplitContainer "is_collapsed" '[] (IO Bool) where nodeMethod = Godot.Core.SplitContainer.is_collapsed {-# NOINLINE bindSplitContainer_set_collapsed #-} -- | If @true@, the area of the first @Control@ will be collapsed and the dragger will be disabled. bindSplitContainer_set_collapsed :: MethodBind bindSplitContainer_set_collapsed = unsafePerformIO $ withCString "SplitContainer" $ \ clsNamePtr -> withCString "set_collapsed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the area of the first @Control@ will be collapsed and the dragger will be disabled. set_collapsed :: (SplitContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_collapsed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSplitContainer_set_collapsed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SplitContainer "set_collapsed" '[Bool] (IO ()) where nodeMethod = Godot.Core.SplitContainer.set_collapsed {-# NOINLINE bindSplitContainer_set_dragger_visibility #-} -- | Determines the dragger's visibility. See @enum DraggerVisibility@ for details. bindSplitContainer_set_dragger_visibility :: MethodBind bindSplitContainer_set_dragger_visibility = unsafePerformIO $ withCString "SplitContainer" $ \ clsNamePtr -> withCString "set_dragger_visibility" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines the dragger's visibility. See @enum DraggerVisibility@ for details. set_dragger_visibility :: (SplitContainer :< cls, Object :< cls) => cls -> Int -> IO () set_dragger_visibility cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSplitContainer_set_dragger_visibility (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SplitContainer "set_dragger_visibility" '[Int] (IO ()) where nodeMethod = Godot.Core.SplitContainer.set_dragger_visibility {-# NOINLINE bindSplitContainer_set_split_offset #-} -- | The initial offset of the splitting between the two @Control@s, with @0@ being at the end of the first @Control@. bindSplitContainer_set_split_offset :: MethodBind bindSplitContainer_set_split_offset = unsafePerformIO $ withCString "SplitContainer" $ \ clsNamePtr -> withCString "set_split_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The initial offset of the splitting between the two @Control@s, with @0@ being at the end of the first @Control@. set_split_offset :: (SplitContainer :< cls, Object :< cls) => cls -> Int -> IO () set_split_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSplitContainer_set_split_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SplitContainer "set_split_offset" '[Int] (IO ()) where nodeMethod = Godot.Core.SplitContainer.set_split_offset ================================================ FILE: src/Godot/Core/SpotLight.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SpotLight (Godot.Core.SpotLight.get_param, Godot.Core.SpotLight.set_param) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Light() {-# NOINLINE bindSpotLight_get_param #-} -- | The spotlight's angle in degrees. bindSpotLight_get_param :: MethodBind bindSpotLight_get_param = unsafePerformIO $ withCString "SpotLight" $ \ clsNamePtr -> withCString "get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The spotlight's angle in degrees. get_param :: (SpotLight :< cls, Object :< cls) => cls -> Int -> IO Float get_param cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpotLight_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpotLight "get_param" '[Int] (IO Float) where nodeMethod = Godot.Core.SpotLight.get_param {-# NOINLINE bindSpotLight_set_param #-} -- | The spotlight's angle in degrees. bindSpotLight_set_param :: MethodBind bindSpotLight_set_param = unsafePerformIO $ withCString "SpotLight" $ \ clsNamePtr -> withCString "set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The spotlight's angle in degrees. set_param :: (SpotLight :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpotLight_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpotLight "set_param" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.SpotLight.set_param instance NodeProperty SpotLight "spot_angle" Float 'False where nodeProperty = (wrapIndexedGetter 5 get_param, wrapIndexedSetter 5 set_param, Nothing) instance NodeProperty SpotLight "spot_angle_attenuation" Float 'False where nodeProperty = (wrapIndexedGetter 6 get_param, wrapIndexedSetter 6 set_param, Nothing) instance NodeProperty SpotLight "spot_attenuation" Float 'False where nodeProperty = (wrapIndexedGetter 4 get_param, wrapIndexedSetter 4 set_param, Nothing) instance NodeProperty SpotLight "spot_range" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_param, wrapIndexedSetter 3 set_param, Nothing) ================================================ FILE: src/Godot/Core/SpringArm.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SpringArm (Godot.Core.SpringArm.add_excluded_object, Godot.Core.SpringArm.clear_excluded_objects, Godot.Core.SpringArm.get_collision_mask, Godot.Core.SpringArm.get_hit_length, Godot.Core.SpringArm.get_length, Godot.Core.SpringArm.get_margin, Godot.Core.SpringArm.get_shape, Godot.Core.SpringArm.remove_excluded_object, Godot.Core.SpringArm.set_collision_mask, Godot.Core.SpringArm.set_length, Godot.Core.SpringArm.set_margin, Godot.Core.SpringArm.set_shape) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty SpringArm "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty SpringArm "margin" Float 'False where nodeProperty = (get_margin, wrapDroppingSetter set_margin, Nothing) instance NodeProperty SpringArm "shape" Shape 'False where nodeProperty = (get_shape, wrapDroppingSetter set_shape, Nothing) instance NodeProperty SpringArm "spring_length" Float 'False where nodeProperty = (get_length, wrapDroppingSetter set_length, Nothing) {-# NOINLINE bindSpringArm_add_excluded_object #-} -- | Adds the @PhysicsBody@ object with the given @RID@ to the list of @PhysicsBody@ objects excluded from the collision check. bindSpringArm_add_excluded_object :: MethodBind bindSpringArm_add_excluded_object = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "add_excluded_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the @PhysicsBody@ object with the given @RID@ to the list of @PhysicsBody@ objects excluded from the collision check. add_excluded_object :: (SpringArm :< cls, Object :< cls) => cls -> Rid -> IO () add_excluded_object cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_add_excluded_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "add_excluded_object" '[Rid] (IO ()) where nodeMethod = Godot.Core.SpringArm.add_excluded_object {-# NOINLINE bindSpringArm_clear_excluded_objects #-} -- | Clears the list of @PhysicsBody@ objects excluded from the collision check. bindSpringArm_clear_excluded_objects :: MethodBind bindSpringArm_clear_excluded_objects = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "clear_excluded_objects" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the list of @PhysicsBody@ objects excluded from the collision check. clear_excluded_objects :: (SpringArm :< cls, Object :< cls) => cls -> IO () clear_excluded_objects cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_clear_excluded_objects (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "clear_excluded_objects" '[] (IO ()) where nodeMethod = Godot.Core.SpringArm.clear_excluded_objects {-# NOINLINE bindSpringArm_get_collision_mask #-} -- | The layers against which the collision check shall be done. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindSpringArm_get_collision_mask :: MethodBind bindSpringArm_get_collision_mask = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layers against which the collision check shall be done. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (SpringArm :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.SpringArm.get_collision_mask {-# NOINLINE bindSpringArm_get_hit_length #-} -- | Returns the spring arm's current length. bindSpringArm_get_hit_length :: MethodBind bindSpringArm_get_hit_length = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "get_hit_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the spring arm's current length. get_hit_length :: (SpringArm :< cls, Object :< cls) => cls -> IO Float get_hit_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_get_hit_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "get_hit_length" '[] (IO Float) where nodeMethod = Godot.Core.SpringArm.get_hit_length {-# NOINLINE bindSpringArm_get_length #-} -- | The maximum extent of the SpringArm. This is used as a length for both the ray and the shape cast used internally to calculate the desired position of the SpringArm's child nodes. -- To know more about how to perform a shape cast or a ray cast, please consult the @PhysicsDirectSpaceState@ documentation. bindSpringArm_get_length :: MethodBind bindSpringArm_get_length = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "get_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum extent of the SpringArm. This is used as a length for both the ray and the shape cast used internally to calculate the desired position of the SpringArm's child nodes. -- To know more about how to perform a shape cast or a ray cast, please consult the @PhysicsDirectSpaceState@ documentation. get_length :: (SpringArm :< cls, Object :< cls) => cls -> IO Float get_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_get_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "get_length" '[] (IO Float) where nodeMethod = Godot.Core.SpringArm.get_length {-# NOINLINE bindSpringArm_get_margin #-} -- | When the collision check is made, a candidate length for the SpringArm is given. -- The margin is then subtracted to this length and the translation is applied to the child objects of the SpringArm. -- This margin is useful for when the SpringArm has a @Camera@ as a child node: without the margin, the @Camera@ would be placed on the exact point of collision, while with the margin the @Camera@ would be placed close to the point of collision. bindSpringArm_get_margin :: MethodBind bindSpringArm_get_margin = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "get_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When the collision check is made, a candidate length for the SpringArm is given. -- The margin is then subtracted to this length and the translation is applied to the child objects of the SpringArm. -- This margin is useful for when the SpringArm has a @Camera@ as a child node: without the margin, the @Camera@ would be placed on the exact point of collision, while with the margin the @Camera@ would be placed close to the point of collision. get_margin :: (SpringArm :< cls, Object :< cls) => cls -> IO Float get_margin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_get_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "get_margin" '[] (IO Float) where nodeMethod = Godot.Core.SpringArm.get_margin {-# NOINLINE bindSpringArm_get_shape #-} -- | The @Shape@ to use for the SpringArm. -- When the shape is set, the SpringArm will cast the @Shape@ on its z axis instead of performing a ray cast. bindSpringArm_get_shape :: MethodBind bindSpringArm_get_shape = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Shape@ to use for the SpringArm. -- When the shape is set, the SpringArm will cast the @Shape@ on its z axis instead of performing a ray cast. get_shape :: (SpringArm :< cls, Object :< cls) => cls -> IO Shape get_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "get_shape" '[] (IO Shape) where nodeMethod = Godot.Core.SpringArm.get_shape {-# NOINLINE bindSpringArm_remove_excluded_object #-} -- | Removes the given @RID@ from the list of @PhysicsBody@ objects excluded from the collision check. bindSpringArm_remove_excluded_object :: MethodBind bindSpringArm_remove_excluded_object = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "remove_excluded_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the given @RID@ from the list of @PhysicsBody@ objects excluded from the collision check. remove_excluded_object :: (SpringArm :< cls, Object :< cls) => cls -> Rid -> IO Bool remove_excluded_object cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_remove_excluded_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "remove_excluded_object" '[Rid] (IO Bool) where nodeMethod = Godot.Core.SpringArm.remove_excluded_object {-# NOINLINE bindSpringArm_set_collision_mask #-} -- | The layers against which the collision check shall be done. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindSpringArm_set_collision_mask :: MethodBind bindSpringArm_set_collision_mask = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layers against which the collision check shall be done. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (SpringArm :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.SpringArm.set_collision_mask {-# NOINLINE bindSpringArm_set_length #-} -- | The maximum extent of the SpringArm. This is used as a length for both the ray and the shape cast used internally to calculate the desired position of the SpringArm's child nodes. -- To know more about how to perform a shape cast or a ray cast, please consult the @PhysicsDirectSpaceState@ documentation. bindSpringArm_set_length :: MethodBind bindSpringArm_set_length = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "set_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum extent of the SpringArm. This is used as a length for both the ray and the shape cast used internally to calculate the desired position of the SpringArm's child nodes. -- To know more about how to perform a shape cast or a ray cast, please consult the @PhysicsDirectSpaceState@ documentation. set_length :: (SpringArm :< cls, Object :< cls) => cls -> Float -> IO () set_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_set_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "set_length" '[Float] (IO ()) where nodeMethod = Godot.Core.SpringArm.set_length {-# NOINLINE bindSpringArm_set_margin #-} -- | When the collision check is made, a candidate length for the SpringArm is given. -- The margin is then subtracted to this length and the translation is applied to the child objects of the SpringArm. -- This margin is useful for when the SpringArm has a @Camera@ as a child node: without the margin, the @Camera@ would be placed on the exact point of collision, while with the margin the @Camera@ would be placed close to the point of collision. bindSpringArm_set_margin :: MethodBind bindSpringArm_set_margin = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "set_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When the collision check is made, a candidate length for the SpringArm is given. -- The margin is then subtracted to this length and the translation is applied to the child objects of the SpringArm. -- This margin is useful for when the SpringArm has a @Camera@ as a child node: without the margin, the @Camera@ would be placed on the exact point of collision, while with the margin the @Camera@ would be placed close to the point of collision. set_margin :: (SpringArm :< cls, Object :< cls) => cls -> Float -> IO () set_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_set_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "set_margin" '[Float] (IO ()) where nodeMethod = Godot.Core.SpringArm.set_margin {-# NOINLINE bindSpringArm_set_shape #-} -- | The @Shape@ to use for the SpringArm. -- When the shape is set, the SpringArm will cast the @Shape@ on its z axis instead of performing a ray cast. bindSpringArm_set_shape :: MethodBind bindSpringArm_set_shape = unsafePerformIO $ withCString "SpringArm" $ \ clsNamePtr -> withCString "set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Shape@ to use for the SpringArm. -- When the shape is set, the SpringArm will cast the @Shape@ on its z axis instead of performing a ray cast. set_shape :: (SpringArm :< cls, Object :< cls) => cls -> Shape -> IO () set_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpringArm_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpringArm "set_shape" '[Shape] (IO ()) where nodeMethod = Godot.Core.SpringArm.set_shape ================================================ FILE: src/Godot/Core/Sprite.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Sprite (Godot.Core.Sprite.sig_frame_changed, Godot.Core.Sprite.sig_texture_changed, Godot.Core.Sprite._texture_changed, Godot.Core.Sprite.get_frame, Godot.Core.Sprite.get_frame_coords, Godot.Core.Sprite.get_hframes, Godot.Core.Sprite.get_normal_map, Godot.Core.Sprite.get_offset, Godot.Core.Sprite.get_rect, Godot.Core.Sprite.get_region_rect, Godot.Core.Sprite.get_texture, Godot.Core.Sprite.get_vframes, Godot.Core.Sprite.is_centered, Godot.Core.Sprite.is_flipped_h, Godot.Core.Sprite.is_flipped_v, Godot.Core.Sprite.is_pixel_opaque, Godot.Core.Sprite.is_region, Godot.Core.Sprite.is_region_filter_clip_enabled, Godot.Core.Sprite.set_centered, Godot.Core.Sprite.set_flip_h, Godot.Core.Sprite.set_flip_v, Godot.Core.Sprite.set_frame, Godot.Core.Sprite.set_frame_coords, Godot.Core.Sprite.set_hframes, Godot.Core.Sprite.set_normal_map, Godot.Core.Sprite.set_offset, Godot.Core.Sprite.set_region, Godot.Core.Sprite.set_region_filter_clip, Godot.Core.Sprite.set_region_rect, Godot.Core.Sprite.set_texture, Godot.Core.Sprite.set_vframes) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() -- | Emitted when the @frame@ changes. sig_frame_changed :: Godot.Internal.Dispatch.Signal Sprite sig_frame_changed = Godot.Internal.Dispatch.Signal "frame_changed" instance NodeSignal Sprite "frame_changed" '[] -- | Emitted when the @texture@ changes. sig_texture_changed :: Godot.Internal.Dispatch.Signal Sprite sig_texture_changed = Godot.Internal.Dispatch.Signal "texture_changed" instance NodeSignal Sprite "texture_changed" '[] instance NodeProperty Sprite "centered" Bool 'False where nodeProperty = (is_centered, wrapDroppingSetter set_centered, Nothing) instance NodeProperty Sprite "flip_h" Bool 'False where nodeProperty = (is_flipped_h, wrapDroppingSetter set_flip_h, Nothing) instance NodeProperty Sprite "flip_v" Bool 'False where nodeProperty = (is_flipped_v, wrapDroppingSetter set_flip_v, Nothing) instance NodeProperty Sprite "frame" Int 'False where nodeProperty = (get_frame, wrapDroppingSetter set_frame, Nothing) instance NodeProperty Sprite "frame_coords" Vector2 'False where nodeProperty = (get_frame_coords, wrapDroppingSetter set_frame_coords, Nothing) instance NodeProperty Sprite "hframes" Int 'False where nodeProperty = (get_hframes, wrapDroppingSetter set_hframes, Nothing) instance NodeProperty Sprite "normal_map" Texture 'False where nodeProperty = (get_normal_map, wrapDroppingSetter set_normal_map, Nothing) instance NodeProperty Sprite "offset" Vector2 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty Sprite "region_enabled" Bool 'False where nodeProperty = (is_region, wrapDroppingSetter set_region, Nothing) instance NodeProperty Sprite "region_filter_clip" Bool 'False where nodeProperty = (is_region_filter_clip_enabled, wrapDroppingSetter set_region_filter_clip, Nothing) instance NodeProperty Sprite "region_rect" Rect2 'False where nodeProperty = (get_region_rect, wrapDroppingSetter set_region_rect, Nothing) instance NodeProperty Sprite "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) instance NodeProperty Sprite "vframes" Int 'False where nodeProperty = (get_vframes, wrapDroppingSetter set_vframes, Nothing) {-# NOINLINE bindSprite__texture_changed #-} bindSprite__texture_changed :: MethodBind bindSprite__texture_changed = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "_texture_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _texture_changed :: (Sprite :< cls, Object :< cls) => cls -> IO () _texture_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite__texture_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "_texture_changed" '[] (IO ()) where nodeMethod = Godot.Core.Sprite._texture_changed {-# NOINLINE bindSprite_get_frame #-} -- | Current frame to display from sprite sheet. @vframes@ or @hframes@ must be greater than 1. bindSprite_get_frame :: MethodBind bindSprite_get_frame = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Current frame to display from sprite sheet. @vframes@ or @hframes@ must be greater than 1. get_frame :: (Sprite :< cls, Object :< cls) => cls -> IO Int get_frame cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_frame" '[] (IO Int) where nodeMethod = Godot.Core.Sprite.get_frame {-# NOINLINE bindSprite_get_frame_coords #-} -- | Coordinates of the frame to display from sprite sheet. This is as an alias for the @frame@ property. @vframes@ or @hframes@ must be greater than 1. bindSprite_get_frame_coords :: MethodBind bindSprite_get_frame_coords = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_frame_coords" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Coordinates of the frame to display from sprite sheet. This is as an alias for the @frame@ property. @vframes@ or @hframes@ must be greater than 1. get_frame_coords :: (Sprite :< cls, Object :< cls) => cls -> IO Vector2 get_frame_coords cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_frame_coords (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_frame_coords" '[] (IO Vector2) where nodeMethod = Godot.Core.Sprite.get_frame_coords {-# NOINLINE bindSprite_get_hframes #-} -- | The number of columns in the sprite sheet. bindSprite_get_hframes :: MethodBind bindSprite_get_hframes = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_hframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns in the sprite sheet. get_hframes :: (Sprite :< cls, Object :< cls) => cls -> IO Int get_hframes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_hframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_hframes" '[] (IO Int) where nodeMethod = Godot.Core.Sprite.get_hframes {-# NOINLINE bindSprite_get_normal_map #-} -- | The normal map gives depth to the Sprite. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindSprite_get_normal_map :: MethodBind bindSprite_get_normal_map = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The normal map gives depth to the Sprite. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. get_normal_map :: (Sprite :< cls, Object :< cls) => cls -> IO Texture get_normal_map cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_normal_map" '[] (IO Texture) where nodeMethod = Godot.Core.Sprite.get_normal_map {-# NOINLINE bindSprite_get_offset #-} -- | The texture's drawing offset. bindSprite_get_offset :: MethodBind bindSprite_get_offset = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's drawing offset. get_offset :: (Sprite :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.Sprite.get_offset {-# NOINLINE bindSprite_get_rect #-} -- | Returns a @Rect2@ representing the Sprite's boundary in local coordinates. Can be used to detect if the Sprite was clicked. Example: -- -- @ -- -- func _input(event): -- if event is InputEventMouseButton and event.pressed and event.button_index == BUTTON_LEFT: -- if get_rect().has_point(to_local(event.position)): -- print("A click!") -- -- @ bindSprite_get_rect :: MethodBind bindSprite_get_rect = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @Rect2@ representing the Sprite's boundary in local coordinates. Can be used to detect if the Sprite was clicked. Example: -- -- @ -- -- func _input(event): -- if event is InputEventMouseButton and event.pressed and event.button_index == BUTTON_LEFT: -- if get_rect().has_point(to_local(event.position)): -- print("A click!") -- -- @ get_rect :: (Sprite :< cls, Object :< cls) => cls -> IO Rect2 get_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Sprite.get_rect {-# NOINLINE bindSprite_get_region_rect #-} -- | The region of the atlas texture to display. @region_enabled@ must be @true@. bindSprite_get_region_rect :: MethodBind bindSprite_get_region_rect = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_region_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The region of the atlas texture to display. @region_enabled@ must be @true@. get_region_rect :: (Sprite :< cls, Object :< cls) => cls -> IO Rect2 get_region_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_region_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_region_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Sprite.get_region_rect {-# NOINLINE bindSprite_get_texture #-} -- | @Texture@ object to draw. bindSprite_get_texture :: MethodBind bindSprite_get_texture = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ object to draw. get_texture :: (Sprite :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.Sprite.get_texture {-# NOINLINE bindSprite_get_vframes #-} -- | The number of rows in the sprite sheet. bindSprite_get_vframes :: MethodBind bindSprite_get_vframes = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "get_vframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of rows in the sprite sheet. get_vframes :: (Sprite :< cls, Object :< cls) => cls -> IO Int get_vframes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_get_vframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "get_vframes" '[] (IO Int) where nodeMethod = Godot.Core.Sprite.get_vframes {-# NOINLINE bindSprite_is_centered #-} -- | If @true@, texture is centered. bindSprite_is_centered :: MethodBind bindSprite_is_centered = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "is_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is centered. is_centered :: (Sprite :< cls, Object :< cls) => cls -> IO Bool is_centered cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_is_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "is_centered" '[] (IO Bool) where nodeMethod = Godot.Core.Sprite.is_centered {-# NOINLINE bindSprite_is_flipped_h #-} -- | If @true@, texture is flipped horizontally. bindSprite_is_flipped_h :: MethodBind bindSprite_is_flipped_h = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "is_flipped_h" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped horizontally. is_flipped_h :: (Sprite :< cls, Object :< cls) => cls -> IO Bool is_flipped_h cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_is_flipped_h (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "is_flipped_h" '[] (IO Bool) where nodeMethod = Godot.Core.Sprite.is_flipped_h {-# NOINLINE bindSprite_is_flipped_v #-} -- | If @true@, texture is flipped vertically. bindSprite_is_flipped_v :: MethodBind bindSprite_is_flipped_v = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "is_flipped_v" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped vertically. is_flipped_v :: (Sprite :< cls, Object :< cls) => cls -> IO Bool is_flipped_v cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_is_flipped_v (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "is_flipped_v" '[] (IO Bool) where nodeMethod = Godot.Core.Sprite.is_flipped_v {-# NOINLINE bindSprite_is_pixel_opaque #-} -- | Returns @true@, if the pixel at the given position is opaque and @false@ in other case. -- __Note:__ It also returns @false@, if the sprite's texture is @null@ or if the given position is invalid. bindSprite_is_pixel_opaque :: MethodBind bindSprite_is_pixel_opaque = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "is_pixel_opaque" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@, if the pixel at the given position is opaque and @false@ in other case. -- __Note:__ It also returns @false@, if the sprite's texture is @null@ or if the given position is invalid. is_pixel_opaque :: (Sprite :< cls, Object :< cls) => cls -> Vector2 -> IO Bool is_pixel_opaque cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_is_pixel_opaque (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "is_pixel_opaque" '[Vector2] (IO Bool) where nodeMethod = Godot.Core.Sprite.is_pixel_opaque {-# NOINLINE bindSprite_is_region #-} -- | If @true@, texture is cut from a larger atlas texture. See @region_rect@. bindSprite_is_region :: MethodBind bindSprite_is_region = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "is_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is cut from a larger atlas texture. See @region_rect@. is_region :: (Sprite :< cls, Object :< cls) => cls -> IO Bool is_region cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_is_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "is_region" '[] (IO Bool) where nodeMethod = Godot.Core.Sprite.is_region {-# NOINLINE bindSprite_is_region_filter_clip_enabled #-} -- | If @true@, the outermost pixels get blurred out. bindSprite_is_region_filter_clip_enabled :: MethodBind bindSprite_is_region_filter_clip_enabled = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "is_region_filter_clip_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the outermost pixels get blurred out. is_region_filter_clip_enabled :: (Sprite :< cls, Object :< cls) => cls -> IO Bool is_region_filter_clip_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_is_region_filter_clip_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "is_region_filter_clip_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Sprite.is_region_filter_clip_enabled {-# NOINLINE bindSprite_set_centered #-} -- | If @true@, texture is centered. bindSprite_set_centered :: MethodBind bindSprite_set_centered = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is centered. set_centered :: (Sprite :< cls, Object :< cls) => cls -> Bool -> IO () set_centered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_centered" '[Bool] (IO ()) where nodeMethod = Godot.Core.Sprite.set_centered {-# NOINLINE bindSprite_set_flip_h #-} -- | If @true@, texture is flipped horizontally. bindSprite_set_flip_h :: MethodBind bindSprite_set_flip_h = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_flip_h" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped horizontally. set_flip_h :: (Sprite :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_h cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_flip_h (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_flip_h" '[Bool] (IO ()) where nodeMethod = Godot.Core.Sprite.set_flip_h {-# NOINLINE bindSprite_set_flip_v #-} -- | If @true@, texture is flipped vertically. bindSprite_set_flip_v :: MethodBind bindSprite_set_flip_v = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_flip_v" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped vertically. set_flip_v :: (Sprite :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_v cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_flip_v (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_flip_v" '[Bool] (IO ()) where nodeMethod = Godot.Core.Sprite.set_flip_v {-# NOINLINE bindSprite_set_frame #-} -- | Current frame to display from sprite sheet. @vframes@ or @hframes@ must be greater than 1. bindSprite_set_frame :: MethodBind bindSprite_set_frame = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Current frame to display from sprite sheet. @vframes@ or @hframes@ must be greater than 1. set_frame :: (Sprite :< cls, Object :< cls) => cls -> Int -> IO () set_frame cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_frame" '[Int] (IO ()) where nodeMethod = Godot.Core.Sprite.set_frame {-# NOINLINE bindSprite_set_frame_coords #-} -- | Coordinates of the frame to display from sprite sheet. This is as an alias for the @frame@ property. @vframes@ or @hframes@ must be greater than 1. bindSprite_set_frame_coords :: MethodBind bindSprite_set_frame_coords = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_frame_coords" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Coordinates of the frame to display from sprite sheet. This is as an alias for the @frame@ property. @vframes@ or @hframes@ must be greater than 1. set_frame_coords :: (Sprite :< cls, Object :< cls) => cls -> Vector2 -> IO () set_frame_coords cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_frame_coords (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_frame_coords" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Sprite.set_frame_coords {-# NOINLINE bindSprite_set_hframes #-} -- | The number of columns in the sprite sheet. bindSprite_set_hframes :: MethodBind bindSprite_set_hframes = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_hframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns in the sprite sheet. set_hframes :: (Sprite :< cls, Object :< cls) => cls -> Int -> IO () set_hframes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_hframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_hframes" '[Int] (IO ()) where nodeMethod = Godot.Core.Sprite.set_hframes {-# NOINLINE bindSprite_set_normal_map #-} -- | The normal map gives depth to the Sprite. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindSprite_set_normal_map :: MethodBind bindSprite_set_normal_map = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The normal map gives depth to the Sprite. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. set_normal_map :: (Sprite :< cls, Object :< cls) => cls -> Texture -> IO () set_normal_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_normal_map" '[Texture] (IO ()) where nodeMethod = Godot.Core.Sprite.set_normal_map {-# NOINLINE bindSprite_set_offset #-} -- | The texture's drawing offset. bindSprite_set_offset :: MethodBind bindSprite_set_offset = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's drawing offset. set_offset :: (Sprite :< cls, Object :< cls) => cls -> Vector2 -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Sprite.set_offset {-# NOINLINE bindSprite_set_region #-} -- | If @true@, texture is cut from a larger atlas texture. See @region_rect@. bindSprite_set_region :: MethodBind bindSprite_set_region = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is cut from a larger atlas texture. See @region_rect@. set_region :: (Sprite :< cls, Object :< cls) => cls -> Bool -> IO () set_region cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_region" '[Bool] (IO ()) where nodeMethod = Godot.Core.Sprite.set_region {-# NOINLINE bindSprite_set_region_filter_clip #-} -- | If @true@, the outermost pixels get blurred out. bindSprite_set_region_filter_clip :: MethodBind bindSprite_set_region_filter_clip = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_region_filter_clip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the outermost pixels get blurred out. set_region_filter_clip :: (Sprite :< cls, Object :< cls) => cls -> Bool -> IO () set_region_filter_clip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_region_filter_clip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_region_filter_clip" '[Bool] (IO ()) where nodeMethod = Godot.Core.Sprite.set_region_filter_clip {-# NOINLINE bindSprite_set_region_rect #-} -- | The region of the atlas texture to display. @region_enabled@ must be @true@. bindSprite_set_region_rect :: MethodBind bindSprite_set_region_rect = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_region_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The region of the atlas texture to display. @region_enabled@ must be @true@. set_region_rect :: (Sprite :< cls, Object :< cls) => cls -> Rect2 -> IO () set_region_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_region_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_region_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.Sprite.set_region_rect {-# NOINLINE bindSprite_set_texture #-} -- | @Texture@ object to draw. bindSprite_set_texture :: MethodBind bindSprite_set_texture = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ object to draw. set_texture :: (Sprite :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.Sprite.set_texture {-# NOINLINE bindSprite_set_vframes #-} -- | The number of rows in the sprite sheet. bindSprite_set_vframes :: MethodBind bindSprite_set_vframes = unsafePerformIO $ withCString "Sprite" $ \ clsNamePtr -> withCString "set_vframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of rows in the sprite sheet. set_vframes :: (Sprite :< cls, Object :< cls) => cls -> Int -> IO () set_vframes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite_set_vframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite "set_vframes" '[Int] (IO ()) where nodeMethod = Godot.Core.Sprite.set_vframes ================================================ FILE: src/Godot/Core/Sprite3D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Sprite3D (Godot.Core.Sprite3D.sig_frame_changed, Godot.Core.Sprite3D.get_frame, Godot.Core.Sprite3D.get_frame_coords, Godot.Core.Sprite3D.get_hframes, Godot.Core.Sprite3D.get_region_rect, Godot.Core.Sprite3D.get_texture, Godot.Core.Sprite3D.get_vframes, Godot.Core.Sprite3D.is_region, Godot.Core.Sprite3D.set_frame, Godot.Core.Sprite3D.set_frame_coords, Godot.Core.Sprite3D.set_hframes, Godot.Core.Sprite3D.set_region, Godot.Core.Sprite3D.set_region_rect, Godot.Core.Sprite3D.set_texture, Godot.Core.Sprite3D.set_vframes) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.SpriteBase3D() -- | Emitted when the @frame@ changes. sig_frame_changed :: Godot.Internal.Dispatch.Signal Sprite3D sig_frame_changed = Godot.Internal.Dispatch.Signal "frame_changed" instance NodeSignal Sprite3D "frame_changed" '[] instance NodeProperty Sprite3D "frame" Int 'False where nodeProperty = (get_frame, wrapDroppingSetter set_frame, Nothing) instance NodeProperty Sprite3D "frame_coords" Vector2 'False where nodeProperty = (get_frame_coords, wrapDroppingSetter set_frame_coords, Nothing) instance NodeProperty Sprite3D "hframes" Int 'False where nodeProperty = (get_hframes, wrapDroppingSetter set_hframes, Nothing) instance NodeProperty Sprite3D "region_enabled" Bool 'False where nodeProperty = (is_region, wrapDroppingSetter set_region, Nothing) instance NodeProperty Sprite3D "region_rect" Rect2 'False where nodeProperty = (get_region_rect, wrapDroppingSetter set_region_rect, Nothing) instance NodeProperty Sprite3D "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) instance NodeProperty Sprite3D "vframes" Int 'False where nodeProperty = (get_vframes, wrapDroppingSetter set_vframes, Nothing) {-# NOINLINE bindSprite3D_get_frame #-} -- | Current frame to display from sprite sheet. @vframes@ or @hframes@ must be greater than 1. bindSprite3D_get_frame :: MethodBind bindSprite3D_get_frame = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "get_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Current frame to display from sprite sheet. @vframes@ or @hframes@ must be greater than 1. get_frame :: (Sprite3D :< cls, Object :< cls) => cls -> IO Int get_frame cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_get_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "get_frame" '[] (IO Int) where nodeMethod = Godot.Core.Sprite3D.get_frame {-# NOINLINE bindSprite3D_get_frame_coords #-} -- | Coordinates of the frame to display from sprite sheet. This is as an alias for the @frame@ property. @vframes@ or @hframes@ must be greater than 1. bindSprite3D_get_frame_coords :: MethodBind bindSprite3D_get_frame_coords = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "get_frame_coords" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Coordinates of the frame to display from sprite sheet. This is as an alias for the @frame@ property. @vframes@ or @hframes@ must be greater than 1. get_frame_coords :: (Sprite3D :< cls, Object :< cls) => cls -> IO Vector2 get_frame_coords cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_get_frame_coords (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "get_frame_coords" '[] (IO Vector2) where nodeMethod = Godot.Core.Sprite3D.get_frame_coords {-# NOINLINE bindSprite3D_get_hframes #-} -- | The number of columns in the sprite sheet. bindSprite3D_get_hframes :: MethodBind bindSprite3D_get_hframes = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "get_hframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns in the sprite sheet. get_hframes :: (Sprite3D :< cls, Object :< cls) => cls -> IO Int get_hframes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_get_hframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "get_hframes" '[] (IO Int) where nodeMethod = Godot.Core.Sprite3D.get_hframes {-# NOINLINE bindSprite3D_get_region_rect #-} -- | The region of the atlas texture to display. @region_enabled@ must be @true@. bindSprite3D_get_region_rect :: MethodBind bindSprite3D_get_region_rect = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "get_region_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The region of the atlas texture to display. @region_enabled@ must be @true@. get_region_rect :: (Sprite3D :< cls, Object :< cls) => cls -> IO Rect2 get_region_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_get_region_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "get_region_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Sprite3D.get_region_rect {-# NOINLINE bindSprite3D_get_texture #-} -- | @Texture@ object to draw. If @GeometryInstance.material_override@ is used, this will be overridden. bindSprite3D_get_texture :: MethodBind bindSprite3D_get_texture = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ object to draw. If @GeometryInstance.material_override@ is used, this will be overridden. get_texture :: (Sprite3D :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.Sprite3D.get_texture {-# NOINLINE bindSprite3D_get_vframes #-} -- | The number of rows in the sprite sheet. bindSprite3D_get_vframes :: MethodBind bindSprite3D_get_vframes = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "get_vframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of rows in the sprite sheet. get_vframes :: (Sprite3D :< cls, Object :< cls) => cls -> IO Int get_vframes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_get_vframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "get_vframes" '[] (IO Int) where nodeMethod = Godot.Core.Sprite3D.get_vframes {-# NOINLINE bindSprite3D_is_region #-} -- | If @true@, texture will be cut from a larger atlas texture. See @region_rect@. bindSprite3D_is_region :: MethodBind bindSprite3D_is_region = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "is_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture will be cut from a larger atlas texture. See @region_rect@. is_region :: (Sprite3D :< cls, Object :< cls) => cls -> IO Bool is_region cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_is_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "is_region" '[] (IO Bool) where nodeMethod = Godot.Core.Sprite3D.is_region {-# NOINLINE bindSprite3D_set_frame #-} -- | Current frame to display from sprite sheet. @vframes@ or @hframes@ must be greater than 1. bindSprite3D_set_frame :: MethodBind bindSprite3D_set_frame = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "set_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Current frame to display from sprite sheet. @vframes@ or @hframes@ must be greater than 1. set_frame :: (Sprite3D :< cls, Object :< cls) => cls -> Int -> IO () set_frame cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_set_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "set_frame" '[Int] (IO ()) where nodeMethod = Godot.Core.Sprite3D.set_frame {-# NOINLINE bindSprite3D_set_frame_coords #-} -- | Coordinates of the frame to display from sprite sheet. This is as an alias for the @frame@ property. @vframes@ or @hframes@ must be greater than 1. bindSprite3D_set_frame_coords :: MethodBind bindSprite3D_set_frame_coords = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "set_frame_coords" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Coordinates of the frame to display from sprite sheet. This is as an alias for the @frame@ property. @vframes@ or @hframes@ must be greater than 1. set_frame_coords :: (Sprite3D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_frame_coords cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_set_frame_coords (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "set_frame_coords" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Sprite3D.set_frame_coords {-# NOINLINE bindSprite3D_set_hframes #-} -- | The number of columns in the sprite sheet. bindSprite3D_set_hframes :: MethodBind bindSprite3D_set_hframes = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "set_hframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns in the sprite sheet. set_hframes :: (Sprite3D :< cls, Object :< cls) => cls -> Int -> IO () set_hframes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_set_hframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "set_hframes" '[Int] (IO ()) where nodeMethod = Godot.Core.Sprite3D.set_hframes {-# NOINLINE bindSprite3D_set_region #-} -- | If @true@, texture will be cut from a larger atlas texture. See @region_rect@. bindSprite3D_set_region :: MethodBind bindSprite3D_set_region = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "set_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture will be cut from a larger atlas texture. See @region_rect@. set_region :: (Sprite3D :< cls, Object :< cls) => cls -> Bool -> IO () set_region cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_set_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "set_region" '[Bool] (IO ()) where nodeMethod = Godot.Core.Sprite3D.set_region {-# NOINLINE bindSprite3D_set_region_rect #-} -- | The region of the atlas texture to display. @region_enabled@ must be @true@. bindSprite3D_set_region_rect :: MethodBind bindSprite3D_set_region_rect = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "set_region_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The region of the atlas texture to display. @region_enabled@ must be @true@. set_region_rect :: (Sprite3D :< cls, Object :< cls) => cls -> Rect2 -> IO () set_region_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_set_region_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "set_region_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.Sprite3D.set_region_rect {-# NOINLINE bindSprite3D_set_texture #-} -- | @Texture@ object to draw. If @GeometryInstance.material_override@ is used, this will be overridden. bindSprite3D_set_texture :: MethodBind bindSprite3D_set_texture = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ object to draw. If @GeometryInstance.material_override@ is used, this will be overridden. set_texture :: (Sprite3D :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.Sprite3D.set_texture {-# NOINLINE bindSprite3D_set_vframes #-} -- | The number of rows in the sprite sheet. bindSprite3D_set_vframes :: MethodBind bindSprite3D_set_vframes = unsafePerformIO $ withCString "Sprite3D" $ \ clsNamePtr -> withCString "set_vframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of rows in the sprite sheet. set_vframes :: (Sprite3D :< cls, Object :< cls) => cls -> Int -> IO () set_vframes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSprite3D_set_vframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Sprite3D "set_vframes" '[Int] (IO ()) where nodeMethod = Godot.Core.Sprite3D.set_vframes ================================================ FILE: src/Godot/Core/SpriteBase3D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SpriteBase3D (Godot.Core.SpriteBase3D._FLAG_SHADED, Godot.Core.SpriteBase3D._ALPHA_CUT_OPAQUE_PREPASS, Godot.Core.SpriteBase3D._FLAG_DOUBLE_SIDED, Godot.Core.SpriteBase3D._ALPHA_CUT_DISABLED, Godot.Core.SpriteBase3D._ALPHA_CUT_DISCARD, Godot.Core.SpriteBase3D._FLAG_MAX, Godot.Core.SpriteBase3D._FLAG_TRANSPARENT, Godot.Core.SpriteBase3D._im_update, Godot.Core.SpriteBase3D._queue_update, Godot.Core.SpriteBase3D.generate_triangle_mesh, Godot.Core.SpriteBase3D.get_alpha_cut_mode, Godot.Core.SpriteBase3D.get_axis, Godot.Core.SpriteBase3D.get_billboard_mode, Godot.Core.SpriteBase3D.get_draw_flag, Godot.Core.SpriteBase3D.get_item_rect, Godot.Core.SpriteBase3D.get_modulate, Godot.Core.SpriteBase3D.get_offset, Godot.Core.SpriteBase3D.get_opacity, Godot.Core.SpriteBase3D.get_pixel_size, Godot.Core.SpriteBase3D.is_centered, Godot.Core.SpriteBase3D.is_flipped_h, Godot.Core.SpriteBase3D.is_flipped_v, Godot.Core.SpriteBase3D.set_alpha_cut_mode, Godot.Core.SpriteBase3D.set_axis, Godot.Core.SpriteBase3D.set_billboard_mode, Godot.Core.SpriteBase3D.set_centered, Godot.Core.SpriteBase3D.set_draw_flag, Godot.Core.SpriteBase3D.set_flip_h, Godot.Core.SpriteBase3D.set_flip_v, Godot.Core.SpriteBase3D.set_modulate, Godot.Core.SpriteBase3D.set_offset, Godot.Core.SpriteBase3D.set_opacity, Godot.Core.SpriteBase3D.set_pixel_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.GeometryInstance() _FLAG_SHADED :: Int _FLAG_SHADED = 1 _ALPHA_CUT_OPAQUE_PREPASS :: Int _ALPHA_CUT_OPAQUE_PREPASS = 2 _FLAG_DOUBLE_SIDED :: Int _FLAG_DOUBLE_SIDED = 2 _ALPHA_CUT_DISABLED :: Int _ALPHA_CUT_DISABLED = 0 _ALPHA_CUT_DISCARD :: Int _ALPHA_CUT_DISCARD = 1 _FLAG_MAX :: Int _FLAG_MAX = 3 _FLAG_TRANSPARENT :: Int _FLAG_TRANSPARENT = 0 instance NodeProperty SpriteBase3D "alpha_cut" Int 'False where nodeProperty = (get_alpha_cut_mode, wrapDroppingSetter set_alpha_cut_mode, Nothing) instance NodeProperty SpriteBase3D "axis" Int 'False where nodeProperty = (get_axis, wrapDroppingSetter set_axis, Nothing) instance NodeProperty SpriteBase3D "billboard" Int 'False where nodeProperty = (get_billboard_mode, wrapDroppingSetter set_billboard_mode, Nothing) instance NodeProperty SpriteBase3D "centered" Bool 'False where nodeProperty = (is_centered, wrapDroppingSetter set_centered, Nothing) instance NodeProperty SpriteBase3D "double_sided" Bool 'False where nodeProperty = (wrapIndexedGetter 2 get_draw_flag, wrapIndexedSetter 2 set_draw_flag, Nothing) instance NodeProperty SpriteBase3D "flip_h" Bool 'False where nodeProperty = (is_flipped_h, wrapDroppingSetter set_flip_h, Nothing) instance NodeProperty SpriteBase3D "flip_v" Bool 'False where nodeProperty = (is_flipped_v, wrapDroppingSetter set_flip_v, Nothing) instance NodeProperty SpriteBase3D "modulate" Color 'False where nodeProperty = (get_modulate, wrapDroppingSetter set_modulate, Nothing) instance NodeProperty SpriteBase3D "offset" Vector2 'False where nodeProperty = (get_offset, wrapDroppingSetter set_offset, Nothing) instance NodeProperty SpriteBase3D "opacity" Float 'False where nodeProperty = (get_opacity, wrapDroppingSetter set_opacity, Nothing) instance NodeProperty SpriteBase3D "pixel_size" Float 'False where nodeProperty = (get_pixel_size, wrapDroppingSetter set_pixel_size, Nothing) instance NodeProperty SpriteBase3D "shaded" Bool 'False where nodeProperty = (wrapIndexedGetter 1 get_draw_flag, wrapIndexedSetter 1 set_draw_flag, Nothing) instance NodeProperty SpriteBase3D "transparent" Bool 'False where nodeProperty = (wrapIndexedGetter 0 get_draw_flag, wrapIndexedSetter 0 set_draw_flag, Nothing) {-# NOINLINE bindSpriteBase3D__im_update #-} bindSpriteBase3D__im_update :: MethodBind bindSpriteBase3D__im_update = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "_im_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _im_update :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO () _im_update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D__im_update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "_im_update" '[] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D._im_update {-# NOINLINE bindSpriteBase3D__queue_update #-} bindSpriteBase3D__queue_update :: MethodBind bindSpriteBase3D__queue_update = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "_queue_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _queue_update :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO () _queue_update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D__queue_update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "_queue_update" '[] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D._queue_update {-# NOINLINE bindSpriteBase3D_generate_triangle_mesh #-} bindSpriteBase3D_generate_triangle_mesh :: MethodBind bindSpriteBase3D_generate_triangle_mesh = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "generate_triangle_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr generate_triangle_mesh :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO TriangleMesh generate_triangle_mesh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_generate_triangle_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "generate_triangle_mesh" '[] (IO TriangleMesh) where nodeMethod = Godot.Core.SpriteBase3D.generate_triangle_mesh {-# NOINLINE bindSpriteBase3D_get_alpha_cut_mode #-} bindSpriteBase3D_get_alpha_cut_mode :: MethodBind bindSpriteBase3D_get_alpha_cut_mode = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_alpha_cut_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_alpha_cut_mode :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Int get_alpha_cut_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_alpha_cut_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_alpha_cut_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpriteBase3D.get_alpha_cut_mode {-# NOINLINE bindSpriteBase3D_get_axis #-} -- | The direction in which the front of the texture faces. bindSpriteBase3D_get_axis :: MethodBind bindSpriteBase3D_get_axis = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_axis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The direction in which the front of the texture faces. get_axis :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Int get_axis cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_axis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_axis" '[] (IO Int) where nodeMethod = Godot.Core.SpriteBase3D.get_axis {-# NOINLINE bindSpriteBase3D_get_billboard_mode #-} bindSpriteBase3D_get_billboard_mode :: MethodBind bindSpriteBase3D_get_billboard_mode = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_billboard_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_billboard_mode :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Int get_billboard_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_billboard_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_billboard_mode" '[] (IO Int) where nodeMethod = Godot.Core.SpriteBase3D.get_billboard_mode {-# NOINLINE bindSpriteBase3D_get_draw_flag #-} -- | Returns the value of the specified flag. bindSpriteBase3D_get_draw_flag :: MethodBind bindSpriteBase3D_get_draw_flag = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_draw_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the specified flag. get_draw_flag :: (SpriteBase3D :< cls, Object :< cls) => cls -> Int -> IO Bool get_draw_flag cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_draw_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_draw_flag" '[Int] (IO Bool) where nodeMethod = Godot.Core.SpriteBase3D.get_draw_flag {-# NOINLINE bindSpriteBase3D_get_item_rect #-} -- | Returns the rectangle representing this sprite. bindSpriteBase3D_get_item_rect :: MethodBind bindSpriteBase3D_get_item_rect = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_item_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the rectangle representing this sprite. get_item_rect :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Rect2 get_item_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_item_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_item_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.SpriteBase3D.get_item_rect {-# NOINLINE bindSpriteBase3D_get_modulate #-} -- | A color value that gets multiplied on, could be used for mood-coloring or to simulate the color of light. bindSpriteBase3D_get_modulate :: MethodBind bindSpriteBase3D_get_modulate = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A color value that gets multiplied on, could be used for mood-coloring or to simulate the color of light. get_modulate :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Color get_modulate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_modulate" '[] (IO Color) where nodeMethod = Godot.Core.SpriteBase3D.get_modulate {-# NOINLINE bindSpriteBase3D_get_offset #-} -- | The texture's drawing offset. bindSpriteBase3D_get_offset :: MethodBind bindSpriteBase3D_get_offset = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's drawing offset. get_offset :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.SpriteBase3D.get_offset {-# NOINLINE bindSpriteBase3D_get_opacity #-} -- | The objects visibility on a scale from @0@ fully invisible to @1@ fully visible. bindSpriteBase3D_get_opacity :: MethodBind bindSpriteBase3D_get_opacity = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_opacity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The objects visibility on a scale from @0@ fully invisible to @1@ fully visible. get_opacity :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Float get_opacity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_opacity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_opacity" '[] (IO Float) where nodeMethod = Godot.Core.SpriteBase3D.get_opacity {-# NOINLINE bindSpriteBase3D_get_pixel_size #-} -- | The size of one pixel's width on the sprite to scale it in 3D. bindSpriteBase3D_get_pixel_size :: MethodBind bindSpriteBase3D_get_pixel_size = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "get_pixel_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of one pixel's width on the sprite to scale it in 3D. get_pixel_size :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Float get_pixel_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_get_pixel_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "get_pixel_size" '[] (IO Float) where nodeMethod = Godot.Core.SpriteBase3D.get_pixel_size {-# NOINLINE bindSpriteBase3D_is_centered #-} -- | If @true@, texture will be centered. bindSpriteBase3D_is_centered :: MethodBind bindSpriteBase3D_is_centered = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "is_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture will be centered. is_centered :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Bool is_centered cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_is_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "is_centered" '[] (IO Bool) where nodeMethod = Godot.Core.SpriteBase3D.is_centered {-# NOINLINE bindSpriteBase3D_is_flipped_h #-} -- | If @true@, texture is flipped horizontally. bindSpriteBase3D_is_flipped_h :: MethodBind bindSpriteBase3D_is_flipped_h = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "is_flipped_h" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped horizontally. is_flipped_h :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Bool is_flipped_h cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_is_flipped_h (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "is_flipped_h" '[] (IO Bool) where nodeMethod = Godot.Core.SpriteBase3D.is_flipped_h {-# NOINLINE bindSpriteBase3D_is_flipped_v #-} -- | If @true@, texture is flipped vertically. bindSpriteBase3D_is_flipped_v :: MethodBind bindSpriteBase3D_is_flipped_v = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "is_flipped_v" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped vertically. is_flipped_v :: (SpriteBase3D :< cls, Object :< cls) => cls -> IO Bool is_flipped_v cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_is_flipped_v (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "is_flipped_v" '[] (IO Bool) where nodeMethod = Godot.Core.SpriteBase3D.is_flipped_v {-# NOINLINE bindSpriteBase3D_set_alpha_cut_mode #-} bindSpriteBase3D_set_alpha_cut_mode :: MethodBind bindSpriteBase3D_set_alpha_cut_mode = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_alpha_cut_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_alpha_cut_mode :: (SpriteBase3D :< cls, Object :< cls) => cls -> Int -> IO () set_alpha_cut_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_alpha_cut_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_alpha_cut_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_alpha_cut_mode {-# NOINLINE bindSpriteBase3D_set_axis #-} -- | The direction in which the front of the texture faces. bindSpriteBase3D_set_axis :: MethodBind bindSpriteBase3D_set_axis = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_axis" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The direction in which the front of the texture faces. set_axis :: (SpriteBase3D :< cls, Object :< cls) => cls -> Int -> IO () set_axis cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_axis (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_axis" '[Int] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_axis {-# NOINLINE bindSpriteBase3D_set_billboard_mode #-} bindSpriteBase3D_set_billboard_mode :: MethodBind bindSpriteBase3D_set_billboard_mode = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_billboard_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_billboard_mode :: (SpriteBase3D :< cls, Object :< cls) => cls -> Int -> IO () set_billboard_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_billboard_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_billboard_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_billboard_mode {-# NOINLINE bindSpriteBase3D_set_centered #-} -- | If @true@, texture will be centered. bindSpriteBase3D_set_centered :: MethodBind bindSpriteBase3D_set_centered = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture will be centered. set_centered :: (SpriteBase3D :< cls, Object :< cls) => cls -> Bool -> IO () set_centered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_centered" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_centered {-# NOINLINE bindSpriteBase3D_set_draw_flag #-} -- | If @true@, the specified flag will be enabled. bindSpriteBase3D_set_draw_flag :: MethodBind bindSpriteBase3D_set_draw_flag = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_draw_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the specified flag will be enabled. set_draw_flag :: (SpriteBase3D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_draw_flag cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_draw_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_draw_flag" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_draw_flag {-# NOINLINE bindSpriteBase3D_set_flip_h #-} -- | If @true@, texture is flipped horizontally. bindSpriteBase3D_set_flip_h :: MethodBind bindSpriteBase3D_set_flip_h = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_flip_h" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped horizontally. set_flip_h :: (SpriteBase3D :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_h cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_flip_h (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_flip_h" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_flip_h {-# NOINLINE bindSpriteBase3D_set_flip_v #-} -- | If @true@, texture is flipped vertically. bindSpriteBase3D_set_flip_v :: MethodBind bindSpriteBase3D_set_flip_v = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_flip_v" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped vertically. set_flip_v :: (SpriteBase3D :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_v cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_flip_v (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_flip_v" '[Bool] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_flip_v {-# NOINLINE bindSpriteBase3D_set_modulate #-} -- | A color value that gets multiplied on, could be used for mood-coloring or to simulate the color of light. bindSpriteBase3D_set_modulate :: MethodBind bindSpriteBase3D_set_modulate = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A color value that gets multiplied on, could be used for mood-coloring or to simulate the color of light. set_modulate :: (SpriteBase3D :< cls, Object :< cls) => cls -> Color -> IO () set_modulate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_modulate" '[Color] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_modulate {-# NOINLINE bindSpriteBase3D_set_offset #-} -- | The texture's drawing offset. bindSpriteBase3D_set_offset :: MethodBind bindSpriteBase3D_set_offset = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's drawing offset. set_offset :: (SpriteBase3D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_offset {-# NOINLINE bindSpriteBase3D_set_opacity #-} -- | The objects visibility on a scale from @0@ fully invisible to @1@ fully visible. bindSpriteBase3D_set_opacity :: MethodBind bindSpriteBase3D_set_opacity = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_opacity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The objects visibility on a scale from @0@ fully invisible to @1@ fully visible. set_opacity :: (SpriteBase3D :< cls, Object :< cls) => cls -> Float -> IO () set_opacity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_opacity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_opacity" '[Float] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_opacity {-# NOINLINE bindSpriteBase3D_set_pixel_size #-} -- | The size of one pixel's width on the sprite to scale it in 3D. bindSpriteBase3D_set_pixel_size :: MethodBind bindSpriteBase3D_set_pixel_size = unsafePerformIO $ withCString "SpriteBase3D" $ \ clsNamePtr -> withCString "set_pixel_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of one pixel's width on the sprite to scale it in 3D. set_pixel_size :: (SpriteBase3D :< cls, Object :< cls) => cls -> Float -> IO () set_pixel_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteBase3D_set_pixel_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteBase3D "set_pixel_size" '[Float] (IO ()) where nodeMethod = Godot.Core.SpriteBase3D.set_pixel_size ================================================ FILE: src/Godot/Core/SpriteFrames.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SpriteFrames (Godot.Core.SpriteFrames._get_animations, Godot.Core.SpriteFrames._get_frames, Godot.Core.SpriteFrames._set_animations, Godot.Core.SpriteFrames._set_frames, Godot.Core.SpriteFrames.add_animation, Godot.Core.SpriteFrames.add_frame, Godot.Core.SpriteFrames.clear, Godot.Core.SpriteFrames.clear_all, Godot.Core.SpriteFrames.get_animation_loop, Godot.Core.SpriteFrames.get_animation_names, Godot.Core.SpriteFrames.get_animation_speed, Godot.Core.SpriteFrames.get_frame, Godot.Core.SpriteFrames.get_frame_count, Godot.Core.SpriteFrames.has_animation, Godot.Core.SpriteFrames.remove_animation, Godot.Core.SpriteFrames.remove_frame, Godot.Core.SpriteFrames.rename_animation, Godot.Core.SpriteFrames.set_animation_loop, Godot.Core.SpriteFrames.set_animation_speed, Godot.Core.SpriteFrames.set_frame) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty SpriteFrames "animations" Array 'False where nodeProperty = (_get_animations, wrapDroppingSetter _set_animations, Nothing) instance NodeProperty SpriteFrames "frames" Array 'False where nodeProperty = (_get_frames, wrapDroppingSetter _set_frames, Nothing) {-# NOINLINE bindSpriteFrames__get_animations #-} bindSpriteFrames__get_animations :: MethodBind bindSpriteFrames__get_animations = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "_get_animations" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_animations :: (SpriteFrames :< cls, Object :< cls) => cls -> IO Array _get_animations cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames__get_animations (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "_get_animations" '[] (IO Array) where nodeMethod = Godot.Core.SpriteFrames._get_animations {-# NOINLINE bindSpriteFrames__get_frames #-} -- | Compatibility property, always equals to an empty array. bindSpriteFrames__get_frames :: MethodBind bindSpriteFrames__get_frames = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "_get_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Compatibility property, always equals to an empty array. _get_frames :: (SpriteFrames :< cls, Object :< cls) => cls -> IO Array _get_frames cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames__get_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "_get_frames" '[] (IO Array) where nodeMethod = Godot.Core.SpriteFrames._get_frames {-# NOINLINE bindSpriteFrames__set_animations #-} bindSpriteFrames__set_animations :: MethodBind bindSpriteFrames__set_animations = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "_set_animations" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_animations :: (SpriteFrames :< cls, Object :< cls) => cls -> Array -> IO () _set_animations cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames__set_animations (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "_set_animations" '[Array] (IO ()) where nodeMethod = Godot.Core.SpriteFrames._set_animations {-# NOINLINE bindSpriteFrames__set_frames #-} -- | Compatibility property, always equals to an empty array. bindSpriteFrames__set_frames :: MethodBind bindSpriteFrames__set_frames = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "_set_frames" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Compatibility property, always equals to an empty array. _set_frames :: (SpriteFrames :< cls, Object :< cls) => cls -> Array -> IO () _set_frames cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames__set_frames (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "_set_frames" '[Array] (IO ()) where nodeMethod = Godot.Core.SpriteFrames._set_frames {-# NOINLINE bindSpriteFrames_add_animation #-} -- | Adds a new animation to the library. bindSpriteFrames_add_animation :: MethodBind bindSpriteFrames_add_animation = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "add_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new animation to the library. add_animation :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> IO () add_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_add_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "add_animation" '[GodotString] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.add_animation {-# NOINLINE bindSpriteFrames_add_frame #-} -- | Adds a frame to the given animation. bindSpriteFrames_add_frame :: MethodBind bindSpriteFrames_add_frame = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "add_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a frame to the given animation. add_frame :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> Texture -> Maybe Int -> IO () add_frame cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_add_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "add_frame" '[GodotString, Texture, Maybe Int] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.add_frame {-# NOINLINE bindSpriteFrames_clear #-} -- | Removes all frames from the given animation. bindSpriteFrames_clear :: MethodBind bindSpriteFrames_clear = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all frames from the given animation. clear :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> IO () clear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "clear" '[GodotString] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.clear {-# NOINLINE bindSpriteFrames_clear_all #-} -- | Removes all animations. A "default" animation will be created. bindSpriteFrames_clear_all :: MethodBind bindSpriteFrames_clear_all = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "clear_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all animations. A "default" animation will be created. clear_all :: (SpriteFrames :< cls, Object :< cls) => cls -> IO () clear_all cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_clear_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "clear_all" '[] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.clear_all {-# NOINLINE bindSpriteFrames_get_animation_loop #-} -- | If @true@, the given animation will loop. bindSpriteFrames_get_animation_loop :: MethodBind bindSpriteFrames_get_animation_loop = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "get_animation_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the given animation will loop. get_animation_loop :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> IO Bool get_animation_loop cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_get_animation_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "get_animation_loop" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.SpriteFrames.get_animation_loop {-# NOINLINE bindSpriteFrames_get_animation_names #-} -- | Returns an array containing the names associated to each animation. Values are placed in alphabetical order. bindSpriteFrames_get_animation_names :: MethodBind bindSpriteFrames_get_animation_names = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "get_animation_names" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array containing the names associated to each animation. Values are placed in alphabetical order. get_animation_names :: (SpriteFrames :< cls, Object :< cls) => cls -> IO PoolStringArray get_animation_names cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_get_animation_names (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "get_animation_names" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.SpriteFrames.get_animation_names {-# NOINLINE bindSpriteFrames_get_animation_speed #-} -- | The animation's speed in frames per second. bindSpriteFrames_get_animation_speed :: MethodBind bindSpriteFrames_get_animation_speed = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "get_animation_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The animation's speed in frames per second. get_animation_speed :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> IO Float get_animation_speed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_get_animation_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "get_animation_speed" '[GodotString] (IO Float) where nodeMethod = Godot.Core.SpriteFrames.get_animation_speed {-# NOINLINE bindSpriteFrames_get_frame #-} -- | Returns the animation's selected frame. bindSpriteFrames_get_frame :: MethodBind bindSpriteFrames_get_frame = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "get_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the animation's selected frame. get_frame :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> Int -> IO Texture get_frame cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_get_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "get_frame" '[GodotString, Int] (IO Texture) where nodeMethod = Godot.Core.SpriteFrames.get_frame {-# NOINLINE bindSpriteFrames_get_frame_count #-} -- | Returns the number of frames in the animation. bindSpriteFrames_get_frame_count :: MethodBind bindSpriteFrames_get_frame_count = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "get_frame_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of frames in the animation. get_frame_count :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> IO Int get_frame_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_get_frame_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "get_frame_count" '[GodotString] (IO Int) where nodeMethod = Godot.Core.SpriteFrames.get_frame_count {-# NOINLINE bindSpriteFrames_has_animation #-} -- | If @true@, the named animation exists. bindSpriteFrames_has_animation :: MethodBind bindSpriteFrames_has_animation = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "has_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the named animation exists. has_animation :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_has_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "has_animation" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.SpriteFrames.has_animation {-# NOINLINE bindSpriteFrames_remove_animation #-} -- | Removes the given animation. bindSpriteFrames_remove_animation :: MethodBind bindSpriteFrames_remove_animation = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "remove_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the given animation. remove_animation :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> IO () remove_animation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_remove_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "remove_animation" '[GodotString] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.remove_animation {-# NOINLINE bindSpriteFrames_remove_frame #-} -- | Removes the animation's selected frame. bindSpriteFrames_remove_frame :: MethodBind bindSpriteFrames_remove_frame = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "remove_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the animation's selected frame. remove_frame :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () remove_frame cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_remove_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "remove_frame" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.remove_frame {-# NOINLINE bindSpriteFrames_rename_animation #-} -- | Changes the animation's name to @newname@. bindSpriteFrames_rename_animation :: MethodBind bindSpriteFrames_rename_animation = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "rename_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Changes the animation's name to @newname@. rename_animation :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_animation cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_rename_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "rename_animation" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.rename_animation {-# NOINLINE bindSpriteFrames_set_animation_loop #-} -- | If @true@, the animation will loop. bindSpriteFrames_set_animation_loop :: MethodBind bindSpriteFrames_set_animation_loop = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "set_animation_loop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the animation will loop. set_animation_loop :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> Bool -> IO () set_animation_loop cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_set_animation_loop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "set_animation_loop" '[GodotString, Bool] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.set_animation_loop {-# NOINLINE bindSpriteFrames_set_animation_speed #-} -- | The animation's speed in frames per second. bindSpriteFrames_set_animation_speed :: MethodBind bindSpriteFrames_set_animation_speed = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "set_animation_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The animation's speed in frames per second. set_animation_speed :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> Float -> IO () set_animation_speed cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_set_animation_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "set_animation_speed" '[GodotString, Float] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.set_animation_speed {-# NOINLINE bindSpriteFrames_set_frame #-} -- | Sets the texture of the given frame. bindSpriteFrames_set_frame :: MethodBind bindSpriteFrames_set_frame = unsafePerformIO $ withCString "SpriteFrames" $ \ clsNamePtr -> withCString "set_frame" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the texture of the given frame. set_frame :: (SpriteFrames :< cls, Object :< cls) => cls -> GodotString -> Int -> Texture -> IO () set_frame cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindSpriteFrames_set_frame (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SpriteFrames "set_frame" '[GodotString, Int, Texture] (IO ()) where nodeMethod = Godot.Core.SpriteFrames.set_frame ================================================ FILE: src/Godot/Core/StaticBody.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StaticBody (Godot.Core.StaticBody._reload_physics_characteristics, Godot.Core.StaticBody.get_bounce, Godot.Core.StaticBody.get_constant_angular_velocity, Godot.Core.StaticBody.get_constant_linear_velocity, Godot.Core.StaticBody.get_friction, Godot.Core.StaticBody.get_physics_material_override, Godot.Core.StaticBody.set_bounce, Godot.Core.StaticBody.set_constant_angular_velocity, Godot.Core.StaticBody.set_constant_linear_velocity, Godot.Core.StaticBody.set_friction, Godot.Core.StaticBody.set_physics_material_override) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsBody() instance NodeProperty StaticBody "bounce" Float 'False where nodeProperty = (get_bounce, wrapDroppingSetter set_bounce, Nothing) instance NodeProperty StaticBody "constant_angular_velocity" Vector3 'False where nodeProperty = (get_constant_angular_velocity, wrapDroppingSetter set_constant_angular_velocity, Nothing) instance NodeProperty StaticBody "constant_linear_velocity" Vector3 'False where nodeProperty = (get_constant_linear_velocity, wrapDroppingSetter set_constant_linear_velocity, Nothing) instance NodeProperty StaticBody "friction" Float 'False where nodeProperty = (get_friction, wrapDroppingSetter set_friction, Nothing) instance NodeProperty StaticBody "physics_material_override" PhysicsMaterial 'False where nodeProperty = (get_physics_material_override, wrapDroppingSetter set_physics_material_override, Nothing) {-# NOINLINE bindStaticBody__reload_physics_characteristics #-} bindStaticBody__reload_physics_characteristics :: MethodBind bindStaticBody__reload_physics_characteristics = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "_reload_physics_characteristics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _reload_physics_characteristics :: (StaticBody :< cls, Object :< cls) => cls -> IO () _reload_physics_characteristics cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody__reload_physics_characteristics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "_reload_physics_characteristics" '[] (IO ()) where nodeMethod = Godot.Core.StaticBody._reload_physics_characteristics {-# NOINLINE bindStaticBody_get_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. bindStaticBody_get_bounce :: MethodBind bindStaticBody_get_bounce = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "get_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. get_bounce :: (StaticBody :< cls, Object :< cls) => cls -> IO Float get_bounce cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_get_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "get_bounce" '[] (IO Float) where nodeMethod = Godot.Core.StaticBody.get_bounce {-# NOINLINE bindStaticBody_get_constant_angular_velocity #-} -- | The body's constant angular velocity. This does not rotate the body, but affects other bodies that touch it, as if it was in a state of rotation. bindStaticBody_get_constant_angular_velocity :: MethodBind bindStaticBody_get_constant_angular_velocity = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "get_constant_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's constant angular velocity. This does not rotate the body, but affects other bodies that touch it, as if it was in a state of rotation. get_constant_angular_velocity :: (StaticBody :< cls, Object :< cls) => cls -> IO Vector3 get_constant_angular_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_get_constant_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "get_constant_angular_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.StaticBody.get_constant_angular_velocity {-# NOINLINE bindStaticBody_get_constant_linear_velocity #-} -- | The body's constant linear velocity. This does not move the body, but affects other bodies that touch it, as if it was in a state of movement. bindStaticBody_get_constant_linear_velocity :: MethodBind bindStaticBody_get_constant_linear_velocity = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "get_constant_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's constant linear velocity. This does not move the body, but affects other bodies that touch it, as if it was in a state of movement. get_constant_linear_velocity :: (StaticBody :< cls, Object :< cls) => cls -> IO Vector3 get_constant_linear_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_get_constant_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "get_constant_linear_velocity" '[] (IO Vector3) where nodeMethod = Godot.Core.StaticBody.get_constant_linear_velocity {-# NOINLINE bindStaticBody_get_friction #-} -- | The body's friction, from 0 (frictionless) to 1 (full friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. bindStaticBody_get_friction :: MethodBind bindStaticBody_get_friction = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "get_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction, from 0 (frictionless) to 1 (full friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. get_friction :: (StaticBody :< cls, Object :< cls) => cls -> IO Float get_friction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_get_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "get_friction" '[] (IO Float) where nodeMethod = Godot.Core.StaticBody.get_friction {-# NOINLINE bindStaticBody_get_physics_material_override #-} -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. bindStaticBody_get_physics_material_override :: MethodBind bindStaticBody_get_physics_material_override = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "get_physics_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. get_physics_material_override :: (StaticBody :< cls, Object :< cls) => cls -> IO PhysicsMaterial get_physics_material_override cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_get_physics_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "get_physics_material_override" '[] (IO PhysicsMaterial) where nodeMethod = Godot.Core.StaticBody.get_physics_material_override {-# NOINLINE bindStaticBody_set_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. bindStaticBody_set_bounce :: MethodBind bindStaticBody_set_bounce = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "set_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. set_bounce :: (StaticBody :< cls, Object :< cls) => cls -> Float -> IO () set_bounce cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_set_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "set_bounce" '[Float] (IO ()) where nodeMethod = Godot.Core.StaticBody.set_bounce {-# NOINLINE bindStaticBody_set_constant_angular_velocity #-} -- | The body's constant angular velocity. This does not rotate the body, but affects other bodies that touch it, as if it was in a state of rotation. bindStaticBody_set_constant_angular_velocity :: MethodBind bindStaticBody_set_constant_angular_velocity = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "set_constant_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's constant angular velocity. This does not rotate the body, but affects other bodies that touch it, as if it was in a state of rotation. set_constant_angular_velocity :: (StaticBody :< cls, Object :< cls) => cls -> Vector3 -> IO () set_constant_angular_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_set_constant_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "set_constant_angular_velocity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.StaticBody.set_constant_angular_velocity {-# NOINLINE bindStaticBody_set_constant_linear_velocity #-} -- | The body's constant linear velocity. This does not move the body, but affects other bodies that touch it, as if it was in a state of movement. bindStaticBody_set_constant_linear_velocity :: MethodBind bindStaticBody_set_constant_linear_velocity = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "set_constant_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's constant linear velocity. This does not move the body, but affects other bodies that touch it, as if it was in a state of movement. set_constant_linear_velocity :: (StaticBody :< cls, Object :< cls) => cls -> Vector3 -> IO () set_constant_linear_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_set_constant_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "set_constant_linear_velocity" '[Vector3] (IO ()) where nodeMethod = Godot.Core.StaticBody.set_constant_linear_velocity {-# NOINLINE bindStaticBody_set_friction #-} -- | The body's friction, from 0 (frictionless) to 1 (full friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. bindStaticBody_set_friction :: MethodBind bindStaticBody_set_friction = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "set_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction, from 0 (frictionless) to 1 (full friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. set_friction :: (StaticBody :< cls, Object :< cls) => cls -> Float -> IO () set_friction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_set_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "set_friction" '[Float] (IO ()) where nodeMethod = Godot.Core.StaticBody.set_friction {-# NOINLINE bindStaticBody_set_physics_material_override #-} -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. bindStaticBody_set_physics_material_override :: MethodBind bindStaticBody_set_physics_material_override = unsafePerformIO $ withCString "StaticBody" $ \ clsNamePtr -> withCString "set_physics_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. set_physics_material_override :: (StaticBody :< cls, Object :< cls) => cls -> PhysicsMaterial -> IO () set_physics_material_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody_set_physics_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody "set_physics_material_override" '[PhysicsMaterial] (IO ()) where nodeMethod = Godot.Core.StaticBody.set_physics_material_override ================================================ FILE: src/Godot/Core/StaticBody2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StaticBody2D (Godot.Core.StaticBody2D._reload_physics_characteristics, Godot.Core.StaticBody2D.get_bounce, Godot.Core.StaticBody2D.get_constant_angular_velocity, Godot.Core.StaticBody2D.get_constant_linear_velocity, Godot.Core.StaticBody2D.get_friction, Godot.Core.StaticBody2D.get_physics_material_override, Godot.Core.StaticBody2D.set_bounce, Godot.Core.StaticBody2D.set_constant_angular_velocity, Godot.Core.StaticBody2D.set_constant_linear_velocity, Godot.Core.StaticBody2D.set_friction, Godot.Core.StaticBody2D.set_physics_material_override) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PhysicsBody2D() instance NodeProperty StaticBody2D "bounce" Float 'False where nodeProperty = (get_bounce, wrapDroppingSetter set_bounce, Nothing) instance NodeProperty StaticBody2D "constant_angular_velocity" Float 'False where nodeProperty = (get_constant_angular_velocity, wrapDroppingSetter set_constant_angular_velocity, Nothing) instance NodeProperty StaticBody2D "constant_linear_velocity" Vector2 'False where nodeProperty = (get_constant_linear_velocity, wrapDroppingSetter set_constant_linear_velocity, Nothing) instance NodeProperty StaticBody2D "friction" Float 'False where nodeProperty = (get_friction, wrapDroppingSetter set_friction, Nothing) instance NodeProperty StaticBody2D "physics_material_override" PhysicsMaterial 'False where nodeProperty = (get_physics_material_override, wrapDroppingSetter set_physics_material_override, Nothing) {-# NOINLINE bindStaticBody2D__reload_physics_characteristics #-} bindStaticBody2D__reload_physics_characteristics :: MethodBind bindStaticBody2D__reload_physics_characteristics = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "_reload_physics_characteristics" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _reload_physics_characteristics :: (StaticBody2D :< cls, Object :< cls) => cls -> IO () _reload_physics_characteristics cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D__reload_physics_characteristics (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "_reload_physics_characteristics" '[] (IO ()) where nodeMethod = Godot.Core.StaticBody2D._reload_physics_characteristics {-# NOINLINE bindStaticBody2D_get_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. bindStaticBody2D_get_bounce :: MethodBind bindStaticBody2D_get_bounce = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "get_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. get_bounce :: (StaticBody2D :< cls, Object :< cls) => cls -> IO Float get_bounce cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_get_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "get_bounce" '[] (IO Float) where nodeMethod = Godot.Core.StaticBody2D.get_bounce {-# NOINLINE bindStaticBody2D_get_constant_angular_velocity #-} -- | The body's constant angular velocity. This does not rotate the body, but affects colliding bodies, as if it were rotating. bindStaticBody2D_get_constant_angular_velocity :: MethodBind bindStaticBody2D_get_constant_angular_velocity = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "get_constant_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's constant angular velocity. This does not rotate the body, but affects colliding bodies, as if it were rotating. get_constant_angular_velocity :: (StaticBody2D :< cls, Object :< cls) => cls -> IO Float get_constant_angular_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_get_constant_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "get_constant_angular_velocity" '[] (IO Float) where nodeMethod = Godot.Core.StaticBody2D.get_constant_angular_velocity {-# NOINLINE bindStaticBody2D_get_constant_linear_velocity #-} -- | The body's constant linear velocity. This does not move the body, but affects colliding bodies, as if it were moving. bindStaticBody2D_get_constant_linear_velocity :: MethodBind bindStaticBody2D_get_constant_linear_velocity = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "get_constant_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's constant linear velocity. This does not move the body, but affects colliding bodies, as if it were moving. get_constant_linear_velocity :: (StaticBody2D :< cls, Object :< cls) => cls -> IO Vector2 get_constant_linear_velocity cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_get_constant_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "get_constant_linear_velocity" '[] (IO Vector2) where nodeMethod = Godot.Core.StaticBody2D.get_constant_linear_velocity {-# NOINLINE bindStaticBody2D_get_friction #-} -- | The body's friction. Values range from @0@ (no friction) to @1@ (full friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. bindStaticBody2D_get_friction :: MethodBind bindStaticBody2D_get_friction = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "get_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction. Values range from @0@ (no friction) to @1@ (full friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. get_friction :: (StaticBody2D :< cls, Object :< cls) => cls -> IO Float get_friction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_get_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "get_friction" '[] (IO Float) where nodeMethod = Godot.Core.StaticBody2D.get_friction {-# NOINLINE bindStaticBody2D_get_physics_material_override #-} -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. bindStaticBody2D_get_physics_material_override :: MethodBind bindStaticBody2D_get_physics_material_override = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "get_physics_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. get_physics_material_override :: (StaticBody2D :< cls, Object :< cls) => cls -> IO PhysicsMaterial get_physics_material_override cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_get_physics_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "get_physics_material_override" '[] (IO PhysicsMaterial) where nodeMethod = Godot.Core.StaticBody2D.get_physics_material_override {-# NOINLINE bindStaticBody2D_set_bounce #-} -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. bindStaticBody2D_set_bounce :: MethodBind bindStaticBody2D_set_bounce = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "set_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's bounciness. Values range from @0@ (no bounce) to @1@ (full bounciness). -- Deprecated, use @PhysicsMaterial.bounce@ instead via @physics_material_override@. set_bounce :: (StaticBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_bounce cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_set_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "set_bounce" '[Float] (IO ()) where nodeMethod = Godot.Core.StaticBody2D.set_bounce {-# NOINLINE bindStaticBody2D_set_constant_angular_velocity #-} -- | The body's constant angular velocity. This does not rotate the body, but affects colliding bodies, as if it were rotating. bindStaticBody2D_set_constant_angular_velocity :: MethodBind bindStaticBody2D_set_constant_angular_velocity = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "set_constant_angular_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's constant angular velocity. This does not rotate the body, but affects colliding bodies, as if it were rotating. set_constant_angular_velocity :: (StaticBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_constant_angular_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_set_constant_angular_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "set_constant_angular_velocity" '[Float] (IO ()) where nodeMethod = Godot.Core.StaticBody2D.set_constant_angular_velocity {-# NOINLINE bindStaticBody2D_set_constant_linear_velocity #-} -- | The body's constant linear velocity. This does not move the body, but affects colliding bodies, as if it were moving. bindStaticBody2D_set_constant_linear_velocity :: MethodBind bindStaticBody2D_set_constant_linear_velocity = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "set_constant_linear_velocity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's constant linear velocity. This does not move the body, but affects colliding bodies, as if it were moving. set_constant_linear_velocity :: (StaticBody2D :< cls, Object :< cls) => cls -> Vector2 -> IO () set_constant_linear_velocity cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_set_constant_linear_velocity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "set_constant_linear_velocity" '[Vector2] (IO ()) where nodeMethod = Godot.Core.StaticBody2D.set_constant_linear_velocity {-# NOINLINE bindStaticBody2D_set_friction #-} -- | The body's friction. Values range from @0@ (no friction) to @1@ (full friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. bindStaticBody2D_set_friction :: MethodBind bindStaticBody2D_set_friction = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "set_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The body's friction. Values range from @0@ (no friction) to @1@ (full friction). -- Deprecated, use @PhysicsMaterial.friction@ instead via @physics_material_override@. set_friction :: (StaticBody2D :< cls, Object :< cls) => cls -> Float -> IO () set_friction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_set_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "set_friction" '[Float] (IO ()) where nodeMethod = Godot.Core.StaticBody2D.set_friction {-# NOINLINE bindStaticBody2D_set_physics_material_override #-} -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. bindStaticBody2D_set_physics_material_override :: MethodBind bindStaticBody2D_set_physics_material_override = unsafePerformIO $ withCString "StaticBody2D" $ \ clsNamePtr -> withCString "set_physics_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The physics material override for the body. -- If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one. set_physics_material_override :: (StaticBody2D :< cls, Object :< cls) => cls -> PhysicsMaterial -> IO () set_physics_material_override cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStaticBody2D_set_physics_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StaticBody2D "set_physics_material_override" '[PhysicsMaterial] (IO ()) where nodeMethod = Godot.Core.StaticBody2D.set_physics_material_override ================================================ FILE: src/Godot/Core/StreamPeer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StreamPeer (Godot.Core.StreamPeer.get_16, Godot.Core.StreamPeer.get_32, Godot.Core.StreamPeer.get_64, Godot.Core.StreamPeer.get_8, Godot.Core.StreamPeer.get_available_bytes, Godot.Core.StreamPeer.get_data, Godot.Core.StreamPeer.get_double, Godot.Core.StreamPeer.get_float, Godot.Core.StreamPeer.get_partial_data, Godot.Core.StreamPeer.get_string, Godot.Core.StreamPeer.get_u16, Godot.Core.StreamPeer.get_u32, Godot.Core.StreamPeer.get_u64, Godot.Core.StreamPeer.get_u8, Godot.Core.StreamPeer.get_utf8_string, Godot.Core.StreamPeer.get_var, Godot.Core.StreamPeer.is_big_endian_enabled, Godot.Core.StreamPeer.put_16, Godot.Core.StreamPeer.put_32, Godot.Core.StreamPeer.put_64, Godot.Core.StreamPeer.put_8, Godot.Core.StreamPeer.put_data, Godot.Core.StreamPeer.put_double, Godot.Core.StreamPeer.put_float, Godot.Core.StreamPeer.put_partial_data, Godot.Core.StreamPeer.put_string, Godot.Core.StreamPeer.put_u16, Godot.Core.StreamPeer.put_u32, Godot.Core.StreamPeer.put_u64, Godot.Core.StreamPeer.put_u8, Godot.Core.StreamPeer.put_utf8_string, Godot.Core.StreamPeer.put_var, Godot.Core.StreamPeer.set_big_endian) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() instance NodeProperty StreamPeer "big_endian" Bool 'False where nodeProperty = (is_big_endian_enabled, wrapDroppingSetter set_big_endian, Nothing) {-# NOINLINE bindStreamPeer_get_16 #-} -- | Gets a signed 16-bit value from the stream. bindStreamPeer_get_16 :: MethodBind bindStreamPeer_get_16 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_16" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a signed 16-bit value from the stream. get_16 :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_16 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_16 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_16" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_16 {-# NOINLINE bindStreamPeer_get_32 #-} -- | Gets a signed 32-bit value from the stream. bindStreamPeer_get_32 :: MethodBind bindStreamPeer_get_32 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_32" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a signed 32-bit value from the stream. get_32 :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_32 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_32 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_32" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_32 {-# NOINLINE bindStreamPeer_get_64 #-} -- | Gets a signed 64-bit value from the stream. bindStreamPeer_get_64 :: MethodBind bindStreamPeer_get_64 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a signed 64-bit value from the stream. get_64 :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_64 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_64" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_64 {-# NOINLINE bindStreamPeer_get_8 #-} -- | Gets a signed byte from the stream. bindStreamPeer_get_8 :: MethodBind bindStreamPeer_get_8 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_8" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a signed byte from the stream. get_8 :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_8 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_8 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_8" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_8 {-# NOINLINE bindStreamPeer_get_available_bytes #-} -- | Returns the amount of bytes this @StreamPeer@ has available. bindStreamPeer_get_available_bytes :: MethodBind bindStreamPeer_get_available_bytes = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_available_bytes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of bytes this @StreamPeer@ has available. get_available_bytes :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_available_bytes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_available_bytes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_available_bytes" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_available_bytes {-# NOINLINE bindStreamPeer_get_data #-} -- | Returns a chunk data with the received bytes. The amount of bytes to be received can be requested in the @bytes@ argument. If not enough bytes are available, the function will block until the desired amount is received. This function returns two values, an @enum @GlobalScope.Error@ code and a data array. bindStreamPeer_get_data :: MethodBind bindStreamPeer_get_data = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a chunk data with the received bytes. The amount of bytes to be received can be requested in the @bytes@ argument. If not enough bytes are available, the function will block until the desired amount is received. This function returns two values, an @enum @GlobalScope.Error@ code and a data array. get_data :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO Array get_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_data" '[Int] (IO Array) where nodeMethod = Godot.Core.StreamPeer.get_data {-# NOINLINE bindStreamPeer_get_double #-} -- | Gets a double-precision float from the stream. bindStreamPeer_get_double :: MethodBind bindStreamPeer_get_double = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_double" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a double-precision float from the stream. get_double :: (StreamPeer :< cls, Object :< cls) => cls -> IO Float get_double cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_double (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_double" '[] (IO Float) where nodeMethod = Godot.Core.StreamPeer.get_double {-# NOINLINE bindStreamPeer_get_float #-} -- | Gets a single-precision float from the stream. bindStreamPeer_get_float :: MethodBind bindStreamPeer_get_float = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_float" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a single-precision float from the stream. get_float :: (StreamPeer :< cls, Object :< cls) => cls -> IO Float get_float cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_float (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_float" '[] (IO Float) where nodeMethod = Godot.Core.StreamPeer.get_float {-# NOINLINE bindStreamPeer_get_partial_data #-} -- | Returns a chunk data with the received bytes. The amount of bytes to be received can be requested in the "bytes" argument. If not enough bytes are available, the function will return how many were actually received. This function returns two values, an @enum @GlobalScope.Error@ code, and a data array. bindStreamPeer_get_partial_data :: MethodBind bindStreamPeer_get_partial_data = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_partial_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a chunk data with the received bytes. The amount of bytes to be received can be requested in the "bytes" argument. If not enough bytes are available, the function will return how many were actually received. This function returns two values, an @enum @GlobalScope.Error@ code, and a data array. get_partial_data :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO Array get_partial_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_partial_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_partial_data" '[Int] (IO Array) where nodeMethod = Godot.Core.StreamPeer.get_partial_data {-# NOINLINE bindStreamPeer_get_string #-} -- | Gets a string with byte-length @bytes@ from the stream. If @bytes@ is negative (default) the length will be read from the stream using the reverse process of @method put_string@. bindStreamPeer_get_string :: MethodBind bindStreamPeer_get_string = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a string with byte-length @bytes@ from the stream. If @bytes@ is negative (default) the length will be read from the stream using the reverse process of @method put_string@. get_string :: (StreamPeer :< cls, Object :< cls) => cls -> Maybe Int -> IO GodotString get_string cls arg1 = withVariantArray [maybe (VariantInt (-1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_string" '[Maybe Int] (IO GodotString) where nodeMethod = Godot.Core.StreamPeer.get_string {-# NOINLINE bindStreamPeer_get_u16 #-} -- | Gets an unsigned 16-bit value from the stream. bindStreamPeer_get_u16 :: MethodBind bindStreamPeer_get_u16 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_u16" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets an unsigned 16-bit value from the stream. get_u16 :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_u16 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_u16 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_u16" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_u16 {-# NOINLINE bindStreamPeer_get_u32 #-} -- | Gets an unsigned 32-bit value from the stream. bindStreamPeer_get_u32 :: MethodBind bindStreamPeer_get_u32 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_u32" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets an unsigned 32-bit value from the stream. get_u32 :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_u32 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_u32 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_u32" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_u32 {-# NOINLINE bindStreamPeer_get_u64 #-} -- | Gets an unsigned 64-bit value from the stream. bindStreamPeer_get_u64 :: MethodBind bindStreamPeer_get_u64 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_u64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets an unsigned 64-bit value from the stream. get_u64 :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_u64 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_u64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_u64" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_u64 {-# NOINLINE bindStreamPeer_get_u8 #-} -- | Gets an unsigned byte from the stream. bindStreamPeer_get_u8 :: MethodBind bindStreamPeer_get_u8 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_u8" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets an unsigned byte from the stream. get_u8 :: (StreamPeer :< cls, Object :< cls) => cls -> IO Int get_u8 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_u8 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_u8" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeer.get_u8 {-# NOINLINE bindStreamPeer_get_utf8_string #-} -- | Gets an UTF-8 string with byte-length @bytes@ from the stream (this decodes the string sent as UTF-8). If @bytes@ is negative (default) the length will be read from the stream using the reverse process of @method put_utf8_string@. bindStreamPeer_get_utf8_string :: MethodBind bindStreamPeer_get_utf8_string = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_utf8_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets an UTF-8 string with byte-length @bytes@ from the stream (this decodes the string sent as UTF-8). If @bytes@ is negative (default) the length will be read from the stream using the reverse process of @method put_utf8_string@. get_utf8_string :: (StreamPeer :< cls, Object :< cls) => cls -> Maybe Int -> IO GodotString get_utf8_string cls arg1 = withVariantArray [maybe (VariantInt (-1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_utf8_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_utf8_string" '[Maybe Int] (IO GodotString) where nodeMethod = Godot.Core.StreamPeer.get_utf8_string {-# NOINLINE bindStreamPeer_get_var #-} -- | Gets a Variant from the stream. If @allow_objects@ is @true@, decoding objects is allowed. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. bindStreamPeer_get_var :: MethodBind bindStreamPeer_get_var = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "get_var" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets a Variant from the stream. If @allow_objects@ is @true@, decoding objects is allowed. -- __Warning:__ Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution. get_var :: (StreamPeer :< cls, Object :< cls) => cls -> Maybe Bool -> IO GodotVariant get_var cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_get_var (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "get_var" '[Maybe Bool] (IO GodotVariant) where nodeMethod = Godot.Core.StreamPeer.get_var {-# NOINLINE bindStreamPeer_is_big_endian_enabled #-} -- | If @true@, this @StreamPeer@ will using big-endian format for encoding and decoding. bindStreamPeer_is_big_endian_enabled :: MethodBind bindStreamPeer_is_big_endian_enabled = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "is_big_endian_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this @StreamPeer@ will using big-endian format for encoding and decoding. is_big_endian_enabled :: (StreamPeer :< cls, Object :< cls) => cls -> IO Bool is_big_endian_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_is_big_endian_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "is_big_endian_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.StreamPeer.is_big_endian_enabled {-# NOINLINE bindStreamPeer_put_16 #-} -- | Puts a signed 16-bit value into the stream. bindStreamPeer_put_16 :: MethodBind bindStreamPeer_put_16 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_16" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a signed 16-bit value into the stream. put_16 :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO () put_16 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_16 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_16" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_16 {-# NOINLINE bindStreamPeer_put_32 #-} -- | Puts a signed 32-bit value into the stream. bindStreamPeer_put_32 :: MethodBind bindStreamPeer_put_32 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_32" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a signed 32-bit value into the stream. put_32 :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO () put_32 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_32 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_32" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_32 {-# NOINLINE bindStreamPeer_put_64 #-} -- | Puts a signed 64-bit value into the stream. bindStreamPeer_put_64 :: MethodBind bindStreamPeer_put_64 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a signed 64-bit value into the stream. put_64 :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO () put_64 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_64" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_64 {-# NOINLINE bindStreamPeer_put_8 #-} -- | Puts a signed byte into the stream. bindStreamPeer_put_8 :: MethodBind bindStreamPeer_put_8 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_8" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a signed byte into the stream. put_8 :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO () put_8 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_8 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_8" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_8 {-# NOINLINE bindStreamPeer_put_data #-} -- | Sends a chunk of data through the connection, blocking if necessary until the data is done sending. This function returns an @enum @GlobalScope.Error@ code. bindStreamPeer_put_data :: MethodBind bindStreamPeer_put_data = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a chunk of data through the connection, blocking if necessary until the data is done sending. This function returns an @enum @GlobalScope.Error@ code. put_data :: (StreamPeer :< cls, Object :< cls) => cls -> PoolByteArray -> IO Int put_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_data" '[PoolByteArray] (IO Int) where nodeMethod = Godot.Core.StreamPeer.put_data {-# NOINLINE bindStreamPeer_put_double #-} -- | Puts a double-precision float into the stream. bindStreamPeer_put_double :: MethodBind bindStreamPeer_put_double = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_double" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a double-precision float into the stream. put_double :: (StreamPeer :< cls, Object :< cls) => cls -> Float -> IO () put_double cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_double (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_double" '[Float] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_double {-# NOINLINE bindStreamPeer_put_float #-} -- | Puts a single-precision float into the stream. bindStreamPeer_put_float :: MethodBind bindStreamPeer_put_float = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_float" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a single-precision float into the stream. put_float :: (StreamPeer :< cls, Object :< cls) => cls -> Float -> IO () put_float cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_float (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_float" '[Float] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_float {-# NOINLINE bindStreamPeer_put_partial_data #-} -- | Sends a chunk of data through the connection. If all the data could not be sent at once, only part of it will. This function returns two values, an @enum @GlobalScope.Error@ code and an integer, describing how much data was actually sent. bindStreamPeer_put_partial_data :: MethodBind bindStreamPeer_put_partial_data = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_partial_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sends a chunk of data through the connection. If all the data could not be sent at once, only part of it will. This function returns two values, an @enum @GlobalScope.Error@ code and an integer, describing how much data was actually sent. put_partial_data :: (StreamPeer :< cls, Object :< cls) => cls -> PoolByteArray -> IO Array put_partial_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_partial_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_partial_data" '[PoolByteArray] (IO Array) where nodeMethod = Godot.Core.StreamPeer.put_partial_data {-# NOINLINE bindStreamPeer_put_string #-} -- | Puts a zero-terminated ASCII string into the stream prepended by a 32-bit unsigned integer representing its size. -- Note: To put an ASCII string without prepending its size, you can use @method put_data@: -- -- @ -- -- put_data("Hello world".to_ascii()) -- -- @ bindStreamPeer_put_string :: MethodBind bindStreamPeer_put_string = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a zero-terminated ASCII string into the stream prepended by a 32-bit unsigned integer representing its size. -- Note: To put an ASCII string without prepending its size, you can use @method put_data@: -- -- @ -- -- put_data("Hello world".to_ascii()) -- -- @ put_string :: (StreamPeer :< cls, Object :< cls) => cls -> GodotString -> IO () put_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_string" '[GodotString] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_string {-# NOINLINE bindStreamPeer_put_u16 #-} -- | Puts an unsigned 16-bit value into the stream. bindStreamPeer_put_u16 :: MethodBind bindStreamPeer_put_u16 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_u16" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts an unsigned 16-bit value into the stream. put_u16 :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO () put_u16 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_u16 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_u16" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_u16 {-# NOINLINE bindStreamPeer_put_u32 #-} -- | Puts an unsigned 32-bit value into the stream. bindStreamPeer_put_u32 :: MethodBind bindStreamPeer_put_u32 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_u32" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts an unsigned 32-bit value into the stream. put_u32 :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO () put_u32 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_u32 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_u32" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_u32 {-# NOINLINE bindStreamPeer_put_u64 #-} -- | Puts an unsigned 64-bit value into the stream. bindStreamPeer_put_u64 :: MethodBind bindStreamPeer_put_u64 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_u64" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts an unsigned 64-bit value into the stream. put_u64 :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO () put_u64 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_u64 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_u64" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_u64 {-# NOINLINE bindStreamPeer_put_u8 #-} -- | Puts an unsigned byte into the stream. bindStreamPeer_put_u8 :: MethodBind bindStreamPeer_put_u8 = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_u8" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts an unsigned byte into the stream. put_u8 :: (StreamPeer :< cls, Object :< cls) => cls -> Int -> IO () put_u8 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_u8 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_u8" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_u8 {-# NOINLINE bindStreamPeer_put_utf8_string #-} -- | Puts a zero-terminated UTF-8 string into the stream prepended by a 32 bits unsigned integer representing its size. -- Note: To put an UTF-8 string without prepending its size, you can use @method put_data@: -- -- @ -- -- put_data("Hello world".to_utf8()) -- -- @ bindStreamPeer_put_utf8_string :: MethodBind bindStreamPeer_put_utf8_string = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_utf8_string" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a zero-terminated UTF-8 string into the stream prepended by a 32 bits unsigned integer representing its size. -- Note: To put an UTF-8 string without prepending its size, you can use @method put_data@: -- -- @ -- -- put_data("Hello world".to_utf8()) -- -- @ put_utf8_string :: (StreamPeer :< cls, Object :< cls) => cls -> GodotString -> IO () put_utf8_string cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_utf8_string (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_utf8_string" '[GodotString] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_utf8_string {-# NOINLINE bindStreamPeer_put_var #-} -- | Puts a Variant into the stream. If @full_objects@ is @true@ encoding objects is allowed (and can potentially include code). bindStreamPeer_put_var :: MethodBind bindStreamPeer_put_var = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "put_var" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Puts a Variant into the stream. If @full_objects@ is @true@ encoding objects is allowed (and can potentially include code). put_var :: (StreamPeer :< cls, Object :< cls) => cls -> GodotVariant -> Maybe Bool -> IO () put_var cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_put_var (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "put_var" '[GodotVariant, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.StreamPeer.put_var {-# NOINLINE bindStreamPeer_set_big_endian #-} -- | If @true@, this @StreamPeer@ will using big-endian format for encoding and decoding. bindStreamPeer_set_big_endian :: MethodBind bindStreamPeer_set_big_endian = unsafePerformIO $ withCString "StreamPeer" $ \ clsNamePtr -> withCString "set_big_endian" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this @StreamPeer@ will using big-endian format for encoding and decoding. set_big_endian :: (StreamPeer :< cls, Object :< cls) => cls -> Bool -> IO () set_big_endian cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeer_set_big_endian (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeer "set_big_endian" '[Bool] (IO ()) where nodeMethod = Godot.Core.StreamPeer.set_big_endian ================================================ FILE: src/Godot/Core/StreamPeerBuffer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StreamPeerBuffer (Godot.Core.StreamPeerBuffer.clear, Godot.Core.StreamPeerBuffer.duplicate, Godot.Core.StreamPeerBuffer.get_data_array, Godot.Core.StreamPeerBuffer.get_position, Godot.Core.StreamPeerBuffer.get_size, Godot.Core.StreamPeerBuffer.resize, Godot.Core.StreamPeerBuffer.seek, Godot.Core.StreamPeerBuffer.set_data_array) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.StreamPeer() instance NodeProperty StreamPeerBuffer "data_array" PoolByteArray 'False where nodeProperty = (get_data_array, wrapDroppingSetter set_data_array, Nothing) {-# NOINLINE bindStreamPeerBuffer_clear #-} bindStreamPeerBuffer_clear :: MethodBind bindStreamPeerBuffer_clear = unsafePerformIO $ withCString "StreamPeerBuffer" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear :: (StreamPeerBuffer :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerBuffer_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerBuffer "clear" '[] (IO ()) where nodeMethod = Godot.Core.StreamPeerBuffer.clear {-# NOINLINE bindStreamPeerBuffer_duplicate #-} bindStreamPeerBuffer_duplicate :: MethodBind bindStreamPeerBuffer_duplicate = unsafePerformIO $ withCString "StreamPeerBuffer" $ \ clsNamePtr -> withCString "duplicate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr duplicate :: (StreamPeerBuffer :< cls, Object :< cls) => cls -> IO StreamPeerBuffer duplicate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerBuffer_duplicate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerBuffer "duplicate" '[] (IO StreamPeerBuffer) where nodeMethod = Godot.Core.StreamPeerBuffer.duplicate {-# NOINLINE bindStreamPeerBuffer_get_data_array #-} bindStreamPeerBuffer_get_data_array :: MethodBind bindStreamPeerBuffer_get_data_array = unsafePerformIO $ withCString "StreamPeerBuffer" $ \ clsNamePtr -> withCString "get_data_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_data_array :: (StreamPeerBuffer :< cls, Object :< cls) => cls -> IO PoolByteArray get_data_array cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerBuffer_get_data_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerBuffer "get_data_array" '[] (IO PoolByteArray) where nodeMethod = Godot.Core.StreamPeerBuffer.get_data_array {-# NOINLINE bindStreamPeerBuffer_get_position #-} bindStreamPeerBuffer_get_position :: MethodBind bindStreamPeerBuffer_get_position = unsafePerformIO $ withCString "StreamPeerBuffer" $ \ clsNamePtr -> withCString "get_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_position :: (StreamPeerBuffer :< cls, Object :< cls) => cls -> IO Int get_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerBuffer_get_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerBuffer "get_position" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeerBuffer.get_position {-# NOINLINE bindStreamPeerBuffer_get_size #-} bindStreamPeerBuffer_get_size :: MethodBind bindStreamPeerBuffer_get_size = unsafePerformIO $ withCString "StreamPeerBuffer" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_size :: (StreamPeerBuffer :< cls, Object :< cls) => cls -> IO Int get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerBuffer_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerBuffer "get_size" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeerBuffer.get_size {-# NOINLINE bindStreamPeerBuffer_resize #-} bindStreamPeerBuffer_resize :: MethodBind bindStreamPeerBuffer_resize = unsafePerformIO $ withCString "StreamPeerBuffer" $ \ clsNamePtr -> withCString "resize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr resize :: (StreamPeerBuffer :< cls, Object :< cls) => cls -> Int -> IO () resize cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerBuffer_resize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerBuffer "resize" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeerBuffer.resize {-# NOINLINE bindStreamPeerBuffer_seek #-} bindStreamPeerBuffer_seek :: MethodBind bindStreamPeerBuffer_seek = unsafePerformIO $ withCString "StreamPeerBuffer" $ \ clsNamePtr -> withCString "seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr seek :: (StreamPeerBuffer :< cls, Object :< cls) => cls -> Int -> IO () seek cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerBuffer_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerBuffer "seek" '[Int] (IO ()) where nodeMethod = Godot.Core.StreamPeerBuffer.seek {-# NOINLINE bindStreamPeerBuffer_set_data_array #-} bindStreamPeerBuffer_set_data_array :: MethodBind bindStreamPeerBuffer_set_data_array = unsafePerformIO $ withCString "StreamPeerBuffer" $ \ clsNamePtr -> withCString "set_data_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_data_array :: (StreamPeerBuffer :< cls, Object :< cls) => cls -> PoolByteArray -> IO () set_data_array cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerBuffer_set_data_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerBuffer "set_data_array" '[PoolByteArray] (IO ()) where nodeMethod = Godot.Core.StreamPeerBuffer.set_data_array ================================================ FILE: src/Godot/Core/StreamPeerGDNative.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StreamPeerGDNative () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.StreamPeer() ================================================ FILE: src/Godot/Core/StreamPeerSSL.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StreamPeerSSL (Godot.Core.StreamPeerSSL._STATUS_CONNECTED, Godot.Core.StreamPeerSSL._STATUS_ERROR, Godot.Core.StreamPeerSSL._STATUS_DISCONNECTED, Godot.Core.StreamPeerSSL._STATUS_ERROR_HOSTNAME_MISMATCH, Godot.Core.StreamPeerSSL._STATUS_HANDSHAKING, Godot.Core.StreamPeerSSL.accept_stream, Godot.Core.StreamPeerSSL.connect_to_stream, Godot.Core.StreamPeerSSL.disconnect_from_stream, Godot.Core.StreamPeerSSL.get_status, Godot.Core.StreamPeerSSL.is_blocking_handshake_enabled, Godot.Core.StreamPeerSSL.poll, Godot.Core.StreamPeerSSL.set_blocking_handshake_enabled) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.StreamPeer() _STATUS_CONNECTED :: Int _STATUS_CONNECTED = 2 _STATUS_ERROR :: Int _STATUS_ERROR = 3 _STATUS_DISCONNECTED :: Int _STATUS_DISCONNECTED = 0 _STATUS_ERROR_HOSTNAME_MISMATCH :: Int _STATUS_ERROR_HOSTNAME_MISMATCH = 4 _STATUS_HANDSHAKING :: Int _STATUS_HANDSHAKING = 1 instance NodeProperty StreamPeerSSL "blocking_handshake" Bool 'False where nodeProperty = (is_blocking_handshake_enabled, wrapDroppingSetter set_blocking_handshake_enabled, Nothing) {-# NOINLINE bindStreamPeerSSL_accept_stream #-} -- | Accepts a peer connection as a server using the given @private_key@ and providing the given @certificate@ to the client. You can pass the optional @chain@ parameter to provide additional CA chain information along with the certificate. bindStreamPeerSSL_accept_stream :: MethodBind bindStreamPeerSSL_accept_stream = unsafePerformIO $ withCString "StreamPeerSSL" $ \ clsNamePtr -> withCString "accept_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Accepts a peer connection as a server using the given @private_key@ and providing the given @certificate@ to the client. You can pass the optional @chain@ parameter to provide additional CA chain information along with the certificate. accept_stream :: (StreamPeerSSL :< cls, Object :< cls) => cls -> StreamPeer -> CryptoKey -> X509Certificate -> Maybe X509Certificate -> IO Int accept_stream cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerSSL_accept_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerSSL "accept_stream" '[StreamPeer, CryptoKey, X509Certificate, Maybe X509Certificate] (IO Int) where nodeMethod = Godot.Core.StreamPeerSSL.accept_stream {-# NOINLINE bindStreamPeerSSL_connect_to_stream #-} -- | Connects to a peer using an underlying @StreamPeer@ @stream@. If @validate_certs@ is @true@, @StreamPeerSSL@ will validate that the certificate presented by the peer matches the @for_hostname@. -- __Note:__ Specifying a custom @valid_certificate@ is not supported in HTML5 exports due to browsers restrictions. bindStreamPeerSSL_connect_to_stream :: MethodBind bindStreamPeerSSL_connect_to_stream = unsafePerformIO $ withCString "StreamPeerSSL" $ \ clsNamePtr -> withCString "connect_to_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects to a peer using an underlying @StreamPeer@ @stream@. If @validate_certs@ is @true@, @StreamPeerSSL@ will validate that the certificate presented by the peer matches the @for_hostname@. -- __Note:__ Specifying a custom @valid_certificate@ is not supported in HTML5 exports due to browsers restrictions. connect_to_stream :: (StreamPeerSSL :< cls, Object :< cls) => cls -> StreamPeer -> Maybe Bool -> Maybe GodotString -> Maybe X509Certificate -> IO Int connect_to_stream cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2, defaultedVariant VariantString "" arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerSSL_connect_to_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerSSL "connect_to_stream" '[StreamPeer, Maybe Bool, Maybe GodotString, Maybe X509Certificate] (IO Int) where nodeMethod = Godot.Core.StreamPeerSSL.connect_to_stream {-# NOINLINE bindStreamPeerSSL_disconnect_from_stream #-} -- | Disconnects from host. bindStreamPeerSSL_disconnect_from_stream :: MethodBind bindStreamPeerSSL_disconnect_from_stream = unsafePerformIO $ withCString "StreamPeerSSL" $ \ clsNamePtr -> withCString "disconnect_from_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disconnects from host. disconnect_from_stream :: (StreamPeerSSL :< cls, Object :< cls) => cls -> IO () disconnect_from_stream cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerSSL_disconnect_from_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerSSL "disconnect_from_stream" '[] (IO ()) where nodeMethod = Godot.Core.StreamPeerSSL.disconnect_from_stream {-# NOINLINE bindStreamPeerSSL_get_status #-} -- | Returns the status of the connection. See @enum Status@ for values. bindStreamPeerSSL_get_status :: MethodBind bindStreamPeerSSL_get_status = unsafePerformIO $ withCString "StreamPeerSSL" $ \ clsNamePtr -> withCString "get_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the status of the connection. See @enum Status@ for values. get_status :: (StreamPeerSSL :< cls, Object :< cls) => cls -> IO Int get_status cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerSSL_get_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerSSL "get_status" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeerSSL.get_status {-# NOINLINE bindStreamPeerSSL_is_blocking_handshake_enabled #-} bindStreamPeerSSL_is_blocking_handshake_enabled :: MethodBind bindStreamPeerSSL_is_blocking_handshake_enabled = unsafePerformIO $ withCString "StreamPeerSSL" $ \ clsNamePtr -> withCString "is_blocking_handshake_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_blocking_handshake_enabled :: (StreamPeerSSL :< cls, Object :< cls) => cls -> IO Bool is_blocking_handshake_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerSSL_is_blocking_handshake_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerSSL "is_blocking_handshake_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.StreamPeerSSL.is_blocking_handshake_enabled {-# NOINLINE bindStreamPeerSSL_poll #-} -- | Poll the connection to check for incoming bytes. Call this right before @method StreamPeer.get_available_bytes@ for it to work properly. bindStreamPeerSSL_poll :: MethodBind bindStreamPeerSSL_poll = unsafePerformIO $ withCString "StreamPeerSSL" $ \ clsNamePtr -> withCString "poll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Poll the connection to check for incoming bytes. Call this right before @method StreamPeer.get_available_bytes@ for it to work properly. poll :: (StreamPeerSSL :< cls, Object :< cls) => cls -> IO () poll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerSSL_poll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerSSL "poll" '[] (IO ()) where nodeMethod = Godot.Core.StreamPeerSSL.poll {-# NOINLINE bindStreamPeerSSL_set_blocking_handshake_enabled #-} bindStreamPeerSSL_set_blocking_handshake_enabled :: MethodBind bindStreamPeerSSL_set_blocking_handshake_enabled = unsafePerformIO $ withCString "StreamPeerSSL" $ \ clsNamePtr -> withCString "set_blocking_handshake_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_blocking_handshake_enabled :: (StreamPeerSSL :< cls, Object :< cls) => cls -> Bool -> IO () set_blocking_handshake_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerSSL_set_blocking_handshake_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerSSL "set_blocking_handshake_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.StreamPeerSSL.set_blocking_handshake_enabled ================================================ FILE: src/Godot/Core/StreamPeerTCP.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StreamPeerTCP (Godot.Core.StreamPeerTCP._STATUS_CONNECTED, Godot.Core.StreamPeerTCP._STATUS_CONNECTING, Godot.Core.StreamPeerTCP._STATUS_ERROR, Godot.Core.StreamPeerTCP._STATUS_NONE, Godot.Core.StreamPeerTCP.connect_to_host, Godot.Core.StreamPeerTCP.disconnect_from_host, Godot.Core.StreamPeerTCP.get_connected_host, Godot.Core.StreamPeerTCP.get_connected_port, Godot.Core.StreamPeerTCP.get_status, Godot.Core.StreamPeerTCP.is_connected_to_host, Godot.Core.StreamPeerTCP.set_no_delay) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.StreamPeer() _STATUS_CONNECTED :: Int _STATUS_CONNECTED = 2 _STATUS_CONNECTING :: Int _STATUS_CONNECTING = 1 _STATUS_ERROR :: Int _STATUS_ERROR = 3 _STATUS_NONE :: Int _STATUS_NONE = 0 {-# NOINLINE bindStreamPeerTCP_connect_to_host #-} -- | Connects to the specified @host:port@ pair. A hostname will be resolved if valid. Returns @OK@ on success or @FAILED@ on failure. bindStreamPeerTCP_connect_to_host :: MethodBind bindStreamPeerTCP_connect_to_host = unsafePerformIO $ withCString "StreamPeerTCP" $ \ clsNamePtr -> withCString "connect_to_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects to the specified @host:port@ pair. A hostname will be resolved if valid. Returns @OK@ on success or @FAILED@ on failure. connect_to_host :: (StreamPeerTCP :< cls, Object :< cls) => cls -> GodotString -> Int -> IO Int connect_to_host cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerTCP_connect_to_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerTCP "connect_to_host" '[GodotString, Int] (IO Int) where nodeMethod = Godot.Core.StreamPeerTCP.connect_to_host {-# NOINLINE bindStreamPeerTCP_disconnect_from_host #-} -- | Disconnects from host. bindStreamPeerTCP_disconnect_from_host :: MethodBind bindStreamPeerTCP_disconnect_from_host = unsafePerformIO $ withCString "StreamPeerTCP" $ \ clsNamePtr -> withCString "disconnect_from_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disconnects from host. disconnect_from_host :: (StreamPeerTCP :< cls, Object :< cls) => cls -> IO () disconnect_from_host cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerTCP_disconnect_from_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerTCP "disconnect_from_host" '[] (IO ()) where nodeMethod = Godot.Core.StreamPeerTCP.disconnect_from_host {-# NOINLINE bindStreamPeerTCP_get_connected_host #-} -- | Returns the IP of this peer. bindStreamPeerTCP_get_connected_host :: MethodBind bindStreamPeerTCP_get_connected_host = unsafePerformIO $ withCString "StreamPeerTCP" $ \ clsNamePtr -> withCString "get_connected_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the IP of this peer. get_connected_host :: (StreamPeerTCP :< cls, Object :< cls) => cls -> IO GodotString get_connected_host cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerTCP_get_connected_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerTCP "get_connected_host" '[] (IO GodotString) where nodeMethod = Godot.Core.StreamPeerTCP.get_connected_host {-# NOINLINE bindStreamPeerTCP_get_connected_port #-} -- | Returns the port of this peer. bindStreamPeerTCP_get_connected_port :: MethodBind bindStreamPeerTCP_get_connected_port = unsafePerformIO $ withCString "StreamPeerTCP" $ \ clsNamePtr -> withCString "get_connected_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the port of this peer. get_connected_port :: (StreamPeerTCP :< cls, Object :< cls) => cls -> IO Int get_connected_port cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerTCP_get_connected_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerTCP "get_connected_port" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeerTCP.get_connected_port {-# NOINLINE bindStreamPeerTCP_get_status #-} -- | Returns the status of the connection, see @enum Status@. bindStreamPeerTCP_get_status :: MethodBind bindStreamPeerTCP_get_status = unsafePerformIO $ withCString "StreamPeerTCP" $ \ clsNamePtr -> withCString "get_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the status of the connection, see @enum Status@. get_status :: (StreamPeerTCP :< cls, Object :< cls) => cls -> IO Int get_status cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerTCP_get_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerTCP "get_status" '[] (IO Int) where nodeMethod = Godot.Core.StreamPeerTCP.get_status {-# NOINLINE bindStreamPeerTCP_is_connected_to_host #-} -- | Returns @true@ if this peer is currently connected to a host, @false@ otherwise. bindStreamPeerTCP_is_connected_to_host :: MethodBind bindStreamPeerTCP_is_connected_to_host = unsafePerformIO $ withCString "StreamPeerTCP" $ \ clsNamePtr -> withCString "is_connected_to_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this peer is currently connected to a host, @false@ otherwise. is_connected_to_host :: (StreamPeerTCP :< cls, Object :< cls) => cls -> IO Bool is_connected_to_host cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerTCP_is_connected_to_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerTCP "is_connected_to_host" '[] (IO Bool) where nodeMethod = Godot.Core.StreamPeerTCP.is_connected_to_host {-# NOINLINE bindStreamPeerTCP_set_no_delay #-} -- | Disables Nagle's algorithm to improve latency for small packets. -- __Note:__ For applications that send large packets or need to transfer a lot of data, this can decrease the total available bandwidth. bindStreamPeerTCP_set_no_delay :: MethodBind bindStreamPeerTCP_set_no_delay = unsafePerformIO $ withCString "StreamPeerTCP" $ \ clsNamePtr -> withCString "set_no_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Disables Nagle's algorithm to improve latency for small packets. -- __Note:__ For applications that send large packets or need to transfer a lot of data, this can decrease the total available bandwidth. set_no_delay :: (StreamPeerTCP :< cls, Object :< cls) => cls -> Bool -> IO () set_no_delay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamPeerTCP_set_no_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamPeerTCP "set_no_delay" '[Bool] (IO ()) where nodeMethod = Godot.Core.StreamPeerTCP.set_no_delay ================================================ FILE: src/Godot/Core/StreamTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StreamTexture (Godot.Core.StreamTexture.get_load_path, Godot.Core.StreamTexture.load) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty StreamTexture "load_path" GodotString 'False where nodeProperty = (get_load_path, wrapDroppingSetter load, Nothing) {-# NOINLINE bindStreamTexture_get_load_path #-} -- | The StreamTexture's file path to a @.stex@ file. bindStreamTexture_get_load_path :: MethodBind bindStreamTexture_get_load_path = unsafePerformIO $ withCString "StreamTexture" $ \ clsNamePtr -> withCString "get_load_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The StreamTexture's file path to a @.stex@ file. get_load_path :: (StreamTexture :< cls, Object :< cls) => cls -> IO GodotString get_load_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStreamTexture_get_load_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamTexture "get_load_path" '[] (IO GodotString) where nodeMethod = Godot.Core.StreamTexture.get_load_path {-# NOINLINE bindStreamTexture_load #-} -- | Loads the texture from the given path. bindStreamTexture_load :: MethodBind bindStreamTexture_load = unsafePerformIO $ withCString "StreamTexture" $ \ clsNamePtr -> withCString "load" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads the texture from the given path. load :: (StreamTexture :< cls, Object :< cls) => cls -> GodotString -> IO Int load cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStreamTexture_load (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StreamTexture "load" '[GodotString] (IO Int) where nodeMethod = Godot.Core.StreamTexture.load ================================================ FILE: src/Godot/Core/StyleBox.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StyleBox (Godot.Core.StyleBox.draw, Godot.Core.StyleBox.get_center_size, Godot.Core.StyleBox.get_current_item_drawn, Godot.Core.StyleBox.get_default_margin, Godot.Core.StyleBox.get_margin, Godot.Core.StyleBox.get_minimum_size, Godot.Core.StyleBox.get_offset, Godot.Core.StyleBox.set_default_margin, Godot.Core.StyleBox.test_mask) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty StyleBox "content_margin_bottom" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_default_margin, wrapIndexedSetter 3 set_default_margin, Nothing) instance NodeProperty StyleBox "content_margin_left" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_default_margin, wrapIndexedSetter 0 set_default_margin, Nothing) instance NodeProperty StyleBox "content_margin_right" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_default_margin, wrapIndexedSetter 2 set_default_margin, Nothing) instance NodeProperty StyleBox "content_margin_top" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_default_margin, wrapIndexedSetter 1 set_default_margin, Nothing) {-# NOINLINE bindStyleBox_draw #-} -- | Draws this stylebox using a @CanvasItem@ with given @RID@. -- You can get a @RID@ value using @method Object.get_instance_id@ on a @CanvasItem@-derived node. bindStyleBox_draw :: MethodBind bindStyleBox_draw = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws this stylebox using a @CanvasItem@ with given @RID@. -- You can get a @RID@ value using @method Object.get_instance_id@ on a @CanvasItem@-derived node. draw :: (StyleBox :< cls, Object :< cls) => cls -> Rid -> Rect2 -> IO () draw cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "draw" '[Rid, Rect2] (IO ()) where nodeMethod = Godot.Core.StyleBox.draw {-# NOINLINE bindStyleBox_get_center_size #-} -- | Returns the size of this @StyleBox@ without the margins. bindStyleBox_get_center_size :: MethodBind bindStyleBox_get_center_size = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "get_center_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of this @StyleBox@ without the margins. get_center_size :: (StyleBox :< cls, Object :< cls) => cls -> IO Vector2 get_center_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_get_center_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "get_center_size" '[] (IO Vector2) where nodeMethod = Godot.Core.StyleBox.get_center_size {-# NOINLINE bindStyleBox_get_current_item_drawn #-} -- | Returns the @CanvasItem@ that handles its @CanvasItem.NOTIFICATION_DRAW@ or @method CanvasItem._draw@ callback at this moment. bindStyleBox_get_current_item_drawn :: MethodBind bindStyleBox_get_current_item_drawn = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "get_current_item_drawn" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @CanvasItem@ that handles its @CanvasItem.NOTIFICATION_DRAW@ or @method CanvasItem._draw@ callback at this moment. get_current_item_drawn :: (StyleBox :< cls, Object :< cls) => cls -> IO CanvasItem get_current_item_drawn cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_get_current_item_drawn (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "get_current_item_drawn" '[] (IO CanvasItem) where nodeMethod = Godot.Core.StyleBox.get_current_item_drawn {-# NOINLINE bindStyleBox_get_default_margin #-} -- | Returns the default value of the specified @enum Margin@. bindStyleBox_get_default_margin :: MethodBind bindStyleBox_get_default_margin = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "get_default_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the default value of the specified @enum Margin@. get_default_margin :: (StyleBox :< cls, Object :< cls) => cls -> Int -> IO Float get_default_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_get_default_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "get_default_margin" '[Int] (IO Float) where nodeMethod = Godot.Core.StyleBox.get_default_margin {-# NOINLINE bindStyleBox_get_margin #-} -- | Returns the content margin offset for the specified @enum Margin@. -- Positive values reduce size inwards, unlike @Control@'s margin values. bindStyleBox_get_margin :: MethodBind bindStyleBox_get_margin = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "get_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the content margin offset for the specified @enum Margin@. -- Positive values reduce size inwards, unlike @Control@'s margin values. get_margin :: (StyleBox :< cls, Object :< cls) => cls -> Int -> IO Float get_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_get_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "get_margin" '[Int] (IO Float) where nodeMethod = Godot.Core.StyleBox.get_margin {-# NOINLINE bindStyleBox_get_minimum_size #-} -- | Returns the minimum size that this stylebox can be shrunk to. bindStyleBox_get_minimum_size :: MethodBind bindStyleBox_get_minimum_size = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "get_minimum_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the minimum size that this stylebox can be shrunk to. get_minimum_size :: (StyleBox :< cls, Object :< cls) => cls -> IO Vector2 get_minimum_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_get_minimum_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "get_minimum_size" '[] (IO Vector2) where nodeMethod = Godot.Core.StyleBox.get_minimum_size {-# NOINLINE bindStyleBox_get_offset #-} -- | Returns the "offset" of a stylebox. This helper function returns a value equivalent to @Vector2(style.get_margin(MARGIN_LEFT), style.get_margin(MARGIN_TOP))@. bindStyleBox_get_offset :: MethodBind bindStyleBox_get_offset = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "get_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the "offset" of a stylebox. This helper function returns a value equivalent to @Vector2(style.get_margin(MARGIN_LEFT), style.get_margin(MARGIN_TOP))@. get_offset :: (StyleBox :< cls, Object :< cls) => cls -> IO Vector2 get_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_get_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "get_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.StyleBox.get_offset {-# NOINLINE bindStyleBox_set_default_margin #-} -- | Sets the default value of the specified @enum Margin@ to given @offset@ in pixels. bindStyleBox_set_default_margin :: MethodBind bindStyleBox_set_default_margin = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "set_default_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the default value of the specified @enum Margin@ to given @offset@ in pixels. set_default_margin :: (StyleBox :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_default_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_set_default_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "set_default_margin" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.StyleBox.set_default_margin {-# NOINLINE bindStyleBox_test_mask #-} -- | Test a position in a rectangle, return whether it passes the mask test. bindStyleBox_test_mask :: MethodBind bindStyleBox_test_mask = unsafePerformIO $ withCString "StyleBox" $ \ clsNamePtr -> withCString "test_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Test a position in a rectangle, return whether it passes the mask test. test_mask :: (StyleBox :< cls, Object :< cls) => cls -> Vector2 -> Rect2 -> IO Bool test_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBox_test_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBox "test_mask" '[Vector2, Rect2] (IO Bool) where nodeMethod = Godot.Core.StyleBox.test_mask ================================================ FILE: src/Godot/Core/StyleBoxEmpty.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StyleBoxEmpty () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.StyleBox() ================================================ FILE: src/Godot/Core/StyleBoxFlat.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StyleBoxFlat (Godot.Core.StyleBoxFlat.get_aa_size, Godot.Core.StyleBoxFlat.get_bg_color, Godot.Core.StyleBoxFlat.get_border_blend, Godot.Core.StyleBoxFlat.get_border_color, Godot.Core.StyleBoxFlat.get_border_width, Godot.Core.StyleBoxFlat.get_border_width_min, Godot.Core.StyleBoxFlat.get_corner_detail, Godot.Core.StyleBoxFlat.get_corner_radius, Godot.Core.StyleBoxFlat.get_expand_margin, Godot.Core.StyleBoxFlat.get_shadow_color, Godot.Core.StyleBoxFlat.get_shadow_offset, Godot.Core.StyleBoxFlat.get_shadow_size, Godot.Core.StyleBoxFlat.is_anti_aliased, Godot.Core.StyleBoxFlat.is_draw_center_enabled, Godot.Core.StyleBoxFlat.set_aa_size, Godot.Core.StyleBoxFlat.set_anti_aliased, Godot.Core.StyleBoxFlat.set_bg_color, Godot.Core.StyleBoxFlat.set_border_blend, Godot.Core.StyleBoxFlat.set_border_color, Godot.Core.StyleBoxFlat.set_border_width, Godot.Core.StyleBoxFlat.set_border_width_all, Godot.Core.StyleBoxFlat.set_corner_detail, Godot.Core.StyleBoxFlat.set_corner_radius, Godot.Core.StyleBoxFlat.set_corner_radius_all, Godot.Core.StyleBoxFlat.set_corner_radius_individual, Godot.Core.StyleBoxFlat.set_draw_center, Godot.Core.StyleBoxFlat.set_expand_margin, Godot.Core.StyleBoxFlat.set_expand_margin_all, Godot.Core.StyleBoxFlat.set_expand_margin_individual, Godot.Core.StyleBoxFlat.set_shadow_color, Godot.Core.StyleBoxFlat.set_shadow_offset, Godot.Core.StyleBoxFlat.set_shadow_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.StyleBox() instance NodeProperty StyleBoxFlat "anti_aliasing" Bool 'False where nodeProperty = (is_anti_aliased, wrapDroppingSetter set_anti_aliased, Nothing) instance NodeProperty StyleBoxFlat "anti_aliasing_size" Int 'False where nodeProperty = (get_aa_size, wrapDroppingSetter set_aa_size, Nothing) instance NodeProperty StyleBoxFlat "bg_color" Color 'False where nodeProperty = (get_bg_color, wrapDroppingSetter set_bg_color, Nothing) instance NodeProperty StyleBoxFlat "border_blend" Bool 'False where nodeProperty = (get_border_blend, wrapDroppingSetter set_border_blend, Nothing) instance NodeProperty StyleBoxFlat "border_color" Color 'False where nodeProperty = (get_border_color, wrapDroppingSetter set_border_color, Nothing) instance NodeProperty StyleBoxFlat "border_width_bottom" Int 'False where nodeProperty = (wrapIndexedGetter 3 get_border_width, wrapIndexedSetter 3 set_border_width, Nothing) instance NodeProperty StyleBoxFlat "border_width_left" Int 'False where nodeProperty = (wrapIndexedGetter 0 get_border_width, wrapIndexedSetter 0 set_border_width, Nothing) instance NodeProperty StyleBoxFlat "border_width_right" Int 'False where nodeProperty = (wrapIndexedGetter 2 get_border_width, wrapIndexedSetter 2 set_border_width, Nothing) instance NodeProperty StyleBoxFlat "border_width_top" Int 'False where nodeProperty = (wrapIndexedGetter 1 get_border_width, wrapIndexedSetter 1 set_border_width, Nothing) instance NodeProperty StyleBoxFlat "corner_detail" Int 'False where nodeProperty = (get_corner_detail, wrapDroppingSetter set_corner_detail, Nothing) instance NodeProperty StyleBoxFlat "corner_radius_bottom_left" Int 'False where nodeProperty = (wrapIndexedGetter 3 get_corner_radius, wrapIndexedSetter 3 set_corner_radius, Nothing) instance NodeProperty StyleBoxFlat "corner_radius_bottom_right" Int 'False where nodeProperty = (wrapIndexedGetter 2 get_corner_radius, wrapIndexedSetter 2 set_corner_radius, Nothing) instance NodeProperty StyleBoxFlat "corner_radius_top_left" Int 'False where nodeProperty = (wrapIndexedGetter 0 get_corner_radius, wrapIndexedSetter 0 set_corner_radius, Nothing) instance NodeProperty StyleBoxFlat "corner_radius_top_right" Int 'False where nodeProperty = (wrapIndexedGetter 1 get_corner_radius, wrapIndexedSetter 1 set_corner_radius, Nothing) instance NodeProperty StyleBoxFlat "draw_center" Bool 'False where nodeProperty = (is_draw_center_enabled, wrapDroppingSetter set_draw_center, Nothing) instance NodeProperty StyleBoxFlat "expand_margin_bottom" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_expand_margin, wrapIndexedSetter 3 set_expand_margin, Nothing) instance NodeProperty StyleBoxFlat "expand_margin_left" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_expand_margin, wrapIndexedSetter 0 set_expand_margin, Nothing) instance NodeProperty StyleBoxFlat "expand_margin_right" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_expand_margin, wrapIndexedSetter 2 set_expand_margin, Nothing) instance NodeProperty StyleBoxFlat "expand_margin_top" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_expand_margin, wrapIndexedSetter 1 set_expand_margin, Nothing) instance NodeProperty StyleBoxFlat "shadow_color" Color 'False where nodeProperty = (get_shadow_color, wrapDroppingSetter set_shadow_color, Nothing) instance NodeProperty StyleBoxFlat "shadow_offset" Vector2 'False where nodeProperty = (get_shadow_offset, wrapDroppingSetter set_shadow_offset, Nothing) instance NodeProperty StyleBoxFlat "shadow_size" Int 'False where nodeProperty = (get_shadow_size, wrapDroppingSetter set_shadow_size, Nothing) {-# NOINLINE bindStyleBoxFlat_get_aa_size #-} -- | This changes the size of the faded ring. Higher values can be used to achieve a "blurry" effect. bindStyleBoxFlat_get_aa_size :: MethodBind bindStyleBoxFlat_get_aa_size = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_aa_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This changes the size of the faded ring. Higher values can be used to achieve a "blurry" effect. get_aa_size :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Int get_aa_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_aa_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_aa_size" '[] (IO Int) where nodeMethod = Godot.Core.StyleBoxFlat.get_aa_size {-# NOINLINE bindStyleBoxFlat_get_bg_color #-} -- | The background color of the stylebox. bindStyleBoxFlat_get_bg_color :: MethodBind bindStyleBoxFlat_get_bg_color = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The background color of the stylebox. get_bg_color :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Color get_bg_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_bg_color" '[] (IO Color) where nodeMethod = Godot.Core.StyleBoxFlat.get_bg_color {-# NOINLINE bindStyleBoxFlat_get_border_blend #-} -- | If @true@, the border will fade into the background color. bindStyleBoxFlat_get_border_blend :: MethodBind bindStyleBoxFlat_get_border_blend = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_border_blend" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the border will fade into the background color. get_border_blend :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Bool get_border_blend cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_border_blend (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_border_blend" '[] (IO Bool) where nodeMethod = Godot.Core.StyleBoxFlat.get_border_blend {-# NOINLINE bindStyleBoxFlat_get_border_color #-} -- | Sets the color of the border. bindStyleBoxFlat_get_border_color :: MethodBind bindStyleBoxFlat_get_border_color = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_border_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color of the border. get_border_color :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Color get_border_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_border_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_border_color" '[] (IO Color) where nodeMethod = Godot.Core.StyleBoxFlat.get_border_color {-# NOINLINE bindStyleBoxFlat_get_border_width #-} -- | Returns the given @margin@'s border width. See @enum Margin@ for possible values. bindStyleBoxFlat_get_border_width :: MethodBind bindStyleBoxFlat_get_border_width = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_border_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given @margin@'s border width. See @enum Margin@ for possible values. get_border_width :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> IO Int get_border_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_border_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_border_width" '[Int] (IO Int) where nodeMethod = Godot.Core.StyleBoxFlat.get_border_width {-# NOINLINE bindStyleBoxFlat_get_border_width_min #-} -- | Returns the smallest border width out of all four borders. bindStyleBoxFlat_get_border_width_min :: MethodBind bindStyleBoxFlat_get_border_width_min = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_border_width_min" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the smallest border width out of all four borders. get_border_width_min :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Int get_border_width_min cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_border_width_min (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_border_width_min" '[] (IO Int) where nodeMethod = Godot.Core.StyleBoxFlat.get_border_width_min {-# NOINLINE bindStyleBoxFlat_get_corner_detail #-} -- | This sets the amount of vertices used for each corner. Higher values result in rounder corners but take more processing power to compute. When choosing a value, you should take the corner radius (@method set_corner_radius_all@) into account. -- For corner radii smaller than 10, @4@ or @5@ should be enough. For corner radii smaller than 30, values between @8@ and @12@ should be enough. -- A corner detail of @1@ will result in chamfered corners instead of rounded corners, which is useful for some artistic effects. bindStyleBoxFlat_get_corner_detail :: MethodBind bindStyleBoxFlat_get_corner_detail = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_corner_detail" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This sets the amount of vertices used for each corner. Higher values result in rounder corners but take more processing power to compute. When choosing a value, you should take the corner radius (@method set_corner_radius_all@) into account. -- For corner radii smaller than 10, @4@ or @5@ should be enough. For corner radii smaller than 30, values between @8@ and @12@ should be enough. -- A corner detail of @1@ will result in chamfered corners instead of rounded corners, which is useful for some artistic effects. get_corner_detail :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Int get_corner_detail cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_corner_detail (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_corner_detail" '[] (IO Int) where nodeMethod = Godot.Core.StyleBoxFlat.get_corner_detail {-# NOINLINE bindStyleBoxFlat_get_corner_radius #-} -- | Returns the given @corner@'s radius. See @enum Corner@ for possible values. bindStyleBoxFlat_get_corner_radius :: MethodBind bindStyleBoxFlat_get_corner_radius = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_corner_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given @corner@'s radius. See @enum Corner@ for possible values. get_corner_radius :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> IO Int get_corner_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_corner_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_corner_radius" '[Int] (IO Int) where nodeMethod = Godot.Core.StyleBoxFlat.get_corner_radius {-# NOINLINE bindStyleBoxFlat_get_expand_margin #-} -- | Returns the size of the given @margin@'s expand margin. See @enum Margin@ for possible values. bindStyleBoxFlat_get_expand_margin :: MethodBind bindStyleBoxFlat_get_expand_margin = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_expand_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of the given @margin@'s expand margin. See @enum Margin@ for possible values. get_expand_margin :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> IO Float get_expand_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_expand_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_expand_margin" '[Int] (IO Float) where nodeMethod = Godot.Core.StyleBoxFlat.get_expand_margin {-# NOINLINE bindStyleBoxFlat_get_shadow_color #-} -- | The color of the shadow. This has no effect if @shadow_size@ is lower than 1. bindStyleBoxFlat_get_shadow_color :: MethodBind bindStyleBoxFlat_get_shadow_color = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_shadow_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color of the shadow. This has no effect if @shadow_size@ is lower than 1. get_shadow_color :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Color get_shadow_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_shadow_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_shadow_color" '[] (IO Color) where nodeMethod = Godot.Core.StyleBoxFlat.get_shadow_color {-# NOINLINE bindStyleBoxFlat_get_shadow_offset #-} -- | The shadow offset in pixels. Adjusts the position of the shadow relatively to the stylebox. bindStyleBoxFlat_get_shadow_offset :: MethodBind bindStyleBoxFlat_get_shadow_offset = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_shadow_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shadow offset in pixels. Adjusts the position of the shadow relatively to the stylebox. get_shadow_offset :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Vector2 get_shadow_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_shadow_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_shadow_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.StyleBoxFlat.get_shadow_offset {-# NOINLINE bindStyleBoxFlat_get_shadow_size #-} -- | The shadow size in pixels. bindStyleBoxFlat_get_shadow_size :: MethodBind bindStyleBoxFlat_get_shadow_size = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "get_shadow_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shadow size in pixels. get_shadow_size :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Int get_shadow_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_get_shadow_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "get_shadow_size" '[] (IO Int) where nodeMethod = Godot.Core.StyleBoxFlat.get_shadow_size {-# NOINLINE bindStyleBoxFlat_is_anti_aliased #-} -- | Antialiasing draws a small ring around the edges, which fades to transparency. As a result, edges look much smoother. This is only noticeable when using rounded corners. bindStyleBoxFlat_is_anti_aliased :: MethodBind bindStyleBoxFlat_is_anti_aliased = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "is_anti_aliased" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Antialiasing draws a small ring around the edges, which fades to transparency. As a result, edges look much smoother. This is only noticeable when using rounded corners. is_anti_aliased :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Bool is_anti_aliased cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_is_anti_aliased (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "is_anti_aliased" '[] (IO Bool) where nodeMethod = Godot.Core.StyleBoxFlat.is_anti_aliased {-# NOINLINE bindStyleBoxFlat_is_draw_center_enabled #-} -- | Toggles drawing of the inner part of the stylebox. bindStyleBoxFlat_is_draw_center_enabled :: MethodBind bindStyleBoxFlat_is_draw_center_enabled = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "is_draw_center_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Toggles drawing of the inner part of the stylebox. is_draw_center_enabled :: (StyleBoxFlat :< cls, Object :< cls) => cls -> IO Bool is_draw_center_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_is_draw_center_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "is_draw_center_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.StyleBoxFlat.is_draw_center_enabled {-# NOINLINE bindStyleBoxFlat_set_aa_size #-} -- | This changes the size of the faded ring. Higher values can be used to achieve a "blurry" effect. bindStyleBoxFlat_set_aa_size :: MethodBind bindStyleBoxFlat_set_aa_size = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_aa_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This changes the size of the faded ring. Higher values can be used to achieve a "blurry" effect. set_aa_size :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> IO () set_aa_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_aa_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_aa_size" '[Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_aa_size {-# NOINLINE bindStyleBoxFlat_set_anti_aliased #-} -- | Antialiasing draws a small ring around the edges, which fades to transparency. As a result, edges look much smoother. This is only noticeable when using rounded corners. bindStyleBoxFlat_set_anti_aliased :: MethodBind bindStyleBoxFlat_set_anti_aliased = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_anti_aliased" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Antialiasing draws a small ring around the edges, which fades to transparency. As a result, edges look much smoother. This is only noticeable when using rounded corners. set_anti_aliased :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Bool -> IO () set_anti_aliased cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_anti_aliased (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_anti_aliased" '[Bool] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_anti_aliased {-# NOINLINE bindStyleBoxFlat_set_bg_color #-} -- | The background color of the stylebox. bindStyleBoxFlat_set_bg_color :: MethodBind bindStyleBoxFlat_set_bg_color = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The background color of the stylebox. set_bg_color :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Color -> IO () set_bg_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_bg_color" '[Color] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_bg_color {-# NOINLINE bindStyleBoxFlat_set_border_blend #-} -- | If @true@, the border will fade into the background color. bindStyleBoxFlat_set_border_blend :: MethodBind bindStyleBoxFlat_set_border_blend = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_border_blend" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the border will fade into the background color. set_border_blend :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Bool -> IO () set_border_blend cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_border_blend (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_border_blend" '[Bool] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_border_blend {-# NOINLINE bindStyleBoxFlat_set_border_color #-} -- | Sets the color of the border. bindStyleBoxFlat_set_border_color :: MethodBind bindStyleBoxFlat_set_border_color = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_border_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color of the border. set_border_color :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Color -> IO () set_border_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_border_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_border_color" '[Color] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_border_color {-# NOINLINE bindStyleBoxFlat_set_border_width #-} -- | Sets the border width to @width@ pixels for the given @margin@. See @enum Margin@ for possible values. bindStyleBoxFlat_set_border_width :: MethodBind bindStyleBoxFlat_set_border_width = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_border_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the border width to @width@ pixels for the given @margin@. See @enum Margin@ for possible values. set_border_width :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_border_width cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_border_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_border_width" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_border_width {-# NOINLINE bindStyleBoxFlat_set_border_width_all #-} -- | Sets the border width to @width@ pixels for all margins. bindStyleBoxFlat_set_border_width_all :: MethodBind bindStyleBoxFlat_set_border_width_all = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_border_width_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the border width to @width@ pixels for all margins. set_border_width_all :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> IO () set_border_width_all cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_border_width_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_border_width_all" '[Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_border_width_all {-# NOINLINE bindStyleBoxFlat_set_corner_detail #-} -- | This sets the amount of vertices used for each corner. Higher values result in rounder corners but take more processing power to compute. When choosing a value, you should take the corner radius (@method set_corner_radius_all@) into account. -- For corner radii smaller than 10, @4@ or @5@ should be enough. For corner radii smaller than 30, values between @8@ and @12@ should be enough. -- A corner detail of @1@ will result in chamfered corners instead of rounded corners, which is useful for some artistic effects. bindStyleBoxFlat_set_corner_detail :: MethodBind bindStyleBoxFlat_set_corner_detail = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_corner_detail" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This sets the amount of vertices used for each corner. Higher values result in rounder corners but take more processing power to compute. When choosing a value, you should take the corner radius (@method set_corner_radius_all@) into account. -- For corner radii smaller than 10, @4@ or @5@ should be enough. For corner radii smaller than 30, values between @8@ and @12@ should be enough. -- A corner detail of @1@ will result in chamfered corners instead of rounded corners, which is useful for some artistic effects. set_corner_detail :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> IO () set_corner_detail cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_corner_detail (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_corner_detail" '[Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_corner_detail {-# NOINLINE bindStyleBoxFlat_set_corner_radius #-} -- | Sets the corner radius to @radius@ pixels for the given @corner@. See @enum Corner@ for possible values. bindStyleBoxFlat_set_corner_radius :: MethodBind bindStyleBoxFlat_set_corner_radius = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_corner_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the corner radius to @radius@ pixels for the given @corner@. See @enum Corner@ for possible values. set_corner_radius :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_corner_radius cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_corner_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_corner_radius" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_corner_radius {-# NOINLINE bindStyleBoxFlat_set_corner_radius_all #-} -- | Sets the corner radius to @radius@ pixels for all corners. bindStyleBoxFlat_set_corner_radius_all :: MethodBind bindStyleBoxFlat_set_corner_radius_all = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_corner_radius_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the corner radius to @radius@ pixels for all corners. set_corner_radius_all :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> IO () set_corner_radius_all cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_corner_radius_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_corner_radius_all" '[Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_corner_radius_all {-# NOINLINE bindStyleBoxFlat_set_corner_radius_individual #-} -- | Sets the corner radius for each corner to @radius_top_left@, @radius_top_right@, @radius_bottom_right@, and @radius_bottom_left@ pixels. bindStyleBoxFlat_set_corner_radius_individual :: MethodBind bindStyleBoxFlat_set_corner_radius_individual = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_corner_radius_individual" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the corner radius for each corner to @radius_top_left@, @radius_top_right@, @radius_bottom_right@, and @radius_bottom_left@ pixels. set_corner_radius_individual :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> IO () set_corner_radius_individual cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_corner_radius_individual (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_corner_radius_individual" '[Int, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_corner_radius_individual {-# NOINLINE bindStyleBoxFlat_set_draw_center #-} -- | Toggles drawing of the inner part of the stylebox. bindStyleBoxFlat_set_draw_center :: MethodBind bindStyleBoxFlat_set_draw_center = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_draw_center" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Toggles drawing of the inner part of the stylebox. set_draw_center :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Bool -> IO () set_draw_center cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_draw_center (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_draw_center" '[Bool] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_draw_center {-# NOINLINE bindStyleBoxFlat_set_expand_margin #-} -- | Sets the expand margin to @size@ pixels for the given @margin@. See @enum Margin@ for possible values. bindStyleBoxFlat_set_expand_margin :: MethodBind bindStyleBoxFlat_set_expand_margin = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_expand_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the expand margin to @size@ pixels for the given @margin@. See @enum Margin@ for possible values. set_expand_margin :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_expand_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_expand_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_expand_margin" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_expand_margin {-# NOINLINE bindStyleBoxFlat_set_expand_margin_all #-} -- | Sets the expand margin to @size@ pixels for all margins. bindStyleBoxFlat_set_expand_margin_all :: MethodBind bindStyleBoxFlat_set_expand_margin_all = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_expand_margin_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the expand margin to @size@ pixels for all margins. set_expand_margin_all :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Float -> IO () set_expand_margin_all cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_expand_margin_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_expand_margin_all" '[Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_expand_margin_all {-# NOINLINE bindStyleBoxFlat_set_expand_margin_individual #-} -- | Sets the expand margin for each margin to @size_left@, @size_top@, @size_right@, and @size_bottom@ pixels. bindStyleBoxFlat_set_expand_margin_individual :: MethodBind bindStyleBoxFlat_set_expand_margin_individual = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_expand_margin_individual" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the expand margin for each margin to @size_left@, @size_top@, @size_right@, and @size_bottom@ pixels. set_expand_margin_individual :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Float -> Float -> Float -> Float -> IO () set_expand_margin_individual cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_expand_margin_individual (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_expand_margin_individual" '[Float, Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_expand_margin_individual {-# NOINLINE bindStyleBoxFlat_set_shadow_color #-} -- | The color of the shadow. This has no effect if @shadow_size@ is lower than 1. bindStyleBoxFlat_set_shadow_color :: MethodBind bindStyleBoxFlat_set_shadow_color = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_shadow_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The color of the shadow. This has no effect if @shadow_size@ is lower than 1. set_shadow_color :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Color -> IO () set_shadow_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_shadow_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_shadow_color" '[Color] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_shadow_color {-# NOINLINE bindStyleBoxFlat_set_shadow_offset #-} -- | The shadow offset in pixels. Adjusts the position of the shadow relatively to the stylebox. bindStyleBoxFlat_set_shadow_offset :: MethodBind bindStyleBoxFlat_set_shadow_offset = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_shadow_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shadow offset in pixels. Adjusts the position of the shadow relatively to the stylebox. set_shadow_offset :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Vector2 -> IO () set_shadow_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_shadow_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_shadow_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_shadow_offset {-# NOINLINE bindStyleBoxFlat_set_shadow_size #-} -- | The shadow size in pixels. bindStyleBoxFlat_set_shadow_size :: MethodBind bindStyleBoxFlat_set_shadow_size = unsafePerformIO $ withCString "StyleBoxFlat" $ \ clsNamePtr -> withCString "set_shadow_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shadow size in pixels. set_shadow_size :: (StyleBoxFlat :< cls, Object :< cls) => cls -> Int -> IO () set_shadow_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxFlat_set_shadow_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxFlat "set_shadow_size" '[Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxFlat.set_shadow_size ================================================ FILE: src/Godot/Core/StyleBoxLine.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StyleBoxLine (Godot.Core.StyleBoxLine.get_color, Godot.Core.StyleBoxLine.get_grow_begin, Godot.Core.StyleBoxLine.get_grow_end, Godot.Core.StyleBoxLine.get_thickness, Godot.Core.StyleBoxLine.is_vertical, Godot.Core.StyleBoxLine.set_color, Godot.Core.StyleBoxLine.set_grow_begin, Godot.Core.StyleBoxLine.set_grow_end, Godot.Core.StyleBoxLine.set_thickness, Godot.Core.StyleBoxLine.set_vertical) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.StyleBox() instance NodeProperty StyleBoxLine "color" Color 'False where nodeProperty = (get_color, wrapDroppingSetter set_color, Nothing) instance NodeProperty StyleBoxLine "grow_begin" Float 'False where nodeProperty = (get_grow_begin, wrapDroppingSetter set_grow_begin, Nothing) instance NodeProperty StyleBoxLine "grow_end" Float 'False where nodeProperty = (get_grow_end, wrapDroppingSetter set_grow_end, Nothing) instance NodeProperty StyleBoxLine "thickness" Int 'False where nodeProperty = (get_thickness, wrapDroppingSetter set_thickness, Nothing) instance NodeProperty StyleBoxLine "vertical" Bool 'False where nodeProperty = (is_vertical, wrapDroppingSetter set_vertical, Nothing) {-# NOINLINE bindStyleBoxLine_get_color #-} -- | The line's color. bindStyleBoxLine_get_color :: MethodBind bindStyleBoxLine_get_color = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's color. get_color :: (StyleBoxLine :< cls, Object :< cls) => cls -> IO Color get_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "get_color" '[] (IO Color) where nodeMethod = Godot.Core.StyleBoxLine.get_color {-# NOINLINE bindStyleBoxLine_get_grow_begin #-} -- | The number of pixels the line will extend before the @StyleBoxLine@'s bounds. If set to a negative value, the line will begin inside the @StyleBoxLine@'s bounds. bindStyleBoxLine_get_grow_begin :: MethodBind bindStyleBoxLine_get_grow_begin = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "get_grow_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of pixels the line will extend before the @StyleBoxLine@'s bounds. If set to a negative value, the line will begin inside the @StyleBoxLine@'s bounds. get_grow_begin :: (StyleBoxLine :< cls, Object :< cls) => cls -> IO Float get_grow_begin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_get_grow_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "get_grow_begin" '[] (IO Float) where nodeMethod = Godot.Core.StyleBoxLine.get_grow_begin {-# NOINLINE bindStyleBoxLine_get_grow_end #-} -- | The number of pixels the line will extend past the @StyleBoxLine@'s bounds. If set to a negative value, the line will end inside the @StyleBoxLine@'s bounds. bindStyleBoxLine_get_grow_end :: MethodBind bindStyleBoxLine_get_grow_end = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "get_grow_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of pixels the line will extend past the @StyleBoxLine@'s bounds. If set to a negative value, the line will end inside the @StyleBoxLine@'s bounds. get_grow_end :: (StyleBoxLine :< cls, Object :< cls) => cls -> IO Float get_grow_end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_get_grow_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "get_grow_end" '[] (IO Float) where nodeMethod = Godot.Core.StyleBoxLine.get_grow_end {-# NOINLINE bindStyleBoxLine_get_thickness #-} -- | The line's thickness in pixels. bindStyleBoxLine_get_thickness :: MethodBind bindStyleBoxLine_get_thickness = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "get_thickness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's thickness in pixels. get_thickness :: (StyleBoxLine :< cls, Object :< cls) => cls -> IO Int get_thickness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_get_thickness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "get_thickness" '[] (IO Int) where nodeMethod = Godot.Core.StyleBoxLine.get_thickness {-# NOINLINE bindStyleBoxLine_is_vertical #-} -- | If @true@, the line will be vertical. If @false@, the line will be horizontal. bindStyleBoxLine_is_vertical :: MethodBind bindStyleBoxLine_is_vertical = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "is_vertical" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the line will be vertical. If @false@, the line will be horizontal. is_vertical :: (StyleBoxLine :< cls, Object :< cls) => cls -> IO Bool is_vertical cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_is_vertical (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "is_vertical" '[] (IO Bool) where nodeMethod = Godot.Core.StyleBoxLine.is_vertical {-# NOINLINE bindStyleBoxLine_set_color #-} -- | The line's color. bindStyleBoxLine_set_color :: MethodBind bindStyleBoxLine_set_color = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's color. set_color :: (StyleBoxLine :< cls, Object :< cls) => cls -> Color -> IO () set_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "set_color" '[Color] (IO ()) where nodeMethod = Godot.Core.StyleBoxLine.set_color {-# NOINLINE bindStyleBoxLine_set_grow_begin #-} -- | The number of pixels the line will extend before the @StyleBoxLine@'s bounds. If set to a negative value, the line will begin inside the @StyleBoxLine@'s bounds. bindStyleBoxLine_set_grow_begin :: MethodBind bindStyleBoxLine_set_grow_begin = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "set_grow_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of pixels the line will extend before the @StyleBoxLine@'s bounds. If set to a negative value, the line will begin inside the @StyleBoxLine@'s bounds. set_grow_begin :: (StyleBoxLine :< cls, Object :< cls) => cls -> Float -> IO () set_grow_begin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_set_grow_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "set_grow_begin" '[Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxLine.set_grow_begin {-# NOINLINE bindStyleBoxLine_set_grow_end #-} -- | The number of pixels the line will extend past the @StyleBoxLine@'s bounds. If set to a negative value, the line will end inside the @StyleBoxLine@'s bounds. bindStyleBoxLine_set_grow_end :: MethodBind bindStyleBoxLine_set_grow_end = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "set_grow_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of pixels the line will extend past the @StyleBoxLine@'s bounds. If set to a negative value, the line will end inside the @StyleBoxLine@'s bounds. set_grow_end :: (StyleBoxLine :< cls, Object :< cls) => cls -> Float -> IO () set_grow_end cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_set_grow_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "set_grow_end" '[Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxLine.set_grow_end {-# NOINLINE bindStyleBoxLine_set_thickness #-} -- | The line's thickness in pixels. bindStyleBoxLine_set_thickness :: MethodBind bindStyleBoxLine_set_thickness = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "set_thickness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The line's thickness in pixels. set_thickness :: (StyleBoxLine :< cls, Object :< cls) => cls -> Int -> IO () set_thickness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_set_thickness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "set_thickness" '[Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxLine.set_thickness {-# NOINLINE bindStyleBoxLine_set_vertical #-} -- | If @true@, the line will be vertical. If @false@, the line will be horizontal. bindStyleBoxLine_set_vertical :: MethodBind bindStyleBoxLine_set_vertical = unsafePerformIO $ withCString "StyleBoxLine" $ \ clsNamePtr -> withCString "set_vertical" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the line will be vertical. If @false@, the line will be horizontal. set_vertical :: (StyleBoxLine :< cls, Object :< cls) => cls -> Bool -> IO () set_vertical cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxLine_set_vertical (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxLine "set_vertical" '[Bool] (IO ()) where nodeMethod = Godot.Core.StyleBoxLine.set_vertical ================================================ FILE: src/Godot/Core/StyleBoxTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.StyleBoxTexture (Godot.Core.StyleBoxTexture._AXIS_STRETCH_MODE_TILE_FIT, Godot.Core.StyleBoxTexture._AXIS_STRETCH_MODE_TILE, Godot.Core.StyleBoxTexture._AXIS_STRETCH_MODE_STRETCH, Godot.Core.StyleBoxTexture.sig_texture_changed, Godot.Core.StyleBoxTexture.get_expand_margin_size, Godot.Core.StyleBoxTexture.get_h_axis_stretch_mode, Godot.Core.StyleBoxTexture.get_margin_size, Godot.Core.StyleBoxTexture.get_modulate, Godot.Core.StyleBoxTexture.get_normal_map, Godot.Core.StyleBoxTexture.get_region_rect, Godot.Core.StyleBoxTexture.get_texture, Godot.Core.StyleBoxTexture.get_v_axis_stretch_mode, Godot.Core.StyleBoxTexture.is_draw_center_enabled, Godot.Core.StyleBoxTexture.set_draw_center, Godot.Core.StyleBoxTexture.set_expand_margin_all, Godot.Core.StyleBoxTexture.set_expand_margin_individual, Godot.Core.StyleBoxTexture.set_expand_margin_size, Godot.Core.StyleBoxTexture.set_h_axis_stretch_mode, Godot.Core.StyleBoxTexture.set_margin_size, Godot.Core.StyleBoxTexture.set_modulate, Godot.Core.StyleBoxTexture.set_normal_map, Godot.Core.StyleBoxTexture.set_region_rect, Godot.Core.StyleBoxTexture.set_texture, Godot.Core.StyleBoxTexture.set_v_axis_stretch_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.StyleBox() _AXIS_STRETCH_MODE_TILE_FIT :: Int _AXIS_STRETCH_MODE_TILE_FIT = 2 _AXIS_STRETCH_MODE_TILE :: Int _AXIS_STRETCH_MODE_TILE = 1 _AXIS_STRETCH_MODE_STRETCH :: Int _AXIS_STRETCH_MODE_STRETCH = 0 -- | Emitted when the stylebox's texture is changed. sig_texture_changed :: Godot.Internal.Dispatch.Signal StyleBoxTexture sig_texture_changed = Godot.Internal.Dispatch.Signal "texture_changed" instance NodeSignal StyleBoxTexture "texture_changed" '[] instance NodeProperty StyleBoxTexture "axis_stretch_horizontal" Int 'False where nodeProperty = (get_h_axis_stretch_mode, wrapDroppingSetter set_h_axis_stretch_mode, Nothing) instance NodeProperty StyleBoxTexture "axis_stretch_vertical" Int 'False where nodeProperty = (get_v_axis_stretch_mode, wrapDroppingSetter set_v_axis_stretch_mode, Nothing) instance NodeProperty StyleBoxTexture "draw_center" Bool 'False where nodeProperty = (is_draw_center_enabled, wrapDroppingSetter set_draw_center, Nothing) instance NodeProperty StyleBoxTexture "expand_margin_bottom" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_expand_margin_size, wrapIndexedSetter 3 set_expand_margin_size, Nothing) instance NodeProperty StyleBoxTexture "expand_margin_left" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_expand_margin_size, wrapIndexedSetter 0 set_expand_margin_size, Nothing) instance NodeProperty StyleBoxTexture "expand_margin_right" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_expand_margin_size, wrapIndexedSetter 2 set_expand_margin_size, Nothing) instance NodeProperty StyleBoxTexture "expand_margin_top" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_expand_margin_size, wrapIndexedSetter 1 set_expand_margin_size, Nothing) instance NodeProperty StyleBoxTexture "margin_bottom" Float 'False where nodeProperty = (wrapIndexedGetter 3 get_margin_size, wrapIndexedSetter 3 set_margin_size, Nothing) instance NodeProperty StyleBoxTexture "margin_left" Float 'False where nodeProperty = (wrapIndexedGetter 0 get_margin_size, wrapIndexedSetter 0 set_margin_size, Nothing) instance NodeProperty StyleBoxTexture "margin_right" Float 'False where nodeProperty = (wrapIndexedGetter 2 get_margin_size, wrapIndexedSetter 2 set_margin_size, Nothing) instance NodeProperty StyleBoxTexture "margin_top" Float 'False where nodeProperty = (wrapIndexedGetter 1 get_margin_size, wrapIndexedSetter 1 set_margin_size, Nothing) instance NodeProperty StyleBoxTexture "modulate_color" Color 'False where nodeProperty = (get_modulate, wrapDroppingSetter set_modulate, Nothing) instance NodeProperty StyleBoxTexture "normal_map" Texture 'False where nodeProperty = (get_normal_map, wrapDroppingSetter set_normal_map, Nothing) instance NodeProperty StyleBoxTexture "region_rect" Rect2 'False where nodeProperty = (get_region_rect, wrapDroppingSetter set_region_rect, Nothing) instance NodeProperty StyleBoxTexture "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) {-# NOINLINE bindStyleBoxTexture_get_expand_margin_size #-} -- | Returns the size of the given @margin@'s expand margin. See @enum Margin@ for possible values. bindStyleBoxTexture_get_expand_margin_size :: MethodBind bindStyleBoxTexture_get_expand_margin_size = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "get_expand_margin_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of the given @margin@'s expand margin. See @enum Margin@ for possible values. get_expand_margin_size :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Int -> IO Float get_expand_margin_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_get_expand_margin_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "get_expand_margin_size" '[Int] (IO Float) where nodeMethod = Godot.Core.StyleBoxTexture.get_expand_margin_size {-# NOINLINE bindStyleBoxTexture_get_h_axis_stretch_mode #-} -- | Controls how the stylebox's texture will be stretched or tiled horizontally. See @enum AxisStretchMode@ for possible values. bindStyleBoxTexture_get_h_axis_stretch_mode :: MethodBind bindStyleBoxTexture_get_h_axis_stretch_mode = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "get_h_axis_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how the stylebox's texture will be stretched or tiled horizontally. See @enum AxisStretchMode@ for possible values. get_h_axis_stretch_mode :: (StyleBoxTexture :< cls, Object :< cls) => cls -> IO Int get_h_axis_stretch_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_get_h_axis_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "get_h_axis_stretch_mode" '[] (IO Int) where nodeMethod = Godot.Core.StyleBoxTexture.get_h_axis_stretch_mode {-# NOINLINE bindStyleBoxTexture_get_margin_size #-} -- | Returns the size of the given @margin@. See @enum Margin@ for possible values. bindStyleBoxTexture_get_margin_size :: MethodBind bindStyleBoxTexture_get_margin_size = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "get_margin_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of the given @margin@. See @enum Margin@ for possible values. get_margin_size :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Int -> IO Float get_margin_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_get_margin_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "get_margin_size" '[Int] (IO Float) where nodeMethod = Godot.Core.StyleBoxTexture.get_margin_size {-# NOINLINE bindStyleBoxTexture_get_modulate #-} -- | Modulates the color of the texture when this style box is drawn. bindStyleBoxTexture_get_modulate :: MethodBind bindStyleBoxTexture_get_modulate = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "get_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Modulates the color of the texture when this style box is drawn. get_modulate :: (StyleBoxTexture :< cls, Object :< cls) => cls -> IO Color get_modulate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_get_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "get_modulate" '[] (IO Color) where nodeMethod = Godot.Core.StyleBoxTexture.get_modulate {-# NOINLINE bindStyleBoxTexture_get_normal_map #-} -- | The normal map to use when drawing this style box. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindStyleBoxTexture_get_normal_map :: MethodBind bindStyleBoxTexture_get_normal_map = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "get_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The normal map to use when drawing this style box. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. get_normal_map :: (StyleBoxTexture :< cls, Object :< cls) => cls -> IO Texture get_normal_map cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_get_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "get_normal_map" '[] (IO Texture) where nodeMethod = Godot.Core.StyleBoxTexture.get_normal_map {-# NOINLINE bindStyleBoxTexture_get_region_rect #-} -- | Species a sub-region of the texture to use. -- This is equivalent to first wrapping the texture in an @AtlasTexture@ with the same region. bindStyleBoxTexture_get_region_rect :: MethodBind bindStyleBoxTexture_get_region_rect = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "get_region_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Species a sub-region of the texture to use. -- This is equivalent to first wrapping the texture in an @AtlasTexture@ with the same region. get_region_rect :: (StyleBoxTexture :< cls, Object :< cls) => cls -> IO Rect2 get_region_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_get_region_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "get_region_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.StyleBoxTexture.get_region_rect {-# NOINLINE bindStyleBoxTexture_get_texture #-} -- | The texture to use when drawing this style box. bindStyleBoxTexture_get_texture :: MethodBind bindStyleBoxTexture_get_texture = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture to use when drawing this style box. get_texture :: (StyleBoxTexture :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.StyleBoxTexture.get_texture {-# NOINLINE bindStyleBoxTexture_get_v_axis_stretch_mode #-} -- | Controls how the stylebox's texture will be stretched or tiled vertically. See @enum AxisStretchMode@ for possible values. bindStyleBoxTexture_get_v_axis_stretch_mode :: MethodBind bindStyleBoxTexture_get_v_axis_stretch_mode = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "get_v_axis_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how the stylebox's texture will be stretched or tiled vertically. See @enum AxisStretchMode@ for possible values. get_v_axis_stretch_mode :: (StyleBoxTexture :< cls, Object :< cls) => cls -> IO Int get_v_axis_stretch_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_get_v_axis_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "get_v_axis_stretch_mode" '[] (IO Int) where nodeMethod = Godot.Core.StyleBoxTexture.get_v_axis_stretch_mode {-# NOINLINE bindStyleBoxTexture_is_draw_center_enabled #-} -- | If @true@, the nine-patch texture's center tile will be drawn. bindStyleBoxTexture_is_draw_center_enabled :: MethodBind bindStyleBoxTexture_is_draw_center_enabled = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "is_draw_center_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the nine-patch texture's center tile will be drawn. is_draw_center_enabled :: (StyleBoxTexture :< cls, Object :< cls) => cls -> IO Bool is_draw_center_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_is_draw_center_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "is_draw_center_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.StyleBoxTexture.is_draw_center_enabled {-# NOINLINE bindStyleBoxTexture_set_draw_center #-} -- | If @true@, the nine-patch texture's center tile will be drawn. bindStyleBoxTexture_set_draw_center :: MethodBind bindStyleBoxTexture_set_draw_center = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_draw_center" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the nine-patch texture's center tile will be drawn. set_draw_center :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Bool -> IO () set_draw_center cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_draw_center (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_draw_center" '[Bool] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_draw_center {-# NOINLINE bindStyleBoxTexture_set_expand_margin_all #-} -- | Sets the expand margin to @size@ pixels for all margins. bindStyleBoxTexture_set_expand_margin_all :: MethodBind bindStyleBoxTexture_set_expand_margin_all = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_expand_margin_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the expand margin to @size@ pixels for all margins. set_expand_margin_all :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Float -> IO () set_expand_margin_all cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_expand_margin_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_expand_margin_all" '[Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_expand_margin_all {-# NOINLINE bindStyleBoxTexture_set_expand_margin_individual #-} -- | Sets the expand margin for each margin to @size_left@, @size_top@, @size_right@, and @size_bottom@ pixels. bindStyleBoxTexture_set_expand_margin_individual :: MethodBind bindStyleBoxTexture_set_expand_margin_individual = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_expand_margin_individual" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the expand margin for each margin to @size_left@, @size_top@, @size_right@, and @size_bottom@ pixels. set_expand_margin_individual :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Float -> Float -> Float -> Float -> IO () set_expand_margin_individual cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_expand_margin_individual (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_expand_margin_individual" '[Float, Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_expand_margin_individual {-# NOINLINE bindStyleBoxTexture_set_expand_margin_size #-} -- | Sets the expand margin to @size@ pixels for the given @margin@. See @enum Margin@ for possible values. bindStyleBoxTexture_set_expand_margin_size :: MethodBind bindStyleBoxTexture_set_expand_margin_size = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_expand_margin_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the expand margin to @size@ pixels for the given @margin@. See @enum Margin@ for possible values. set_expand_margin_size :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_expand_margin_size cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_expand_margin_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_expand_margin_size" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_expand_margin_size {-# NOINLINE bindStyleBoxTexture_set_h_axis_stretch_mode #-} -- | Controls how the stylebox's texture will be stretched or tiled horizontally. See @enum AxisStretchMode@ for possible values. bindStyleBoxTexture_set_h_axis_stretch_mode :: MethodBind bindStyleBoxTexture_set_h_axis_stretch_mode = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_h_axis_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how the stylebox's texture will be stretched or tiled horizontally. See @enum AxisStretchMode@ for possible values. set_h_axis_stretch_mode :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Int -> IO () set_h_axis_stretch_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_h_axis_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_h_axis_stretch_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_h_axis_stretch_mode {-# NOINLINE bindStyleBoxTexture_set_margin_size #-} -- | Sets the margin to @size@ pixels for the given @margin@. See @enum Margin@ for possible values. bindStyleBoxTexture_set_margin_size :: MethodBind bindStyleBoxTexture_set_margin_size = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_margin_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the margin to @size@ pixels for the given @margin@. See @enum Margin@ for possible values. set_margin_size :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_margin_size cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_margin_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_margin_size" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_margin_size {-# NOINLINE bindStyleBoxTexture_set_modulate #-} -- | Modulates the color of the texture when this style box is drawn. bindStyleBoxTexture_set_modulate :: MethodBind bindStyleBoxTexture_set_modulate = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Modulates the color of the texture when this style box is drawn. set_modulate :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Color -> IO () set_modulate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_modulate" '[Color] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_modulate {-# NOINLINE bindStyleBoxTexture_set_normal_map #-} -- | The normal map to use when drawing this style box. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindStyleBoxTexture_set_normal_map :: MethodBind bindStyleBoxTexture_set_normal_map = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The normal map to use when drawing this style box. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. set_normal_map :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Texture -> IO () set_normal_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_normal_map" '[Texture] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_normal_map {-# NOINLINE bindStyleBoxTexture_set_region_rect #-} -- | Species a sub-region of the texture to use. -- This is equivalent to first wrapping the texture in an @AtlasTexture@ with the same region. bindStyleBoxTexture_set_region_rect :: MethodBind bindStyleBoxTexture_set_region_rect = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_region_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Species a sub-region of the texture to use. -- This is equivalent to first wrapping the texture in an @AtlasTexture@ with the same region. set_region_rect :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Rect2 -> IO () set_region_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_region_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_region_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_region_rect {-# NOINLINE bindStyleBoxTexture_set_texture #-} -- | The texture to use when drawing this style box. bindStyleBoxTexture_set_texture :: MethodBind bindStyleBoxTexture_set_texture = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture to use when drawing this style box. set_texture :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_texture {-# NOINLINE bindStyleBoxTexture_set_v_axis_stretch_mode #-} -- | Controls how the stylebox's texture will be stretched or tiled vertically. See @enum AxisStretchMode@ for possible values. bindStyleBoxTexture_set_v_axis_stretch_mode :: MethodBind bindStyleBoxTexture_set_v_axis_stretch_mode = unsafePerformIO $ withCString "StyleBoxTexture" $ \ clsNamePtr -> withCString "set_v_axis_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls how the stylebox's texture will be stretched or tiled vertically. See @enum AxisStretchMode@ for possible values. set_v_axis_stretch_mode :: (StyleBoxTexture :< cls, Object :< cls) => cls -> Int -> IO () set_v_axis_stretch_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindStyleBoxTexture_set_v_axis_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod StyleBoxTexture "set_v_axis_stretch_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.StyleBoxTexture.set_v_axis_stretch_mode ================================================ FILE: src/Godot/Core/SurfaceTool.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.SurfaceTool (Godot.Core.SurfaceTool.add_bones, Godot.Core.SurfaceTool.add_color, Godot.Core.SurfaceTool.add_index, Godot.Core.SurfaceTool.add_normal, Godot.Core.SurfaceTool.add_smooth_group, Godot.Core.SurfaceTool.add_tangent, Godot.Core.SurfaceTool.add_triangle_fan, Godot.Core.SurfaceTool.add_uv, Godot.Core.SurfaceTool.add_uv2, Godot.Core.SurfaceTool.add_vertex, Godot.Core.SurfaceTool.add_weights, Godot.Core.SurfaceTool.append_from, Godot.Core.SurfaceTool.begin, Godot.Core.SurfaceTool.clear, Godot.Core.SurfaceTool.commit, Godot.Core.SurfaceTool.commit_to_arrays, Godot.Core.SurfaceTool.create_from, Godot.Core.SurfaceTool.create_from_blend_shape, Godot.Core.SurfaceTool.deindex, Godot.Core.SurfaceTool.generate_normals, Godot.Core.SurfaceTool.generate_tangents, Godot.Core.SurfaceTool.index, Godot.Core.SurfaceTool.set_material) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindSurfaceTool_add_bones #-} -- | Adds an array of bones for the next vertex to use. @bones@ must contain 4 integers. bindSurfaceTool_add_bones :: MethodBind bindSurfaceTool_add_bones = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_bones" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an array of bones for the next vertex to use. @bones@ must contain 4 integers. add_bones :: (SurfaceTool :< cls, Object :< cls) => cls -> PoolIntArray -> IO () add_bones cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_bones (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_bones" '[PoolIntArray] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_bones {-# NOINLINE bindSurfaceTool_add_color #-} -- | Specifies a @Color@ for the next vertex to use. bindSurfaceTool_add_color :: MethodBind bindSurfaceTool_add_color = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies a @Color@ for the next vertex to use. add_color :: (SurfaceTool :< cls, Object :< cls) => cls -> Color -> IO () add_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_color" '[Color] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_color {-# NOINLINE bindSurfaceTool_add_index #-} -- | Adds an index to index array if you are using indexed vertices. Does not need to be called before adding vertices. bindSurfaceTool_add_index :: MethodBind bindSurfaceTool_add_index = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an index to index array if you are using indexed vertices. Does not need to be called before adding vertices. add_index :: (SurfaceTool :< cls, Object :< cls) => cls -> Int -> IO () add_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_index" '[Int] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_index {-# NOINLINE bindSurfaceTool_add_normal #-} -- | Specifies a normal for the next vertex to use. bindSurfaceTool_add_normal :: MethodBind bindSurfaceTool_add_normal = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies a normal for the next vertex to use. add_normal :: (SurfaceTool :< cls, Object :< cls) => cls -> Vector3 -> IO () add_normal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_normal" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_normal {-# NOINLINE bindSurfaceTool_add_smooth_group #-} -- | Specifies whether the current vertex (if using only vertex arrays) or current index (if also using index arrays) should use smooth normals for normal calculation. bindSurfaceTool_add_smooth_group :: MethodBind bindSurfaceTool_add_smooth_group = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_smooth_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies whether the current vertex (if using only vertex arrays) or current index (if also using index arrays) should use smooth normals for normal calculation. add_smooth_group :: (SurfaceTool :< cls, Object :< cls) => cls -> Bool -> IO () add_smooth_group cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_smooth_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_smooth_group" '[Bool] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_smooth_group {-# NOINLINE bindSurfaceTool_add_tangent #-} -- | Specifies a tangent for the next vertex to use. bindSurfaceTool_add_tangent :: MethodBind bindSurfaceTool_add_tangent = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies a tangent for the next vertex to use. add_tangent :: (SurfaceTool :< cls, Object :< cls) => cls -> Plane -> IO () add_tangent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_tangent" '[Plane] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_tangent {-# NOINLINE bindSurfaceTool_add_triangle_fan #-} -- | Inserts a triangle fan made of array data into @Mesh@ being constructed. -- Requires the primitive type be set to @Mesh.PRIMITIVE_TRIANGLES@. bindSurfaceTool_add_triangle_fan :: MethodBind bindSurfaceTool_add_triangle_fan = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_triangle_fan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Inserts a triangle fan made of array data into @Mesh@ being constructed. -- Requires the primitive type be set to @Mesh.PRIMITIVE_TRIANGLES@. add_triangle_fan :: (SurfaceTool :< cls, Object :< cls) => cls -> PoolVector3Array -> Maybe PoolVector2Array -> Maybe PoolColorArray -> Maybe PoolVector2Array -> Maybe PoolVector3Array -> Maybe Array -> IO () add_triangle_fan cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, defaultedVariant VariantPoolVector2Array V.empty arg2, defaultedVariant VariantPoolColorArray V.empty arg3, defaultedVariant VariantPoolVector2Array V.empty arg4, defaultedVariant VariantPoolVector3Array V.empty arg5, defaultedVariant VariantArray V.empty arg6] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_triangle_fan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_triangle_fan" '[PoolVector3Array, Maybe PoolVector2Array, Maybe PoolColorArray, Maybe PoolVector2Array, Maybe PoolVector3Array, Maybe Array] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_triangle_fan {-# NOINLINE bindSurfaceTool_add_uv #-} -- | Specifies a set of UV coordinates to use for the next vertex. bindSurfaceTool_add_uv :: MethodBind bindSurfaceTool_add_uv = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies a set of UV coordinates to use for the next vertex. add_uv :: (SurfaceTool :< cls, Object :< cls) => cls -> Vector2 -> IO () add_uv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_uv" '[Vector2] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_uv {-# NOINLINE bindSurfaceTool_add_uv2 #-} -- | Specifies an optional second set of UV coordinates to use for the next vertex. bindSurfaceTool_add_uv2 :: MethodBind bindSurfaceTool_add_uv2 = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_uv2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies an optional second set of UV coordinates to use for the next vertex. add_uv2 :: (SurfaceTool :< cls, Object :< cls) => cls -> Vector2 -> IO () add_uv2 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_uv2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_uv2" '[Vector2] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_uv2 {-# NOINLINE bindSurfaceTool_add_vertex #-} -- | Specifies the position of current vertex. Should be called after specifying other vertex properties (e.g. Color, UV). bindSurfaceTool_add_vertex :: MethodBind bindSurfaceTool_add_vertex = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_vertex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the position of current vertex. Should be called after specifying other vertex properties (e.g. Color, UV). add_vertex :: (SurfaceTool :< cls, Object :< cls) => cls -> Vector3 -> IO () add_vertex cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_vertex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_vertex" '[Vector3] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_vertex {-# NOINLINE bindSurfaceTool_add_weights #-} -- | Specifies weight values for next vertex to use. @weights@ must contain 4 values. bindSurfaceTool_add_weights :: MethodBind bindSurfaceTool_add_weights = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "add_weights" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies weight values for next vertex to use. @weights@ must contain 4 values. add_weights :: (SurfaceTool :< cls, Object :< cls) => cls -> PoolRealArray -> IO () add_weights cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_add_weights (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "add_weights" '[PoolRealArray] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.add_weights {-# NOINLINE bindSurfaceTool_append_from #-} -- | Append vertices from a given @Mesh@ surface onto the current vertex array with specified @Transform@. bindSurfaceTool_append_from :: MethodBind bindSurfaceTool_append_from = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "append_from" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Append vertices from a given @Mesh@ surface onto the current vertex array with specified @Transform@. append_from :: (SurfaceTool :< cls, Object :< cls) => cls -> Mesh -> Int -> Transform -> IO () append_from cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_append_from (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "append_from" '[Mesh, Int, Transform] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.append_from {-# NOINLINE bindSurfaceTool_begin #-} -- | Called before adding any vertices. Takes the primitive type as an argument (e.g. @Mesh.PRIMITIVE_TRIANGLES@). bindSurfaceTool_begin :: MethodBind bindSurfaceTool_begin = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called before adding any vertices. Takes the primitive type as an argument (e.g. @Mesh.PRIMITIVE_TRIANGLES@). begin :: (SurfaceTool :< cls, Object :< cls) => cls -> Int -> IO () begin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "begin" '[Int] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.begin {-# NOINLINE bindSurfaceTool_clear #-} -- | Clear all information passed into the surface tool so far. bindSurfaceTool_clear :: MethodBind bindSurfaceTool_clear = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear all information passed into the surface tool so far. clear :: (SurfaceTool :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "clear" '[] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.clear {-# NOINLINE bindSurfaceTool_commit #-} -- | Returns a constructed @ArrayMesh@ from current information passed in. If an existing @ArrayMesh@ is passed in as an argument, will add an extra surface to the existing @ArrayMesh@. -- Default flag is @Mesh.ARRAY_COMPRESS_DEFAULT@. See @ARRAY_COMPRESS_*@ constants in @enum Mesh.ArrayFormat@ for other flags. bindSurfaceTool_commit :: MethodBind bindSurfaceTool_commit = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "commit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a constructed @ArrayMesh@ from current information passed in. If an existing @ArrayMesh@ is passed in as an argument, will add an extra surface to the existing @ArrayMesh@. -- Default flag is @Mesh.ARRAY_COMPRESS_DEFAULT@. See @ARRAY_COMPRESS_*@ constants in @enum Mesh.ArrayFormat@ for other flags. commit :: (SurfaceTool :< cls, Object :< cls) => cls -> Maybe ArrayMesh -> Maybe Int -> IO ArrayMesh commit cls arg1 arg2 = withVariantArray [maybe VariantNil toVariant arg1, maybe (VariantInt (97280)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_commit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "commit" '[Maybe ArrayMesh, Maybe Int] (IO ArrayMesh) where nodeMethod = Godot.Core.SurfaceTool.commit {-# NOINLINE bindSurfaceTool_commit_to_arrays #-} -- | Commits the data to the same format used by @method ArrayMesh.add_surface_from_arrays@. This way you can further process the mesh data using the @ArrayMesh@ API. bindSurfaceTool_commit_to_arrays :: MethodBind bindSurfaceTool_commit_to_arrays = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "commit_to_arrays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Commits the data to the same format used by @method ArrayMesh.add_surface_from_arrays@. This way you can further process the mesh data using the @ArrayMesh@ API. commit_to_arrays :: (SurfaceTool :< cls, Object :< cls) => cls -> IO Array commit_to_arrays cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_commit_to_arrays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "commit_to_arrays" '[] (IO Array) where nodeMethod = Godot.Core.SurfaceTool.commit_to_arrays {-# NOINLINE bindSurfaceTool_create_from #-} -- | Creates a vertex array from an existing @Mesh@. bindSurfaceTool_create_from :: MethodBind bindSurfaceTool_create_from = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "create_from" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a vertex array from an existing @Mesh@. create_from :: (SurfaceTool :< cls, Object :< cls) => cls -> Mesh -> Int -> IO () create_from cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_create_from (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "create_from" '[Mesh, Int] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.create_from {-# NOINLINE bindSurfaceTool_create_from_blend_shape #-} -- | Creates a vertex array from the specified blend shape of an existing @Mesh@. This can be used to extract a specific pose from a blend shape. bindSurfaceTool_create_from_blend_shape :: MethodBind bindSurfaceTool_create_from_blend_shape = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "create_from_blend_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a vertex array from the specified blend shape of an existing @Mesh@. This can be used to extract a specific pose from a blend shape. create_from_blend_shape :: (SurfaceTool :< cls, Object :< cls) => cls -> Mesh -> Int -> GodotString -> IO () create_from_blend_shape cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_create_from_blend_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "create_from_blend_shape" '[Mesh, Int, GodotString] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.create_from_blend_shape {-# NOINLINE bindSurfaceTool_deindex #-} -- | Removes the index array by expanding the vertex array. bindSurfaceTool_deindex :: MethodBind bindSurfaceTool_deindex = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "deindex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the index array by expanding the vertex array. deindex :: (SurfaceTool :< cls, Object :< cls) => cls -> IO () deindex cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_deindex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "deindex" '[] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.deindex {-# NOINLINE bindSurfaceTool_generate_normals #-} -- | Generates normals from vertices so you do not have to do it manually. If @flip@ is @true@, the resulting normals will be inverted. -- Requires the primitive type to be set to @Mesh.PRIMITIVE_TRIANGLES@. bindSurfaceTool_generate_normals :: MethodBind bindSurfaceTool_generate_normals = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "generate_normals" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates normals from vertices so you do not have to do it manually. If @flip@ is @true@, the resulting normals will be inverted. -- Requires the primitive type to be set to @Mesh.PRIMITIVE_TRIANGLES@. generate_normals :: (SurfaceTool :< cls, Object :< cls) => cls -> Maybe Bool -> IO () generate_normals cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_generate_normals (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "generate_normals" '[Maybe Bool] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.generate_normals {-# NOINLINE bindSurfaceTool_generate_tangents #-} -- | Generates a tangent vector for each vertex. Requires that each vertex have UVs and normals set already. bindSurfaceTool_generate_tangents :: MethodBind bindSurfaceTool_generate_tangents = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "generate_tangents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generates a tangent vector for each vertex. Requires that each vertex have UVs and normals set already. generate_tangents :: (SurfaceTool :< cls, Object :< cls) => cls -> IO () generate_tangents cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_generate_tangents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "generate_tangents" '[] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.generate_tangents {-# NOINLINE bindSurfaceTool_index #-} -- | Shrinks the vertex array by creating an index array (avoids reusing vertices). bindSurfaceTool_index :: MethodBind bindSurfaceTool_index = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shrinks the vertex array by creating an index array (avoids reusing vertices). index :: (SurfaceTool :< cls, Object :< cls) => cls -> IO () index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "index" '[] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.index {-# NOINLINE bindSurfaceTool_set_material #-} -- | Sets @Material@ to be used by the @Mesh@ you are constructing. bindSurfaceTool_set_material :: MethodBind bindSurfaceTool_set_material = unsafePerformIO $ withCString "SurfaceTool" $ \ clsNamePtr -> withCString "set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets @Material@ to be used by the @Mesh@ you are constructing. set_material :: (SurfaceTool :< cls, Object :< cls) => cls -> Material -> IO () set_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindSurfaceTool_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod SurfaceTool "set_material" '[Material] (IO ()) where nodeMethod = Godot.Core.SurfaceTool.set_material ================================================ FILE: src/Godot/Core/TCP_Server.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TCP_Server (Godot.Core.TCP_Server.is_connection_available, Godot.Core.TCP_Server.is_listening, Godot.Core.TCP_Server.listen, Godot.Core.TCP_Server.stop, Godot.Core.TCP_Server.take_connection) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindTCP_Server_is_connection_available #-} -- | Returns @true@ if a connection is available for taking. bindTCP_Server_is_connection_available :: MethodBind bindTCP_Server_is_connection_available = unsafePerformIO $ withCString "TCP_Server" $ \ clsNamePtr -> withCString "is_connection_available" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a connection is available for taking. is_connection_available :: (TCP_Server :< cls, Object :< cls) => cls -> IO Bool is_connection_available cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTCP_Server_is_connection_available (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TCP_Server "is_connection_available" '[] (IO Bool) where nodeMethod = Godot.Core.TCP_Server.is_connection_available {-# NOINLINE bindTCP_Server_is_listening #-} -- | Returns @true@ if the server is currently listening for connections. bindTCP_Server_is_listening :: MethodBind bindTCP_Server_is_listening = unsafePerformIO $ withCString "TCP_Server" $ \ clsNamePtr -> withCString "is_listening" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the server is currently listening for connections. is_listening :: (TCP_Server :< cls, Object :< cls) => cls -> IO Bool is_listening cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTCP_Server_is_listening (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TCP_Server "is_listening" '[] (IO Bool) where nodeMethod = Godot.Core.TCP_Server.is_listening {-# NOINLINE bindTCP_Server_listen #-} -- | Listen on the @port@ binding to @bind_address@. -- If @bind_address@ is set as @"*"@ (default), the server will listen on all available addresses (both IPv4 and IPv6). -- If @bind_address@ is set as @"0.0.0.0"@ (for IPv4) or @"::"@ (for IPv6), the server will listen on all available addresses matching that IP type. -- If @bind_address@ is set to any valid address (e.g. @"192.168.1.101"@, @"::1"@, etc), the server will only listen on the interface with that addresses (or fail if no interface with the given address exists). bindTCP_Server_listen :: MethodBind bindTCP_Server_listen = unsafePerformIO $ withCString "TCP_Server" $ \ clsNamePtr -> withCString "listen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Listen on the @port@ binding to @bind_address@. -- If @bind_address@ is set as @"*"@ (default), the server will listen on all available addresses (both IPv4 and IPv6). -- If @bind_address@ is set as @"0.0.0.0"@ (for IPv4) or @"::"@ (for IPv6), the server will listen on all available addresses matching that IP type. -- If @bind_address@ is set to any valid address (e.g. @"192.168.1.101"@, @"::1"@, etc), the server will only listen on the interface with that addresses (or fail if no interface with the given address exists). listen :: (TCP_Server :< cls, Object :< cls) => cls -> Int -> Maybe GodotString -> IO Int listen cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "*" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTCP_Server_listen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TCP_Server "listen" '[Int, Maybe GodotString] (IO Int) where nodeMethod = Godot.Core.TCP_Server.listen {-# NOINLINE bindTCP_Server_stop #-} -- | Stops listening. bindTCP_Server_stop :: MethodBind bindTCP_Server_stop = unsafePerformIO $ withCString "TCP_Server" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops listening. stop :: (TCP_Server :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTCP_Server_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TCP_Server "stop" '[] (IO ()) where nodeMethod = Godot.Core.TCP_Server.stop {-# NOINLINE bindTCP_Server_take_connection #-} -- | If a connection is available, returns a StreamPeerTCP with the connection. bindTCP_Server_take_connection :: MethodBind bindTCP_Server_take_connection = unsafePerformIO $ withCString "TCP_Server" $ \ clsNamePtr -> withCString "take_connection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If a connection is available, returns a StreamPeerTCP with the connection. take_connection :: (TCP_Server :< cls, Object :< cls) => cls -> IO StreamPeerTCP take_connection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTCP_Server_take_connection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TCP_Server "take_connection" '[] (IO StreamPeerTCP) where nodeMethod = Godot.Core.TCP_Server.take_connection ================================================ FILE: src/Godot/Core/TabContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TabContainer (Godot.Core.TabContainer._ALIGN_RIGHT, Godot.Core.TabContainer._ALIGN_LEFT, Godot.Core.TabContainer._ALIGN_CENTER, Godot.Core.TabContainer.sig_pre_popup_pressed, Godot.Core.TabContainer.sig_tab_changed, Godot.Core.TabContainer.sig_tab_selected, Godot.Core.TabContainer._child_renamed_callback, Godot.Core.TabContainer._gui_input, Godot.Core.TabContainer._on_mouse_exited, Godot.Core.TabContainer._on_theme_changed, Godot.Core.TabContainer._update_current_tab, Godot.Core.TabContainer.are_tabs_visible, Godot.Core.TabContainer.get_current_tab, Godot.Core.TabContainer.get_current_tab_control, Godot.Core.TabContainer.get_drag_to_rearrange_enabled, Godot.Core.TabContainer.get_popup, Godot.Core.TabContainer.get_previous_tab, Godot.Core.TabContainer.get_tab_align, Godot.Core.TabContainer.get_tab_control, Godot.Core.TabContainer.get_tab_count, Godot.Core.TabContainer.get_tab_disabled, Godot.Core.TabContainer.get_tab_icon, Godot.Core.TabContainer.get_tab_title, Godot.Core.TabContainer.get_tabs_rearrange_group, Godot.Core.TabContainer.get_use_hidden_tabs_for_min_size, Godot.Core.TabContainer.set_current_tab, Godot.Core.TabContainer.set_drag_to_rearrange_enabled, Godot.Core.TabContainer.set_popup, Godot.Core.TabContainer.set_tab_align, Godot.Core.TabContainer.set_tab_disabled, Godot.Core.TabContainer.set_tab_icon, Godot.Core.TabContainer.set_tab_title, Godot.Core.TabContainer.set_tabs_rearrange_group, Godot.Core.TabContainer.set_tabs_visible, Godot.Core.TabContainer.set_use_hidden_tabs_for_min_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() _ALIGN_RIGHT :: Int _ALIGN_RIGHT = 2 _ALIGN_LEFT :: Int _ALIGN_LEFT = 0 _ALIGN_CENTER :: Int _ALIGN_CENTER = 1 -- | Emitted when the @TabContainer@'s @Popup@ button is clicked. See @method set_popup@ for details. sig_pre_popup_pressed :: Godot.Internal.Dispatch.Signal TabContainer sig_pre_popup_pressed = Godot.Internal.Dispatch.Signal "pre_popup_pressed" instance NodeSignal TabContainer "pre_popup_pressed" '[] -- | Emitted when switching to another tab. sig_tab_changed :: Godot.Internal.Dispatch.Signal TabContainer sig_tab_changed = Godot.Internal.Dispatch.Signal "tab_changed" instance NodeSignal TabContainer "tab_changed" '[Int] -- | Emitted when a tab is selected, even if it is the current tab. sig_tab_selected :: Godot.Internal.Dispatch.Signal TabContainer sig_tab_selected = Godot.Internal.Dispatch.Signal "tab_selected" instance NodeSignal TabContainer "tab_selected" '[Int] instance NodeProperty TabContainer "current_tab" Int 'False where nodeProperty = (get_current_tab, wrapDroppingSetter set_current_tab, Nothing) instance NodeProperty TabContainer "drag_to_rearrange_enabled" Bool 'False where nodeProperty = (get_drag_to_rearrange_enabled, wrapDroppingSetter set_drag_to_rearrange_enabled, Nothing) instance NodeProperty TabContainer "tab_align" Int 'False where nodeProperty = (get_tab_align, wrapDroppingSetter set_tab_align, Nothing) instance NodeProperty TabContainer "tabs_visible" Bool 'False where nodeProperty = (are_tabs_visible, wrapDroppingSetter set_tabs_visible, Nothing) instance NodeProperty TabContainer "use_hidden_tabs_for_min_size" Bool 'False where nodeProperty = (get_use_hidden_tabs_for_min_size, wrapDroppingSetter set_use_hidden_tabs_for_min_size, Nothing) {-# NOINLINE bindTabContainer__child_renamed_callback #-} bindTabContainer__child_renamed_callback :: MethodBind bindTabContainer__child_renamed_callback = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "_child_renamed_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _child_renamed_callback :: (TabContainer :< cls, Object :< cls) => cls -> IO () _child_renamed_callback cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer__child_renamed_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "_child_renamed_callback" '[] (IO ()) where nodeMethod = Godot.Core.TabContainer._child_renamed_callback {-# NOINLINE bindTabContainer__gui_input #-} bindTabContainer__gui_input :: MethodBind bindTabContainer__gui_input = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (TabContainer :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.TabContainer._gui_input {-# NOINLINE bindTabContainer__on_mouse_exited #-} bindTabContainer__on_mouse_exited :: MethodBind bindTabContainer__on_mouse_exited = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "_on_mouse_exited" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _on_mouse_exited :: (TabContainer :< cls, Object :< cls) => cls -> IO () _on_mouse_exited cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer__on_mouse_exited (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "_on_mouse_exited" '[] (IO ()) where nodeMethod = Godot.Core.TabContainer._on_mouse_exited {-# NOINLINE bindTabContainer__on_theme_changed #-} bindTabContainer__on_theme_changed :: MethodBind bindTabContainer__on_theme_changed = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "_on_theme_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _on_theme_changed :: (TabContainer :< cls, Object :< cls) => cls -> IO () _on_theme_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer__on_theme_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "_on_theme_changed" '[] (IO ()) where nodeMethod = Godot.Core.TabContainer._on_theme_changed {-# NOINLINE bindTabContainer__update_current_tab #-} bindTabContainer__update_current_tab :: MethodBind bindTabContainer__update_current_tab = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "_update_current_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_current_tab :: (TabContainer :< cls, Object :< cls) => cls -> IO () _update_current_tab cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer__update_current_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "_update_current_tab" '[] (IO ()) where nodeMethod = Godot.Core.TabContainer._update_current_tab {-# NOINLINE bindTabContainer_are_tabs_visible #-} -- | If @true@, tabs are visible. If @false@, tabs' content and titles are hidden. bindTabContainer_are_tabs_visible :: MethodBind bindTabContainer_are_tabs_visible = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "are_tabs_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, tabs are visible. If @false@, tabs' content and titles are hidden. are_tabs_visible :: (TabContainer :< cls, Object :< cls) => cls -> IO Bool are_tabs_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_are_tabs_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "are_tabs_visible" '[] (IO Bool) where nodeMethod = Godot.Core.TabContainer.are_tabs_visible {-# NOINLINE bindTabContainer_get_current_tab #-} -- | The current tab index. When set, this index's @Control@ node's @visible@ property is set to @true@ and all others are set to @false@. bindTabContainer_get_current_tab :: MethodBind bindTabContainer_get_current_tab = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_current_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current tab index. When set, this index's @Control@ node's @visible@ property is set to @true@ and all others are set to @false@. get_current_tab :: (TabContainer :< cls, Object :< cls) => cls -> IO Int get_current_tab cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_current_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_current_tab" '[] (IO Int) where nodeMethod = Godot.Core.TabContainer.get_current_tab {-# NOINLINE bindTabContainer_get_current_tab_control #-} -- | Returns the child @Control@ node located at the active tab index. bindTabContainer_get_current_tab_control :: MethodBind bindTabContainer_get_current_tab_control = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_current_tab_control" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the child @Control@ node located at the active tab index. get_current_tab_control :: (TabContainer :< cls, Object :< cls) => cls -> IO Control get_current_tab_control cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_current_tab_control (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_current_tab_control" '[] (IO Control) where nodeMethod = Godot.Core.TabContainer.get_current_tab_control {-# NOINLINE bindTabContainer_get_drag_to_rearrange_enabled #-} -- | If @true@, tabs can be rearranged with mouse drag. bindTabContainer_get_drag_to_rearrange_enabled :: MethodBind bindTabContainer_get_drag_to_rearrange_enabled = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_drag_to_rearrange_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, tabs can be rearranged with mouse drag. get_drag_to_rearrange_enabled :: (TabContainer :< cls, Object :< cls) => cls -> IO Bool get_drag_to_rearrange_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_drag_to_rearrange_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_drag_to_rearrange_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TabContainer.get_drag_to_rearrange_enabled {-# NOINLINE bindTabContainer_get_popup #-} -- | Returns the @Popup@ node instance if one has been set already with @method set_popup@. bindTabContainer_get_popup :: MethodBind bindTabContainer_get_popup = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_popup" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Popup@ node instance if one has been set already with @method set_popup@. get_popup :: (TabContainer :< cls, Object :< cls) => cls -> IO Popup get_popup cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_popup (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_popup" '[] (IO Popup) where nodeMethod = Godot.Core.TabContainer.get_popup {-# NOINLINE bindTabContainer_get_previous_tab #-} -- | Returns the previously active tab index. bindTabContainer_get_previous_tab :: MethodBind bindTabContainer_get_previous_tab = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_previous_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the previously active tab index. get_previous_tab :: (TabContainer :< cls, Object :< cls) => cls -> IO Int get_previous_tab cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_previous_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_previous_tab" '[] (IO Int) where nodeMethod = Godot.Core.TabContainer.get_previous_tab {-# NOINLINE bindTabContainer_get_tab_align #-} -- | The alignment of all tabs in the tab container. See the @enum TabAlign@ constants for details. bindTabContainer_get_tab_align :: MethodBind bindTabContainer_get_tab_align = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_tab_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The alignment of all tabs in the tab container. See the @enum TabAlign@ constants for details. get_tab_align :: (TabContainer :< cls, Object :< cls) => cls -> IO Int get_tab_align cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_tab_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_tab_align" '[] (IO Int) where nodeMethod = Godot.Core.TabContainer.get_tab_align {-# NOINLINE bindTabContainer_get_tab_control #-} -- | Returns the @Control@ node from the tab at index @tab_idx@. bindTabContainer_get_tab_control :: MethodBind bindTabContainer_get_tab_control = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_tab_control" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Control@ node from the tab at index @tab_idx@. get_tab_control :: (TabContainer :< cls, Object :< cls) => cls -> Int -> IO Control get_tab_control cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_tab_control (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_tab_control" '[Int] (IO Control) where nodeMethod = Godot.Core.TabContainer.get_tab_control {-# NOINLINE bindTabContainer_get_tab_count #-} -- | Returns the number of tabs. bindTabContainer_get_tab_count :: MethodBind bindTabContainer_get_tab_count = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_tab_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of tabs. get_tab_count :: (TabContainer :< cls, Object :< cls) => cls -> IO Int get_tab_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_tab_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_tab_count" '[] (IO Int) where nodeMethod = Godot.Core.TabContainer.get_tab_count {-# NOINLINE bindTabContainer_get_tab_disabled #-} -- | Returns @true@ if the tab at index @tab_idx@ is disabled. bindTabContainer_get_tab_disabled :: MethodBind bindTabContainer_get_tab_disabled = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_tab_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the tab at index @tab_idx@ is disabled. get_tab_disabled :: (TabContainer :< cls, Object :< cls) => cls -> Int -> IO Bool get_tab_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_tab_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_tab_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.TabContainer.get_tab_disabled {-# NOINLINE bindTabContainer_get_tab_icon #-} -- | Returns the @Texture@ for the tab at index @tab_idx@ or @null@ if the tab has no @Texture@. bindTabContainer_get_tab_icon :: MethodBind bindTabContainer_get_tab_icon = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_tab_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Texture@ for the tab at index @tab_idx@ or @null@ if the tab has no @Texture@. get_tab_icon :: (TabContainer :< cls, Object :< cls) => cls -> Int -> IO Texture get_tab_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_tab_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_tab_icon" '[Int] (IO Texture) where nodeMethod = Godot.Core.TabContainer.get_tab_icon {-# NOINLINE bindTabContainer_get_tab_title #-} -- | Returns the title of the tab at index @tab_idx@. Tab titles default to the name of the indexed child node, but this can be overridden with @method set_tab_title@. bindTabContainer_get_tab_title :: MethodBind bindTabContainer_get_tab_title = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_tab_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the title of the tab at index @tab_idx@. Tab titles default to the name of the indexed child node, but this can be overridden with @method set_tab_title@. get_tab_title :: (TabContainer :< cls, Object :< cls) => cls -> Int -> IO GodotString get_tab_title cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_tab_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_tab_title" '[Int] (IO GodotString) where nodeMethod = Godot.Core.TabContainer.get_tab_title {-# NOINLINE bindTabContainer_get_tabs_rearrange_group #-} -- | Returns the @TabContainer@ rearrange group id. bindTabContainer_get_tabs_rearrange_group :: MethodBind bindTabContainer_get_tabs_rearrange_group = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_tabs_rearrange_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @TabContainer@ rearrange group id. get_tabs_rearrange_group :: (TabContainer :< cls, Object :< cls) => cls -> IO Int get_tabs_rearrange_group cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_tabs_rearrange_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_tabs_rearrange_group" '[] (IO Int) where nodeMethod = Godot.Core.TabContainer.get_tabs_rearrange_group {-# NOINLINE bindTabContainer_get_use_hidden_tabs_for_min_size #-} -- | If @true@, children @Control@ nodes that are hidden have their minimum size take into account in the total, instead of only the currently visible one. bindTabContainer_get_use_hidden_tabs_for_min_size :: MethodBind bindTabContainer_get_use_hidden_tabs_for_min_size = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "get_use_hidden_tabs_for_min_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, children @Control@ nodes that are hidden have their minimum size take into account in the total, instead of only the currently visible one. get_use_hidden_tabs_for_min_size :: (TabContainer :< cls, Object :< cls) => cls -> IO Bool get_use_hidden_tabs_for_min_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_get_use_hidden_tabs_for_min_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "get_use_hidden_tabs_for_min_size" '[] (IO Bool) where nodeMethod = Godot.Core.TabContainer.get_use_hidden_tabs_for_min_size {-# NOINLINE bindTabContainer_set_current_tab #-} -- | The current tab index. When set, this index's @Control@ node's @visible@ property is set to @true@ and all others are set to @false@. bindTabContainer_set_current_tab :: MethodBind bindTabContainer_set_current_tab = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_current_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current tab index. When set, this index's @Control@ node's @visible@ property is set to @true@ and all others are set to @false@. set_current_tab :: (TabContainer :< cls, Object :< cls) => cls -> Int -> IO () set_current_tab cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_current_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_current_tab" '[Int] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_current_tab {-# NOINLINE bindTabContainer_set_drag_to_rearrange_enabled #-} -- | If @true@, tabs can be rearranged with mouse drag. bindTabContainer_set_drag_to_rearrange_enabled :: MethodBind bindTabContainer_set_drag_to_rearrange_enabled = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_drag_to_rearrange_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, tabs can be rearranged with mouse drag. set_drag_to_rearrange_enabled :: (TabContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_drag_to_rearrange_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_drag_to_rearrange_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_drag_to_rearrange_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_drag_to_rearrange_enabled {-# NOINLINE bindTabContainer_set_popup #-} -- | If set on a @Popup@ node instance, a popup menu icon appears in the top-right corner of the @TabContainer@. Clicking it will expand the @Popup@ node. bindTabContainer_set_popup :: MethodBind bindTabContainer_set_popup = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_popup" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If set on a @Popup@ node instance, a popup menu icon appears in the top-right corner of the @TabContainer@. Clicking it will expand the @Popup@ node. set_popup :: (TabContainer :< cls, Object :< cls) => cls -> Node -> IO () set_popup cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_popup (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_popup" '[Node] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_popup {-# NOINLINE bindTabContainer_set_tab_align #-} -- | The alignment of all tabs in the tab container. See the @enum TabAlign@ constants for details. bindTabContainer_set_tab_align :: MethodBind bindTabContainer_set_tab_align = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_tab_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The alignment of all tabs in the tab container. See the @enum TabAlign@ constants for details. set_tab_align :: (TabContainer :< cls, Object :< cls) => cls -> Int -> IO () set_tab_align cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_tab_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_tab_align" '[Int] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_tab_align {-# NOINLINE bindTabContainer_set_tab_disabled #-} -- | If @disabled@ is @false@, hides the tab at index @tab_idx@. -- __Note:__ Its title text will remain, unless also removed with @method set_tab_title@. bindTabContainer_set_tab_disabled :: MethodBind bindTabContainer_set_tab_disabled = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_tab_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @disabled@ is @false@, hides the tab at index @tab_idx@. -- __Note:__ Its title text will remain, unless also removed with @method set_tab_title@. set_tab_disabled :: (TabContainer :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_tab_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_tab_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_tab_disabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_tab_disabled {-# NOINLINE bindTabContainer_set_tab_icon #-} -- | Sets an icon for the tab at index @tab_idx@. bindTabContainer_set_tab_icon :: MethodBind bindTabContainer_set_tab_icon = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_tab_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an icon for the tab at index @tab_idx@. set_tab_icon :: (TabContainer :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_tab_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_tab_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_tab_icon" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_tab_icon {-# NOINLINE bindTabContainer_set_tab_title #-} -- | Sets a title for the tab at index @tab_idx@. Tab titles default to the name of the indexed child node, but this can be overridden with @method set_tab_title@. bindTabContainer_set_tab_title :: MethodBind bindTabContainer_set_tab_title = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_tab_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a title for the tab at index @tab_idx@. Tab titles default to the name of the indexed child node, but this can be overridden with @method set_tab_title@. set_tab_title :: (TabContainer :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_tab_title cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_tab_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_tab_title" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_tab_title {-# NOINLINE bindTabContainer_set_tabs_rearrange_group #-} -- | Defines rearrange group id, choose for each @TabContainer@ the same value to enable tab drag between @TabContainer@. Enable drag with @set_drag_to_rearrange_enabled(true)@. bindTabContainer_set_tabs_rearrange_group :: MethodBind bindTabContainer_set_tabs_rearrange_group = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_tabs_rearrange_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines rearrange group id, choose for each @TabContainer@ the same value to enable tab drag between @TabContainer@. Enable drag with @set_drag_to_rearrange_enabled(true)@. set_tabs_rearrange_group :: (TabContainer :< cls, Object :< cls) => cls -> Int -> IO () set_tabs_rearrange_group cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_tabs_rearrange_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_tabs_rearrange_group" '[Int] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_tabs_rearrange_group {-# NOINLINE bindTabContainer_set_tabs_visible #-} -- | If @true@, tabs are visible. If @false@, tabs' content and titles are hidden. bindTabContainer_set_tabs_visible :: MethodBind bindTabContainer_set_tabs_visible = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_tabs_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, tabs are visible. If @false@, tabs' content and titles are hidden. set_tabs_visible :: (TabContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_tabs_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_tabs_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_tabs_visible" '[Bool] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_tabs_visible {-# NOINLINE bindTabContainer_set_use_hidden_tabs_for_min_size #-} -- | If @true@, children @Control@ nodes that are hidden have their minimum size take into account in the total, instead of only the currently visible one. bindTabContainer_set_use_hidden_tabs_for_min_size :: MethodBind bindTabContainer_set_use_hidden_tabs_for_min_size = unsafePerformIO $ withCString "TabContainer" $ \ clsNamePtr -> withCString "set_use_hidden_tabs_for_min_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, children @Control@ nodes that are hidden have their minimum size take into account in the total, instead of only the currently visible one. set_use_hidden_tabs_for_min_size :: (TabContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_use_hidden_tabs_for_min_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabContainer_set_use_hidden_tabs_for_min_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TabContainer "set_use_hidden_tabs_for_min_size" '[Bool] (IO ()) where nodeMethod = Godot.Core.TabContainer.set_use_hidden_tabs_for_min_size ================================================ FILE: src/Godot/Core/Tabs.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Tabs (Godot.Core.Tabs._ALIGN_RIGHT, Godot.Core.Tabs._CLOSE_BUTTON_SHOW_ACTIVE_ONLY, Godot.Core.Tabs._ALIGN_MAX, Godot.Core.Tabs._CLOSE_BUTTON_MAX, Godot.Core.Tabs._CLOSE_BUTTON_SHOW_ALWAYS, Godot.Core.Tabs._CLOSE_BUTTON_SHOW_NEVER, Godot.Core.Tabs._ALIGN_LEFT, Godot.Core.Tabs._ALIGN_CENTER, Godot.Core.Tabs.sig_reposition_active_tab_request, Godot.Core.Tabs.sig_right_button_pressed, Godot.Core.Tabs.sig_tab_changed, Godot.Core.Tabs.sig_tab_clicked, Godot.Core.Tabs.sig_tab_close, Godot.Core.Tabs.sig_tab_hover, Godot.Core.Tabs._gui_input, Godot.Core.Tabs._on_mouse_exited, Godot.Core.Tabs._update_hover, Godot.Core.Tabs.add_tab, Godot.Core.Tabs.ensure_tab_visible, Godot.Core.Tabs.get_current_tab, Godot.Core.Tabs.get_drag_to_rearrange_enabled, Godot.Core.Tabs.get_offset_buttons_visible, Godot.Core.Tabs.get_scrolling_enabled, Godot.Core.Tabs.get_select_with_rmb, Godot.Core.Tabs.get_tab_align, Godot.Core.Tabs.get_tab_close_display_policy, Godot.Core.Tabs.get_tab_count, Godot.Core.Tabs.get_tab_disabled, Godot.Core.Tabs.get_tab_icon, Godot.Core.Tabs.get_tab_offset, Godot.Core.Tabs.get_tab_rect, Godot.Core.Tabs.get_tab_title, Godot.Core.Tabs.get_tabs_rearrange_group, Godot.Core.Tabs.move_tab, Godot.Core.Tabs.remove_tab, Godot.Core.Tabs.set_current_tab, Godot.Core.Tabs.set_drag_to_rearrange_enabled, Godot.Core.Tabs.set_scrolling_enabled, Godot.Core.Tabs.set_select_with_rmb, Godot.Core.Tabs.set_tab_align, Godot.Core.Tabs.set_tab_close_display_policy, Godot.Core.Tabs.set_tab_disabled, Godot.Core.Tabs.set_tab_icon, Godot.Core.Tabs.set_tab_title, Godot.Core.Tabs.set_tabs_rearrange_group) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _ALIGN_RIGHT :: Int _ALIGN_RIGHT = 2 _CLOSE_BUTTON_SHOW_ACTIVE_ONLY :: Int _CLOSE_BUTTON_SHOW_ACTIVE_ONLY = 1 _ALIGN_MAX :: Int _ALIGN_MAX = 3 _CLOSE_BUTTON_MAX :: Int _CLOSE_BUTTON_MAX = 3 _CLOSE_BUTTON_SHOW_ALWAYS :: Int _CLOSE_BUTTON_SHOW_ALWAYS = 2 _CLOSE_BUTTON_SHOW_NEVER :: Int _CLOSE_BUTTON_SHOW_NEVER = 0 _ALIGN_LEFT :: Int _ALIGN_LEFT = 0 _ALIGN_CENTER :: Int _ALIGN_CENTER = 1 -- | Emitted when the active tab is rearranged via mouse drag. See @drag_to_rearrange_enabled@. sig_reposition_active_tab_request :: Godot.Internal.Dispatch.Signal Tabs sig_reposition_active_tab_request = Godot.Internal.Dispatch.Signal "reposition_active_tab_request" instance NodeSignal Tabs "reposition_active_tab_request" '[Int] -- | Emitted when a tab is right-clicked. sig_right_button_pressed :: Godot.Internal.Dispatch.Signal Tabs sig_right_button_pressed = Godot.Internal.Dispatch.Signal "right_button_pressed" instance NodeSignal Tabs "right_button_pressed" '[Int] -- | Emitted when switching to another tab. sig_tab_changed :: Godot.Internal.Dispatch.Signal Tabs sig_tab_changed = Godot.Internal.Dispatch.Signal "tab_changed" instance NodeSignal Tabs "tab_changed" '[Int] -- | Emitted when a tab is clicked, even if it is the current tab. sig_tab_clicked :: Godot.Internal.Dispatch.Signal Tabs sig_tab_clicked = Godot.Internal.Dispatch.Signal "tab_clicked" instance NodeSignal Tabs "tab_clicked" '[Int] -- | Emitted when a tab is closed. sig_tab_close :: Godot.Internal.Dispatch.Signal Tabs sig_tab_close = Godot.Internal.Dispatch.Signal "tab_close" instance NodeSignal Tabs "tab_close" '[Int] -- | Emitted when a tab is hovered by the mouse. sig_tab_hover :: Godot.Internal.Dispatch.Signal Tabs sig_tab_hover = Godot.Internal.Dispatch.Signal "tab_hover" instance NodeSignal Tabs "tab_hover" '[Int] instance NodeProperty Tabs "current_tab" Int 'False where nodeProperty = (get_current_tab, wrapDroppingSetter set_current_tab, Nothing) instance NodeProperty Tabs "drag_to_rearrange_enabled" Bool 'False where nodeProperty = (get_drag_to_rearrange_enabled, wrapDroppingSetter set_drag_to_rearrange_enabled, Nothing) instance NodeProperty Tabs "scrolling_enabled" Bool 'False where nodeProperty = (get_scrolling_enabled, wrapDroppingSetter set_scrolling_enabled, Nothing) instance NodeProperty Tabs "tab_align" Int 'False where nodeProperty = (get_tab_align, wrapDroppingSetter set_tab_align, Nothing) instance NodeProperty Tabs "tab_close_display_policy" Int 'False where nodeProperty = (get_tab_close_display_policy, wrapDroppingSetter set_tab_close_display_policy, Nothing) {-# NOINLINE bindTabs__gui_input #-} bindTabs__gui_input :: MethodBind bindTabs__gui_input = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (Tabs :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Tabs._gui_input {-# NOINLINE bindTabs__on_mouse_exited #-} bindTabs__on_mouse_exited :: MethodBind bindTabs__on_mouse_exited = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "_on_mouse_exited" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _on_mouse_exited :: (Tabs :< cls, Object :< cls) => cls -> IO () _on_mouse_exited cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs__on_mouse_exited (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "_on_mouse_exited" '[] (IO ()) where nodeMethod = Godot.Core.Tabs._on_mouse_exited {-# NOINLINE bindTabs__update_hover #-} bindTabs__update_hover :: MethodBind bindTabs__update_hover = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "_update_hover" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_hover :: (Tabs :< cls, Object :< cls) => cls -> IO () _update_hover cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs__update_hover (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "_update_hover" '[] (IO ()) where nodeMethod = Godot.Core.Tabs._update_hover {-# NOINLINE bindTabs_add_tab #-} -- | Adds a new tab. bindTabs_add_tab :: MethodBind bindTabs_add_tab = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "add_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new tab. add_tab :: (Tabs :< cls, Object :< cls) => cls -> Maybe GodotString -> Maybe Texture -> IO () add_tab cls arg1 arg2 = withVariantArray [defaultedVariant VariantString "" arg1, maybe VariantNil toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_add_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "add_tab" '[Maybe GodotString, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.Tabs.add_tab {-# NOINLINE bindTabs_ensure_tab_visible #-} -- | Moves the scroll view to make the tab visible. bindTabs_ensure_tab_visible :: MethodBind bindTabs_ensure_tab_visible = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "ensure_tab_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the scroll view to make the tab visible. ensure_tab_visible :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO () ensure_tab_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_ensure_tab_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "ensure_tab_visible" '[Int] (IO ()) where nodeMethod = Godot.Core.Tabs.ensure_tab_visible {-# NOINLINE bindTabs_get_current_tab #-} -- | Select tab at index @tab_idx@. bindTabs_get_current_tab :: MethodBind bindTabs_get_current_tab = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_current_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Select tab at index @tab_idx@. get_current_tab :: (Tabs :< cls, Object :< cls) => cls -> IO Int get_current_tab cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_current_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_current_tab" '[] (IO Int) where nodeMethod = Godot.Core.Tabs.get_current_tab {-# NOINLINE bindTabs_get_drag_to_rearrange_enabled #-} -- | If @true@, tabs can be rearranged with mouse drag. bindTabs_get_drag_to_rearrange_enabled :: MethodBind bindTabs_get_drag_to_rearrange_enabled = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_drag_to_rearrange_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, tabs can be rearranged with mouse drag. get_drag_to_rearrange_enabled :: (Tabs :< cls, Object :< cls) => cls -> IO Bool get_drag_to_rearrange_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_drag_to_rearrange_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_drag_to_rearrange_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Tabs.get_drag_to_rearrange_enabled {-# NOINLINE bindTabs_get_offset_buttons_visible #-} -- | Returns @true@ if the offset buttons (the ones that appear when there's not enough space for all tabs) are visible. bindTabs_get_offset_buttons_visible :: MethodBind bindTabs_get_offset_buttons_visible = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_offset_buttons_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the offset buttons (the ones that appear when there's not enough space for all tabs) are visible. get_offset_buttons_visible :: (Tabs :< cls, Object :< cls) => cls -> IO Bool get_offset_buttons_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_offset_buttons_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_offset_buttons_visible" '[] (IO Bool) where nodeMethod = Godot.Core.Tabs.get_offset_buttons_visible {-# NOINLINE bindTabs_get_scrolling_enabled #-} -- | if @true@, the mouse's scroll wheel cab be used to navigate the scroll view. bindTabs_get_scrolling_enabled :: MethodBind bindTabs_get_scrolling_enabled = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_scrolling_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | if @true@, the mouse's scroll wheel cab be used to navigate the scroll view. get_scrolling_enabled :: (Tabs :< cls, Object :< cls) => cls -> IO Bool get_scrolling_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_scrolling_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_scrolling_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Tabs.get_scrolling_enabled {-# NOINLINE bindTabs_get_select_with_rmb #-} -- | Returns @true@ if select with right mouse button is enabled. bindTabs_get_select_with_rmb :: MethodBind bindTabs_get_select_with_rmb = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_select_with_rmb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if select with right mouse button is enabled. get_select_with_rmb :: (Tabs :< cls, Object :< cls) => cls -> IO Bool get_select_with_rmb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_select_with_rmb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_select_with_rmb" '[] (IO Bool) where nodeMethod = Godot.Core.Tabs.get_select_with_rmb {-# NOINLINE bindTabs_get_tab_align #-} -- | The alignment of all tabs. See @enum TabAlign@ for details. bindTabs_get_tab_align :: MethodBind bindTabs_get_tab_align = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tab_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The alignment of all tabs. See @enum TabAlign@ for details. get_tab_align :: (Tabs :< cls, Object :< cls) => cls -> IO Int get_tab_align cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tab_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tab_align" '[] (IO Int) where nodeMethod = Godot.Core.Tabs.get_tab_align {-# NOINLINE bindTabs_get_tab_close_display_policy #-} -- | Sets when the close button will appear on the tabs. See @enum CloseButtonDisplayPolicy@ for details. bindTabs_get_tab_close_display_policy :: MethodBind bindTabs_get_tab_close_display_policy = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tab_close_display_policy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets when the close button will appear on the tabs. See @enum CloseButtonDisplayPolicy@ for details. get_tab_close_display_policy :: (Tabs :< cls, Object :< cls) => cls -> IO Int get_tab_close_display_policy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tab_close_display_policy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tab_close_display_policy" '[] (IO Int) where nodeMethod = Godot.Core.Tabs.get_tab_close_display_policy {-# NOINLINE bindTabs_get_tab_count #-} -- | Returns the number of tabs. bindTabs_get_tab_count :: MethodBind bindTabs_get_tab_count = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tab_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of tabs. get_tab_count :: (Tabs :< cls, Object :< cls) => cls -> IO Int get_tab_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tab_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tab_count" '[] (IO Int) where nodeMethod = Godot.Core.Tabs.get_tab_count {-# NOINLINE bindTabs_get_tab_disabled #-} -- | Returns @true@ if the tab at index @tab_idx@ is disabled. bindTabs_get_tab_disabled :: MethodBind bindTabs_get_tab_disabled = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tab_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the tab at index @tab_idx@ is disabled. get_tab_disabled :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO Bool get_tab_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tab_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tab_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.Tabs.get_tab_disabled {-# NOINLINE bindTabs_get_tab_icon #-} -- | Returns the @Texture@ for the tab at index @tab_idx@ or @null@ if the tab has no @Texture@. bindTabs_get_tab_icon :: MethodBind bindTabs_get_tab_icon = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tab_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Texture@ for the tab at index @tab_idx@ or @null@ if the tab has no @Texture@. get_tab_icon :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO Texture get_tab_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tab_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tab_icon" '[Int] (IO Texture) where nodeMethod = Godot.Core.Tabs.get_tab_icon {-# NOINLINE bindTabs_get_tab_offset #-} -- | Returns the number of hidden tabs offsetted to the left. bindTabs_get_tab_offset :: MethodBind bindTabs_get_tab_offset = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tab_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of hidden tabs offsetted to the left. get_tab_offset :: (Tabs :< cls, Object :< cls) => cls -> IO Int get_tab_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tab_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tab_offset" '[] (IO Int) where nodeMethod = Godot.Core.Tabs.get_tab_offset {-# NOINLINE bindTabs_get_tab_rect #-} -- | Returns tab @Rect2@ with local position and size. bindTabs_get_tab_rect :: MethodBind bindTabs_get_tab_rect = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tab_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns tab @Rect2@ with local position and size. get_tab_rect :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO Rect2 get_tab_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tab_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tab_rect" '[Int] (IO Rect2) where nodeMethod = Godot.Core.Tabs.get_tab_rect {-# NOINLINE bindTabs_get_tab_title #-} -- | Returns the title of the tab at index @tab_idx@. Tab titles default to the name of the indexed child node, but this can be overridden with @method set_tab_title@. bindTabs_get_tab_title :: MethodBind bindTabs_get_tab_title = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tab_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the title of the tab at index @tab_idx@. Tab titles default to the name of the indexed child node, but this can be overridden with @method set_tab_title@. get_tab_title :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO GodotString get_tab_title cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tab_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tab_title" '[Int] (IO GodotString) where nodeMethod = Godot.Core.Tabs.get_tab_title {-# NOINLINE bindTabs_get_tabs_rearrange_group #-} -- | Returns the @Tabs@' rearrange group ID. bindTabs_get_tabs_rearrange_group :: MethodBind bindTabs_get_tabs_rearrange_group = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "get_tabs_rearrange_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Tabs@' rearrange group ID. get_tabs_rearrange_group :: (Tabs :< cls, Object :< cls) => cls -> IO Int get_tabs_rearrange_group cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_get_tabs_rearrange_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "get_tabs_rearrange_group" '[] (IO Int) where nodeMethod = Godot.Core.Tabs.get_tabs_rearrange_group {-# NOINLINE bindTabs_move_tab #-} -- | Moves a tab from @from@ to @to@. bindTabs_move_tab :: MethodBind bindTabs_move_tab = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "move_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves a tab from @from@ to @to@. move_tab :: (Tabs :< cls, Object :< cls) => cls -> Int -> Int -> IO () move_tab cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_move_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "move_tab" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Tabs.move_tab {-# NOINLINE bindTabs_remove_tab #-} -- | Removes the tab at index @tab_idx@. bindTabs_remove_tab :: MethodBind bindTabs_remove_tab = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "remove_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the tab at index @tab_idx@. remove_tab :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO () remove_tab cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_remove_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "remove_tab" '[Int] (IO ()) where nodeMethod = Godot.Core.Tabs.remove_tab {-# NOINLINE bindTabs_set_current_tab #-} -- | Select tab at index @tab_idx@. bindTabs_set_current_tab :: MethodBind bindTabs_set_current_tab = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_current_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Select tab at index @tab_idx@. set_current_tab :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO () set_current_tab cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_current_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_current_tab" '[Int] (IO ()) where nodeMethod = Godot.Core.Tabs.set_current_tab {-# NOINLINE bindTabs_set_drag_to_rearrange_enabled #-} -- | If @true@, tabs can be rearranged with mouse drag. bindTabs_set_drag_to_rearrange_enabled :: MethodBind bindTabs_set_drag_to_rearrange_enabled = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_drag_to_rearrange_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, tabs can be rearranged with mouse drag. set_drag_to_rearrange_enabled :: (Tabs :< cls, Object :< cls) => cls -> Bool -> IO () set_drag_to_rearrange_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_drag_to_rearrange_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_drag_to_rearrange_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tabs.set_drag_to_rearrange_enabled {-# NOINLINE bindTabs_set_scrolling_enabled #-} -- | if @true@, the mouse's scroll wheel cab be used to navigate the scroll view. bindTabs_set_scrolling_enabled :: MethodBind bindTabs_set_scrolling_enabled = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_scrolling_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | if @true@, the mouse's scroll wheel cab be used to navigate the scroll view. set_scrolling_enabled :: (Tabs :< cls, Object :< cls) => cls -> Bool -> IO () set_scrolling_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_scrolling_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_scrolling_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tabs.set_scrolling_enabled {-# NOINLINE bindTabs_set_select_with_rmb #-} -- | If @true@, enables selecting a tab with the right mouse button. bindTabs_set_select_with_rmb :: MethodBind bindTabs_set_select_with_rmb = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_select_with_rmb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables selecting a tab with the right mouse button. set_select_with_rmb :: (Tabs :< cls, Object :< cls) => cls -> Bool -> IO () set_select_with_rmb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_select_with_rmb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_select_with_rmb" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tabs.set_select_with_rmb {-# NOINLINE bindTabs_set_tab_align #-} -- | The alignment of all tabs. See @enum TabAlign@ for details. bindTabs_set_tab_align :: MethodBind bindTabs_set_tab_align = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_tab_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The alignment of all tabs. See @enum TabAlign@ for details. set_tab_align :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO () set_tab_align cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_tab_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_tab_align" '[Int] (IO ()) where nodeMethod = Godot.Core.Tabs.set_tab_align {-# NOINLINE bindTabs_set_tab_close_display_policy #-} -- | Sets when the close button will appear on the tabs. See @enum CloseButtonDisplayPolicy@ for details. bindTabs_set_tab_close_display_policy :: MethodBind bindTabs_set_tab_close_display_policy = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_tab_close_display_policy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets when the close button will appear on the tabs. See @enum CloseButtonDisplayPolicy@ for details. set_tab_close_display_policy :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO () set_tab_close_display_policy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_tab_close_display_policy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_tab_close_display_policy" '[Int] (IO ()) where nodeMethod = Godot.Core.Tabs.set_tab_close_display_policy {-# NOINLINE bindTabs_set_tab_disabled #-} -- | If @disabled@ is @false@, hides the tab at index @tab_idx@. -- __Note:__ Its title text will remain unless it is also removed with @method set_tab_title@. bindTabs_set_tab_disabled :: MethodBind bindTabs_set_tab_disabled = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_tab_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @disabled@ is @false@, hides the tab at index @tab_idx@. -- __Note:__ Its title text will remain unless it is also removed with @method set_tab_title@. set_tab_disabled :: (Tabs :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_tab_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_tab_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_tab_disabled" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Tabs.set_tab_disabled {-# NOINLINE bindTabs_set_tab_icon #-} -- | Sets an @icon@ for the tab at index @tab_idx@. bindTabs_set_tab_icon :: MethodBind bindTabs_set_tab_icon = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_tab_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an @icon@ for the tab at index @tab_idx@. set_tab_icon :: (Tabs :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_tab_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_tab_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_tab_icon" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.Tabs.set_tab_icon {-# NOINLINE bindTabs_set_tab_title #-} -- | Sets a @title@ for the tab at index @tab_idx@. bindTabs_set_tab_title :: MethodBind bindTabs_set_tab_title = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_tab_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a @title@ for the tab at index @tab_idx@. set_tab_title :: (Tabs :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_tab_title cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_tab_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_tab_title" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.Tabs.set_tab_title {-# NOINLINE bindTabs_set_tabs_rearrange_group #-} -- | Defines the rearrange group ID. Choose for each @Tabs@ the same value to dragging tabs between @Tabs@. Enable drag with @set_drag_to_rearrange_enabled(true)@. bindTabs_set_tabs_rearrange_group :: MethodBind bindTabs_set_tabs_rearrange_group = unsafePerformIO $ withCString "Tabs" $ \ clsNamePtr -> withCString "set_tabs_rearrange_group" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the rearrange group ID. Choose for each @Tabs@ the same value to dragging tabs between @Tabs@. Enable drag with @set_drag_to_rearrange_enabled(true)@. set_tabs_rearrange_group :: (Tabs :< cls, Object :< cls) => cls -> Int -> IO () set_tabs_rearrange_group cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTabs_set_tabs_rearrange_group (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tabs "set_tabs_rearrange_group" '[Int] (IO ()) where nodeMethod = Godot.Core.Tabs.set_tabs_rearrange_group ================================================ FILE: src/Godot/Core/TextEdit.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TextEdit (Godot.Core.TextEdit._MENU_PASTE, Godot.Core.TextEdit._SEARCH_WHOLE_WORDS, Godot.Core.TextEdit._MENU_CLEAR, Godot.Core.TextEdit._MENU_MAX, Godot.Core.TextEdit._MENU_REDO, Godot.Core.TextEdit._SEARCH_BACKWARDS, Godot.Core.TextEdit._MENU_COPY, Godot.Core.TextEdit._SEARCH_RESULT_COLUMN, Godot.Core.TextEdit._MENU_UNDO, Godot.Core.TextEdit._MENU_SELECT_ALL, Godot.Core.TextEdit._MENU_CUT, Godot.Core.TextEdit._SEARCH_RESULT_LINE, Godot.Core.TextEdit._SEARCH_MATCH_CASE, Godot.Core.TextEdit.sig_breakpoint_toggled, Godot.Core.TextEdit.sig_cursor_changed, Godot.Core.TextEdit.sig_info_clicked, Godot.Core.TextEdit.sig_request_completion, Godot.Core.TextEdit.sig_symbol_lookup, Godot.Core.TextEdit.sig_text_changed, Godot.Core.TextEdit._click_selection_held, Godot.Core.TextEdit._cursor_changed_emit, Godot.Core.TextEdit._gui_input, Godot.Core.TextEdit._push_current_op, Godot.Core.TextEdit._scroll_moved, Godot.Core.TextEdit._text_changed_emit, Godot.Core.TextEdit._toggle_draw_caret, Godot.Core.TextEdit._update_wrap_at, Godot.Core.TextEdit._v_scroll_input, Godot.Core.TextEdit.add_color_region, Godot.Core.TextEdit.add_keyword_color, Godot.Core.TextEdit.can_fold, Godot.Core.TextEdit.center_viewport_to_cursor, Godot.Core.TextEdit.clear_colors, Godot.Core.TextEdit.clear_undo_history, Godot.Core.TextEdit.copy, Godot.Core.TextEdit.cursor_get_blink_enabled, Godot.Core.TextEdit.cursor_get_blink_speed, Godot.Core.TextEdit.cursor_get_column, Godot.Core.TextEdit.cursor_get_line, Godot.Core.TextEdit.cursor_is_block_mode, Godot.Core.TextEdit.cursor_set_blink_enabled, Godot.Core.TextEdit.cursor_set_blink_speed, Godot.Core.TextEdit.cursor_set_block_mode, Godot.Core.TextEdit.cursor_set_column, Godot.Core.TextEdit.cursor_set_line, Godot.Core.TextEdit.cut, Godot.Core.TextEdit.deselect, Godot.Core.TextEdit.draw_minimap, Godot.Core.TextEdit.fold_all_lines, Godot.Core.TextEdit.fold_line, Godot.Core.TextEdit.get_breakpoints, Godot.Core.TextEdit.get_h_scroll, Godot.Core.TextEdit.get_keyword_color, Godot.Core.TextEdit.get_line, Godot.Core.TextEdit.get_line_count, Godot.Core.TextEdit.get_menu, Godot.Core.TextEdit.get_minimap_width, Godot.Core.TextEdit.get_selection_from_column, Godot.Core.TextEdit.get_selection_from_line, Godot.Core.TextEdit.get_selection_text, Godot.Core.TextEdit.get_selection_to_column, Godot.Core.TextEdit.get_selection_to_line, Godot.Core.TextEdit.get_text, Godot.Core.TextEdit.get_v_scroll, Godot.Core.TextEdit.get_v_scroll_speed, Godot.Core.TextEdit.get_word_under_cursor, Godot.Core.TextEdit.has_keyword_color, Godot.Core.TextEdit.insert_text_at_cursor, Godot.Core.TextEdit.is_breakpoint_gutter_enabled, Godot.Core.TextEdit.is_context_menu_enabled, Godot.Core.TextEdit.is_drawing_fold_gutter, Godot.Core.TextEdit.is_drawing_minimap, Godot.Core.TextEdit.is_drawing_spaces, Godot.Core.TextEdit.is_drawing_tabs, Godot.Core.TextEdit.is_folded, Godot.Core.TextEdit.is_hiding_enabled, Godot.Core.TextEdit.is_highlight_all_occurrences_enabled, Godot.Core.TextEdit.is_highlight_current_line_enabled, Godot.Core.TextEdit.is_line_hidden, Godot.Core.TextEdit.is_overriding_selected_font_color, Godot.Core.TextEdit.is_readonly, Godot.Core.TextEdit.is_right_click_moving_caret, Godot.Core.TextEdit.is_selecting_enabled, Godot.Core.TextEdit.is_selection_active, Godot.Core.TextEdit.is_shortcut_keys_enabled, Godot.Core.TextEdit.is_show_line_numbers_enabled, Godot.Core.TextEdit.is_smooth_scroll_enabled, Godot.Core.TextEdit.is_syntax_coloring_enabled, Godot.Core.TextEdit.is_wrap_enabled, Godot.Core.TextEdit.menu_option, Godot.Core.TextEdit.paste, Godot.Core.TextEdit.redo, Godot.Core.TextEdit.remove_breakpoints, Godot.Core.TextEdit.search, Godot.Core.TextEdit.select, Godot.Core.TextEdit.select_all, Godot.Core.TextEdit.set_breakpoint_gutter_enabled, Godot.Core.TextEdit.set_context_menu_enabled, Godot.Core.TextEdit.set_draw_fold_gutter, Godot.Core.TextEdit.set_draw_spaces, Godot.Core.TextEdit.set_draw_tabs, Godot.Core.TextEdit.set_h_scroll, Godot.Core.TextEdit.set_hiding_enabled, Godot.Core.TextEdit.set_highlight_all_occurrences, Godot.Core.TextEdit.set_highlight_current_line, Godot.Core.TextEdit.set_line_as_hidden, Godot.Core.TextEdit.set_minimap_width, Godot.Core.TextEdit.set_override_selected_font_color, Godot.Core.TextEdit.set_readonly, Godot.Core.TextEdit.set_right_click_moves_caret, Godot.Core.TextEdit.set_selecting_enabled, Godot.Core.TextEdit.set_shortcut_keys_enabled, Godot.Core.TextEdit.set_show_line_numbers, Godot.Core.TextEdit.set_smooth_scroll_enable, Godot.Core.TextEdit.set_syntax_coloring, Godot.Core.TextEdit.set_text, Godot.Core.TextEdit.set_v_scroll, Godot.Core.TextEdit.set_v_scroll_speed, Godot.Core.TextEdit.set_wrap_enabled, Godot.Core.TextEdit.toggle_fold_line, Godot.Core.TextEdit.undo, Godot.Core.TextEdit.unfold_line, Godot.Core.TextEdit.unhide_all_lines) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _MENU_PASTE :: Int _MENU_PASTE = 2 _SEARCH_WHOLE_WORDS :: Int _SEARCH_WHOLE_WORDS = 2 _MENU_CLEAR :: Int _MENU_CLEAR = 3 _MENU_MAX :: Int _MENU_MAX = 7 _MENU_REDO :: Int _MENU_REDO = 6 _SEARCH_BACKWARDS :: Int _SEARCH_BACKWARDS = 4 _MENU_COPY :: Int _MENU_COPY = 1 _SEARCH_RESULT_COLUMN :: Int _SEARCH_RESULT_COLUMN = 0 _MENU_UNDO :: Int _MENU_UNDO = 5 _MENU_SELECT_ALL :: Int _MENU_SELECT_ALL = 4 _MENU_CUT :: Int _MENU_CUT = 0 _SEARCH_RESULT_LINE :: Int _SEARCH_RESULT_LINE = 1 _SEARCH_MATCH_CASE :: Int _SEARCH_MATCH_CASE = 1 -- | Emitted when a breakpoint is placed via the breakpoint gutter. sig_breakpoint_toggled :: Godot.Internal.Dispatch.Signal TextEdit sig_breakpoint_toggled = Godot.Internal.Dispatch.Signal "breakpoint_toggled" instance NodeSignal TextEdit "breakpoint_toggled" '[Int] -- | Emitted when the cursor changes. sig_cursor_changed :: Godot.Internal.Dispatch.Signal TextEdit sig_cursor_changed = Godot.Internal.Dispatch.Signal "cursor_changed" instance NodeSignal TextEdit "cursor_changed" '[] -- | Emitted when the info icon is clicked. sig_info_clicked :: Godot.Internal.Dispatch.Signal TextEdit sig_info_clicked = Godot.Internal.Dispatch.Signal "info_clicked" instance NodeSignal TextEdit "info_clicked" '[Int, GodotString] sig_request_completion :: Godot.Internal.Dispatch.Signal TextEdit sig_request_completion = Godot.Internal.Dispatch.Signal "request_completion" instance NodeSignal TextEdit "request_completion" '[] sig_symbol_lookup :: Godot.Internal.Dispatch.Signal TextEdit sig_symbol_lookup = Godot.Internal.Dispatch.Signal "symbol_lookup" instance NodeSignal TextEdit "symbol_lookup" '[GodotString, Int, Int] -- | Emitted when the text changes. sig_text_changed :: Godot.Internal.Dispatch.Signal TextEdit sig_text_changed = Godot.Internal.Dispatch.Signal "text_changed" instance NodeSignal TextEdit "text_changed" '[] instance NodeProperty TextEdit "breakpoint_gutter" Bool 'False where nodeProperty = (is_breakpoint_gutter_enabled, wrapDroppingSetter set_breakpoint_gutter_enabled, Nothing) instance NodeProperty TextEdit "caret_blink" Bool 'False where nodeProperty = (cursor_get_blink_enabled, wrapDroppingSetter cursor_set_blink_enabled, Nothing) instance NodeProperty TextEdit "caret_blink_speed" Float 'False where nodeProperty = (cursor_get_blink_speed, wrapDroppingSetter cursor_set_blink_speed, Nothing) instance NodeProperty TextEdit "caret_block_mode" Bool 'False where nodeProperty = (cursor_is_block_mode, wrapDroppingSetter cursor_set_block_mode, Nothing) instance NodeProperty TextEdit "caret_moving_by_right_click" Bool 'False where nodeProperty = (is_right_click_moving_caret, wrapDroppingSetter set_right_click_moves_caret, Nothing) instance NodeProperty TextEdit "context_menu_enabled" Bool 'False where nodeProperty = (is_context_menu_enabled, wrapDroppingSetter set_context_menu_enabled, Nothing) instance NodeProperty TextEdit "draw_spaces" Bool 'False where nodeProperty = (is_drawing_spaces, wrapDroppingSetter set_draw_spaces, Nothing) instance NodeProperty TextEdit "draw_tabs" Bool 'False where nodeProperty = (is_drawing_tabs, wrapDroppingSetter set_draw_tabs, Nothing) instance NodeProperty TextEdit "fold_gutter" Bool 'False where nodeProperty = (is_drawing_fold_gutter, wrapDroppingSetter set_draw_fold_gutter, Nothing) instance NodeProperty TextEdit "hiding_enabled" Bool 'False where nodeProperty = (is_hiding_enabled, wrapDroppingSetter set_hiding_enabled, Nothing) instance NodeProperty TextEdit "highlight_all_occurrences" Bool 'False where nodeProperty = (is_highlight_all_occurrences_enabled, wrapDroppingSetter set_highlight_all_occurrences, Nothing) instance NodeProperty TextEdit "highlight_current_line" Bool 'False where nodeProperty = (is_highlight_current_line_enabled, wrapDroppingSetter set_highlight_current_line, Nothing) instance NodeProperty TextEdit "minimap_draw" Bool 'False where nodeProperty = (is_drawing_minimap, wrapDroppingSetter draw_minimap, Nothing) instance NodeProperty TextEdit "minimap_width" Int 'False where nodeProperty = (get_minimap_width, wrapDroppingSetter set_minimap_width, Nothing) instance NodeProperty TextEdit "override_selected_font_color" Bool 'False where nodeProperty = (is_overriding_selected_font_color, wrapDroppingSetter set_override_selected_font_color, Nothing) instance NodeProperty TextEdit "readonly" Bool 'False where nodeProperty = (is_readonly, wrapDroppingSetter set_readonly, Nothing) instance NodeProperty TextEdit "scroll_horizontal" Int 'False where nodeProperty = (get_h_scroll, wrapDroppingSetter set_h_scroll, Nothing) instance NodeProperty TextEdit "scroll_vertical" Float 'False where nodeProperty = (get_v_scroll, wrapDroppingSetter set_v_scroll, Nothing) instance NodeProperty TextEdit "selecting_enabled" Bool 'False where nodeProperty = (is_selecting_enabled, wrapDroppingSetter set_selecting_enabled, Nothing) instance NodeProperty TextEdit "shortcut_keys_enabled" Bool 'False where nodeProperty = (is_shortcut_keys_enabled, wrapDroppingSetter set_shortcut_keys_enabled, Nothing) instance NodeProperty TextEdit "show_line_numbers" Bool 'False where nodeProperty = (is_show_line_numbers_enabled, wrapDroppingSetter set_show_line_numbers, Nothing) instance NodeProperty TextEdit "smooth_scrolling" Bool 'False where nodeProperty = (is_smooth_scroll_enabled, wrapDroppingSetter set_smooth_scroll_enable, Nothing) instance NodeProperty TextEdit "syntax_highlighting" Bool 'False where nodeProperty = (is_syntax_coloring_enabled, wrapDroppingSetter set_syntax_coloring, Nothing) instance NodeProperty TextEdit "text" GodotString 'False where nodeProperty = (get_text, wrapDroppingSetter set_text, Nothing) instance NodeProperty TextEdit "v_scroll_speed" Float 'False where nodeProperty = (get_v_scroll_speed, wrapDroppingSetter set_v_scroll_speed, Nothing) instance NodeProperty TextEdit "wrap_enabled" Bool 'False where nodeProperty = (is_wrap_enabled, wrapDroppingSetter set_wrap_enabled, Nothing) {-# NOINLINE bindTextEdit__click_selection_held #-} bindTextEdit__click_selection_held :: MethodBind bindTextEdit__click_selection_held = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_click_selection_held" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _click_selection_held :: (TextEdit :< cls, Object :< cls) => cls -> IO () _click_selection_held cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__click_selection_held (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_click_selection_held" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit._click_selection_held {-# NOINLINE bindTextEdit__cursor_changed_emit #-} bindTextEdit__cursor_changed_emit :: MethodBind bindTextEdit__cursor_changed_emit = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_cursor_changed_emit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _cursor_changed_emit :: (TextEdit :< cls, Object :< cls) => cls -> IO () _cursor_changed_emit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__cursor_changed_emit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_cursor_changed_emit" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit._cursor_changed_emit {-# NOINLINE bindTextEdit__gui_input #-} bindTextEdit__gui_input :: MethodBind bindTextEdit__gui_input = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (TextEdit :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.TextEdit._gui_input {-# NOINLINE bindTextEdit__push_current_op #-} bindTextEdit__push_current_op :: MethodBind bindTextEdit__push_current_op = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_push_current_op" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _push_current_op :: (TextEdit :< cls, Object :< cls) => cls -> IO () _push_current_op cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__push_current_op (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_push_current_op" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit._push_current_op {-# NOINLINE bindTextEdit__scroll_moved #-} bindTextEdit__scroll_moved :: MethodBind bindTextEdit__scroll_moved = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_scroll_moved" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _scroll_moved :: (TextEdit :< cls, Object :< cls) => cls -> Float -> IO () _scroll_moved cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__scroll_moved (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_scroll_moved" '[Float] (IO ()) where nodeMethod = Godot.Core.TextEdit._scroll_moved {-# NOINLINE bindTextEdit__text_changed_emit #-} bindTextEdit__text_changed_emit :: MethodBind bindTextEdit__text_changed_emit = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_text_changed_emit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _text_changed_emit :: (TextEdit :< cls, Object :< cls) => cls -> IO () _text_changed_emit cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__text_changed_emit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_text_changed_emit" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit._text_changed_emit {-# NOINLINE bindTextEdit__toggle_draw_caret #-} bindTextEdit__toggle_draw_caret :: MethodBind bindTextEdit__toggle_draw_caret = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_toggle_draw_caret" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _toggle_draw_caret :: (TextEdit :< cls, Object :< cls) => cls -> IO () _toggle_draw_caret cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__toggle_draw_caret (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_toggle_draw_caret" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit._toggle_draw_caret {-# NOINLINE bindTextEdit__update_wrap_at #-} bindTextEdit__update_wrap_at :: MethodBind bindTextEdit__update_wrap_at = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_update_wrap_at" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_wrap_at :: (TextEdit :< cls, Object :< cls) => cls -> IO () _update_wrap_at cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__update_wrap_at (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_update_wrap_at" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit._update_wrap_at {-# NOINLINE bindTextEdit__v_scroll_input #-} bindTextEdit__v_scroll_input :: MethodBind bindTextEdit__v_scroll_input = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "_v_scroll_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _v_scroll_input :: (TextEdit :< cls, Object :< cls) => cls -> IO () _v_scroll_input cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit__v_scroll_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "_v_scroll_input" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit._v_scroll_input {-# NOINLINE bindTextEdit_add_color_region #-} -- | Adds color region (given the delimiters) and its colors. bindTextEdit_add_color_region :: MethodBind bindTextEdit_add_color_region = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "add_color_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds color region (given the delimiters) and its colors. add_color_region :: (TextEdit :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Color -> Maybe Bool -> IO () add_color_region cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_add_color_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "add_color_region" '[GodotString, GodotString, Color, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.add_color_region {-# NOINLINE bindTextEdit_add_keyword_color #-} -- | Adds a @keyword@ and its @Color@. bindTextEdit_add_keyword_color :: MethodBind bindTextEdit_add_keyword_color = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "add_keyword_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @keyword@ and its @Color@. add_keyword_color :: (TextEdit :< cls, Object :< cls) => cls -> GodotString -> Color -> IO () add_keyword_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_add_keyword_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "add_keyword_color" '[GodotString, Color] (IO ()) where nodeMethod = Godot.Core.TextEdit.add_keyword_color {-# NOINLINE bindTextEdit_can_fold #-} -- | Returns if the given line is foldable, that is, it has indented lines right below it. bindTextEdit_can_fold :: MethodBind bindTextEdit_can_fold = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "can_fold" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns if the given line is foldable, that is, it has indented lines right below it. can_fold :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO Bool can_fold cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_can_fold (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "can_fold" '[Int] (IO Bool) where nodeMethod = Godot.Core.TextEdit.can_fold {-# NOINLINE bindTextEdit_center_viewport_to_cursor #-} -- | Centers the viewport on the line the editing cursor is at. This also resets the @scroll_horizontal@ value to @0@. bindTextEdit_center_viewport_to_cursor :: MethodBind bindTextEdit_center_viewport_to_cursor = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "center_viewport_to_cursor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Centers the viewport on the line the editing cursor is at. This also resets the @scroll_horizontal@ value to @0@. center_viewport_to_cursor :: (TextEdit :< cls, Object :< cls) => cls -> IO () center_viewport_to_cursor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_center_viewport_to_cursor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "center_viewport_to_cursor" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.center_viewport_to_cursor {-# NOINLINE bindTextEdit_clear_colors #-} -- | Clears all custom syntax coloring information previously added with @method add_color_region@ or @method add_keyword_color@. bindTextEdit_clear_colors :: MethodBind bindTextEdit_clear_colors = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "clear_colors" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all custom syntax coloring information previously added with @method add_color_region@ or @method add_keyword_color@. clear_colors :: (TextEdit :< cls, Object :< cls) => cls -> IO () clear_colors cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_clear_colors (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "clear_colors" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.clear_colors {-# NOINLINE bindTextEdit_clear_undo_history #-} -- | Clears the undo history. bindTextEdit_clear_undo_history :: MethodBind bindTextEdit_clear_undo_history = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "clear_undo_history" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the undo history. clear_undo_history :: (TextEdit :< cls, Object :< cls) => cls -> IO () clear_undo_history cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_clear_undo_history (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "clear_undo_history" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.clear_undo_history {-# NOINLINE bindTextEdit_copy #-} -- | Copy's the current text selection. bindTextEdit_copy :: MethodBind bindTextEdit_copy = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "copy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Copy's the current text selection. copy :: (TextEdit :< cls, Object :< cls) => cls -> IO () copy cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_copy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "copy" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.copy {-# NOINLINE bindTextEdit_cursor_get_blink_enabled #-} -- | If @true@, the caret (visual cursor) blinks. bindTextEdit_cursor_get_blink_enabled :: MethodBind bindTextEdit_cursor_get_blink_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_get_blink_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the caret (visual cursor) blinks. cursor_get_blink_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool cursor_get_blink_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_get_blink_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_get_blink_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.cursor_get_blink_enabled {-# NOINLINE bindTextEdit_cursor_get_blink_speed #-} -- | Duration (in seconds) of a caret's blinking cycle. bindTextEdit_cursor_get_blink_speed :: MethodBind bindTextEdit_cursor_get_blink_speed = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_get_blink_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Duration (in seconds) of a caret's blinking cycle. cursor_get_blink_speed :: (TextEdit :< cls, Object :< cls) => cls -> IO Float cursor_get_blink_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_get_blink_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_get_blink_speed" '[] (IO Float) where nodeMethod = Godot.Core.TextEdit.cursor_get_blink_speed {-# NOINLINE bindTextEdit_cursor_get_column #-} -- | Returns the column the editing cursor is at. bindTextEdit_cursor_get_column :: MethodBind bindTextEdit_cursor_get_column = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_get_column" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the column the editing cursor is at. cursor_get_column :: (TextEdit :< cls, Object :< cls) => cls -> IO Int cursor_get_column cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_get_column (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_get_column" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.cursor_get_column {-# NOINLINE bindTextEdit_cursor_get_line #-} -- | Returns the line the editing cursor is at. bindTextEdit_cursor_get_line :: MethodBind bindTextEdit_cursor_get_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_get_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the line the editing cursor is at. cursor_get_line :: (TextEdit :< cls, Object :< cls) => cls -> IO Int cursor_get_line cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_get_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_get_line" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.cursor_get_line {-# NOINLINE bindTextEdit_cursor_is_block_mode #-} -- | If @true@, the caret displays as a rectangle. -- If @false@, the caret displays as a bar. bindTextEdit_cursor_is_block_mode :: MethodBind bindTextEdit_cursor_is_block_mode = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_is_block_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the caret displays as a rectangle. -- If @false@, the caret displays as a bar. cursor_is_block_mode :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool cursor_is_block_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_is_block_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_is_block_mode" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.cursor_is_block_mode {-# NOINLINE bindTextEdit_cursor_set_blink_enabled #-} -- | If @true@, the caret (visual cursor) blinks. bindTextEdit_cursor_set_blink_enabled :: MethodBind bindTextEdit_cursor_set_blink_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_set_blink_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the caret (visual cursor) blinks. cursor_set_blink_enabled :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () cursor_set_blink_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_set_blink_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_set_blink_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.cursor_set_blink_enabled {-# NOINLINE bindTextEdit_cursor_set_blink_speed #-} -- | Duration (in seconds) of a caret's blinking cycle. bindTextEdit_cursor_set_blink_speed :: MethodBind bindTextEdit_cursor_set_blink_speed = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_set_blink_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Duration (in seconds) of a caret's blinking cycle. cursor_set_blink_speed :: (TextEdit :< cls, Object :< cls) => cls -> Float -> IO () cursor_set_blink_speed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_set_blink_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_set_blink_speed" '[Float] (IO ()) where nodeMethod = Godot.Core.TextEdit.cursor_set_blink_speed {-# NOINLINE bindTextEdit_cursor_set_block_mode #-} -- | If @true@, the caret displays as a rectangle. -- If @false@, the caret displays as a bar. bindTextEdit_cursor_set_block_mode :: MethodBind bindTextEdit_cursor_set_block_mode = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_set_block_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the caret displays as a rectangle. -- If @false@, the caret displays as a bar. cursor_set_block_mode :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () cursor_set_block_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_set_block_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_set_block_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.cursor_set_block_mode {-# NOINLINE bindTextEdit_cursor_set_column #-} -- | Moves the cursor at the specified @column@ index. -- If @adjust_viewport@ is set to @true@, the viewport will center at the cursor position after the move occurs. bindTextEdit_cursor_set_column :: MethodBind bindTextEdit_cursor_set_column = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_set_column" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the cursor at the specified @column@ index. -- If @adjust_viewport@ is set to @true@, the viewport will center at the cursor position after the move occurs. cursor_set_column :: (TextEdit :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO () cursor_set_column cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_set_column (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_set_column" '[Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.cursor_set_column {-# NOINLINE bindTextEdit_cursor_set_line #-} -- | Moves the cursor at the specified @line@ index. -- If @adjust_viewport@ is set to @true@, the viewport will center at the cursor position after the move occurs. -- If @can_be_hidden@ is set to @true@, the specified @line@ can be hidden using @method set_line_as_hidden@. bindTextEdit_cursor_set_line :: MethodBind bindTextEdit_cursor_set_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cursor_set_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the cursor at the specified @line@ index. -- If @adjust_viewport@ is set to @true@, the viewport will center at the cursor position after the move occurs. -- If @can_be_hidden@ is set to @true@, the specified @line@ can be hidden using @method set_line_as_hidden@. cursor_set_line :: (TextEdit :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> Maybe Bool -> Maybe Int -> IO () cursor_set_line cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2, maybe (VariantBool True) toVariant arg3, maybe (VariantInt (0)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cursor_set_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cursor_set_line" '[Int, Maybe Bool, Maybe Bool, Maybe Int] (IO ()) where nodeMethod = Godot.Core.TextEdit.cursor_set_line {-# NOINLINE bindTextEdit_cut #-} -- | Cut's the current selection. bindTextEdit_cut :: MethodBind bindTextEdit_cut = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "cut" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Cut's the current selection. cut :: (TextEdit :< cls, Object :< cls) => cls -> IO () cut cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_cut (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "cut" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.cut {-# NOINLINE bindTextEdit_deselect #-} -- | Deselects the current selection. bindTextEdit_deselect :: MethodBind bindTextEdit_deselect = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "deselect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deselects the current selection. deselect :: (TextEdit :< cls, Object :< cls) => cls -> IO () deselect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_deselect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "deselect" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.deselect {-# NOINLINE bindTextEdit_draw_minimap #-} -- | If @true@, a minimap is shown, providing an outline of your source code. bindTextEdit_draw_minimap :: MethodBind bindTextEdit_draw_minimap = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "draw_minimap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a minimap is shown, providing an outline of your source code. draw_minimap :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () draw_minimap cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_draw_minimap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "draw_minimap" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.draw_minimap {-# NOINLINE bindTextEdit_fold_all_lines #-} -- | Folds all lines that are possible to be folded (see @method can_fold@). bindTextEdit_fold_all_lines :: MethodBind bindTextEdit_fold_all_lines = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "fold_all_lines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Folds all lines that are possible to be folded (see @method can_fold@). fold_all_lines :: (TextEdit :< cls, Object :< cls) => cls -> IO () fold_all_lines cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_fold_all_lines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "fold_all_lines" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.fold_all_lines {-# NOINLINE bindTextEdit_fold_line #-} -- | Folds the given line, if possible (see @method can_fold@). bindTextEdit_fold_line :: MethodBind bindTextEdit_fold_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "fold_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Folds the given line, if possible (see @method can_fold@). fold_line :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO () fold_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_fold_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "fold_line" '[Int] (IO ()) where nodeMethod = Godot.Core.TextEdit.fold_line {-# NOINLINE bindTextEdit_get_breakpoints #-} -- | Returns an array containing the line number of each breakpoint. bindTextEdit_get_breakpoints :: MethodBind bindTextEdit_get_breakpoints = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_breakpoints" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array containing the line number of each breakpoint. get_breakpoints :: (TextEdit :< cls, Object :< cls) => cls -> IO Array get_breakpoints cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_breakpoints (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_breakpoints" '[] (IO Array) where nodeMethod = Godot.Core.TextEdit.get_breakpoints {-# NOINLINE bindTextEdit_get_h_scroll #-} -- | The current horizontal scroll value. bindTextEdit_get_h_scroll :: MethodBind bindTextEdit_get_h_scroll = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_h_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current horizontal scroll value. get_h_scroll :: (TextEdit :< cls, Object :< cls) => cls -> IO Int get_h_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_h_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_h_scroll" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.get_h_scroll {-# NOINLINE bindTextEdit_get_keyword_color #-} -- | Returns the @Color@ of the specified @keyword@. bindTextEdit_get_keyword_color :: MethodBind bindTextEdit_get_keyword_color = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_keyword_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Color@ of the specified @keyword@. get_keyword_color :: (TextEdit :< cls, Object :< cls) => cls -> GodotString -> IO Color get_keyword_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_keyword_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_keyword_color" '[GodotString] (IO Color) where nodeMethod = Godot.Core.TextEdit.get_keyword_color {-# NOINLINE bindTextEdit_get_line #-} -- | Returns the text of a specific line. bindTextEdit_get_line :: MethodBind bindTextEdit_get_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the text of a specific line. get_line :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO GodotString get_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_line" '[Int] (IO GodotString) where nodeMethod = Godot.Core.TextEdit.get_line {-# NOINLINE bindTextEdit_get_line_count #-} -- | Returns the amount of total lines in the text. bindTextEdit_get_line_count :: MethodBind bindTextEdit_get_line_count = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_line_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the amount of total lines in the text. get_line_count :: (TextEdit :< cls, Object :< cls) => cls -> IO Int get_line_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_line_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_line_count" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.get_line_count {-# NOINLINE bindTextEdit_get_menu #-} -- | Returns the @PopupMenu@ of this @TextEdit@. By default, this menu is displayed when right-clicking on the @TextEdit@. bindTextEdit_get_menu :: MethodBind bindTextEdit_get_menu = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_menu" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @PopupMenu@ of this @TextEdit@. By default, this menu is displayed when right-clicking on the @TextEdit@. get_menu :: (TextEdit :< cls, Object :< cls) => cls -> IO PopupMenu get_menu cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_menu (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_menu" '[] (IO PopupMenu) where nodeMethod = Godot.Core.TextEdit.get_menu {-# NOINLINE bindTextEdit_get_minimap_width #-} -- | The width, in pixels, of the minimap. bindTextEdit_get_minimap_width :: MethodBind bindTextEdit_get_minimap_width = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_minimap_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The width, in pixels, of the minimap. get_minimap_width :: (TextEdit :< cls, Object :< cls) => cls -> IO Int get_minimap_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_minimap_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_minimap_width" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.get_minimap_width {-# NOINLINE bindTextEdit_get_selection_from_column #-} -- | Returns the selection begin column. bindTextEdit_get_selection_from_column :: MethodBind bindTextEdit_get_selection_from_column = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_selection_from_column" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the selection begin column. get_selection_from_column :: (TextEdit :< cls, Object :< cls) => cls -> IO Int get_selection_from_column cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_selection_from_column (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_selection_from_column" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.get_selection_from_column {-# NOINLINE bindTextEdit_get_selection_from_line #-} -- | Returns the selection begin line. bindTextEdit_get_selection_from_line :: MethodBind bindTextEdit_get_selection_from_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_selection_from_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the selection begin line. get_selection_from_line :: (TextEdit :< cls, Object :< cls) => cls -> IO Int get_selection_from_line cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_selection_from_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_selection_from_line" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.get_selection_from_line {-# NOINLINE bindTextEdit_get_selection_text #-} -- | Returns the text inside the selection. bindTextEdit_get_selection_text :: MethodBind bindTextEdit_get_selection_text = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_selection_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the text inside the selection. get_selection_text :: (TextEdit :< cls, Object :< cls) => cls -> IO GodotString get_selection_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_selection_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_selection_text" '[] (IO GodotString) where nodeMethod = Godot.Core.TextEdit.get_selection_text {-# NOINLINE bindTextEdit_get_selection_to_column #-} -- | Returns the selection end column. bindTextEdit_get_selection_to_column :: MethodBind bindTextEdit_get_selection_to_column = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_selection_to_column" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the selection end column. get_selection_to_column :: (TextEdit :< cls, Object :< cls) => cls -> IO Int get_selection_to_column cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_selection_to_column (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_selection_to_column" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.get_selection_to_column {-# NOINLINE bindTextEdit_get_selection_to_line #-} -- | Returns the selection end line. bindTextEdit_get_selection_to_line :: MethodBind bindTextEdit_get_selection_to_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_selection_to_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the selection end line. get_selection_to_line :: (TextEdit :< cls, Object :< cls) => cls -> IO Int get_selection_to_line cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_selection_to_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_selection_to_line" '[] (IO Int) where nodeMethod = Godot.Core.TextEdit.get_selection_to_line {-# NOINLINE bindTextEdit_get_text #-} -- | String value of the @TextEdit@. bindTextEdit_get_text :: MethodBind bindTextEdit_get_text = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | String value of the @TextEdit@. get_text :: (TextEdit :< cls, Object :< cls) => cls -> IO GodotString get_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_text" '[] (IO GodotString) where nodeMethod = Godot.Core.TextEdit.get_text {-# NOINLINE bindTextEdit_get_v_scroll #-} -- | The current vertical scroll value. bindTextEdit_get_v_scroll :: MethodBind bindTextEdit_get_v_scroll = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_v_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current vertical scroll value. get_v_scroll :: (TextEdit :< cls, Object :< cls) => cls -> IO Float get_v_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_v_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_v_scroll" '[] (IO Float) where nodeMethod = Godot.Core.TextEdit.get_v_scroll {-# NOINLINE bindTextEdit_get_v_scroll_speed #-} -- | Vertical scroll sensitivity. bindTextEdit_get_v_scroll_speed :: MethodBind bindTextEdit_get_v_scroll_speed = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_v_scroll_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Vertical scroll sensitivity. get_v_scroll_speed :: (TextEdit :< cls, Object :< cls) => cls -> IO Float get_v_scroll_speed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_v_scroll_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_v_scroll_speed" '[] (IO Float) where nodeMethod = Godot.Core.TextEdit.get_v_scroll_speed {-# NOINLINE bindTextEdit_get_word_under_cursor #-} -- | Returns a @String@ text with the word under the mouse cursor location. bindTextEdit_get_word_under_cursor :: MethodBind bindTextEdit_get_word_under_cursor = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "get_word_under_cursor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @String@ text with the word under the mouse cursor location. get_word_under_cursor :: (TextEdit :< cls, Object :< cls) => cls -> IO GodotString get_word_under_cursor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_get_word_under_cursor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "get_word_under_cursor" '[] (IO GodotString) where nodeMethod = Godot.Core.TextEdit.get_word_under_cursor {-# NOINLINE bindTextEdit_has_keyword_color #-} -- | Returns whether the specified @keyword@ has a color set to it or not. bindTextEdit_has_keyword_color :: MethodBind bindTextEdit_has_keyword_color = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "has_keyword_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the specified @keyword@ has a color set to it or not. has_keyword_color :: (TextEdit :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_keyword_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_has_keyword_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "has_keyword_color" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.TextEdit.has_keyword_color {-# NOINLINE bindTextEdit_insert_text_at_cursor #-} -- | Insert the specified text at the cursor position. bindTextEdit_insert_text_at_cursor :: MethodBind bindTextEdit_insert_text_at_cursor = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "insert_text_at_cursor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Insert the specified text at the cursor position. insert_text_at_cursor :: (TextEdit :< cls, Object :< cls) => cls -> GodotString -> IO () insert_text_at_cursor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_insert_text_at_cursor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "insert_text_at_cursor" '[GodotString] (IO ()) where nodeMethod = Godot.Core.TextEdit.insert_text_at_cursor {-# NOINLINE bindTextEdit_is_breakpoint_gutter_enabled #-} -- | If @true@, the breakpoint gutter is visible. bindTextEdit_is_breakpoint_gutter_enabled :: MethodBind bindTextEdit_is_breakpoint_gutter_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_breakpoint_gutter_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the breakpoint gutter is visible. is_breakpoint_gutter_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_breakpoint_gutter_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_breakpoint_gutter_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_breakpoint_gutter_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_breakpoint_gutter_enabled {-# NOINLINE bindTextEdit_is_context_menu_enabled #-} -- | If @true@, a right-click displays the context menu. bindTextEdit_is_context_menu_enabled :: MethodBind bindTextEdit_is_context_menu_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_context_menu_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a right-click displays the context menu. is_context_menu_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_context_menu_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_context_menu_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_context_menu_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_context_menu_enabled {-# NOINLINE bindTextEdit_is_drawing_fold_gutter #-} -- | If @true@, the fold gutter is visible. This enables folding groups of indented lines. bindTextEdit_is_drawing_fold_gutter :: MethodBind bindTextEdit_is_drawing_fold_gutter = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_drawing_fold_gutter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the fold gutter is visible. This enables folding groups of indented lines. is_drawing_fold_gutter :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_drawing_fold_gutter cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_drawing_fold_gutter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_drawing_fold_gutter" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_drawing_fold_gutter {-# NOINLINE bindTextEdit_is_drawing_minimap #-} -- | If @true@, a minimap is shown, providing an outline of your source code. bindTextEdit_is_drawing_minimap :: MethodBind bindTextEdit_is_drawing_minimap = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_drawing_minimap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a minimap is shown, providing an outline of your source code. is_drawing_minimap :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_drawing_minimap cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_drawing_minimap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_drawing_minimap" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_drawing_minimap {-# NOINLINE bindTextEdit_is_drawing_spaces #-} -- | If @true@, the "space" character will have a visible representation. bindTextEdit_is_drawing_spaces :: MethodBind bindTextEdit_is_drawing_spaces = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_drawing_spaces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the "space" character will have a visible representation. is_drawing_spaces :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_drawing_spaces cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_drawing_spaces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_drawing_spaces" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_drawing_spaces {-# NOINLINE bindTextEdit_is_drawing_tabs #-} -- | If @true@, the "tab" character will have a visible representation. bindTextEdit_is_drawing_tabs :: MethodBind bindTextEdit_is_drawing_tabs = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_drawing_tabs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the "tab" character will have a visible representation. is_drawing_tabs :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_drawing_tabs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_drawing_tabs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_drawing_tabs" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_drawing_tabs {-# NOINLINE bindTextEdit_is_folded #-} -- | Returns whether the line at the specified index is folded or not. bindTextEdit_is_folded :: MethodBind bindTextEdit_is_folded = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_folded" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the line at the specified index is folded or not. is_folded :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO Bool is_folded cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_folded (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_folded" '[Int] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_folded {-# NOINLINE bindTextEdit_is_hiding_enabled #-} -- | If @true@, all lines that have been set to hidden by @method set_line_as_hidden@, will not be visible. bindTextEdit_is_hiding_enabled :: MethodBind bindTextEdit_is_hiding_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_hiding_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, all lines that have been set to hidden by @method set_line_as_hidden@, will not be visible. is_hiding_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_hiding_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_hiding_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_hiding_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_hiding_enabled {-# NOINLINE bindTextEdit_is_highlight_all_occurrences_enabled #-} -- | If @true@, all occurrences of the selected text will be highlighted. bindTextEdit_is_highlight_all_occurrences_enabled :: MethodBind bindTextEdit_is_highlight_all_occurrences_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_highlight_all_occurrences_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, all occurrences of the selected text will be highlighted. is_highlight_all_occurrences_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_highlight_all_occurrences_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_highlight_all_occurrences_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_highlight_all_occurrences_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_highlight_all_occurrences_enabled {-# NOINLINE bindTextEdit_is_highlight_current_line_enabled #-} -- | If @true@, the line containing the cursor is highlighted. bindTextEdit_is_highlight_current_line_enabled :: MethodBind bindTextEdit_is_highlight_current_line_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_highlight_current_line_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the line containing the cursor is highlighted. is_highlight_current_line_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_highlight_current_line_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_highlight_current_line_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_highlight_current_line_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_highlight_current_line_enabled {-# NOINLINE bindTextEdit_is_line_hidden #-} -- | Returns whether the line at the specified index is hidden or not. bindTextEdit_is_line_hidden :: MethodBind bindTextEdit_is_line_hidden = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_line_hidden" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the line at the specified index is hidden or not. is_line_hidden :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO Bool is_line_hidden cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_line_hidden (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_line_hidden" '[Int] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_line_hidden {-# NOINLINE bindTextEdit_is_overriding_selected_font_color #-} -- | If @true@, custom @font_color_selected@ will be used for selected text. bindTextEdit_is_overriding_selected_font_color :: MethodBind bindTextEdit_is_overriding_selected_font_color = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_overriding_selected_font_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, custom @font_color_selected@ will be used for selected text. is_overriding_selected_font_color :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_overriding_selected_font_color cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_overriding_selected_font_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_overriding_selected_font_color" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_overriding_selected_font_color {-# NOINLINE bindTextEdit_is_readonly #-} -- | If @true@, read-only mode is enabled. Existing text cannot be modified and new text cannot be added. bindTextEdit_is_readonly :: MethodBind bindTextEdit_is_readonly = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_readonly" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, read-only mode is enabled. Existing text cannot be modified and new text cannot be added. is_readonly :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_readonly cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_readonly (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_readonly" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_readonly {-# NOINLINE bindTextEdit_is_right_click_moving_caret #-} -- | If @true@, a right-click moves the cursor at the mouse position before displaying the context menu. -- If @false@, the context menu disregards mouse location. bindTextEdit_is_right_click_moving_caret :: MethodBind bindTextEdit_is_right_click_moving_caret = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_right_click_moving_caret" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a right-click moves the cursor at the mouse position before displaying the context menu. -- If @false@, the context menu disregards mouse location. is_right_click_moving_caret :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_right_click_moving_caret cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_right_click_moving_caret (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_right_click_moving_caret" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_right_click_moving_caret {-# NOINLINE bindTextEdit_is_selecting_enabled #-} -- | If @true@, text can be selected. -- If @false@, text can not be selected by the user or by the @method select@ or @method select_all@ methods. bindTextEdit_is_selecting_enabled :: MethodBind bindTextEdit_is_selecting_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_selecting_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, text can be selected. -- If @false@, text can not be selected by the user or by the @method select@ or @method select_all@ methods. is_selecting_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_selecting_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_selecting_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_selecting_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_selecting_enabled {-# NOINLINE bindTextEdit_is_selection_active #-} -- | Returns @true@ if the selection is active. bindTextEdit_is_selection_active :: MethodBind bindTextEdit_is_selection_active = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_selection_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the selection is active. is_selection_active :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_selection_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_selection_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_selection_active" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_selection_active {-# NOINLINE bindTextEdit_is_shortcut_keys_enabled #-} -- | If @true@, shortcut keys for context menu items are enabled, even if the context menu is disabled. bindTextEdit_is_shortcut_keys_enabled :: MethodBind bindTextEdit_is_shortcut_keys_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_shortcut_keys_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, shortcut keys for context menu items are enabled, even if the context menu is disabled. is_shortcut_keys_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_shortcut_keys_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_shortcut_keys_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_shortcut_keys_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_shortcut_keys_enabled {-# NOINLINE bindTextEdit_is_show_line_numbers_enabled #-} -- | If @true@, line numbers are displayed to the left of the text. bindTextEdit_is_show_line_numbers_enabled :: MethodBind bindTextEdit_is_show_line_numbers_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_show_line_numbers_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, line numbers are displayed to the left of the text. is_show_line_numbers_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_show_line_numbers_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_show_line_numbers_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_show_line_numbers_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_show_line_numbers_enabled {-# NOINLINE bindTextEdit_is_smooth_scroll_enabled #-} -- | If @true@, sets the @step@ of the scrollbars to @0.25@ which results in smoother scrolling. bindTextEdit_is_smooth_scroll_enabled :: MethodBind bindTextEdit_is_smooth_scroll_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_smooth_scroll_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @step@ of the scrollbars to @0.25@ which results in smoother scrolling. is_smooth_scroll_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_smooth_scroll_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_smooth_scroll_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_smooth_scroll_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_smooth_scroll_enabled {-# NOINLINE bindTextEdit_is_syntax_coloring_enabled #-} -- | If @true@, any custom color properties that have been set for this @TextEdit@ will be visible. bindTextEdit_is_syntax_coloring_enabled :: MethodBind bindTextEdit_is_syntax_coloring_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_syntax_coloring_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, any custom color properties that have been set for this @TextEdit@ will be visible. is_syntax_coloring_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_syntax_coloring_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_syntax_coloring_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_syntax_coloring_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_syntax_coloring_enabled {-# NOINLINE bindTextEdit_is_wrap_enabled #-} -- | If @true@, enables text wrapping when it goes beyond the edge of what is visible. bindTextEdit_is_wrap_enabled :: MethodBind bindTextEdit_is_wrap_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "is_wrap_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables text wrapping when it goes beyond the edge of what is visible. is_wrap_enabled :: (TextEdit :< cls, Object :< cls) => cls -> IO Bool is_wrap_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_is_wrap_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "is_wrap_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TextEdit.is_wrap_enabled {-# NOINLINE bindTextEdit_menu_option #-} -- | Triggers a right-click menu action by the specified index. See @enum MenuItems@ for a list of available indexes. bindTextEdit_menu_option :: MethodBind bindTextEdit_menu_option = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "menu_option" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Triggers a right-click menu action by the specified index. See @enum MenuItems@ for a list of available indexes. menu_option :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO () menu_option cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_menu_option (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "menu_option" '[Int] (IO ()) where nodeMethod = Godot.Core.TextEdit.menu_option {-# NOINLINE bindTextEdit_paste #-} -- | Paste the current selection. bindTextEdit_paste :: MethodBind bindTextEdit_paste = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "paste" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Paste the current selection. paste :: (TextEdit :< cls, Object :< cls) => cls -> IO () paste cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_paste (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "paste" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.paste {-# NOINLINE bindTextEdit_redo #-} -- | Perform redo operation. bindTextEdit_redo :: MethodBind bindTextEdit_redo = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "redo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Perform redo operation. redo :: (TextEdit :< cls, Object :< cls) => cls -> IO () redo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_redo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "redo" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.redo {-# NOINLINE bindTextEdit_remove_breakpoints #-} -- | Removes all the breakpoints. This will not fire the @signal breakpoint_toggled@ signal. bindTextEdit_remove_breakpoints :: MethodBind bindTextEdit_remove_breakpoints = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "remove_breakpoints" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all the breakpoints. This will not fire the @signal breakpoint_toggled@ signal. remove_breakpoints :: (TextEdit :< cls, Object :< cls) => cls -> IO () remove_breakpoints cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_remove_breakpoints (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "remove_breakpoints" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.remove_breakpoints {-# NOINLINE bindTextEdit_search #-} -- | Perform a search inside the text. Search flags can be specified in the @enum SearchFlags@ enum. -- Returns an empty @PoolIntArray@ if no result was found. Otherwise, the result line and column can be accessed at indices specified in the @enum SearchResult@ enum, e.g: -- -- @ -- -- var result = search(key, flags, line, column) -- if result.size() > 0: -- # Result found. -- var res_line = result@TextEdit.SEARCH_RESULT_LINE@ -- var res_column = result@TextEdit.SEARCH_RESULT_COLUMN@ -- -- @ bindTextEdit_search :: MethodBind bindTextEdit_search = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "search" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Perform a search inside the text. Search flags can be specified in the @enum SearchFlags@ enum. -- Returns an empty @PoolIntArray@ if no result was found. Otherwise, the result line and column can be accessed at indices specified in the @enum SearchResult@ enum, e.g: -- -- @ -- -- var result = search(key, flags, line, column) -- if result.size() > 0: -- # Result found. -- var res_line = result@TextEdit.SEARCH_RESULT_LINE@ -- var res_column = result@TextEdit.SEARCH_RESULT_COLUMN@ -- -- @ search :: (TextEdit :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> Int -> IO PoolIntArray search cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_search (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "search" '[GodotString, Int, Int, Int] (IO PoolIntArray) where nodeMethod = Godot.Core.TextEdit.search {-# NOINLINE bindTextEdit_select #-} -- | Perform selection, from line/column to line/column. -- If @selecting_enabled@ is @false@, no selection will occur. bindTextEdit_select :: MethodBind bindTextEdit_select = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Perform selection, from line/column to line/column. -- If @selecting_enabled@ is @false@, no selection will occur. select :: (TextEdit :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> IO () select cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "select" '[Int, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.TextEdit.select {-# NOINLINE bindTextEdit_select_all #-} -- | Select all the text. -- If @selecting_enabled@ is @false@, no selection will occur. bindTextEdit_select_all :: MethodBind bindTextEdit_select_all = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "select_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Select all the text. -- If @selecting_enabled@ is @false@, no selection will occur. select_all :: (TextEdit :< cls, Object :< cls) => cls -> IO () select_all cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_select_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "select_all" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.select_all {-# NOINLINE bindTextEdit_set_breakpoint_gutter_enabled #-} -- | If @true@, the breakpoint gutter is visible. bindTextEdit_set_breakpoint_gutter_enabled :: MethodBind bindTextEdit_set_breakpoint_gutter_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_breakpoint_gutter_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the breakpoint gutter is visible. set_breakpoint_gutter_enabled :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_breakpoint_gutter_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_breakpoint_gutter_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_breakpoint_gutter_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_breakpoint_gutter_enabled {-# NOINLINE bindTextEdit_set_context_menu_enabled #-} -- | If @true@, a right-click displays the context menu. bindTextEdit_set_context_menu_enabled :: MethodBind bindTextEdit_set_context_menu_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_context_menu_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a right-click displays the context menu. set_context_menu_enabled :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_context_menu_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_context_menu_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_context_menu_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_context_menu_enabled {-# NOINLINE bindTextEdit_set_draw_fold_gutter #-} -- | If @true@, the fold gutter is visible. This enables folding groups of indented lines. bindTextEdit_set_draw_fold_gutter :: MethodBind bindTextEdit_set_draw_fold_gutter = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_draw_fold_gutter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the fold gutter is visible. This enables folding groups of indented lines. set_draw_fold_gutter :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_draw_fold_gutter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_draw_fold_gutter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_draw_fold_gutter" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_draw_fold_gutter {-# NOINLINE bindTextEdit_set_draw_spaces #-} -- | If @true@, the "space" character will have a visible representation. bindTextEdit_set_draw_spaces :: MethodBind bindTextEdit_set_draw_spaces = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_draw_spaces" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the "space" character will have a visible representation. set_draw_spaces :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_draw_spaces cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_draw_spaces (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_draw_spaces" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_draw_spaces {-# NOINLINE bindTextEdit_set_draw_tabs #-} -- | If @true@, the "tab" character will have a visible representation. bindTextEdit_set_draw_tabs :: MethodBind bindTextEdit_set_draw_tabs = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_draw_tabs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the "tab" character will have a visible representation. set_draw_tabs :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_draw_tabs cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_draw_tabs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_draw_tabs" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_draw_tabs {-# NOINLINE bindTextEdit_set_h_scroll #-} -- | The current horizontal scroll value. bindTextEdit_set_h_scroll :: MethodBind bindTextEdit_set_h_scroll = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_h_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current horizontal scroll value. set_h_scroll :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO () set_h_scroll cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_h_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_h_scroll" '[Int] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_h_scroll {-# NOINLINE bindTextEdit_set_hiding_enabled #-} -- | If @true@, all lines that have been set to hidden by @method set_line_as_hidden@, will not be visible. bindTextEdit_set_hiding_enabled :: MethodBind bindTextEdit_set_hiding_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_hiding_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, all lines that have been set to hidden by @method set_line_as_hidden@, will not be visible. set_hiding_enabled :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_hiding_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_hiding_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_hiding_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_hiding_enabled {-# NOINLINE bindTextEdit_set_highlight_all_occurrences #-} -- | If @true@, all occurrences of the selected text will be highlighted. bindTextEdit_set_highlight_all_occurrences :: MethodBind bindTextEdit_set_highlight_all_occurrences = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_highlight_all_occurrences" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, all occurrences of the selected text will be highlighted. set_highlight_all_occurrences :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_highlight_all_occurrences cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_highlight_all_occurrences (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_highlight_all_occurrences" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_highlight_all_occurrences {-# NOINLINE bindTextEdit_set_highlight_current_line #-} -- | If @true@, the line containing the cursor is highlighted. bindTextEdit_set_highlight_current_line :: MethodBind bindTextEdit_set_highlight_current_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_highlight_current_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the line containing the cursor is highlighted. set_highlight_current_line :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_highlight_current_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_highlight_current_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_highlight_current_line" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_highlight_current_line {-# NOINLINE bindTextEdit_set_line_as_hidden #-} -- | If @true@, hides the line of the specified index. bindTextEdit_set_line_as_hidden :: MethodBind bindTextEdit_set_line_as_hidden = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_line_as_hidden" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hides the line of the specified index. set_line_as_hidden :: (TextEdit :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_line_as_hidden cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_line_as_hidden (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_line_as_hidden" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_line_as_hidden {-# NOINLINE bindTextEdit_set_minimap_width #-} -- | The width, in pixels, of the minimap. bindTextEdit_set_minimap_width :: MethodBind bindTextEdit_set_minimap_width = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_minimap_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The width, in pixels, of the minimap. set_minimap_width :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO () set_minimap_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_minimap_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_minimap_width" '[Int] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_minimap_width {-# NOINLINE bindTextEdit_set_override_selected_font_color #-} -- | If @true@, custom @font_color_selected@ will be used for selected text. bindTextEdit_set_override_selected_font_color :: MethodBind bindTextEdit_set_override_selected_font_color = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_override_selected_font_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, custom @font_color_selected@ will be used for selected text. set_override_selected_font_color :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_override_selected_font_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_override_selected_font_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_override_selected_font_color" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_override_selected_font_color {-# NOINLINE bindTextEdit_set_readonly #-} -- | If @true@, read-only mode is enabled. Existing text cannot be modified and new text cannot be added. bindTextEdit_set_readonly :: MethodBind bindTextEdit_set_readonly = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_readonly" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, read-only mode is enabled. Existing text cannot be modified and new text cannot be added. set_readonly :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_readonly cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_readonly (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_readonly" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_readonly {-# NOINLINE bindTextEdit_set_right_click_moves_caret #-} -- | If @true@, a right-click moves the cursor at the mouse position before displaying the context menu. -- If @false@, the context menu disregards mouse location. bindTextEdit_set_right_click_moves_caret :: MethodBind bindTextEdit_set_right_click_moves_caret = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_right_click_moves_caret" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a right-click moves the cursor at the mouse position before displaying the context menu. -- If @false@, the context menu disregards mouse location. set_right_click_moves_caret :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_right_click_moves_caret cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_right_click_moves_caret (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_right_click_moves_caret" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_right_click_moves_caret {-# NOINLINE bindTextEdit_set_selecting_enabled #-} -- | If @true@, text can be selected. -- If @false@, text can not be selected by the user or by the @method select@ or @method select_all@ methods. bindTextEdit_set_selecting_enabled :: MethodBind bindTextEdit_set_selecting_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_selecting_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, text can be selected. -- If @false@, text can not be selected by the user or by the @method select@ or @method select_all@ methods. set_selecting_enabled :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_selecting_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_selecting_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_selecting_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_selecting_enabled {-# NOINLINE bindTextEdit_set_shortcut_keys_enabled #-} -- | If @true@, shortcut keys for context menu items are enabled, even if the context menu is disabled. bindTextEdit_set_shortcut_keys_enabled :: MethodBind bindTextEdit_set_shortcut_keys_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_shortcut_keys_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, shortcut keys for context menu items are enabled, even if the context menu is disabled. set_shortcut_keys_enabled :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_shortcut_keys_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_shortcut_keys_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_shortcut_keys_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_shortcut_keys_enabled {-# NOINLINE bindTextEdit_set_show_line_numbers #-} -- | If @true@, line numbers are displayed to the left of the text. bindTextEdit_set_show_line_numbers :: MethodBind bindTextEdit_set_show_line_numbers = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_show_line_numbers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, line numbers are displayed to the left of the text. set_show_line_numbers :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_show_line_numbers cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_show_line_numbers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_show_line_numbers" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_show_line_numbers {-# NOINLINE bindTextEdit_set_smooth_scroll_enable #-} -- | If @true@, sets the @step@ of the scrollbars to @0.25@ which results in smoother scrolling. bindTextEdit_set_smooth_scroll_enable :: MethodBind bindTextEdit_set_smooth_scroll_enable = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_smooth_scroll_enable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the @step@ of the scrollbars to @0.25@ which results in smoother scrolling. set_smooth_scroll_enable :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_smooth_scroll_enable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_smooth_scroll_enable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_smooth_scroll_enable" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_smooth_scroll_enable {-# NOINLINE bindTextEdit_set_syntax_coloring #-} -- | If @true@, any custom color properties that have been set for this @TextEdit@ will be visible. bindTextEdit_set_syntax_coloring :: MethodBind bindTextEdit_set_syntax_coloring = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_syntax_coloring" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, any custom color properties that have been set for this @TextEdit@ will be visible. set_syntax_coloring :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_syntax_coloring cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_syntax_coloring (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_syntax_coloring" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_syntax_coloring {-# NOINLINE bindTextEdit_set_text #-} -- | String value of the @TextEdit@. bindTextEdit_set_text :: MethodBind bindTextEdit_set_text = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | String value of the @TextEdit@. set_text :: (TextEdit :< cls, Object :< cls) => cls -> GodotString -> IO () set_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_text {-# NOINLINE bindTextEdit_set_v_scroll #-} -- | The current vertical scroll value. bindTextEdit_set_v_scroll :: MethodBind bindTextEdit_set_v_scroll = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_v_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current vertical scroll value. set_v_scroll :: (TextEdit :< cls, Object :< cls) => cls -> Float -> IO () set_v_scroll cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_v_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_v_scroll" '[Float] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_v_scroll {-# NOINLINE bindTextEdit_set_v_scroll_speed #-} -- | Vertical scroll sensitivity. bindTextEdit_set_v_scroll_speed :: MethodBind bindTextEdit_set_v_scroll_speed = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_v_scroll_speed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Vertical scroll sensitivity. set_v_scroll_speed :: (TextEdit :< cls, Object :< cls) => cls -> Float -> IO () set_v_scroll_speed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_v_scroll_speed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_v_scroll_speed" '[Float] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_v_scroll_speed {-# NOINLINE bindTextEdit_set_wrap_enabled #-} -- | If @true@, enables text wrapping when it goes beyond the edge of what is visible. bindTextEdit_set_wrap_enabled :: MethodBind bindTextEdit_set_wrap_enabled = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "set_wrap_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables text wrapping when it goes beyond the edge of what is visible. set_wrap_enabled :: (TextEdit :< cls, Object :< cls) => cls -> Bool -> IO () set_wrap_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_set_wrap_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "set_wrap_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextEdit.set_wrap_enabled {-# NOINLINE bindTextEdit_toggle_fold_line #-} -- | Toggle the folding of the code block at the given line. bindTextEdit_toggle_fold_line :: MethodBind bindTextEdit_toggle_fold_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "toggle_fold_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Toggle the folding of the code block at the given line. toggle_fold_line :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO () toggle_fold_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_toggle_fold_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "toggle_fold_line" '[Int] (IO ()) where nodeMethod = Godot.Core.TextEdit.toggle_fold_line {-# NOINLINE bindTextEdit_undo #-} -- | Perform undo operation. bindTextEdit_undo :: MethodBind bindTextEdit_undo = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "undo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Perform undo operation. undo :: (TextEdit :< cls, Object :< cls) => cls -> IO () undo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_undo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "undo" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.undo {-# NOINLINE bindTextEdit_unfold_line #-} -- | Unfolds the given line, if folded. bindTextEdit_unfold_line :: MethodBind bindTextEdit_unfold_line = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "unfold_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unfolds the given line, if folded. unfold_line :: (TextEdit :< cls, Object :< cls) => cls -> Int -> IO () unfold_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_unfold_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "unfold_line" '[Int] (IO ()) where nodeMethod = Godot.Core.TextEdit.unfold_line {-# NOINLINE bindTextEdit_unhide_all_lines #-} -- | Unhide all lines that were previously set to hidden by @method set_line_as_hidden@. bindTextEdit_unhide_all_lines :: MethodBind bindTextEdit_unhide_all_lines = unsafePerformIO $ withCString "TextEdit" $ \ clsNamePtr -> withCString "unhide_all_lines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unhide all lines that were previously set to hidden by @method set_line_as_hidden@. unhide_all_lines :: (TextEdit :< cls, Object :< cls) => cls -> IO () unhide_all_lines cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextEdit_unhide_all_lines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextEdit "unhide_all_lines" '[] (IO ()) where nodeMethod = Godot.Core.TextEdit.unhide_all_lines ================================================ FILE: src/Godot/Core/TextFile.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TextFile () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() ================================================ FILE: src/Godot/Core/Texture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Texture (Godot.Core.Texture._FLAG_VIDEO_SURFACE, Godot.Core.Texture._FLAGS_DEFAULT, Godot.Core.Texture._FLAG_REPEAT, Godot.Core.Texture._FLAG_CONVERT_TO_LINEAR, Godot.Core.Texture._FLAG_ANISOTROPIC_FILTER, Godot.Core.Texture._FLAG_MIPMAPS, Godot.Core.Texture._FLAG_FILTER, Godot.Core.Texture._FLAG_MIRRORED_REPEAT, Godot.Core.Texture.draw, Godot.Core.Texture.draw_rect, Godot.Core.Texture.draw_rect_region, Godot.Core.Texture.get_data, Godot.Core.Texture.get_flags, Godot.Core.Texture.get_height, Godot.Core.Texture.get_size, Godot.Core.Texture.get_width, Godot.Core.Texture.has_alpha, Godot.Core.Texture.set_flags) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _FLAG_VIDEO_SURFACE :: Int _FLAG_VIDEO_SURFACE = 2048 _FLAGS_DEFAULT :: Int _FLAGS_DEFAULT = 7 _FLAG_REPEAT :: Int _FLAG_REPEAT = 2 _FLAG_CONVERT_TO_LINEAR :: Int _FLAG_CONVERT_TO_LINEAR = 16 _FLAG_ANISOTROPIC_FILTER :: Int _FLAG_ANISOTROPIC_FILTER = 8 _FLAG_MIPMAPS :: Int _FLAG_MIPMAPS = 1 _FLAG_FILTER :: Int _FLAG_FILTER = 4 _FLAG_MIRRORED_REPEAT :: Int _FLAG_MIRRORED_REPEAT = 32 instance NodeProperty Texture "flags" Int 'False where nodeProperty = (get_flags, wrapDroppingSetter set_flags, Nothing) {-# NOINLINE bindTexture_draw #-} -- | Draws the texture using a @CanvasItem@ with the @VisualServer@ API at the specified @position@. Equivalent to @method VisualServer.canvas_item_add_texture_rect@ with a rect at @position@ and the size of this @Texture@. bindTexture_draw :: MethodBind bindTexture_draw = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws the texture using a @CanvasItem@ with the @VisualServer@ API at the specified @position@. Equivalent to @method VisualServer.canvas_item_add_texture_rect@ with a rect at @position@ and the size of this @Texture@. draw :: (Texture :< cls, Object :< cls) => cls -> Rid -> Vector2 -> Maybe Color -> Maybe Bool -> Maybe Texture -> IO () draw cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg3, maybe (VariantBool False) toVariant arg4, maybe VariantNil toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "draw" '[Rid, Vector2, Maybe Color, Maybe Bool, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.Texture.draw {-# NOINLINE bindTexture_draw_rect #-} -- | Draws the texture using a @CanvasItem@ with the @VisualServer@ API. Equivalent to @method VisualServer.canvas_item_add_texture_rect@. bindTexture_draw_rect :: MethodBind bindTexture_draw_rect = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "draw_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws the texture using a @CanvasItem@ with the @VisualServer@ API. Equivalent to @method VisualServer.canvas_item_add_texture_rect@. draw_rect :: (Texture :< cls, Object :< cls) => cls -> Rid -> Rect2 -> Bool -> Maybe Color -> Maybe Bool -> Maybe Texture -> IO () draw_rect cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4, maybe (VariantBool False) toVariant arg5, maybe VariantNil toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_draw_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "draw_rect" '[Rid, Rect2, Bool, Maybe Color, Maybe Bool, Maybe Texture] (IO ()) where nodeMethod = Godot.Core.Texture.draw_rect {-# NOINLINE bindTexture_draw_rect_region #-} -- | Draws a part of the texture using a @CanvasItem@ with the @VisualServer@ API. Equivalent to @method VisualServer.canvas_item_add_texture_rect_region@. bindTexture_draw_rect_region :: MethodBind bindTexture_draw_rect_region = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "draw_rect_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a part of the texture using a @CanvasItem@ with the @VisualServer@ API. Equivalent to @method VisualServer.canvas_item_add_texture_rect_region@. draw_rect_region :: (Texture :< cls, Object :< cls) => cls -> Rid -> Rect2 -> Rect2 -> Maybe Color -> Maybe Bool -> Maybe Texture -> Maybe Bool -> IO () draw_rect_region cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4, maybe (VariantBool False) toVariant arg5, maybe VariantNil toVariant arg6, maybe (VariantBool True) toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_draw_rect_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "draw_rect_region" '[Rid, Rect2, Rect2, Maybe Color, Maybe Bool, Maybe Texture, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.Texture.draw_rect_region {-# NOINLINE bindTexture_get_data #-} -- | Returns an @Image@ that is a copy of data from this @Texture@. @Image@s can be accessed and manipulated directly. bindTexture_get_data :: MethodBind bindTexture_get_data = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Image@ that is a copy of data from this @Texture@. @Image@s can be accessed and manipulated directly. get_data :: (Texture :< cls, Object :< cls) => cls -> IO Image get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "get_data" '[] (IO Image) where nodeMethod = Godot.Core.Texture.get_data {-# NOINLINE bindTexture_get_flags #-} -- | The texture's @enum Flags@. @enum Flags@ are used to set various properties of the @Texture@. bindTexture_get_flags :: MethodBind bindTexture_get_flags = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "get_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's @enum Flags@. @enum Flags@ are used to set various properties of the @Texture@. get_flags :: (Texture :< cls, Object :< cls) => cls -> IO Int get_flags cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_get_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "get_flags" '[] (IO Int) where nodeMethod = Godot.Core.Texture.get_flags {-# NOINLINE bindTexture_get_height #-} -- | Returns the texture height. bindTexture_get_height :: MethodBind bindTexture_get_height = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the texture height. get_height :: (Texture :< cls, Object :< cls) => cls -> IO Int get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "get_height" '[] (IO Int) where nodeMethod = Godot.Core.Texture.get_height {-# NOINLINE bindTexture_get_size #-} -- | Returns the texture size. bindTexture_get_size :: MethodBind bindTexture_get_size = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the texture size. get_size :: (Texture :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Texture.get_size {-# NOINLINE bindTexture_get_width #-} -- | Returns the texture width. bindTexture_get_width :: MethodBind bindTexture_get_width = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the texture width. get_width :: (Texture :< cls, Object :< cls) => cls -> IO Int get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "get_width" '[] (IO Int) where nodeMethod = Godot.Core.Texture.get_width {-# NOINLINE bindTexture_has_alpha #-} -- | Returns @true@ if this @Texture@ has an alpha channel. bindTexture_has_alpha :: MethodBind bindTexture_has_alpha = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "has_alpha" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this @Texture@ has an alpha channel. has_alpha :: (Texture :< cls, Object :< cls) => cls -> IO Bool has_alpha cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_has_alpha (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "has_alpha" '[] (IO Bool) where nodeMethod = Godot.Core.Texture.has_alpha {-# NOINLINE bindTexture_set_flags #-} -- | The texture's @enum Flags@. @enum Flags@ are used to set various properties of the @Texture@. bindTexture_set_flags :: MethodBind bindTexture_set_flags = unsafePerformIO $ withCString "Texture" $ \ clsNamePtr -> withCString "set_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The texture's @enum Flags@. @enum Flags@ are used to set various properties of the @Texture@. set_flags :: (Texture :< cls, Object :< cls) => cls -> Int -> IO () set_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTexture_set_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Texture "set_flags" '[Int] (IO ()) where nodeMethod = Godot.Core.Texture.set_flags ================================================ FILE: src/Godot/Core/Texture3D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Texture3D () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.TextureLayered() ================================================ FILE: src/Godot/Core/TextureArray.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TextureArray () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.TextureLayered() ================================================ FILE: src/Godot/Core/TextureButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TextureButton (Godot.Core.TextureButton._STRETCH_TILE, Godot.Core.TextureButton._STRETCH_KEEP_ASPECT_COVERED, Godot.Core.TextureButton._STRETCH_KEEP_ASPECT, Godot.Core.TextureButton._STRETCH_SCALE, Godot.Core.TextureButton._STRETCH_KEEP, Godot.Core.TextureButton._STRETCH_KEEP_CENTERED, Godot.Core.TextureButton._STRETCH_KEEP_ASPECT_CENTERED, Godot.Core.TextureButton.get_click_mask, Godot.Core.TextureButton.get_disabled_texture, Godot.Core.TextureButton.get_expand, Godot.Core.TextureButton.get_focused_texture, Godot.Core.TextureButton.get_hover_texture, Godot.Core.TextureButton.get_normal_texture, Godot.Core.TextureButton.get_pressed_texture, Godot.Core.TextureButton.get_stretch_mode, Godot.Core.TextureButton.set_click_mask, Godot.Core.TextureButton.set_disabled_texture, Godot.Core.TextureButton.set_expand, Godot.Core.TextureButton.set_focused_texture, Godot.Core.TextureButton.set_hover_texture, Godot.Core.TextureButton.set_normal_texture, Godot.Core.TextureButton.set_pressed_texture, Godot.Core.TextureButton.set_stretch_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.BaseButton() _STRETCH_TILE :: Int _STRETCH_TILE = 1 _STRETCH_KEEP_ASPECT_COVERED :: Int _STRETCH_KEEP_ASPECT_COVERED = 6 _STRETCH_KEEP_ASPECT :: Int _STRETCH_KEEP_ASPECT = 4 _STRETCH_SCALE :: Int _STRETCH_SCALE = 0 _STRETCH_KEEP :: Int _STRETCH_KEEP = 2 _STRETCH_KEEP_CENTERED :: Int _STRETCH_KEEP_CENTERED = 3 _STRETCH_KEEP_ASPECT_CENTERED :: Int _STRETCH_KEEP_ASPECT_CENTERED = 5 instance NodeProperty TextureButton "expand" Bool 'False where nodeProperty = (get_expand, wrapDroppingSetter set_expand, Nothing) instance NodeProperty TextureButton "stretch_mode" Int 'False where nodeProperty = (get_stretch_mode, wrapDroppingSetter set_stretch_mode, Nothing) instance NodeProperty TextureButton "texture_click_mask" BitMap 'False where nodeProperty = (get_click_mask, wrapDroppingSetter set_click_mask, Nothing) instance NodeProperty TextureButton "texture_disabled" Texture 'False where nodeProperty = (get_disabled_texture, wrapDroppingSetter set_disabled_texture, Nothing) instance NodeProperty TextureButton "texture_focused" Texture 'False where nodeProperty = (get_focused_texture, wrapDroppingSetter set_focused_texture, Nothing) instance NodeProperty TextureButton "texture_hover" Texture 'False where nodeProperty = (get_hover_texture, wrapDroppingSetter set_hover_texture, Nothing) instance NodeProperty TextureButton "texture_normal" Texture 'False where nodeProperty = (get_normal_texture, wrapDroppingSetter set_normal_texture, Nothing) instance NodeProperty TextureButton "texture_pressed" Texture 'False where nodeProperty = (get_pressed_texture, wrapDroppingSetter set_pressed_texture, Nothing) {-# NOINLINE bindTextureButton_get_click_mask #-} -- | Pure black and white @BitMap@ image to use for click detection. On the mask, white pixels represent the button's clickable area. Use it to create buttons with curved shapes. bindTextureButton_get_click_mask :: MethodBind bindTextureButton_get_click_mask = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "get_click_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pure black and white @BitMap@ image to use for click detection. On the mask, white pixels represent the button's clickable area. Use it to create buttons with curved shapes. get_click_mask :: (TextureButton :< cls, Object :< cls) => cls -> IO BitMap get_click_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_get_click_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "get_click_mask" '[] (IO BitMap) where nodeMethod = Godot.Core.TextureButton.get_click_mask {-# NOINLINE bindTextureButton_get_disabled_texture #-} -- | Texture to display when the node is disabled. See @BaseButton.disabled@. bindTextureButton_get_disabled_texture :: MethodBind bindTextureButton_get_disabled_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "get_disabled_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display when the node is disabled. See @BaseButton.disabled@. get_disabled_texture :: (TextureButton :< cls, Object :< cls) => cls -> IO Texture get_disabled_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_get_disabled_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "get_disabled_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureButton.get_disabled_texture {-# NOINLINE bindTextureButton_get_expand #-} -- | If @true@, the texture stretches to the edges of the node's bounding rectangle using the @stretch_mode@. If @false@, the texture will not scale with the node. bindTextureButton_get_expand :: MethodBind bindTextureButton_get_expand = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "get_expand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the texture stretches to the edges of the node's bounding rectangle using the @stretch_mode@. If @false@, the texture will not scale with the node. get_expand :: (TextureButton :< cls, Object :< cls) => cls -> IO Bool get_expand cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_get_expand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "get_expand" '[] (IO Bool) where nodeMethod = Godot.Core.TextureButton.get_expand {-# NOINLINE bindTextureButton_get_focused_texture #-} -- | Texture to display when the node has mouse or keyboard focus. bindTextureButton_get_focused_texture :: MethodBind bindTextureButton_get_focused_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "get_focused_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display when the node has mouse or keyboard focus. get_focused_texture :: (TextureButton :< cls, Object :< cls) => cls -> IO Texture get_focused_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_get_focused_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "get_focused_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureButton.get_focused_texture {-# NOINLINE bindTextureButton_get_hover_texture #-} -- | Texture to display when the mouse hovers the node. bindTextureButton_get_hover_texture :: MethodBind bindTextureButton_get_hover_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "get_hover_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display when the mouse hovers the node. get_hover_texture :: (TextureButton :< cls, Object :< cls) => cls -> IO Texture get_hover_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_get_hover_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "get_hover_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureButton.get_hover_texture {-# NOINLINE bindTextureButton_get_normal_texture #-} -- | Texture to display by default, when the node is __not__ in the disabled, focused, hover or pressed state. bindTextureButton_get_normal_texture :: MethodBind bindTextureButton_get_normal_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "get_normal_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display by default, when the node is __not__ in the disabled, focused, hover or pressed state. get_normal_texture :: (TextureButton :< cls, Object :< cls) => cls -> IO Texture get_normal_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_get_normal_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "get_normal_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureButton.get_normal_texture {-# NOINLINE bindTextureButton_get_pressed_texture #-} -- | Texture to display on mouse down over the node, if the node has keyboard focus and the player presses the Enter key or if the player presses the @BaseButton.shortcut@ key. bindTextureButton_get_pressed_texture :: MethodBind bindTextureButton_get_pressed_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "get_pressed_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display on mouse down over the node, if the node has keyboard focus and the player presses the Enter key or if the player presses the @BaseButton.shortcut@ key. get_pressed_texture :: (TextureButton :< cls, Object :< cls) => cls -> IO Texture get_pressed_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_get_pressed_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "get_pressed_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureButton.get_pressed_texture {-# NOINLINE bindTextureButton_get_stretch_mode #-} -- | Controls the texture's behavior when you resize the node's bounding rectangle, __only if__ @expand@ is @true@. Set it to one of the @enum StretchMode@ constants. See the constants to learn more. bindTextureButton_get_stretch_mode :: MethodBind bindTextureButton_get_stretch_mode = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "get_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the texture's behavior when you resize the node's bounding rectangle, __only if__ @expand@ is @true@. Set it to one of the @enum StretchMode@ constants. See the constants to learn more. get_stretch_mode :: (TextureButton :< cls, Object :< cls) => cls -> IO Int get_stretch_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_get_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "get_stretch_mode" '[] (IO Int) where nodeMethod = Godot.Core.TextureButton.get_stretch_mode {-# NOINLINE bindTextureButton_set_click_mask #-} -- | Pure black and white @BitMap@ image to use for click detection. On the mask, white pixels represent the button's clickable area. Use it to create buttons with curved shapes. bindTextureButton_set_click_mask :: MethodBind bindTextureButton_set_click_mask = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "set_click_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Pure black and white @BitMap@ image to use for click detection. On the mask, white pixels represent the button's clickable area. Use it to create buttons with curved shapes. set_click_mask :: (TextureButton :< cls, Object :< cls) => cls -> BitMap -> IO () set_click_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_set_click_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "set_click_mask" '[BitMap] (IO ()) where nodeMethod = Godot.Core.TextureButton.set_click_mask {-# NOINLINE bindTextureButton_set_disabled_texture #-} -- | Texture to display when the node is disabled. See @BaseButton.disabled@. bindTextureButton_set_disabled_texture :: MethodBind bindTextureButton_set_disabled_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "set_disabled_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display when the node is disabled. See @BaseButton.disabled@. set_disabled_texture :: (TextureButton :< cls, Object :< cls) => cls -> Texture -> IO () set_disabled_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_set_disabled_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "set_disabled_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureButton.set_disabled_texture {-# NOINLINE bindTextureButton_set_expand #-} -- | If @true@, the texture stretches to the edges of the node's bounding rectangle using the @stretch_mode@. If @false@, the texture will not scale with the node. bindTextureButton_set_expand :: MethodBind bindTextureButton_set_expand = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "set_expand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the texture stretches to the edges of the node's bounding rectangle using the @stretch_mode@. If @false@, the texture will not scale with the node. set_expand :: (TextureButton :< cls, Object :< cls) => cls -> Bool -> IO () set_expand cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_set_expand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "set_expand" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextureButton.set_expand {-# NOINLINE bindTextureButton_set_focused_texture #-} -- | Texture to display when the node has mouse or keyboard focus. bindTextureButton_set_focused_texture :: MethodBind bindTextureButton_set_focused_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "set_focused_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display when the node has mouse or keyboard focus. set_focused_texture :: (TextureButton :< cls, Object :< cls) => cls -> Texture -> IO () set_focused_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_set_focused_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "set_focused_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureButton.set_focused_texture {-# NOINLINE bindTextureButton_set_hover_texture #-} -- | Texture to display when the mouse hovers the node. bindTextureButton_set_hover_texture :: MethodBind bindTextureButton_set_hover_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "set_hover_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display when the mouse hovers the node. set_hover_texture :: (TextureButton :< cls, Object :< cls) => cls -> Texture -> IO () set_hover_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_set_hover_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "set_hover_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureButton.set_hover_texture {-# NOINLINE bindTextureButton_set_normal_texture #-} -- | Texture to display by default, when the node is __not__ in the disabled, focused, hover or pressed state. bindTextureButton_set_normal_texture :: MethodBind bindTextureButton_set_normal_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "set_normal_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display by default, when the node is __not__ in the disabled, focused, hover or pressed state. set_normal_texture :: (TextureButton :< cls, Object :< cls) => cls -> Texture -> IO () set_normal_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_set_normal_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "set_normal_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureButton.set_normal_texture {-# NOINLINE bindTextureButton_set_pressed_texture #-} -- | Texture to display on mouse down over the node, if the node has keyboard focus and the player presses the Enter key or if the player presses the @BaseButton.shortcut@ key. bindTextureButton_set_pressed_texture :: MethodBind bindTextureButton_set_pressed_texture = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "set_pressed_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Texture to display on mouse down over the node, if the node has keyboard focus and the player presses the Enter key or if the player presses the @BaseButton.shortcut@ key. set_pressed_texture :: (TextureButton :< cls, Object :< cls) => cls -> Texture -> IO () set_pressed_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_set_pressed_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "set_pressed_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureButton.set_pressed_texture {-# NOINLINE bindTextureButton_set_stretch_mode #-} -- | Controls the texture's behavior when you resize the node's bounding rectangle, __only if__ @expand@ is @true@. Set it to one of the @enum StretchMode@ constants. See the constants to learn more. bindTextureButton_set_stretch_mode :: MethodBind bindTextureButton_set_stretch_mode = unsafePerformIO $ withCString "TextureButton" $ \ clsNamePtr -> withCString "set_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the texture's behavior when you resize the node's bounding rectangle, __only if__ @expand@ is @true@. Set it to one of the @enum StretchMode@ constants. See the constants to learn more. set_stretch_mode :: (TextureButton :< cls, Object :< cls) => cls -> Int -> IO () set_stretch_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureButton_set_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureButton "set_stretch_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.TextureButton.set_stretch_mode ================================================ FILE: src/Godot/Core/TextureLayered.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TextureLayered (Godot.Core.TextureLayered._FLAGS_DEFAULT, Godot.Core.TextureLayered._FLAG_REPEAT, Godot.Core.TextureLayered._FLAG_MIPMAPS, Godot.Core.TextureLayered._FLAG_FILTER, Godot.Core.TextureLayered._get_data, Godot.Core.TextureLayered._set_data, Godot.Core.TextureLayered.create, Godot.Core.TextureLayered.get_depth, Godot.Core.TextureLayered.get_flags, Godot.Core.TextureLayered.get_format, Godot.Core.TextureLayered.get_height, Godot.Core.TextureLayered.get_layer_data, Godot.Core.TextureLayered.get_width, Godot.Core.TextureLayered.set_data_partial, Godot.Core.TextureLayered.set_flags, Godot.Core.TextureLayered.set_layer_data) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _FLAGS_DEFAULT :: Int _FLAGS_DEFAULT = 4 _FLAG_REPEAT :: Int _FLAG_REPEAT = 2 _FLAG_MIPMAPS :: Int _FLAG_MIPMAPS = 1 _FLAG_FILTER :: Int _FLAG_FILTER = 4 instance NodeProperty TextureLayered "data" Dictionary 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) instance NodeProperty TextureLayered "flags" Int 'False where nodeProperty = (get_flags, wrapDroppingSetter set_flags, Nothing) {-# NOINLINE bindTextureLayered__get_data #-} -- | Returns a dictionary with all the data used by this texture. bindTextureLayered__get_data :: MethodBind bindTextureLayered__get_data = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a dictionary with all the data used by this texture. _get_data :: (TextureLayered :< cls, Object :< cls) => cls -> IO Dictionary _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "_get_data" '[] (IO Dictionary) where nodeMethod = Godot.Core.TextureLayered._get_data {-# NOINLINE bindTextureLayered__set_data #-} -- | Returns a dictionary with all the data used by this texture. bindTextureLayered__set_data :: MethodBind bindTextureLayered__set_data = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a dictionary with all the data used by this texture. _set_data :: (TextureLayered :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "_set_data" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.TextureLayered._set_data {-# NOINLINE bindTextureLayered_create #-} -- | Creates the @Texture3D@ or @TextureArray@ with specified @width@, @height@, and @depth@. See @enum Image.Format@ for @format@ options. See @enum Flags@ enumerator for @flags@ options. bindTextureLayered_create :: MethodBind bindTextureLayered_create = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates the @Texture3D@ or @TextureArray@ with specified @width@, @height@, and @depth@. See @enum Image.Format@ for @format@ options. See @enum Flags@ enumerator for @flags@ options. create :: (TextureLayered :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> Maybe Int -> IO () create cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantInt (4)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "create" '[Int, Int, Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.TextureLayered.create {-# NOINLINE bindTextureLayered_get_depth #-} -- | Returns the depth of the texture. Depth is the 3rd dimension (typically Z-axis). bindTextureLayered_get_depth :: MethodBind bindTextureLayered_get_depth = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "get_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the depth of the texture. Depth is the 3rd dimension (typically Z-axis). get_depth :: (TextureLayered :< cls, Object :< cls) => cls -> IO Int get_depth cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_get_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "get_depth" '[] (IO Int) where nodeMethod = Godot.Core.TextureLayered.get_depth {-# NOINLINE bindTextureLayered_get_flags #-} -- | Specifies which @enum Flags@ apply to this texture. bindTextureLayered_get_flags :: MethodBind bindTextureLayered_get_flags = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "get_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies which @enum Flags@ apply to this texture. get_flags :: (TextureLayered :< cls, Object :< cls) => cls -> IO Int get_flags cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_get_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "get_flags" '[] (IO Int) where nodeMethod = Godot.Core.TextureLayered.get_flags {-# NOINLINE bindTextureLayered_get_format #-} -- | Returns the current format being used by this texture. See @enum Image.Format@ for details. bindTextureLayered_get_format :: MethodBind bindTextureLayered_get_format = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current format being used by this texture. See @enum Image.Format@ for details. get_format :: (TextureLayered :< cls, Object :< cls) => cls -> IO Int get_format cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "get_format" '[] (IO Int) where nodeMethod = Godot.Core.TextureLayered.get_format {-# NOINLINE bindTextureLayered_get_height #-} -- | Returns the height of the texture. Height is typically represented by the Y-axis. bindTextureLayered_get_height :: MethodBind bindTextureLayered_get_height = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the height of the texture. Height is typically represented by the Y-axis. get_height :: (TextureLayered :< cls, Object :< cls) => cls -> IO Int get_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "get_height" '[] (IO Int) where nodeMethod = Godot.Core.TextureLayered.get_height {-# NOINLINE bindTextureLayered_get_layer_data #-} -- | Returns an @Image@ resource with the data from specified @layer@. bindTextureLayered_get_layer_data :: MethodBind bindTextureLayered_get_layer_data = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "get_layer_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Image@ resource with the data from specified @layer@. get_layer_data :: (TextureLayered :< cls, Object :< cls) => cls -> Int -> IO Image get_layer_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_get_layer_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "get_layer_data" '[Int] (IO Image) where nodeMethod = Godot.Core.TextureLayered.get_layer_data {-# NOINLINE bindTextureLayered_get_width #-} -- | Returns the width of the texture. Width is typically represented by the X-axis. bindTextureLayered_get_width :: MethodBind bindTextureLayered_get_width = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the width of the texture. Width is typically represented by the X-axis. get_width :: (TextureLayered :< cls, Object :< cls) => cls -> IO Int get_width cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "get_width" '[] (IO Int) where nodeMethod = Godot.Core.TextureLayered.get_width {-# NOINLINE bindTextureLayered_set_data_partial #-} -- | Partially sets the data for a specified @layer@ by overwriting using the data of the specified @image@. @x_offset@ and @y_offset@ determine where the @Image@ is "stamped" over the texture. The @image@ must fit within the texture. bindTextureLayered_set_data_partial :: MethodBind bindTextureLayered_set_data_partial = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "set_data_partial" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Partially sets the data for a specified @layer@ by overwriting using the data of the specified @image@. @x_offset@ and @y_offset@ determine where the @Image@ is "stamped" over the texture. The @image@ must fit within the texture. set_data_partial :: (TextureLayered :< cls, Object :< cls) => cls -> Image -> Int -> Int -> Int -> Maybe Int -> IO () set_data_partial cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_set_data_partial (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "set_data_partial" '[Image, Int, Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.TextureLayered.set_data_partial {-# NOINLINE bindTextureLayered_set_flags #-} -- | Specifies which @enum Flags@ apply to this texture. bindTextureLayered_set_flags :: MethodBind bindTextureLayered_set_flags = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "set_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies which @enum Flags@ apply to this texture. set_flags :: (TextureLayered :< cls, Object :< cls) => cls -> Int -> IO () set_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_set_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "set_flags" '[Int] (IO ()) where nodeMethod = Godot.Core.TextureLayered.set_flags {-# NOINLINE bindTextureLayered_set_layer_data #-} -- | Sets the data for the specified layer. Data takes the form of a 2-dimensional @Image@ resource. bindTextureLayered_set_layer_data :: MethodBind bindTextureLayered_set_layer_data = unsafePerformIO $ withCString "TextureLayered" $ \ clsNamePtr -> withCString "set_layer_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the data for the specified layer. Data takes the form of a 2-dimensional @Image@ resource. set_layer_data :: (TextureLayered :< cls, Object :< cls) => cls -> Image -> Int -> IO () set_layer_data cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTextureLayered_set_layer_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureLayered "set_layer_data" '[Image, Int] (IO ()) where nodeMethod = Godot.Core.TextureLayered.set_layer_data ================================================ FILE: src/Godot/Core/TextureProgress.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TextureProgress (Godot.Core.TextureProgress._FILL_BOTTOM_TO_TOP, Godot.Core.TextureProgress._FILL_TOP_TO_BOTTOM, Godot.Core.TextureProgress._FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE, Godot.Core.TextureProgress._FILL_RIGHT_TO_LEFT, Godot.Core.TextureProgress._FILL_CLOCKWISE, Godot.Core.TextureProgress._FILL_LEFT_TO_RIGHT, Godot.Core.TextureProgress._FILL_BILINEAR_LEFT_AND_RIGHT, Godot.Core.TextureProgress._FILL_COUNTER_CLOCKWISE, Godot.Core.TextureProgress._FILL_BILINEAR_TOP_AND_BOTTOM, Godot.Core.TextureProgress.get_fill_degrees, Godot.Core.TextureProgress.get_fill_mode, Godot.Core.TextureProgress.get_nine_patch_stretch, Godot.Core.TextureProgress.get_over_texture, Godot.Core.TextureProgress.get_progress_texture, Godot.Core.TextureProgress.get_radial_center_offset, Godot.Core.TextureProgress.get_radial_initial_angle, Godot.Core.TextureProgress.get_stretch_margin, Godot.Core.TextureProgress.get_tint_over, Godot.Core.TextureProgress.get_tint_progress, Godot.Core.TextureProgress.get_tint_under, Godot.Core.TextureProgress.get_under_texture, Godot.Core.TextureProgress.set_fill_degrees, Godot.Core.TextureProgress.set_fill_mode, Godot.Core.TextureProgress.set_nine_patch_stretch, Godot.Core.TextureProgress.set_over_texture, Godot.Core.TextureProgress.set_progress_texture, Godot.Core.TextureProgress.set_radial_center_offset, Godot.Core.TextureProgress.set_radial_initial_angle, Godot.Core.TextureProgress.set_stretch_margin, Godot.Core.TextureProgress.set_tint_over, Godot.Core.TextureProgress.set_tint_progress, Godot.Core.TextureProgress.set_tint_under, Godot.Core.TextureProgress.set_under_texture) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Range() _FILL_BOTTOM_TO_TOP :: Int _FILL_BOTTOM_TO_TOP = 3 _FILL_TOP_TO_BOTTOM :: Int _FILL_TOP_TO_BOTTOM = 2 _FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE :: Int _FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE = 8 _FILL_RIGHT_TO_LEFT :: Int _FILL_RIGHT_TO_LEFT = 1 _FILL_CLOCKWISE :: Int _FILL_CLOCKWISE = 4 _FILL_LEFT_TO_RIGHT :: Int _FILL_LEFT_TO_RIGHT = 0 _FILL_BILINEAR_LEFT_AND_RIGHT :: Int _FILL_BILINEAR_LEFT_AND_RIGHT = 6 _FILL_COUNTER_CLOCKWISE :: Int _FILL_COUNTER_CLOCKWISE = 5 _FILL_BILINEAR_TOP_AND_BOTTOM :: Int _FILL_BILINEAR_TOP_AND_BOTTOM = 7 instance NodeProperty TextureProgress "fill_mode" Int 'False where nodeProperty = (get_fill_mode, wrapDroppingSetter set_fill_mode, Nothing) instance NodeProperty TextureProgress "nine_patch_stretch" Bool 'False where nodeProperty = (get_nine_patch_stretch, wrapDroppingSetter set_nine_patch_stretch, Nothing) instance NodeProperty TextureProgress "radial_center_offset" Vector2 'False where nodeProperty = (get_radial_center_offset, wrapDroppingSetter set_radial_center_offset, Nothing) instance NodeProperty TextureProgress "radial_fill_degrees" Float 'False where nodeProperty = (get_fill_degrees, wrapDroppingSetter set_fill_degrees, Nothing) instance NodeProperty TextureProgress "radial_initial_angle" Float 'False where nodeProperty = (get_radial_initial_angle, wrapDroppingSetter set_radial_initial_angle, Nothing) instance NodeProperty TextureProgress "stretch_margin_bottom" Int 'False where nodeProperty = (wrapIndexedGetter 3 get_stretch_margin, wrapIndexedSetter 3 set_stretch_margin, Nothing) instance NodeProperty TextureProgress "stretch_margin_left" Int 'False where nodeProperty = (wrapIndexedGetter 0 get_stretch_margin, wrapIndexedSetter 0 set_stretch_margin, Nothing) instance NodeProperty TextureProgress "stretch_margin_right" Int 'False where nodeProperty = (wrapIndexedGetter 2 get_stretch_margin, wrapIndexedSetter 2 set_stretch_margin, Nothing) instance NodeProperty TextureProgress "stretch_margin_top" Int 'False where nodeProperty = (wrapIndexedGetter 1 get_stretch_margin, wrapIndexedSetter 1 set_stretch_margin, Nothing) instance NodeProperty TextureProgress "texture_over" Texture 'False where nodeProperty = (get_over_texture, wrapDroppingSetter set_over_texture, Nothing) instance NodeProperty TextureProgress "texture_progress" Texture 'False where nodeProperty = (get_progress_texture, wrapDroppingSetter set_progress_texture, Nothing) instance NodeProperty TextureProgress "texture_under" Texture 'False where nodeProperty = (get_under_texture, wrapDroppingSetter set_under_texture, Nothing) instance NodeProperty TextureProgress "tint_over" Color 'False where nodeProperty = (get_tint_over, wrapDroppingSetter set_tint_over, Nothing) instance NodeProperty TextureProgress "tint_progress" Color 'False where nodeProperty = (get_tint_progress, wrapDroppingSetter set_tint_progress, Nothing) instance NodeProperty TextureProgress "tint_under" Color 'False where nodeProperty = (get_tint_under, wrapDroppingSetter set_tint_under, Nothing) {-# NOINLINE bindTextureProgress_get_fill_degrees #-} -- | Upper limit for the fill of @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. When the node's @value@ is equal to its @max_value@, the texture fills up to this angle. -- See @Range.value@, @Range.max_value@. bindTextureProgress_get_fill_degrees :: MethodBind bindTextureProgress_get_fill_degrees = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_fill_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Upper limit for the fill of @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. When the node's @value@ is equal to its @max_value@, the texture fills up to this angle. -- See @Range.value@, @Range.max_value@. get_fill_degrees :: (TextureProgress :< cls, Object :< cls) => cls -> IO Float get_fill_degrees cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_fill_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_fill_degrees" '[] (IO Float) where nodeMethod = Godot.Core.TextureProgress.get_fill_degrees {-# NOINLINE bindTextureProgress_get_fill_mode #-} -- | The fill direction. See @enum FillMode@ for possible values. bindTextureProgress_get_fill_mode :: MethodBind bindTextureProgress_get_fill_mode = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_fill_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fill direction. See @enum FillMode@ for possible values. get_fill_mode :: (TextureProgress :< cls, Object :< cls) => cls -> IO Int get_fill_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_fill_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_fill_mode" '[] (IO Int) where nodeMethod = Godot.Core.TextureProgress.get_fill_mode {-# NOINLINE bindTextureProgress_get_nine_patch_stretch #-} -- | If @true@, Godot treats the bar's textures like in @NinePatchRect@. Use the @stretch_margin_*@ properties like @stretch_margin_bottom@ to set up the nine patch's 3×3 grid. When using a radial @fill_mode@, this setting will enable stretching. bindTextureProgress_get_nine_patch_stretch :: MethodBind bindTextureProgress_get_nine_patch_stretch = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_nine_patch_stretch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, Godot treats the bar's textures like in @NinePatchRect@. Use the @stretch_margin_*@ properties like @stretch_margin_bottom@ to set up the nine patch's 3×3 grid. When using a radial @fill_mode@, this setting will enable stretching. get_nine_patch_stretch :: (TextureProgress :< cls, Object :< cls) => cls -> IO Bool get_nine_patch_stretch cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_nine_patch_stretch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_nine_patch_stretch" '[] (IO Bool) where nodeMethod = Godot.Core.TextureProgress.get_nine_patch_stretch {-# NOINLINE bindTextureProgress_get_over_texture #-} -- | @Texture@ that draws over the progress bar. Use it to add highlights or an upper-frame that hides part of @texture_progress@. bindTextureProgress_get_over_texture :: MethodBind bindTextureProgress_get_over_texture = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_over_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ that draws over the progress bar. Use it to add highlights or an upper-frame that hides part of @texture_progress@. get_over_texture :: (TextureProgress :< cls, Object :< cls) => cls -> IO Texture get_over_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_over_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_over_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureProgress.get_over_texture {-# NOINLINE bindTextureProgress_get_progress_texture #-} -- | @Texture@ that clips based on the node's @value@ and @fill_mode@. As @value@ increased, the texture fills up. It shows entirely when @value@ reaches @max_value@. It doesn't show at all if @value@ is equal to @min_value@. -- The @value@ property comes from @Range@. See @Range.value@, @Range.min_value@, @Range.max_value@. bindTextureProgress_get_progress_texture :: MethodBind bindTextureProgress_get_progress_texture = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_progress_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ that clips based on the node's @value@ and @fill_mode@. As @value@ increased, the texture fills up. It shows entirely when @value@ reaches @max_value@. It doesn't show at all if @value@ is equal to @min_value@. -- The @value@ property comes from @Range@. See @Range.value@, @Range.min_value@, @Range.max_value@. get_progress_texture :: (TextureProgress :< cls, Object :< cls) => cls -> IO Texture get_progress_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_progress_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_progress_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureProgress.get_progress_texture {-# NOINLINE bindTextureProgress_get_radial_center_offset #-} -- | Offsets @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. bindTextureProgress_get_radial_center_offset :: MethodBind bindTextureProgress_get_radial_center_offset = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_radial_center_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Offsets @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. get_radial_center_offset :: (TextureProgress :< cls, Object :< cls) => cls -> IO Vector2 get_radial_center_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_radial_center_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_radial_center_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.TextureProgress.get_radial_center_offset {-# NOINLINE bindTextureProgress_get_radial_initial_angle #-} -- | Starting angle for the fill of @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. When the node's @value@ is equal to its @min_value@, the texture doesn't show up at all. When the @value@ increases, the texture fills and tends towards @radial_fill_degrees@. bindTextureProgress_get_radial_initial_angle :: MethodBind bindTextureProgress_get_radial_initial_angle = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_radial_initial_angle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starting angle for the fill of @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. When the node's @value@ is equal to its @min_value@, the texture doesn't show up at all. When the @value@ increases, the texture fills and tends towards @radial_fill_degrees@. get_radial_initial_angle :: (TextureProgress :< cls, Object :< cls) => cls -> IO Float get_radial_initial_angle cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_radial_initial_angle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_radial_initial_angle" '[] (IO Float) where nodeMethod = Godot.Core.TextureProgress.get_radial_initial_angle {-# NOINLINE bindTextureProgress_get_stretch_margin #-} -- | The height of the 9-patch's bottom row. A margin of 16 means the 9-slice's bottom corners and side will have a height of 16 pixels. You can set all 4 margin values individually to create panels with non-uniform borders. bindTextureProgress_get_stretch_margin :: MethodBind bindTextureProgress_get_stretch_margin = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_stretch_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The height of the 9-patch's bottom row. A margin of 16 means the 9-slice's bottom corners and side will have a height of 16 pixels. You can set all 4 margin values individually to create panels with non-uniform borders. get_stretch_margin :: (TextureProgress :< cls, Object :< cls) => cls -> Int -> IO Int get_stretch_margin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_stretch_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_stretch_margin" '[Int] (IO Int) where nodeMethod = Godot.Core.TextureProgress.get_stretch_margin {-# NOINLINE bindTextureProgress_get_tint_over #-} -- | Multiplies the color of the bar's @texture_over@ texture. The effect is similar to @CanvasItem.modulate@, except it only affects this specific texture instead of the entire node. bindTextureProgress_get_tint_over :: MethodBind bindTextureProgress_get_tint_over = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_tint_over" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the color of the bar's @texture_over@ texture. The effect is similar to @CanvasItem.modulate@, except it only affects this specific texture instead of the entire node. get_tint_over :: (TextureProgress :< cls, Object :< cls) => cls -> IO Color get_tint_over cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_tint_over (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_tint_over" '[] (IO Color) where nodeMethod = Godot.Core.TextureProgress.get_tint_over {-# NOINLINE bindTextureProgress_get_tint_progress #-} -- | Multiplies the color of the bar's @texture_progress@ texture. bindTextureProgress_get_tint_progress :: MethodBind bindTextureProgress_get_tint_progress = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_tint_progress" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the color of the bar's @texture_progress@ texture. get_tint_progress :: (TextureProgress :< cls, Object :< cls) => cls -> IO Color get_tint_progress cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_tint_progress (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_tint_progress" '[] (IO Color) where nodeMethod = Godot.Core.TextureProgress.get_tint_progress {-# NOINLINE bindTextureProgress_get_tint_under #-} -- | Multiplies the color of the bar's @texture_under@ texture. bindTextureProgress_get_tint_under :: MethodBind bindTextureProgress_get_tint_under = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_tint_under" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the color of the bar's @texture_under@ texture. get_tint_under :: (TextureProgress :< cls, Object :< cls) => cls -> IO Color get_tint_under cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_tint_under (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_tint_under" '[] (IO Color) where nodeMethod = Godot.Core.TextureProgress.get_tint_under {-# NOINLINE bindTextureProgress_get_under_texture #-} -- | @Texture@ that draws under the progress bar. The bar's background. bindTextureProgress_get_under_texture :: MethodBind bindTextureProgress_get_under_texture = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "get_under_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ that draws under the progress bar. The bar's background. get_under_texture :: (TextureProgress :< cls, Object :< cls) => cls -> IO Texture get_under_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_get_under_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "get_under_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureProgress.get_under_texture {-# NOINLINE bindTextureProgress_set_fill_degrees #-} -- | Upper limit for the fill of @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. When the node's @value@ is equal to its @max_value@, the texture fills up to this angle. -- See @Range.value@, @Range.max_value@. bindTextureProgress_set_fill_degrees :: MethodBind bindTextureProgress_set_fill_degrees = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_fill_degrees" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Upper limit for the fill of @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. When the node's @value@ is equal to its @max_value@, the texture fills up to this angle. -- See @Range.value@, @Range.max_value@. set_fill_degrees :: (TextureProgress :< cls, Object :< cls) => cls -> Float -> IO () set_fill_degrees cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_fill_degrees (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_fill_degrees" '[Float] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_fill_degrees {-# NOINLINE bindTextureProgress_set_fill_mode #-} -- | The fill direction. See @enum FillMode@ for possible values. bindTextureProgress_set_fill_mode :: MethodBind bindTextureProgress_set_fill_mode = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_fill_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The fill direction. See @enum FillMode@ for possible values. set_fill_mode :: (TextureProgress :< cls, Object :< cls) => cls -> Int -> IO () set_fill_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_fill_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_fill_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_fill_mode {-# NOINLINE bindTextureProgress_set_nine_patch_stretch #-} -- | If @true@, Godot treats the bar's textures like in @NinePatchRect@. Use the @stretch_margin_*@ properties like @stretch_margin_bottom@ to set up the nine patch's 3×3 grid. When using a radial @fill_mode@, this setting will enable stretching. bindTextureProgress_set_nine_patch_stretch :: MethodBind bindTextureProgress_set_nine_patch_stretch = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_nine_patch_stretch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, Godot treats the bar's textures like in @NinePatchRect@. Use the @stretch_margin_*@ properties like @stretch_margin_bottom@ to set up the nine patch's 3×3 grid. When using a radial @fill_mode@, this setting will enable stretching. set_nine_patch_stretch :: (TextureProgress :< cls, Object :< cls) => cls -> Bool -> IO () set_nine_patch_stretch cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_nine_patch_stretch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_nine_patch_stretch" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_nine_patch_stretch {-# NOINLINE bindTextureProgress_set_over_texture #-} -- | @Texture@ that draws over the progress bar. Use it to add highlights or an upper-frame that hides part of @texture_progress@. bindTextureProgress_set_over_texture :: MethodBind bindTextureProgress_set_over_texture = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_over_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ that draws over the progress bar. Use it to add highlights or an upper-frame that hides part of @texture_progress@. set_over_texture :: (TextureProgress :< cls, Object :< cls) => cls -> Texture -> IO () set_over_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_over_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_over_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_over_texture {-# NOINLINE bindTextureProgress_set_progress_texture #-} -- | @Texture@ that clips based on the node's @value@ and @fill_mode@. As @value@ increased, the texture fills up. It shows entirely when @value@ reaches @max_value@. It doesn't show at all if @value@ is equal to @min_value@. -- The @value@ property comes from @Range@. See @Range.value@, @Range.min_value@, @Range.max_value@. bindTextureProgress_set_progress_texture :: MethodBind bindTextureProgress_set_progress_texture = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_progress_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ that clips based on the node's @value@ and @fill_mode@. As @value@ increased, the texture fills up. It shows entirely when @value@ reaches @max_value@. It doesn't show at all if @value@ is equal to @min_value@. -- The @value@ property comes from @Range@. See @Range.value@, @Range.min_value@, @Range.max_value@. set_progress_texture :: (TextureProgress :< cls, Object :< cls) => cls -> Texture -> IO () set_progress_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_progress_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_progress_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_progress_texture {-# NOINLINE bindTextureProgress_set_radial_center_offset #-} -- | Offsets @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. bindTextureProgress_set_radial_center_offset :: MethodBind bindTextureProgress_set_radial_center_offset = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_radial_center_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Offsets @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. set_radial_center_offset :: (TextureProgress :< cls, Object :< cls) => cls -> Vector2 -> IO () set_radial_center_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_radial_center_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_radial_center_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_radial_center_offset {-# NOINLINE bindTextureProgress_set_radial_initial_angle #-} -- | Starting angle for the fill of @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. When the node's @value@ is equal to its @min_value@, the texture doesn't show up at all. When the @value@ increases, the texture fills and tends towards @radial_fill_degrees@. bindTextureProgress_set_radial_initial_angle :: MethodBind bindTextureProgress_set_radial_initial_angle = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_radial_initial_angle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starting angle for the fill of @texture_progress@ if @fill_mode@ is @FILL_CLOCKWISE@ or @FILL_COUNTER_CLOCKWISE@. When the node's @value@ is equal to its @min_value@, the texture doesn't show up at all. When the @value@ increases, the texture fills and tends towards @radial_fill_degrees@. set_radial_initial_angle :: (TextureProgress :< cls, Object :< cls) => cls -> Float -> IO () set_radial_initial_angle cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_radial_initial_angle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_radial_initial_angle" '[Float] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_radial_initial_angle {-# NOINLINE bindTextureProgress_set_stretch_margin #-} -- | The height of the 9-patch's bottom row. A margin of 16 means the 9-slice's bottom corners and side will have a height of 16 pixels. You can set all 4 margin values individually to create panels with non-uniform borders. bindTextureProgress_set_stretch_margin :: MethodBind bindTextureProgress_set_stretch_margin = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_stretch_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The height of the 9-patch's bottom row. A margin of 16 means the 9-slice's bottom corners and side will have a height of 16 pixels. You can set all 4 margin values individually to create panels with non-uniform borders. set_stretch_margin :: (TextureProgress :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_stretch_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_stretch_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_stretch_margin" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_stretch_margin {-# NOINLINE bindTextureProgress_set_tint_over #-} -- | Multiplies the color of the bar's @texture_over@ texture. The effect is similar to @CanvasItem.modulate@, except it only affects this specific texture instead of the entire node. bindTextureProgress_set_tint_over :: MethodBind bindTextureProgress_set_tint_over = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_tint_over" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the color of the bar's @texture_over@ texture. The effect is similar to @CanvasItem.modulate@, except it only affects this specific texture instead of the entire node. set_tint_over :: (TextureProgress :< cls, Object :< cls) => cls -> Color -> IO () set_tint_over cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_tint_over (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_tint_over" '[Color] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_tint_over {-# NOINLINE bindTextureProgress_set_tint_progress #-} -- | Multiplies the color of the bar's @texture_progress@ texture. bindTextureProgress_set_tint_progress :: MethodBind bindTextureProgress_set_tint_progress = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_tint_progress" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the color of the bar's @texture_progress@ texture. set_tint_progress :: (TextureProgress :< cls, Object :< cls) => cls -> Color -> IO () set_tint_progress cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_tint_progress (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_tint_progress" '[Color] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_tint_progress {-# NOINLINE bindTextureProgress_set_tint_under #-} -- | Multiplies the color of the bar's @texture_under@ texture. bindTextureProgress_set_tint_under :: MethodBind bindTextureProgress_set_tint_under = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_tint_under" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Multiplies the color of the bar's @texture_under@ texture. set_tint_under :: (TextureProgress :< cls, Object :< cls) => cls -> Color -> IO () set_tint_under cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_tint_under (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_tint_under" '[Color] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_tint_under {-# NOINLINE bindTextureProgress_set_under_texture #-} -- | @Texture@ that draws under the progress bar. The bar's background. bindTextureProgress_set_under_texture :: MethodBind bindTextureProgress_set_under_texture = unsafePerformIO $ withCString "TextureProgress" $ \ clsNamePtr -> withCString "set_under_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | @Texture@ that draws under the progress bar. The bar's background. set_under_texture :: (TextureProgress :< cls, Object :< cls) => cls -> Texture -> IO () set_under_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureProgress_set_under_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureProgress "set_under_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureProgress.set_under_texture ================================================ FILE: src/Godot/Core/TextureRect.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TextureRect (Godot.Core.TextureRect._STRETCH_TILE, Godot.Core.TextureRect._STRETCH_KEEP_ASPECT_COVERED, Godot.Core.TextureRect._STRETCH_KEEP_ASPECT, Godot.Core.TextureRect._STRETCH_SCALE_ON_EXPAND, Godot.Core.TextureRect._STRETCH_SCALE, Godot.Core.TextureRect._STRETCH_KEEP, Godot.Core.TextureRect._STRETCH_KEEP_CENTERED, Godot.Core.TextureRect._STRETCH_KEEP_ASPECT_CENTERED, Godot.Core.TextureRect._texture_changed, Godot.Core.TextureRect.get_stretch_mode, Godot.Core.TextureRect.get_texture, Godot.Core.TextureRect.has_expand, Godot.Core.TextureRect.is_flipped_h, Godot.Core.TextureRect.is_flipped_v, Godot.Core.TextureRect.set_expand, Godot.Core.TextureRect.set_flip_h, Godot.Core.TextureRect.set_flip_v, Godot.Core.TextureRect.set_stretch_mode, Godot.Core.TextureRect.set_texture) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _STRETCH_TILE :: Int _STRETCH_TILE = 2 _STRETCH_KEEP_ASPECT_COVERED :: Int _STRETCH_KEEP_ASPECT_COVERED = 7 _STRETCH_KEEP_ASPECT :: Int _STRETCH_KEEP_ASPECT = 5 _STRETCH_SCALE_ON_EXPAND :: Int _STRETCH_SCALE_ON_EXPAND = 0 _STRETCH_SCALE :: Int _STRETCH_SCALE = 1 _STRETCH_KEEP :: Int _STRETCH_KEEP = 3 _STRETCH_KEEP_CENTERED :: Int _STRETCH_KEEP_CENTERED = 4 _STRETCH_KEEP_ASPECT_CENTERED :: Int _STRETCH_KEEP_ASPECT_CENTERED = 6 instance NodeProperty TextureRect "expand" Bool 'False where nodeProperty = (has_expand, wrapDroppingSetter set_expand, Nothing) instance NodeProperty TextureRect "flip_h" Bool 'False where nodeProperty = (is_flipped_h, wrapDroppingSetter set_flip_h, Nothing) instance NodeProperty TextureRect "flip_v" Bool 'False where nodeProperty = (is_flipped_v, wrapDroppingSetter set_flip_v, Nothing) instance NodeProperty TextureRect "stretch_mode" Int 'False where nodeProperty = (get_stretch_mode, wrapDroppingSetter set_stretch_mode, Nothing) instance NodeProperty TextureRect "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) {-# NOINLINE bindTextureRect__texture_changed #-} bindTextureRect__texture_changed :: MethodBind bindTextureRect__texture_changed = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "_texture_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _texture_changed :: (TextureRect :< cls, Object :< cls) => cls -> IO () _texture_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect__texture_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "_texture_changed" '[] (IO ()) where nodeMethod = Godot.Core.TextureRect._texture_changed {-# NOINLINE bindTextureRect_get_stretch_mode #-} -- | Controls the texture's behavior when resizing the node's bounding rectangle. See @enum StretchMode@. bindTextureRect_get_stretch_mode :: MethodBind bindTextureRect_get_stretch_mode = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "get_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the texture's behavior when resizing the node's bounding rectangle. See @enum StretchMode@. get_stretch_mode :: (TextureRect :< cls, Object :< cls) => cls -> IO Int get_stretch_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_get_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "get_stretch_mode" '[] (IO Int) where nodeMethod = Godot.Core.TextureRect.get_stretch_mode {-# NOINLINE bindTextureRect_get_texture #-} -- | The node's @Texture@ resource. bindTextureRect_get_texture :: MethodBind bindTextureRect_get_texture = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's @Texture@ resource. get_texture :: (TextureRect :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TextureRect.get_texture {-# NOINLINE bindTextureRect_has_expand #-} -- | If @true@, the texture scales to fit its bounding rectangle. bindTextureRect_has_expand :: MethodBind bindTextureRect_has_expand = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "has_expand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the texture scales to fit its bounding rectangle. has_expand :: (TextureRect :< cls, Object :< cls) => cls -> IO Bool has_expand cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_has_expand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "has_expand" '[] (IO Bool) where nodeMethod = Godot.Core.TextureRect.has_expand {-# NOINLINE bindTextureRect_is_flipped_h #-} -- | If @true@, texture is flipped horizontally. bindTextureRect_is_flipped_h :: MethodBind bindTextureRect_is_flipped_h = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "is_flipped_h" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped horizontally. is_flipped_h :: (TextureRect :< cls, Object :< cls) => cls -> IO Bool is_flipped_h cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_is_flipped_h (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "is_flipped_h" '[] (IO Bool) where nodeMethod = Godot.Core.TextureRect.is_flipped_h {-# NOINLINE bindTextureRect_is_flipped_v #-} -- | If @true@, texture is flipped vertically. bindTextureRect_is_flipped_v :: MethodBind bindTextureRect_is_flipped_v = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "is_flipped_v" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped vertically. is_flipped_v :: (TextureRect :< cls, Object :< cls) => cls -> IO Bool is_flipped_v cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_is_flipped_v (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "is_flipped_v" '[] (IO Bool) where nodeMethod = Godot.Core.TextureRect.is_flipped_v {-# NOINLINE bindTextureRect_set_expand #-} -- | If @true@, the texture scales to fit its bounding rectangle. bindTextureRect_set_expand :: MethodBind bindTextureRect_set_expand = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "set_expand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the texture scales to fit its bounding rectangle. set_expand :: (TextureRect :< cls, Object :< cls) => cls -> Bool -> IO () set_expand cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_set_expand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "set_expand" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextureRect.set_expand {-# NOINLINE bindTextureRect_set_flip_h #-} -- | If @true@, texture is flipped horizontally. bindTextureRect_set_flip_h :: MethodBind bindTextureRect_set_flip_h = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "set_flip_h" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped horizontally. set_flip_h :: (TextureRect :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_h cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_set_flip_h (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "set_flip_h" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextureRect.set_flip_h {-# NOINLINE bindTextureRect_set_flip_v #-} -- | If @true@, texture is flipped vertically. bindTextureRect_set_flip_v :: MethodBind bindTextureRect_set_flip_v = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "set_flip_v" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, texture is flipped vertically. set_flip_v :: (TextureRect :< cls, Object :< cls) => cls -> Bool -> IO () set_flip_v cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_set_flip_v (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "set_flip_v" '[Bool] (IO ()) where nodeMethod = Godot.Core.TextureRect.set_flip_v {-# NOINLINE bindTextureRect_set_stretch_mode #-} -- | Controls the texture's behavior when resizing the node's bounding rectangle. See @enum StretchMode@. bindTextureRect_set_stretch_mode :: MethodBind bindTextureRect_set_stretch_mode = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "set_stretch_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Controls the texture's behavior when resizing the node's bounding rectangle. See @enum StretchMode@. set_stretch_mode :: (TextureRect :< cls, Object :< cls) => cls -> Int -> IO () set_stretch_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_set_stretch_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "set_stretch_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.TextureRect.set_stretch_mode {-# NOINLINE bindTextureRect_set_texture #-} -- | The node's @Texture@ resource. bindTextureRect_set_texture :: MethodBind bindTextureRect_set_texture = unsafePerformIO $ withCString "TextureRect" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The node's @Texture@ resource. set_texture :: (TextureRect :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTextureRect_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TextureRect "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TextureRect.set_texture ================================================ FILE: src/Godot/Core/Theme.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Theme (Godot.Core.Theme._emit_theme_changed, Godot.Core.Theme.clear, Godot.Core.Theme.clear_color, Godot.Core.Theme.clear_constant, Godot.Core.Theme.clear_font, Godot.Core.Theme.clear_icon, Godot.Core.Theme.clear_stylebox, Godot.Core.Theme.copy_default_theme, Godot.Core.Theme.copy_theme, Godot.Core.Theme.get_color, Godot.Core.Theme.get_color_list, Godot.Core.Theme.get_constant, Godot.Core.Theme.get_constant_list, Godot.Core.Theme.get_default_font, Godot.Core.Theme.get_font, Godot.Core.Theme.get_font_list, Godot.Core.Theme.get_icon, Godot.Core.Theme.get_icon_list, Godot.Core.Theme.get_stylebox, Godot.Core.Theme.get_stylebox_list, Godot.Core.Theme.get_stylebox_types, Godot.Core.Theme.get_type_list, Godot.Core.Theme.has_color, Godot.Core.Theme.has_constant, Godot.Core.Theme.has_font, Godot.Core.Theme.has_icon, Godot.Core.Theme.has_stylebox, Godot.Core.Theme.set_color, Godot.Core.Theme.set_constant, Godot.Core.Theme.set_default_font, Godot.Core.Theme.set_font, Godot.Core.Theme.set_icon, Godot.Core.Theme.set_stylebox) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty Theme "default_font" Font 'False where nodeProperty = (get_default_font, wrapDroppingSetter set_default_font, Nothing) {-# NOINLINE bindTheme__emit_theme_changed #-} bindTheme__emit_theme_changed :: MethodBind bindTheme__emit_theme_changed = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "_emit_theme_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _emit_theme_changed :: (Theme :< cls, Object :< cls) => cls -> IO () _emit_theme_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTheme__emit_theme_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "_emit_theme_changed" '[] (IO ()) where nodeMethod = Godot.Core.Theme._emit_theme_changed {-# NOINLINE bindTheme_clear #-} -- | Clears all values on the theme. bindTheme_clear :: MethodBind bindTheme_clear = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all values on the theme. clear :: (Theme :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "clear" '[] (IO ()) where nodeMethod = Godot.Core.Theme.clear {-# NOINLINE bindTheme_clear_color #-} -- | Clears the @Color@ at @name@ if the theme has @type@. bindTheme_clear_color :: MethodBind bindTheme_clear_color = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "clear_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the @Color@ at @name@ if the theme has @type@. clear_color :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () clear_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_clear_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "clear_color" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.Theme.clear_color {-# NOINLINE bindTheme_clear_constant #-} -- | Clears the constant at @name@ if the theme has @type@. bindTheme_clear_constant :: MethodBind bindTheme_clear_constant = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "clear_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the constant at @name@ if the theme has @type@. clear_constant :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () clear_constant cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_clear_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "clear_constant" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.Theme.clear_constant {-# NOINLINE bindTheme_clear_font #-} -- | Clears the @Font@ at @name@ if the theme has @type@. bindTheme_clear_font :: MethodBind bindTheme_clear_font = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "clear_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the @Font@ at @name@ if the theme has @type@. clear_font :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () clear_font cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_clear_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "clear_font" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.Theme.clear_font {-# NOINLINE bindTheme_clear_icon #-} -- | Clears the icon at @name@ if the theme has @type@. bindTheme_clear_icon :: MethodBind bindTheme_clear_icon = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "clear_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the icon at @name@ if the theme has @type@. clear_icon :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () clear_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_clear_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "clear_icon" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.Theme.clear_icon {-# NOINLINE bindTheme_clear_stylebox #-} -- | Clears @StyleBox@ at @name@ if the theme has @type@. bindTheme_clear_stylebox :: MethodBind bindTheme_clear_stylebox = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "clear_stylebox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears @StyleBox@ at @name@ if the theme has @type@. clear_stylebox :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () clear_stylebox cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_clear_stylebox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "clear_stylebox" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.Theme.clear_stylebox {-# NOINLINE bindTheme_copy_default_theme #-} -- | Sets the theme's values to a copy of the default theme values. bindTheme_copy_default_theme :: MethodBind bindTheme_copy_default_theme = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "copy_default_theme" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the theme's values to a copy of the default theme values. copy_default_theme :: (Theme :< cls, Object :< cls) => cls -> IO () copy_default_theme cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_copy_default_theme (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "copy_default_theme" '[] (IO ()) where nodeMethod = Godot.Core.Theme.copy_default_theme {-# NOINLINE bindTheme_copy_theme #-} -- | Sets the theme's values to a copy of a given theme. bindTheme_copy_theme :: MethodBind bindTheme_copy_theme = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "copy_theme" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the theme's values to a copy of a given theme. copy_theme :: (Theme :< cls, Object :< cls) => cls -> Theme -> IO () copy_theme cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_copy_theme (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "copy_theme" '[Theme] (IO ()) where nodeMethod = Godot.Core.Theme.copy_theme {-# NOINLINE bindTheme_get_color #-} -- | Returns the @Color@ at @name@ if the theme has @type@. bindTheme_get_color :: MethodBind bindTheme_get_color = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Color@ at @name@ if the theme has @type@. get_color :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Color get_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_color" '[GodotString, GodotString] (IO Color) where nodeMethod = Godot.Core.Theme.get_color {-# NOINLINE bindTheme_get_color_list #-} -- | Returns all the @Color@s as a @PoolStringArray@ filled with each @Color@'s name, for use in @method get_color@, if the theme has @type@. bindTheme_get_color_list :: MethodBind bindTheme_get_color_list = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_color_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the @Color@s as a @PoolStringArray@ filled with each @Color@'s name, for use in @method get_color@, if the theme has @type@. get_color_list :: (Theme :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_color_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_color_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_color_list" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.Theme.get_color_list {-# NOINLINE bindTheme_get_constant #-} -- | Returns the constant at @name@ if the theme has @type@. bindTheme_get_constant :: MethodBind bindTheme_get_constant = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the constant at @name@ if the theme has @type@. get_constant :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int get_constant cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_constant" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.Theme.get_constant {-# NOINLINE bindTheme_get_constant_list #-} -- | Returns all the constants as a @PoolStringArray@ filled with each constant's name, for use in @method get_constant@, if the theme has @type@. bindTheme_get_constant_list :: MethodBind bindTheme_get_constant_list = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_constant_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the constants as a @PoolStringArray@ filled with each constant's name, for use in @method get_constant@, if the theme has @type@. get_constant_list :: (Theme :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_constant_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_constant_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_constant_list" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.Theme.get_constant_list {-# NOINLINE bindTheme_get_default_font #-} -- | The theme's default font. bindTheme_get_default_font :: MethodBind bindTheme_get_default_font = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_default_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The theme's default font. get_default_font :: (Theme :< cls, Object :< cls) => cls -> IO Font get_default_font cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_default_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_default_font" '[] (IO Font) where nodeMethod = Godot.Core.Theme.get_default_font {-# NOINLINE bindTheme_get_font #-} -- | Returns the @Font@ at @name@ if the theme has @type@. bindTheme_get_font :: MethodBind bindTheme_get_font = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Font@ at @name@ if the theme has @type@. get_font :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Font get_font cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_font" '[GodotString, GodotString] (IO Font) where nodeMethod = Godot.Core.Theme.get_font {-# NOINLINE bindTheme_get_font_list #-} -- | Returns all the @Font@s as a @PoolStringArray@ filled with each @Font@'s name, for use in @method get_font@, if the theme has @type@. bindTheme_get_font_list :: MethodBind bindTheme_get_font_list = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_font_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the @Font@s as a @PoolStringArray@ filled with each @Font@'s name, for use in @method get_font@, if the theme has @type@. get_font_list :: (Theme :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_font_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_font_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_font_list" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.Theme.get_font_list {-# NOINLINE bindTheme_get_icon #-} -- | Returns the icon @Texture@ at @name@ if the theme has @type@. bindTheme_get_icon :: MethodBind bindTheme_get_icon = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the icon @Texture@ at @name@ if the theme has @type@. get_icon :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Texture get_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_icon" '[GodotString, GodotString] (IO Texture) where nodeMethod = Godot.Core.Theme.get_icon {-# NOINLINE bindTheme_get_icon_list #-} -- | Returns all the icons as a @PoolStringArray@ filled with each @Texture@'s name, for use in @method get_icon@, if the theme has @type@. bindTheme_get_icon_list :: MethodBind bindTheme_get_icon_list = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_icon_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the icons as a @PoolStringArray@ filled with each @Texture@'s name, for use in @method get_icon@, if the theme has @type@. get_icon_list :: (Theme :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_icon_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_icon_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_icon_list" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.Theme.get_icon_list {-# NOINLINE bindTheme_get_stylebox #-} -- | Returns the icon @StyleBox@ at @name@ if the theme has @type@. bindTheme_get_stylebox :: MethodBind bindTheme_get_stylebox = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_stylebox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the icon @StyleBox@ at @name@ if the theme has @type@. get_stylebox :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO StyleBox get_stylebox cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_stylebox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_stylebox" '[GodotString, GodotString] (IO StyleBox) where nodeMethod = Godot.Core.Theme.get_stylebox {-# NOINLINE bindTheme_get_stylebox_list #-} -- | Returns all the @StyleBox@s as a @PoolStringArray@ filled with each @StyleBox@'s name, for use in @method get_stylebox@, if the theme has @type@. bindTheme_get_stylebox_list :: MethodBind bindTheme_get_stylebox_list = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_stylebox_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the @StyleBox@s as a @PoolStringArray@ filled with each @StyleBox@'s name, for use in @method get_stylebox@, if the theme has @type@. get_stylebox_list :: (Theme :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_stylebox_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_stylebox_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_stylebox_list" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.Theme.get_stylebox_list {-# NOINLINE bindTheme_get_stylebox_types #-} -- | Returns all the @StyleBox@ types as a @PoolStringArray@ filled with each @StyleBox@'s type, for use in @method get_stylebox@ and/or @method get_stylebox_list@, if the theme has @type@. bindTheme_get_stylebox_types :: MethodBind bindTheme_get_stylebox_types = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_stylebox_types" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the @StyleBox@ types as a @PoolStringArray@ filled with each @StyleBox@'s type, for use in @method get_stylebox@ and/or @method get_stylebox_list@, if the theme has @type@. get_stylebox_types :: (Theme :< cls, Object :< cls) => cls -> IO PoolStringArray get_stylebox_types cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_stylebox_types (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_stylebox_types" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.Theme.get_stylebox_types {-# NOINLINE bindTheme_get_type_list #-} -- | Returns all the types in @type@ as a @PoolStringArray@ for use in any of the @get_*@ functions, if the theme has @type@. bindTheme_get_type_list :: MethodBind bindTheme_get_type_list = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "get_type_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the types in @type@ as a @PoolStringArray@ for use in any of the @get_*@ functions, if the theme has @type@. get_type_list :: (Theme :< cls, Object :< cls) => cls -> GodotString -> IO PoolStringArray get_type_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_get_type_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "get_type_list" '[GodotString] (IO PoolStringArray) where nodeMethod = Godot.Core.Theme.get_type_list {-# NOINLINE bindTheme_has_color #-} -- | Returns @true@ if @Color@ with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. bindTheme_has_color :: MethodBind bindTheme_has_color = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "has_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @Color@ with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. has_color :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool has_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_has_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "has_color" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.Theme.has_color {-# NOINLINE bindTheme_has_constant #-} -- | Returns @true@ if constant with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. bindTheme_has_constant :: MethodBind bindTheme_has_constant = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "has_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if constant with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. has_constant :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool has_constant cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_has_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "has_constant" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.Theme.has_constant {-# NOINLINE bindTheme_has_font #-} -- | Returns @true@ if @Font@ with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. bindTheme_has_font :: MethodBind bindTheme_has_font = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "has_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @Font@ with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. has_font :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool has_font cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_has_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "has_font" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.Theme.has_font {-# NOINLINE bindTheme_has_icon #-} -- | Returns @true@ if icon @Texture@ with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. bindTheme_has_icon :: MethodBind bindTheme_has_icon = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "has_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if icon @Texture@ with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. has_icon :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool has_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_has_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "has_icon" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.Theme.has_icon {-# NOINLINE bindTheme_has_stylebox #-} -- | Returns @true@ if @StyleBox@ with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. bindTheme_has_stylebox :: MethodBind bindTheme_has_stylebox = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "has_stylebox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @StyleBox@ with @name@ is in @type@. -- Returns @false@ if the theme does not have @type@. has_stylebox :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool has_stylebox cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_has_stylebox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "has_stylebox" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Core.Theme.has_stylebox {-# NOINLINE bindTheme_set_color #-} -- | Sets the theme's @Color@ to @color@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. bindTheme_set_color :: MethodBind bindTheme_set_color = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the theme's @Color@ to @color@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. set_color :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Color -> IO () set_color cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "set_color" '[GodotString, GodotString, Color] (IO ()) where nodeMethod = Godot.Core.Theme.set_color {-# NOINLINE bindTheme_set_constant #-} -- | Sets the theme's constant to @constant@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. bindTheme_set_constant :: MethodBind bindTheme_set_constant = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "set_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the theme's constant to @constant@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. set_constant :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Int -> IO () set_constant cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_set_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "set_constant" '[GodotString, GodotString, Int] (IO ()) where nodeMethod = Godot.Core.Theme.set_constant {-# NOINLINE bindTheme_set_default_font #-} -- | The theme's default font. bindTheme_set_default_font :: MethodBind bindTheme_set_default_font = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "set_default_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The theme's default font. set_default_font :: (Theme :< cls, Object :< cls) => cls -> Font -> IO () set_default_font cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_set_default_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "set_default_font" '[Font] (IO ()) where nodeMethod = Godot.Core.Theme.set_default_font {-# NOINLINE bindTheme_set_font #-} -- | Sets the theme's @Font@ to @font@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. bindTheme_set_font :: MethodBind bindTheme_set_font = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "set_font" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the theme's @Font@ to @font@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. set_font :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Font -> IO () set_font cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_set_font (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "set_font" '[GodotString, GodotString, Font] (IO ()) where nodeMethod = Godot.Core.Theme.set_font {-# NOINLINE bindTheme_set_icon #-} -- | Sets the theme's icon @Texture@ to @texture@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. bindTheme_set_icon :: MethodBind bindTheme_set_icon = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "set_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the theme's icon @Texture@ to @texture@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. set_icon :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Texture -> IO () set_icon cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_set_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "set_icon" '[GodotString, GodotString, Texture] (IO ()) where nodeMethod = Godot.Core.Theme.set_icon {-# NOINLINE bindTheme_set_stylebox #-} -- | Sets theme's @StyleBox@ to @stylebox@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. bindTheme_set_stylebox :: MethodBind bindTheme_set_stylebox = unsafePerformIO $ withCString "Theme" $ \ clsNamePtr -> withCString "set_stylebox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets theme's @StyleBox@ to @stylebox@ at @name@ in @type@. -- Does nothing if the theme does not have @type@. set_stylebox :: (Theme :< cls, Object :< cls) => cls -> GodotString -> GodotString -> StyleBox -> IO () set_stylebox cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTheme_set_stylebox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Theme "set_stylebox" '[GodotString, GodotString, StyleBox] (IO ()) where nodeMethod = Godot.Core.Theme.set_stylebox ================================================ FILE: src/Godot/Core/Thread.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Thread (Godot.Core.Thread._PRIORITY_NORMAL, Godot.Core.Thread._PRIORITY_LOW, Godot.Core.Thread._PRIORITY_HIGH, Godot.Core.Thread.get_id, Godot.Core.Thread.is_active, Godot.Core.Thread.start, Godot.Core.Thread.wait_to_finish) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _PRIORITY_NORMAL :: Int _PRIORITY_NORMAL = 1 _PRIORITY_LOW :: Int _PRIORITY_LOW = 0 _PRIORITY_HIGH :: Int _PRIORITY_HIGH = 2 {-# NOINLINE bindThread_get_id #-} -- | Returns the current @Thread@'s ID, uniquely identifying it among all threads. If the @Thread@ is not running this returns an empty string. bindThread_get_id :: MethodBind bindThread_get_id = unsafePerformIO $ withCString "_Thread" $ \ clsNamePtr -> withCString "get_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current @Thread@'s ID, uniquely identifying it among all threads. If the @Thread@ is not running this returns an empty string. get_id :: (Thread :< cls, Object :< cls) => cls -> IO GodotString get_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindThread_get_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Thread "get_id" '[] (IO GodotString) where nodeMethod = Godot.Core.Thread.get_id {-# NOINLINE bindThread_is_active #-} -- | Returns @true@ if this @Thread@ is currently active. An active @Thread@ cannot start work on a new method but can be joined with @method wait_to_finish@. bindThread_is_active :: MethodBind bindThread_is_active = unsafePerformIO $ withCString "_Thread" $ \ clsNamePtr -> withCString "is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this @Thread@ is currently active. An active @Thread@ cannot start work on a new method but can be joined with @method wait_to_finish@. is_active :: (Thread :< cls, Object :< cls) => cls -> IO Bool is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindThread_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Thread "is_active" '[] (IO Bool) where nodeMethod = Godot.Core.Thread.is_active {-# NOINLINE bindThread_start #-} -- | Starts a new @Thread@ that runs @method@ on object @instance@ with @userdata@ passed as an argument. Even if no userdata is passed, @method@ must accept one argument and it will be null. The @priority@ of the @Thread@ can be changed by passing a value from the @enum Priority@ enum. -- Returns @OK@ on success, or @ERR_CANT_CREATE@ on failure. bindThread_start :: MethodBind bindThread_start = unsafePerformIO $ withCString "_Thread" $ \ clsNamePtr -> withCString "start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts a new @Thread@ that runs @method@ on object @instance@ with @userdata@ passed as an argument. Even if no userdata is passed, @method@ must accept one argument and it will be null. The @priority@ of the @Thread@ can be changed by passing a value from the @enum Priority@ enum. -- Returns @OK@ on success, or @ERR_CANT_CREATE@ on failure. start :: (Thread :< cls, Object :< cls) => cls -> Object -> GodotString -> Maybe GodotVariant -> Maybe Int -> IO Int start cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3, maybe (VariantInt (1)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindThread_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Thread "start" '[Object, GodotString, Maybe GodotVariant, Maybe Int] (IO Int) where nodeMethod = Godot.Core.Thread.start {-# NOINLINE bindThread_wait_to_finish #-} -- | Joins the @Thread@ and waits for it to finish. Returns what the method called returned. bindThread_wait_to_finish :: MethodBind bindThread_wait_to_finish = unsafePerformIO $ withCString "_Thread" $ \ clsNamePtr -> withCString "wait_to_finish" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Joins the @Thread@ and waits for it to finish. Returns what the method called returned. wait_to_finish :: (Thread :< cls, Object :< cls) => cls -> IO GodotVariant wait_to_finish cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindThread_wait_to_finish (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Thread "wait_to_finish" '[] (IO GodotVariant) where nodeMethod = Godot.Core.Thread.wait_to_finish ================================================ FILE: src/Godot/Core/TileMap.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TileMap (Godot.Core.TileMap._MODE_CUSTOM, Godot.Core.TileMap._HALF_OFFSET_Y, Godot.Core.TileMap._HALF_OFFSET_NEGATIVE_X, Godot.Core.TileMap._MODE_SQUARE, Godot.Core.TileMap._HALF_OFFSET_NEGATIVE_Y, Godot.Core.TileMap._TILE_ORIGIN_BOTTOM_LEFT, Godot.Core.TileMap._TILE_ORIGIN_CENTER, Godot.Core.TileMap._HALF_OFFSET_DISABLED, Godot.Core.TileMap._TILE_ORIGIN_TOP_LEFT, Godot.Core.TileMap._MODE_ISOMETRIC, Godot.Core.TileMap._INVALID_CELL, Godot.Core.TileMap._HALF_OFFSET_X, Godot.Core.TileMap.sig_settings_changed, Godot.Core.TileMap._clear_quadrants, Godot.Core.TileMap._get_old_cell_size, Godot.Core.TileMap._get_tile_data, Godot.Core.TileMap._recreate_quadrants, Godot.Core.TileMap._set_celld, Godot.Core.TileMap._set_old_cell_size, Godot.Core.TileMap._set_tile_data, Godot.Core.TileMap.clear, Godot.Core.TileMap.fix_invalid_tiles, Godot.Core.TileMap.get_cell, Godot.Core.TileMap.get_cell_autotile_coord, Godot.Core.TileMap.get_cell_size, Godot.Core.TileMap.get_cellv, Godot.Core.TileMap.get_clip_uv, Godot.Core.TileMap.get_collision_bounce, Godot.Core.TileMap.get_collision_friction, Godot.Core.TileMap.get_collision_layer, Godot.Core.TileMap.get_collision_layer_bit, Godot.Core.TileMap.get_collision_mask, Godot.Core.TileMap.get_collision_mask_bit, Godot.Core.TileMap.get_collision_use_kinematic, Godot.Core.TileMap.get_collision_use_parent, Godot.Core.TileMap.get_custom_transform, Godot.Core.TileMap.get_half_offset, Godot.Core.TileMap.get_mode, Godot.Core.TileMap.get_occluder_light_mask, Godot.Core.TileMap.get_quadrant_size, Godot.Core.TileMap.get_tile_origin, Godot.Core.TileMap.get_tileset, Godot.Core.TileMap.get_used_cells, Godot.Core.TileMap.get_used_cells_by_id, Godot.Core.TileMap.get_used_rect, Godot.Core.TileMap.is_cell_transposed, Godot.Core.TileMap.is_cell_x_flipped, Godot.Core.TileMap.is_cell_y_flipped, Godot.Core.TileMap.is_centered_textures_enabled, Godot.Core.TileMap.is_compatibility_mode_enabled, Godot.Core.TileMap.is_y_sort_mode_enabled, Godot.Core.TileMap.map_to_world, Godot.Core.TileMap.set_cell, Godot.Core.TileMap.set_cell_size, Godot.Core.TileMap.set_cellv, Godot.Core.TileMap.set_centered_textures, Godot.Core.TileMap.set_clip_uv, Godot.Core.TileMap.set_collision_bounce, Godot.Core.TileMap.set_collision_friction, Godot.Core.TileMap.set_collision_layer, Godot.Core.TileMap.set_collision_layer_bit, Godot.Core.TileMap.set_collision_mask, Godot.Core.TileMap.set_collision_mask_bit, Godot.Core.TileMap.set_collision_use_kinematic, Godot.Core.TileMap.set_collision_use_parent, Godot.Core.TileMap.set_compatibility_mode, Godot.Core.TileMap.set_custom_transform, Godot.Core.TileMap.set_half_offset, Godot.Core.TileMap.set_mode, Godot.Core.TileMap.set_occluder_light_mask, Godot.Core.TileMap.set_quadrant_size, Godot.Core.TileMap.set_tile_origin, Godot.Core.TileMap.set_tileset, Godot.Core.TileMap.set_y_sort_mode, Godot.Core.TileMap.update_bitmask_area, Godot.Core.TileMap.update_bitmask_region, Godot.Core.TileMap.update_dirty_quadrants, Godot.Core.TileMap.world_to_map) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _MODE_CUSTOM :: Int _MODE_CUSTOM = 2 _HALF_OFFSET_Y :: Int _HALF_OFFSET_Y = 1 _HALF_OFFSET_NEGATIVE_X :: Int _HALF_OFFSET_NEGATIVE_X = 3 _MODE_SQUARE :: Int _MODE_SQUARE = 0 _HALF_OFFSET_NEGATIVE_Y :: Int _HALF_OFFSET_NEGATIVE_Y = 4 _TILE_ORIGIN_BOTTOM_LEFT :: Int _TILE_ORIGIN_BOTTOM_LEFT = 2 _TILE_ORIGIN_CENTER :: Int _TILE_ORIGIN_CENTER = 1 _HALF_OFFSET_DISABLED :: Int _HALF_OFFSET_DISABLED = 2 _TILE_ORIGIN_TOP_LEFT :: Int _TILE_ORIGIN_TOP_LEFT = 0 _MODE_ISOMETRIC :: Int _MODE_ISOMETRIC = 1 _INVALID_CELL :: Int _INVALID_CELL = -1 _HALF_OFFSET_X :: Int _HALF_OFFSET_X = 0 -- | Emitted when a tilemap setting has changed. sig_settings_changed :: Godot.Internal.Dispatch.Signal TileMap sig_settings_changed = Godot.Internal.Dispatch.Signal "settings_changed" instance NodeSignal TileMap "settings_changed" '[] instance NodeProperty TileMap "cell_clip_uv" Bool 'False where nodeProperty = (get_clip_uv, wrapDroppingSetter set_clip_uv, Nothing) instance NodeProperty TileMap "cell_custom_transform" Transform2d 'False where nodeProperty = (get_custom_transform, wrapDroppingSetter set_custom_transform, Nothing) instance NodeProperty TileMap "cell_half_offset" Int 'False where nodeProperty = (get_half_offset, wrapDroppingSetter set_half_offset, Nothing) instance NodeProperty TileMap "cell_quadrant_size" Int 'False where nodeProperty = (get_quadrant_size, wrapDroppingSetter set_quadrant_size, Nothing) instance NodeProperty TileMap "cell_size" Vector2 'False where nodeProperty = (get_cell_size, wrapDroppingSetter set_cell_size, Nothing) instance NodeProperty TileMap "cell_tile_origin" Int 'False where nodeProperty = (get_tile_origin, wrapDroppingSetter set_tile_origin, Nothing) instance NodeProperty TileMap "cell_y_sort" Bool 'False where nodeProperty = (is_y_sort_mode_enabled, wrapDroppingSetter set_y_sort_mode, Nothing) instance NodeProperty TileMap "centered_textures" Bool 'False where nodeProperty = (is_centered_textures_enabled, wrapDroppingSetter set_centered_textures, Nothing) instance NodeProperty TileMap "collision_bounce" Float 'False where nodeProperty = (get_collision_bounce, wrapDroppingSetter set_collision_bounce, Nothing) instance NodeProperty TileMap "collision_friction" Float 'False where nodeProperty = (get_collision_friction, wrapDroppingSetter set_collision_friction, Nothing) instance NodeProperty TileMap "collision_layer" Int 'False where nodeProperty = (get_collision_layer, wrapDroppingSetter set_collision_layer, Nothing) instance NodeProperty TileMap "collision_mask" Int 'False where nodeProperty = (get_collision_mask, wrapDroppingSetter set_collision_mask, Nothing) instance NodeProperty TileMap "collision_use_kinematic" Bool 'False where nodeProperty = (get_collision_use_kinematic, wrapDroppingSetter set_collision_use_kinematic, Nothing) instance NodeProperty TileMap "collision_use_parent" Bool 'False where nodeProperty = (get_collision_use_parent, wrapDroppingSetter set_collision_use_parent, Nothing) instance NodeProperty TileMap "compatibility_mode" Bool 'False where nodeProperty = (is_compatibility_mode_enabled, wrapDroppingSetter set_compatibility_mode, Nothing) instance NodeProperty TileMap "mode" Int 'False where nodeProperty = (get_mode, wrapDroppingSetter set_mode, Nothing) instance NodeProperty TileMap "occluder_light_mask" Int 'False where nodeProperty = (get_occluder_light_mask, wrapDroppingSetter set_occluder_light_mask, Nothing) instance NodeProperty TileMap "tile_set" TileSet 'False where nodeProperty = (get_tileset, wrapDroppingSetter set_tileset, Nothing) {-# NOINLINE bindTileMap__clear_quadrants #-} bindTileMap__clear_quadrants :: MethodBind bindTileMap__clear_quadrants = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "_clear_quadrants" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _clear_quadrants :: (TileMap :< cls, Object :< cls) => cls -> IO () _clear_quadrants cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap__clear_quadrants (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "_clear_quadrants" '[] (IO ()) where nodeMethod = Godot.Core.TileMap._clear_quadrants {-# NOINLINE bindTileMap__get_old_cell_size #-} bindTileMap__get_old_cell_size :: MethodBind bindTileMap__get_old_cell_size = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "_get_old_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_old_cell_size :: (TileMap :< cls, Object :< cls) => cls -> IO Int _get_old_cell_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap__get_old_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "_get_old_cell_size" '[] (IO Int) where nodeMethod = Godot.Core.TileMap._get_old_cell_size {-# NOINLINE bindTileMap__get_tile_data #-} bindTileMap__get_tile_data :: MethodBind bindTileMap__get_tile_data = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "_get_tile_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_tile_data :: (TileMap :< cls, Object :< cls) => cls -> IO PoolIntArray _get_tile_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap__get_tile_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "_get_tile_data" '[] (IO PoolIntArray) where nodeMethod = Godot.Core.TileMap._get_tile_data {-# NOINLINE bindTileMap__recreate_quadrants #-} bindTileMap__recreate_quadrants :: MethodBind bindTileMap__recreate_quadrants = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "_recreate_quadrants" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _recreate_quadrants :: (TileMap :< cls, Object :< cls) => cls -> IO () _recreate_quadrants cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap__recreate_quadrants (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "_recreate_quadrants" '[] (IO ()) where nodeMethod = Godot.Core.TileMap._recreate_quadrants {-# NOINLINE bindTileMap__set_celld #-} bindTileMap__set_celld :: MethodBind bindTileMap__set_celld = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "_set_celld" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_celld :: (TileMap :< cls, Object :< cls) => cls -> Vector2 -> Dictionary -> IO () _set_celld cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap__set_celld (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "_set_celld" '[Vector2, Dictionary] (IO ()) where nodeMethod = Godot.Core.TileMap._set_celld {-# NOINLINE bindTileMap__set_old_cell_size #-} bindTileMap__set_old_cell_size :: MethodBind bindTileMap__set_old_cell_size = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "_set_old_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_old_cell_size :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO () _set_old_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap__set_old_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "_set_old_cell_size" '[Int] (IO ()) where nodeMethod = Godot.Core.TileMap._set_old_cell_size {-# NOINLINE bindTileMap__set_tile_data #-} bindTileMap__set_tile_data :: MethodBind bindTileMap__set_tile_data = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "_set_tile_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_tile_data :: (TileMap :< cls, Object :< cls) => cls -> PoolIntArray -> IO () _set_tile_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap__set_tile_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "_set_tile_data" '[PoolIntArray] (IO ()) where nodeMethod = Godot.Core.TileMap._set_tile_data {-# NOINLINE bindTileMap_clear #-} -- | Clears all cells. bindTileMap_clear :: MethodBind bindTileMap_clear = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all cells. clear :: (TileMap :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "clear" '[] (IO ()) where nodeMethod = Godot.Core.TileMap.clear {-# NOINLINE bindTileMap_fix_invalid_tiles #-} -- | Clears cells that do not exist in the tileset. bindTileMap_fix_invalid_tiles :: MethodBind bindTileMap_fix_invalid_tiles = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "fix_invalid_tiles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears cells that do not exist in the tileset. fix_invalid_tiles :: (TileMap :< cls, Object :< cls) => cls -> IO () fix_invalid_tiles cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_fix_invalid_tiles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "fix_invalid_tiles" '[] (IO ()) where nodeMethod = Godot.Core.TileMap.fix_invalid_tiles {-# NOINLINE bindTileMap_get_cell #-} -- | Returns the tile index of the given cell. If no tile exists in the cell, returns @INVALID_CELL@. bindTileMap_get_cell :: MethodBind bindTileMap_get_cell = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_cell" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile index of the given cell. If no tile exists in the cell, returns @INVALID_CELL@. get_cell :: (TileMap :< cls, Object :< cls) => cls -> Int -> Int -> IO Int get_cell cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_cell (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_cell" '[Int, Int] (IO Int) where nodeMethod = Godot.Core.TileMap.get_cell {-# NOINLINE bindTileMap_get_cell_autotile_coord #-} -- | Returns the coordinate (subtile column and row) of the autotile variation in the tileset. Returns a zero vector if the cell doesn't have autotiling. bindTileMap_get_cell_autotile_coord :: MethodBind bindTileMap_get_cell_autotile_coord = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_cell_autotile_coord" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the coordinate (subtile column and row) of the autotile variation in the tileset. Returns a zero vector if the cell doesn't have autotiling. get_cell_autotile_coord :: (TileMap :< cls, Object :< cls) => cls -> Int -> Int -> IO Vector2 get_cell_autotile_coord cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_cell_autotile_coord (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_cell_autotile_coord" '[Int, Int] (IO Vector2) where nodeMethod = Godot.Core.TileMap.get_cell_autotile_coord {-# NOINLINE bindTileMap_get_cell_size #-} -- | The TileMap's cell size. bindTileMap_get_cell_size :: MethodBind bindTileMap_get_cell_size = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The TileMap's cell size. get_cell_size :: (TileMap :< cls, Object :< cls) => cls -> IO Vector2 get_cell_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_cell_size" '[] (IO Vector2) where nodeMethod = Godot.Core.TileMap.get_cell_size {-# NOINLINE bindTileMap_get_cellv #-} -- | Returns the tile index of the cell given by a Vector2. If no tile exists in the cell, returns @INVALID_CELL@. bindTileMap_get_cellv :: MethodBind bindTileMap_get_cellv = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_cellv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile index of the cell given by a Vector2. If no tile exists in the cell, returns @INVALID_CELL@. get_cellv :: (TileMap :< cls, Object :< cls) => cls -> Vector2 -> IO Int get_cellv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_cellv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_cellv" '[Vector2] (IO Int) where nodeMethod = Godot.Core.TileMap.get_cellv {-# NOINLINE bindTileMap_get_clip_uv #-} -- | If @true@, the cell's UVs will be clipped. bindTileMap_get_clip_uv :: MethodBind bindTileMap_get_clip_uv = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_clip_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the cell's UVs will be clipped. get_clip_uv :: (TileMap :< cls, Object :< cls) => cls -> IO Bool get_clip_uv cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_clip_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_clip_uv" '[] (IO Bool) where nodeMethod = Godot.Core.TileMap.get_clip_uv {-# NOINLINE bindTileMap_get_collision_bounce #-} -- | Bounce value for static body collisions (see @collision_use_kinematic@). bindTileMap_get_collision_bounce :: MethodBind bindTileMap_get_collision_bounce = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_collision_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bounce value for static body collisions (see @collision_use_kinematic@). get_collision_bounce :: (TileMap :< cls, Object :< cls) => cls -> IO Float get_collision_bounce cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_collision_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_collision_bounce" '[] (IO Float) where nodeMethod = Godot.Core.TileMap.get_collision_bounce {-# NOINLINE bindTileMap_get_collision_friction #-} -- | Friction value for static body collisions (see @collision_use_kinematic@). bindTileMap_get_collision_friction :: MethodBind bindTileMap_get_collision_friction = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_collision_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Friction value for static body collisions (see @collision_use_kinematic@). get_collision_friction :: (TileMap :< cls, Object :< cls) => cls -> IO Float get_collision_friction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_collision_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_collision_friction" '[] (IO Float) where nodeMethod = Godot.Core.TileMap.get_collision_friction {-# NOINLINE bindTileMap_get_collision_layer #-} -- | The collision layer(s) for all colliders in the TileMap. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindTileMap_get_collision_layer :: MethodBind bindTileMap_get_collision_layer = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision layer(s) for all colliders in the TileMap. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_layer :: (TileMap :< cls, Object :< cls) => cls -> IO Int get_collision_layer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_collision_layer" '[] (IO Int) where nodeMethod = Godot.Core.TileMap.get_collision_layer {-# NOINLINE bindTileMap_get_collision_layer_bit #-} -- | Returns @true@ if the given collision layer bit is set. bindTileMap_get_collision_layer_bit :: MethodBind bindTileMap_get_collision_layer_bit = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given collision layer bit is set. get_collision_layer_bit :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_layer_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_collision_layer_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.TileMap.get_collision_layer_bit {-# NOINLINE bindTileMap_get_collision_mask #-} -- | The collision mask(s) for all colliders in the TileMap. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindTileMap_get_collision_mask :: MethodBind bindTileMap_get_collision_mask = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision mask(s) for all colliders in the TileMap. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. get_collision_mask :: (TileMap :< cls, Object :< cls) => cls -> IO Int get_collision_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_collision_mask" '[] (IO Int) where nodeMethod = Godot.Core.TileMap.get_collision_mask {-# NOINLINE bindTileMap_get_collision_mask_bit #-} -- | Returns @true@ if the given collision mask bit is set. bindTileMap_get_collision_mask_bit :: MethodBind bindTileMap_get_collision_mask_bit = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given collision mask bit is set. get_collision_mask_bit :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO Bool get_collision_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_collision_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.TileMap.get_collision_mask_bit {-# NOINLINE bindTileMap_get_collision_use_kinematic #-} -- | If @true@, TileMap collisions will be handled as a kinematic body. If @false@, collisions will be handled as static body. bindTileMap_get_collision_use_kinematic :: MethodBind bindTileMap_get_collision_use_kinematic = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_collision_use_kinematic" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, TileMap collisions will be handled as a kinematic body. If @false@, collisions will be handled as static body. get_collision_use_kinematic :: (TileMap :< cls, Object :< cls) => cls -> IO Bool get_collision_use_kinematic cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_collision_use_kinematic (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_collision_use_kinematic" '[] (IO Bool) where nodeMethod = Godot.Core.TileMap.get_collision_use_kinematic {-# NOINLINE bindTileMap_get_collision_use_parent #-} -- | If @true@, this tilemap's collision shape will be added to the collision shape of the parent. The parent has to be a @CollisionObject2D@. bindTileMap_get_collision_use_parent :: MethodBind bindTileMap_get_collision_use_parent = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_collision_use_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this tilemap's collision shape will be added to the collision shape of the parent. The parent has to be a @CollisionObject2D@. get_collision_use_parent :: (TileMap :< cls, Object :< cls) => cls -> IO Bool get_collision_use_parent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_collision_use_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_collision_use_parent" '[] (IO Bool) where nodeMethod = Godot.Core.TileMap.get_collision_use_parent {-# NOINLINE bindTileMap_get_custom_transform #-} -- | The custom @Transform2D@ to be applied to the TileMap's cells. bindTileMap_get_custom_transform :: MethodBind bindTileMap_get_custom_transform = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_custom_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @Transform2D@ to be applied to the TileMap's cells. get_custom_transform :: (TileMap :< cls, Object :< cls) => cls -> IO Transform2d get_custom_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_custom_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_custom_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.TileMap.get_custom_transform {-# NOINLINE bindTileMap_get_half_offset #-} -- | Amount to offset alternating tiles. See @enum HalfOffset@ for possible values. bindTileMap_get_half_offset :: MethodBind bindTileMap_get_half_offset = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_half_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount to offset alternating tiles. See @enum HalfOffset@ for possible values. get_half_offset :: (TileMap :< cls, Object :< cls) => cls -> IO Int get_half_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_half_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_half_offset" '[] (IO Int) where nodeMethod = Godot.Core.TileMap.get_half_offset {-# NOINLINE bindTileMap_get_mode #-} -- | The TileMap orientation mode. See @enum Mode@ for possible values. bindTileMap_get_mode :: MethodBind bindTileMap_get_mode = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The TileMap orientation mode. See @enum Mode@ for possible values. get_mode :: (TileMap :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_mode" '[] (IO Int) where nodeMethod = Godot.Core.TileMap.get_mode {-# NOINLINE bindTileMap_get_occluder_light_mask #-} -- | The light mask assigned to all light occluders in the TileMap. The TileSet's light occluders will cast shadows only from Light2D(s) that have the same light mask(s). bindTileMap_get_occluder_light_mask :: MethodBind bindTileMap_get_occluder_light_mask = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_occluder_light_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light mask assigned to all light occluders in the TileMap. The TileSet's light occluders will cast shadows only from Light2D(s) that have the same light mask(s). get_occluder_light_mask :: (TileMap :< cls, Object :< cls) => cls -> IO Int get_occluder_light_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_occluder_light_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_occluder_light_mask" '[] (IO Int) where nodeMethod = Godot.Core.TileMap.get_occluder_light_mask {-# NOINLINE bindTileMap_get_quadrant_size #-} -- | The TileMap's quadrant size. Optimizes drawing by batching, using chunks of this size. bindTileMap_get_quadrant_size :: MethodBind bindTileMap_get_quadrant_size = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_quadrant_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The TileMap's quadrant size. Optimizes drawing by batching, using chunks of this size. get_quadrant_size :: (TileMap :< cls, Object :< cls) => cls -> IO Int get_quadrant_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_quadrant_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_quadrant_size" '[] (IO Int) where nodeMethod = Godot.Core.TileMap.get_quadrant_size {-# NOINLINE bindTileMap_get_tile_origin #-} -- | Position for tile origin. See @enum TileOrigin@ for possible values. bindTileMap_get_tile_origin :: MethodBind bindTileMap_get_tile_origin = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_tile_origin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Position for tile origin. See @enum TileOrigin@ for possible values. get_tile_origin :: (TileMap :< cls, Object :< cls) => cls -> IO Int get_tile_origin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_tile_origin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_tile_origin" '[] (IO Int) where nodeMethod = Godot.Core.TileMap.get_tile_origin {-# NOINLINE bindTileMap_get_tileset #-} -- | The assigned @TileSet@. bindTileMap_get_tileset :: MethodBind bindTileMap_get_tileset = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_tileset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The assigned @TileSet@. get_tileset :: (TileMap :< cls, Object :< cls) => cls -> IO TileSet get_tileset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_tileset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_tileset" '[] (IO TileSet) where nodeMethod = Godot.Core.TileMap.get_tileset {-# NOINLINE bindTileMap_get_used_cells #-} -- | Returns a @Vector2@ array with the positions of all cells containing a tile from the tileset (i.e. a tile index different from @-1@). bindTileMap_get_used_cells :: MethodBind bindTileMap_get_used_cells = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_used_cells" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @Vector2@ array with the positions of all cells containing a tile from the tileset (i.e. a tile index different from @-1@). get_used_cells :: (TileMap :< cls, Object :< cls) => cls -> IO Array get_used_cells cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_used_cells (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_used_cells" '[] (IO Array) where nodeMethod = Godot.Core.TileMap.get_used_cells {-# NOINLINE bindTileMap_get_used_cells_by_id #-} -- | Returns an array of all cells with the given tile index specified in @id@. bindTileMap_get_used_cells_by_id :: MethodBind bindTileMap_get_used_cells_by_id = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_used_cells_by_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of all cells with the given tile index specified in @id@. get_used_cells_by_id :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO Array get_used_cells_by_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_used_cells_by_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_used_cells_by_id" '[Int] (IO Array) where nodeMethod = Godot.Core.TileMap.get_used_cells_by_id {-# NOINLINE bindTileMap_get_used_rect #-} -- | Returns a rectangle enclosing the used (non-empty) tiles of the map. bindTileMap_get_used_rect :: MethodBind bindTileMap_get_used_rect = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "get_used_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a rectangle enclosing the used (non-empty) tiles of the map. get_used_rect :: (TileMap :< cls, Object :< cls) => cls -> IO Rect2 get_used_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_get_used_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "get_used_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.TileMap.get_used_rect {-# NOINLINE bindTileMap_is_cell_transposed #-} -- | Returns @true@ if the given cell is transposed, i.e. the X and Y axes are swapped. bindTileMap_is_cell_transposed :: MethodBind bindTileMap_is_cell_transposed = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "is_cell_transposed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given cell is transposed, i.e. the X and Y axes are swapped. is_cell_transposed :: (TileMap :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool is_cell_transposed cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_is_cell_transposed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "is_cell_transposed" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.TileMap.is_cell_transposed {-# NOINLINE bindTileMap_is_cell_x_flipped #-} -- | Returns @true@ if the given cell is flipped in the X axis. bindTileMap_is_cell_x_flipped :: MethodBind bindTileMap_is_cell_x_flipped = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "is_cell_x_flipped" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given cell is flipped in the X axis. is_cell_x_flipped :: (TileMap :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool is_cell_x_flipped cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_is_cell_x_flipped (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "is_cell_x_flipped" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.TileMap.is_cell_x_flipped {-# NOINLINE bindTileMap_is_cell_y_flipped #-} -- | Returns @true@ if the given cell is flipped in the Y axis. bindTileMap_is_cell_y_flipped :: MethodBind bindTileMap_is_cell_y_flipped = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "is_cell_y_flipped" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given cell is flipped in the Y axis. is_cell_y_flipped :: (TileMap :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool is_cell_y_flipped cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_is_cell_y_flipped (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "is_cell_y_flipped" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.TileMap.is_cell_y_flipped {-# NOINLINE bindTileMap_is_centered_textures_enabled #-} -- | If @true@, the textures will be centered in the middle of each tile. This is useful for certain isometric or top-down modes when textures are made larger or smaller than the tiles (e.g. to avoid flickering on tile edges). The offset is still applied, but from the center of the tile. If used, @compatibility_mode@ is ignored. -- If @false@, the texture position start in the top-left corner unless @compatibility_mode@ is enabled. bindTileMap_is_centered_textures_enabled :: MethodBind bindTileMap_is_centered_textures_enabled = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "is_centered_textures_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the textures will be centered in the middle of each tile. This is useful for certain isometric or top-down modes when textures are made larger or smaller than the tiles (e.g. to avoid flickering on tile edges). The offset is still applied, but from the center of the tile. If used, @compatibility_mode@ is ignored. -- If @false@, the texture position start in the top-left corner unless @compatibility_mode@ is enabled. is_centered_textures_enabled :: (TileMap :< cls, Object :< cls) => cls -> IO Bool is_centered_textures_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_is_centered_textures_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "is_centered_textures_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TileMap.is_centered_textures_enabled {-# NOINLINE bindTileMap_is_compatibility_mode_enabled #-} -- | If @true@, the compatibility with the tilemaps made in Godot 3.1 or earlier is maintained (textures move when the tile origin changes and rotate if the texture size is not homogeneous). This mode presents problems when doing @flip_h@, @flip_v@ and @transpose@ tile operations on non-homogeneous isometric tiles (e.g. 2:1), in which the texture could not coincide with the collision, thus it is not recommended for isometric or non-square tiles. -- If @false@, the textures do not move when doing @flip_h@, @flip_v@ operations if no offset is used, nor when changing the tile origin. -- The compatibility mode doesn't work with the @centered_textures@ option, because displacing textures with the @cell_tile_origin@ option or in irregular tiles is not relevant when centering those textures. bindTileMap_is_compatibility_mode_enabled :: MethodBind bindTileMap_is_compatibility_mode_enabled = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "is_compatibility_mode_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the compatibility with the tilemaps made in Godot 3.1 or earlier is maintained (textures move when the tile origin changes and rotate if the texture size is not homogeneous). This mode presents problems when doing @flip_h@, @flip_v@ and @transpose@ tile operations on non-homogeneous isometric tiles (e.g. 2:1), in which the texture could not coincide with the collision, thus it is not recommended for isometric or non-square tiles. -- If @false@, the textures do not move when doing @flip_h@, @flip_v@ operations if no offset is used, nor when changing the tile origin. -- The compatibility mode doesn't work with the @centered_textures@ option, because displacing textures with the @cell_tile_origin@ option or in irregular tiles is not relevant when centering those textures. is_compatibility_mode_enabled :: (TileMap :< cls, Object :< cls) => cls -> IO Bool is_compatibility_mode_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_is_compatibility_mode_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "is_compatibility_mode_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TileMap.is_compatibility_mode_enabled {-# NOINLINE bindTileMap_is_y_sort_mode_enabled #-} -- | If @true@, the TileMap's children will be drawn in order of their Y coordinate. bindTileMap_is_y_sort_mode_enabled :: MethodBind bindTileMap_is_y_sort_mode_enabled = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "is_y_sort_mode_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the TileMap's children will be drawn in order of their Y coordinate. is_y_sort_mode_enabled :: (TileMap :< cls, Object :< cls) => cls -> IO Bool is_y_sort_mode_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_is_y_sort_mode_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "is_y_sort_mode_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TileMap.is_y_sort_mode_enabled {-# NOINLINE bindTileMap_map_to_world #-} -- | Returns the global position corresponding to the given tilemap (grid-based) coordinates. -- Optionally, the tilemap's half offset can be ignored. bindTileMap_map_to_world :: MethodBind bindTileMap_map_to_world = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "map_to_world" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the global position corresponding to the given tilemap (grid-based) coordinates. -- Optionally, the tilemap's half offset can be ignored. map_to_world :: (TileMap :< cls, Object :< cls) => cls -> Vector2 -> Maybe Bool -> IO Vector2 map_to_world cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_map_to_world (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "map_to_world" '[Vector2, Maybe Bool] (IO Vector2) where nodeMethod = Godot.Core.TileMap.map_to_world {-# NOINLINE bindTileMap_set_cell #-} -- | Sets the tile index for the cell given by a Vector2. -- An index of @-1@ clears the cell. -- Optionally, the tile can also be flipped, transposed, or given autotile coordinates. The autotile coordinate refers to the column and row of the subtile. -- __Note:__ Data such as navigation polygons and collision shapes are not immediately updated for performance reasons. -- If you need these to be immediately updated, you can call @method update_dirty_quadrants@. -- Overriding this method also overrides it internally, allowing custom logic to be implemented when tiles are placed/removed: -- -- @ -- -- func set_cell(x, y, tile, flip_x=false, flip_y=false, transpose=false, autotile_coord=Vector2()) -- # Write your custom logic here. -- # To call the default method: -- .set_cell(x, y, tile, flip_x, flip_y, transpose, autotile_coord) -- -- @ bindTileMap_set_cell :: MethodBind bindTileMap_set_cell = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_cell" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile index for the cell given by a Vector2. -- An index of @-1@ clears the cell. -- Optionally, the tile can also be flipped, transposed, or given autotile coordinates. The autotile coordinate refers to the column and row of the subtile. -- __Note:__ Data such as navigation polygons and collision shapes are not immediately updated for performance reasons. -- If you need these to be immediately updated, you can call @method update_dirty_quadrants@. -- Overriding this method also overrides it internally, allowing custom logic to be implemented when tiles are placed/removed: -- -- @ -- -- func set_cell(x, y, tile, flip_x=false, flip_y=false, transpose=false, autotile_coord=Vector2()) -- # Write your custom logic here. -- # To call the default method: -- .set_cell(x, y, tile, flip_x, flip_y, transpose, autotile_coord) -- -- @ set_cell :: (TileMap :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Maybe Bool -> Maybe Bool -> Maybe Bool -> Maybe Vector2 -> IO () set_cell cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantBool False) toVariant arg4, maybe (VariantBool False) toVariant arg5, maybe (VariantBool False) toVariant arg6, defaultedVariant VariantVector2 (V2 0 0) arg7] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_cell (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_cell" '[Int, Int, Int, Maybe Bool, Maybe Bool, Maybe Bool, Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.TileMap.set_cell {-# NOINLINE bindTileMap_set_cell_size #-} -- | The TileMap's cell size. bindTileMap_set_cell_size :: MethodBind bindTileMap_set_cell_size = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The TileMap's cell size. set_cell_size :: (TileMap :< cls, Object :< cls) => cls -> Vector2 -> IO () set_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_cell_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.TileMap.set_cell_size {-# NOINLINE bindTileMap_set_cellv #-} -- | Sets the tile index for the given cell. -- An index of @-1@ clears the cell. -- Optionally, the tile can also be flipped or transposed. -- __Note:__ Data such as navigation polygons and collision shapes are not immediately updated for performance reasons. -- If you need these to be immediately updated, you can call @method update_dirty_quadrants@. bindTileMap_set_cellv :: MethodBind bindTileMap_set_cellv = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_cellv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile index for the given cell. -- An index of @-1@ clears the cell. -- Optionally, the tile can also be flipped or transposed. -- __Note:__ Data such as navigation polygons and collision shapes are not immediately updated for performance reasons. -- If you need these to be immediately updated, you can call @method update_dirty_quadrants@. set_cellv :: (TileMap :< cls, Object :< cls) => cls -> Vector2 -> Int -> Maybe Bool -> Maybe Bool -> Maybe Bool -> IO () set_cellv cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3, maybe (VariantBool False) toVariant arg4, maybe (VariantBool False) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_cellv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_cellv" '[Vector2, Int, Maybe Bool, Maybe Bool, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_cellv {-# NOINLINE bindTileMap_set_centered_textures #-} -- | If @true@, the textures will be centered in the middle of each tile. This is useful for certain isometric or top-down modes when textures are made larger or smaller than the tiles (e.g. to avoid flickering on tile edges). The offset is still applied, but from the center of the tile. If used, @compatibility_mode@ is ignored. -- If @false@, the texture position start in the top-left corner unless @compatibility_mode@ is enabled. bindTileMap_set_centered_textures :: MethodBind bindTileMap_set_centered_textures = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_centered_textures" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the textures will be centered in the middle of each tile. This is useful for certain isometric or top-down modes when textures are made larger or smaller than the tiles (e.g. to avoid flickering on tile edges). The offset is still applied, but from the center of the tile. If used, @compatibility_mode@ is ignored. -- If @false@, the texture position start in the top-left corner unless @compatibility_mode@ is enabled. set_centered_textures :: (TileMap :< cls, Object :< cls) => cls -> Bool -> IO () set_centered_textures cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_centered_textures (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_centered_textures" '[Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_centered_textures {-# NOINLINE bindTileMap_set_clip_uv #-} -- | If @true@, the cell's UVs will be clipped. bindTileMap_set_clip_uv :: MethodBind bindTileMap_set_clip_uv = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_clip_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the cell's UVs will be clipped. set_clip_uv :: (TileMap :< cls, Object :< cls) => cls -> Bool -> IO () set_clip_uv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_clip_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_clip_uv" '[Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_clip_uv {-# NOINLINE bindTileMap_set_collision_bounce #-} -- | Bounce value for static body collisions (see @collision_use_kinematic@). bindTileMap_set_collision_bounce :: MethodBind bindTileMap_set_collision_bounce = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_collision_bounce" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Bounce value for static body collisions (see @collision_use_kinematic@). set_collision_bounce :: (TileMap :< cls, Object :< cls) => cls -> Float -> IO () set_collision_bounce cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_collision_bounce (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_collision_bounce" '[Float] (IO ()) where nodeMethod = Godot.Core.TileMap.set_collision_bounce {-# NOINLINE bindTileMap_set_collision_friction #-} -- | Friction value for static body collisions (see @collision_use_kinematic@). bindTileMap_set_collision_friction :: MethodBind bindTileMap_set_collision_friction = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_collision_friction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Friction value for static body collisions (see @collision_use_kinematic@). set_collision_friction :: (TileMap :< cls, Object :< cls) => cls -> Float -> IO () set_collision_friction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_collision_friction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_collision_friction" '[Float] (IO ()) where nodeMethod = Godot.Core.TileMap.set_collision_friction {-# NOINLINE bindTileMap_set_collision_layer #-} -- | The collision layer(s) for all colliders in the TileMap. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindTileMap_set_collision_layer :: MethodBind bindTileMap_set_collision_layer = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_collision_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision layer(s) for all colliders in the TileMap. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_layer :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO () set_collision_layer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_collision_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_collision_layer" '[Int] (IO ()) where nodeMethod = Godot.Core.TileMap.set_collision_layer {-# NOINLINE bindTileMap_set_collision_layer_bit #-} -- | Sets the given collision layer bit. bindTileMap_set_collision_layer_bit :: MethodBind bindTileMap_set_collision_layer_bit = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_collision_layer_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given collision layer bit. set_collision_layer_bit :: (TileMap :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_layer_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_collision_layer_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_collision_layer_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_collision_layer_bit {-# NOINLINE bindTileMap_set_collision_mask #-} -- | The collision mask(s) for all colliders in the TileMap. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. bindTileMap_set_collision_mask :: MethodBind bindTileMap_set_collision_mask = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_collision_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The collision mask(s) for all colliders in the TileMap. See @url=https://docs.godotengine.org/en/latest/tutorials/physics/physics_introduction.html#collision-layers-and-masks@Collision layers and masks@/url@ in the documentation for more information. set_collision_mask :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO () set_collision_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_collision_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_collision_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.TileMap.set_collision_mask {-# NOINLINE bindTileMap_set_collision_mask_bit #-} -- | Sets the given collision mask bit. bindTileMap_set_collision_mask_bit :: MethodBind bindTileMap_set_collision_mask_bit = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_collision_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given collision mask bit. set_collision_mask_bit :: (TileMap :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_collision_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_collision_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_collision_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_collision_mask_bit {-# NOINLINE bindTileMap_set_collision_use_kinematic #-} -- | If @true@, TileMap collisions will be handled as a kinematic body. If @false@, collisions will be handled as static body. bindTileMap_set_collision_use_kinematic :: MethodBind bindTileMap_set_collision_use_kinematic = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_collision_use_kinematic" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, TileMap collisions will be handled as a kinematic body. If @false@, collisions will be handled as static body. set_collision_use_kinematic :: (TileMap :< cls, Object :< cls) => cls -> Bool -> IO () set_collision_use_kinematic cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_collision_use_kinematic (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_collision_use_kinematic" '[Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_collision_use_kinematic {-# NOINLINE bindTileMap_set_collision_use_parent #-} -- | If @true@, this tilemap's collision shape will be added to the collision shape of the parent. The parent has to be a @CollisionObject2D@. bindTileMap_set_collision_use_parent :: MethodBind bindTileMap_set_collision_use_parent = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_collision_use_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this tilemap's collision shape will be added to the collision shape of the parent. The parent has to be a @CollisionObject2D@. set_collision_use_parent :: (TileMap :< cls, Object :< cls) => cls -> Bool -> IO () set_collision_use_parent cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_collision_use_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_collision_use_parent" '[Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_collision_use_parent {-# NOINLINE bindTileMap_set_compatibility_mode #-} -- | If @true@, the compatibility with the tilemaps made in Godot 3.1 or earlier is maintained (textures move when the tile origin changes and rotate if the texture size is not homogeneous). This mode presents problems when doing @flip_h@, @flip_v@ and @transpose@ tile operations on non-homogeneous isometric tiles (e.g. 2:1), in which the texture could not coincide with the collision, thus it is not recommended for isometric or non-square tiles. -- If @false@, the textures do not move when doing @flip_h@, @flip_v@ operations if no offset is used, nor when changing the tile origin. -- The compatibility mode doesn't work with the @centered_textures@ option, because displacing textures with the @cell_tile_origin@ option or in irregular tiles is not relevant when centering those textures. bindTileMap_set_compatibility_mode :: MethodBind bindTileMap_set_compatibility_mode = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_compatibility_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the compatibility with the tilemaps made in Godot 3.1 or earlier is maintained (textures move when the tile origin changes and rotate if the texture size is not homogeneous). This mode presents problems when doing @flip_h@, @flip_v@ and @transpose@ tile operations on non-homogeneous isometric tiles (e.g. 2:1), in which the texture could not coincide with the collision, thus it is not recommended for isometric or non-square tiles. -- If @false@, the textures do not move when doing @flip_h@, @flip_v@ operations if no offset is used, nor when changing the tile origin. -- The compatibility mode doesn't work with the @centered_textures@ option, because displacing textures with the @cell_tile_origin@ option or in irregular tiles is not relevant when centering those textures. set_compatibility_mode :: (TileMap :< cls, Object :< cls) => cls -> Bool -> IO () set_compatibility_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_compatibility_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_compatibility_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_compatibility_mode {-# NOINLINE bindTileMap_set_custom_transform #-} -- | The custom @Transform2D@ to be applied to the TileMap's cells. bindTileMap_set_custom_transform :: MethodBind bindTileMap_set_custom_transform = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_custom_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @Transform2D@ to be applied to the TileMap's cells. set_custom_transform :: (TileMap :< cls, Object :< cls) => cls -> Transform2d -> IO () set_custom_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_custom_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_custom_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.TileMap.set_custom_transform {-# NOINLINE bindTileMap_set_half_offset #-} -- | Amount to offset alternating tiles. See @enum HalfOffset@ for possible values. bindTileMap_set_half_offset :: MethodBind bindTileMap_set_half_offset = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_half_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount to offset alternating tiles. See @enum HalfOffset@ for possible values. set_half_offset :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO () set_half_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_half_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_half_offset" '[Int] (IO ()) where nodeMethod = Godot.Core.TileMap.set_half_offset {-# NOINLINE bindTileMap_set_mode #-} -- | The TileMap orientation mode. See @enum Mode@ for possible values. bindTileMap_set_mode :: MethodBind bindTileMap_set_mode = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The TileMap orientation mode. See @enum Mode@ for possible values. set_mode :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.TileMap.set_mode {-# NOINLINE bindTileMap_set_occluder_light_mask #-} -- | The light mask assigned to all light occluders in the TileMap. The TileSet's light occluders will cast shadows only from Light2D(s) that have the same light mask(s). bindTileMap_set_occluder_light_mask :: MethodBind bindTileMap_set_occluder_light_mask = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_occluder_light_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light mask assigned to all light occluders in the TileMap. The TileSet's light occluders will cast shadows only from Light2D(s) that have the same light mask(s). set_occluder_light_mask :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO () set_occluder_light_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_occluder_light_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_occluder_light_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.TileMap.set_occluder_light_mask {-# NOINLINE bindTileMap_set_quadrant_size #-} -- | The TileMap's quadrant size. Optimizes drawing by batching, using chunks of this size. bindTileMap_set_quadrant_size :: MethodBind bindTileMap_set_quadrant_size = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_quadrant_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The TileMap's quadrant size. Optimizes drawing by batching, using chunks of this size. set_quadrant_size :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO () set_quadrant_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_quadrant_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_quadrant_size" '[Int] (IO ()) where nodeMethod = Godot.Core.TileMap.set_quadrant_size {-# NOINLINE bindTileMap_set_tile_origin #-} -- | Position for tile origin. See @enum TileOrigin@ for possible values. bindTileMap_set_tile_origin :: MethodBind bindTileMap_set_tile_origin = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_tile_origin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Position for tile origin. See @enum TileOrigin@ for possible values. set_tile_origin :: (TileMap :< cls, Object :< cls) => cls -> Int -> IO () set_tile_origin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_tile_origin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_tile_origin" '[Int] (IO ()) where nodeMethod = Godot.Core.TileMap.set_tile_origin {-# NOINLINE bindTileMap_set_tileset #-} -- | The assigned @TileSet@. bindTileMap_set_tileset :: MethodBind bindTileMap_set_tileset = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_tileset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The assigned @TileSet@. set_tileset :: (TileMap :< cls, Object :< cls) => cls -> TileSet -> IO () set_tileset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_tileset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_tileset" '[TileSet] (IO ()) where nodeMethod = Godot.Core.TileMap.set_tileset {-# NOINLINE bindTileMap_set_y_sort_mode #-} -- | If @true@, the TileMap's children will be drawn in order of their Y coordinate. bindTileMap_set_y_sort_mode :: MethodBind bindTileMap_set_y_sort_mode = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "set_y_sort_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the TileMap's children will be drawn in order of their Y coordinate. set_y_sort_mode :: (TileMap :< cls, Object :< cls) => cls -> Bool -> IO () set_y_sort_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_set_y_sort_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "set_y_sort_mode" '[Bool] (IO ()) where nodeMethod = Godot.Core.TileMap.set_y_sort_mode {-# NOINLINE bindTileMap_update_bitmask_area #-} -- | Applies autotiling rules to the cell (and its adjacent cells) referenced by its grid-based X and Y coordinates. bindTileMap_update_bitmask_area :: MethodBind bindTileMap_update_bitmask_area = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "update_bitmask_area" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies autotiling rules to the cell (and its adjacent cells) referenced by its grid-based X and Y coordinates. update_bitmask_area :: (TileMap :< cls, Object :< cls) => cls -> Vector2 -> IO () update_bitmask_area cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_update_bitmask_area (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "update_bitmask_area" '[Vector2] (IO ()) where nodeMethod = Godot.Core.TileMap.update_bitmask_area {-# NOINLINE bindTileMap_update_bitmask_region #-} -- | Applies autotiling rules to the cells in the given region (specified by grid-based X and Y coordinates). -- Calling with invalid (or missing) parameters applies autotiling rules for the entire tilemap. bindTileMap_update_bitmask_region :: MethodBind bindTileMap_update_bitmask_region = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "update_bitmask_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Applies autotiling rules to the cells in the given region (specified by grid-based X and Y coordinates). -- Calling with invalid (or missing) parameters applies autotiling rules for the entire tilemap. update_bitmask_region :: (TileMap :< cls, Object :< cls) => cls -> Maybe Vector2 -> Maybe Vector2 -> IO () update_bitmask_region cls arg1 arg2 = withVariantArray [defaultedVariant VariantVector2 (V2 0 0) arg1, defaultedVariant VariantVector2 (V2 0 0) arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_update_bitmask_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "update_bitmask_region" '[Maybe Vector2, Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.TileMap.update_bitmask_region {-# NOINLINE bindTileMap_update_dirty_quadrants #-} -- | Updates the tile map's quadrants, allowing things such as navigation and collision shapes to be immediately used if modified. bindTileMap_update_dirty_quadrants :: MethodBind bindTileMap_update_dirty_quadrants = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "update_dirty_quadrants" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the tile map's quadrants, allowing things such as navigation and collision shapes to be immediately used if modified. update_dirty_quadrants :: (TileMap :< cls, Object :< cls) => cls -> IO () update_dirty_quadrants cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_update_dirty_quadrants (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "update_dirty_quadrants" '[] (IO ()) where nodeMethod = Godot.Core.TileMap.update_dirty_quadrants {-# NOINLINE bindTileMap_world_to_map #-} -- | Returns the tilemap (grid-based) coordinates corresponding to the given local position. bindTileMap_world_to_map :: MethodBind bindTileMap_world_to_map = unsafePerformIO $ withCString "TileMap" $ \ clsNamePtr -> withCString "world_to_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tilemap (grid-based) coordinates corresponding to the given local position. world_to_map :: (TileMap :< cls, Object :< cls) => cls -> Vector2 -> IO Vector2 world_to_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileMap_world_to_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileMap "world_to_map" '[Vector2] (IO Vector2) where nodeMethod = Godot.Core.TileMap.world_to_map ================================================ FILE: src/Godot/Core/TileSet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TileSet (Godot.Core.TileSet._BITMASK_2X2, Godot.Core.TileSet._BITMASK_3X3, Godot.Core.TileSet._BIND_BOTTOMLEFT, Godot.Core.TileSet._BIND_CENTER, Godot.Core.TileSet._BIND_LEFT, Godot.Core.TileSet._ATLAS_TILE, Godot.Core.TileSet._BITMASK_3X3_MINIMAL, Godot.Core.TileSet._BIND_RIGHT, Godot.Core.TileSet._BIND_TOPLEFT, Godot.Core.TileSet._BIND_BOTTOM, Godot.Core.TileSet._BIND_BOTTOMRIGHT, Godot.Core.TileSet._AUTO_TILE, Godot.Core.TileSet._BIND_TOP, Godot.Core.TileSet._BIND_TOPRIGHT, Godot.Core.TileSet._SINGLE_TILE, Godot.Core.TileSet._forward_atlas_subtile_selection, Godot.Core.TileSet._forward_subtile_selection, Godot.Core.TileSet._is_tile_bound, Godot.Core.TileSet.autotile_clear_bitmask_map, Godot.Core.TileSet.autotile_get_bitmask, Godot.Core.TileSet.autotile_get_bitmask_mode, Godot.Core.TileSet.autotile_get_icon_coordinate, Godot.Core.TileSet.autotile_get_light_occluder, Godot.Core.TileSet.autotile_get_navigation_polygon, Godot.Core.TileSet.autotile_get_size, Godot.Core.TileSet.autotile_get_spacing, Godot.Core.TileSet.autotile_get_subtile_priority, Godot.Core.TileSet.autotile_get_z_index, Godot.Core.TileSet.autotile_set_bitmask, Godot.Core.TileSet.autotile_set_bitmask_mode, Godot.Core.TileSet.autotile_set_icon_coordinate, Godot.Core.TileSet.autotile_set_light_occluder, Godot.Core.TileSet.autotile_set_navigation_polygon, Godot.Core.TileSet.autotile_set_size, Godot.Core.TileSet.autotile_set_spacing, Godot.Core.TileSet.autotile_set_subtile_priority, Godot.Core.TileSet.autotile_set_z_index, Godot.Core.TileSet.clear, Godot.Core.TileSet.create_tile, Godot.Core.TileSet.find_tile_by_name, Godot.Core.TileSet.get_last_unused_tile_id, Godot.Core.TileSet.get_tiles_ids, Godot.Core.TileSet.remove_tile, Godot.Core.TileSet.tile_add_shape, Godot.Core.TileSet.tile_get_light_occluder, Godot.Core.TileSet.tile_get_material, Godot.Core.TileSet.tile_get_modulate, Godot.Core.TileSet.tile_get_name, Godot.Core.TileSet.tile_get_navigation_polygon, Godot.Core.TileSet.tile_get_navigation_polygon_offset, Godot.Core.TileSet.tile_get_normal_map, Godot.Core.TileSet.tile_get_occluder_offset, Godot.Core.TileSet.tile_get_region, Godot.Core.TileSet.tile_get_shape, Godot.Core.TileSet.tile_get_shape_count, Godot.Core.TileSet.tile_get_shape_offset, Godot.Core.TileSet.tile_get_shape_one_way, Godot.Core.TileSet.tile_get_shape_one_way_margin, Godot.Core.TileSet.tile_get_shape_transform, Godot.Core.TileSet.tile_get_shapes, Godot.Core.TileSet.tile_get_texture, Godot.Core.TileSet.tile_get_texture_offset, Godot.Core.TileSet.tile_get_tile_mode, Godot.Core.TileSet.tile_get_z_index, Godot.Core.TileSet.tile_set_light_occluder, Godot.Core.TileSet.tile_set_material, Godot.Core.TileSet.tile_set_modulate, Godot.Core.TileSet.tile_set_name, Godot.Core.TileSet.tile_set_navigation_polygon, Godot.Core.TileSet.tile_set_navigation_polygon_offset, Godot.Core.TileSet.tile_set_normal_map, Godot.Core.TileSet.tile_set_occluder_offset, Godot.Core.TileSet.tile_set_region, Godot.Core.TileSet.tile_set_shape, Godot.Core.TileSet.tile_set_shape_offset, Godot.Core.TileSet.tile_set_shape_one_way, Godot.Core.TileSet.tile_set_shape_one_way_margin, Godot.Core.TileSet.tile_set_shape_transform, Godot.Core.TileSet.tile_set_shapes, Godot.Core.TileSet.tile_set_texture, Godot.Core.TileSet.tile_set_texture_offset, Godot.Core.TileSet.tile_set_tile_mode, Godot.Core.TileSet.tile_set_z_index) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _BITMASK_2X2 :: Int _BITMASK_2X2 = 0 _BITMASK_3X3 :: Int _BITMASK_3X3 = 2 _BIND_BOTTOMLEFT :: Int _BIND_BOTTOMLEFT = 64 _BIND_CENTER :: Int _BIND_CENTER = 16 _BIND_LEFT :: Int _BIND_LEFT = 8 _ATLAS_TILE :: Int _ATLAS_TILE = 2 _BITMASK_3X3_MINIMAL :: Int _BITMASK_3X3_MINIMAL = 1 _BIND_RIGHT :: Int _BIND_RIGHT = 32 _BIND_TOPLEFT :: Int _BIND_TOPLEFT = 1 _BIND_BOTTOM :: Int _BIND_BOTTOM = 128 _BIND_BOTTOMRIGHT :: Int _BIND_BOTTOMRIGHT = 256 _AUTO_TILE :: Int _AUTO_TILE = 1 _BIND_TOP :: Int _BIND_TOP = 2 _BIND_TOPRIGHT :: Int _BIND_TOPRIGHT = 4 _SINGLE_TILE :: Int _SINGLE_TILE = 0 {-# NOINLINE bindTileSet__forward_atlas_subtile_selection #-} bindTileSet__forward_atlas_subtile_selection :: MethodBind bindTileSet__forward_atlas_subtile_selection = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "_forward_atlas_subtile_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _forward_atlas_subtile_selection :: (TileSet :< cls, Object :< cls) => cls -> Int -> Object -> Vector2 -> IO Vector2 _forward_atlas_subtile_selection cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet__forward_atlas_subtile_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "_forward_atlas_subtile_selection" '[Int, Object, Vector2] (IO Vector2) where nodeMethod = Godot.Core.TileSet._forward_atlas_subtile_selection {-# NOINLINE bindTileSet__forward_subtile_selection #-} bindTileSet__forward_subtile_selection :: MethodBind bindTileSet__forward_subtile_selection = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "_forward_subtile_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _forward_subtile_selection :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> Object -> Vector2 -> IO Vector2 _forward_subtile_selection cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet__forward_subtile_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "_forward_subtile_selection" '[Int, Int, Object, Vector2] (IO Vector2) where nodeMethod = Godot.Core.TileSet._forward_subtile_selection {-# NOINLINE bindTileSet__is_tile_bound #-} -- | Determines when the auto-tiler should consider two different auto-tile IDs to be bound together. -- __Note:__ @neighbor_id@ will be @-1@ (@TileMap.INVALID_CELL@) when checking a tile against an empty neighbor tile. bindTileSet__is_tile_bound :: MethodBind bindTileSet__is_tile_bound = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "_is_tile_bound" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines when the auto-tiler should consider two different auto-tile IDs to be bound together. -- __Note:__ @neighbor_id@ will be @-1@ (@TileMap.INVALID_CELL@) when checking a tile against an empty neighbor tile. _is_tile_bound :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool _is_tile_bound cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet__is_tile_bound (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "_is_tile_bound" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.TileSet._is_tile_bound {-# NOINLINE bindTileSet_autotile_clear_bitmask_map #-} -- | Clears all bitmask information of the autotile. bindTileSet_autotile_clear_bitmask_map :: MethodBind bindTileSet_autotile_clear_bitmask_map = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_clear_bitmask_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all bitmask information of the autotile. autotile_clear_bitmask_map :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO () autotile_clear_bitmask_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_clear_bitmask_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_clear_bitmask_map" '[Int] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_clear_bitmask_map {-# NOINLINE bindTileSet_autotile_get_bitmask #-} -- | Returns the bitmask of the subtile from an autotile given its coordinates. -- The value is the sum of the values in @enum AutotileBindings@ present in the subtile (e.g. a value of 5 means the bitmask has bindings in both the top left and top right). bindTileSet_autotile_get_bitmask :: MethodBind bindTileSet_autotile_get_bitmask = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_bitmask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the bitmask of the subtile from an autotile given its coordinates. -- The value is the sum of the values in @enum AutotileBindings@ present in the subtile (e.g. a value of 5 means the bitmask has bindings in both the top left and top right). autotile_get_bitmask :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO Int autotile_get_bitmask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_bitmask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_bitmask" '[Int, Vector2] (IO Int) where nodeMethod = Godot.Core.TileSet.autotile_get_bitmask {-# NOINLINE bindTileSet_autotile_get_bitmask_mode #-} -- | Returns the @enum BitmaskMode@ of the autotile. bindTileSet_autotile_get_bitmask_mode :: MethodBind bindTileSet_autotile_get_bitmask_mode = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_bitmask_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @enum BitmaskMode@ of the autotile. autotile_get_bitmask_mode :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Int autotile_get_bitmask_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_bitmask_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_bitmask_mode" '[Int] (IO Int) where nodeMethod = Godot.Core.TileSet.autotile_get_bitmask_mode {-# NOINLINE bindTileSet_autotile_get_icon_coordinate #-} -- | Returns the subtile that's being used as an icon in an atlas/autotile given its coordinates. -- The subtile defined as the icon will be used as a fallback when the atlas/autotile's bitmask information is incomplete. It will also be used to represent it in the TileSet editor. bindTileSet_autotile_get_icon_coordinate :: MethodBind bindTileSet_autotile_get_icon_coordinate = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_icon_coordinate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the subtile that's being used as an icon in an atlas/autotile given its coordinates. -- The subtile defined as the icon will be used as a fallback when the atlas/autotile's bitmask information is incomplete. It will also be used to represent it in the TileSet editor. autotile_get_icon_coordinate :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Vector2 autotile_get_icon_coordinate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_icon_coordinate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_icon_coordinate" '[Int] (IO Vector2) where nodeMethod = Godot.Core.TileSet.autotile_get_icon_coordinate {-# NOINLINE bindTileSet_autotile_get_light_occluder #-} -- | Returns the light occluder of the subtile from an atlas/autotile given its coordinates. bindTileSet_autotile_get_light_occluder :: MethodBind bindTileSet_autotile_get_light_occluder = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_light_occluder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the light occluder of the subtile from an atlas/autotile given its coordinates. autotile_get_light_occluder :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO OccluderPolygon2D autotile_get_light_occluder cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_light_occluder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_light_occluder" '[Int, Vector2] (IO OccluderPolygon2D) where nodeMethod = Godot.Core.TileSet.autotile_get_light_occluder {-# NOINLINE bindTileSet_autotile_get_navigation_polygon #-} -- | Returns the navigation polygon of the subtile from an atlas/autotile given its coordinates. bindTileSet_autotile_get_navigation_polygon :: MethodBind bindTileSet_autotile_get_navigation_polygon = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_navigation_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the navigation polygon of the subtile from an atlas/autotile given its coordinates. autotile_get_navigation_polygon :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO NavigationPolygon autotile_get_navigation_polygon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_navigation_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_navigation_polygon" '[Int, Vector2] (IO NavigationPolygon) where nodeMethod = Godot.Core.TileSet.autotile_get_navigation_polygon {-# NOINLINE bindTileSet_autotile_get_size #-} -- | Returns the size of the subtiles in an atlas/autotile. bindTileSet_autotile_get_size :: MethodBind bindTileSet_autotile_get_size = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of the subtiles in an atlas/autotile. autotile_get_size :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Vector2 autotile_get_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_size" '[Int] (IO Vector2) where nodeMethod = Godot.Core.TileSet.autotile_get_size {-# NOINLINE bindTileSet_autotile_get_spacing #-} -- | Returns the spacing between subtiles of the atlas/autotile. bindTileSet_autotile_get_spacing :: MethodBind bindTileSet_autotile_get_spacing = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_spacing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the spacing between subtiles of the atlas/autotile. autotile_get_spacing :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Int autotile_get_spacing cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_spacing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_spacing" '[Int] (IO Int) where nodeMethod = Godot.Core.TileSet.autotile_get_spacing {-# NOINLINE bindTileSet_autotile_get_subtile_priority #-} -- | Returns the priority of the subtile from an autotile given its coordinates. -- When more than one subtile has the same bitmask value, one of them will be picked randomly for drawing. Its priority will define how often it will be picked. bindTileSet_autotile_get_subtile_priority :: MethodBind bindTileSet_autotile_get_subtile_priority = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_subtile_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the priority of the subtile from an autotile given its coordinates. -- When more than one subtile has the same bitmask value, one of them will be picked randomly for drawing. Its priority will define how often it will be picked. autotile_get_subtile_priority :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO Int autotile_get_subtile_priority cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_subtile_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_subtile_priority" '[Int, Vector2] (IO Int) where nodeMethod = Godot.Core.TileSet.autotile_get_subtile_priority {-# NOINLINE bindTileSet_autotile_get_z_index #-} -- | Returns the drawing index of the subtile from an atlas/autotile given its coordinates. bindTileSet_autotile_get_z_index :: MethodBind bindTileSet_autotile_get_z_index = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_get_z_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the drawing index of the subtile from an atlas/autotile given its coordinates. autotile_get_z_index :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO Int autotile_get_z_index cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_get_z_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_get_z_index" '[Int, Vector2] (IO Int) where nodeMethod = Godot.Core.TileSet.autotile_get_z_index {-# NOINLINE bindTileSet_autotile_set_bitmask #-} -- | Sets the bitmask of the subtile from an autotile given its coordinates. -- The value is the sum of the values in @enum AutotileBindings@ present in the subtile (e.g. a value of 5 means the bitmask has bindings in both the top left and top right). bindTileSet_autotile_set_bitmask :: MethodBind bindTileSet_autotile_set_bitmask = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_bitmask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the bitmask of the subtile from an autotile given its coordinates. -- The value is the sum of the values in @enum AutotileBindings@ present in the subtile (e.g. a value of 5 means the bitmask has bindings in both the top left and top right). autotile_set_bitmask :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> Int -> IO () autotile_set_bitmask cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_bitmask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_bitmask" '[Int, Vector2, Int] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_bitmask {-# NOINLINE bindTileSet_autotile_set_bitmask_mode #-} -- | Sets the @enum BitmaskMode@ of the autotile. bindTileSet_autotile_set_bitmask_mode :: MethodBind bindTileSet_autotile_set_bitmask_mode = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_bitmask_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @enum BitmaskMode@ of the autotile. autotile_set_bitmask_mode :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO () autotile_set_bitmask_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_bitmask_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_bitmask_mode" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_bitmask_mode {-# NOINLINE bindTileSet_autotile_set_icon_coordinate #-} -- | Sets the subtile that will be used as an icon in an atlas/autotile given its coordinates. -- The subtile defined as the icon will be used as a fallback when the atlas/autotile's bitmask information is incomplete. It will also be used to represent it in the TileSet editor. bindTileSet_autotile_set_icon_coordinate :: MethodBind bindTileSet_autotile_set_icon_coordinate = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_icon_coordinate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the subtile that will be used as an icon in an atlas/autotile given its coordinates. -- The subtile defined as the icon will be used as a fallback when the atlas/autotile's bitmask information is incomplete. It will also be used to represent it in the TileSet editor. autotile_set_icon_coordinate :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () autotile_set_icon_coordinate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_icon_coordinate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_icon_coordinate" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_icon_coordinate {-# NOINLINE bindTileSet_autotile_set_light_occluder #-} -- | Sets the light occluder of the subtile from an atlas/autotile given its coordinates. bindTileSet_autotile_set_light_occluder :: MethodBind bindTileSet_autotile_set_light_occluder = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_light_occluder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the light occluder of the subtile from an atlas/autotile given its coordinates. autotile_set_light_occluder :: (TileSet :< cls, Object :< cls) => cls -> Int -> OccluderPolygon2D -> Vector2 -> IO () autotile_set_light_occluder cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_light_occluder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_light_occluder" '[Int, OccluderPolygon2D, Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_light_occluder {-# NOINLINE bindTileSet_autotile_set_navigation_polygon #-} -- | Sets the navigation polygon of the subtile from an atlas/autotile given its coordinates. bindTileSet_autotile_set_navigation_polygon :: MethodBind bindTileSet_autotile_set_navigation_polygon = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_navigation_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the navigation polygon of the subtile from an atlas/autotile given its coordinates. autotile_set_navigation_polygon :: (TileSet :< cls, Object :< cls) => cls -> Int -> NavigationPolygon -> Vector2 -> IO () autotile_set_navigation_polygon cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_navigation_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_navigation_polygon" '[Int, NavigationPolygon, Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_navigation_polygon {-# NOINLINE bindTileSet_autotile_set_size #-} -- | Sets the size of the subtiles in an atlas/autotile. bindTileSet_autotile_set_size :: MethodBind bindTileSet_autotile_set_size = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the subtiles in an atlas/autotile. autotile_set_size :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () autotile_set_size cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_size" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_size {-# NOINLINE bindTileSet_autotile_set_spacing #-} -- | Sets the spacing between subtiles of the atlas/autotile. bindTileSet_autotile_set_spacing :: MethodBind bindTileSet_autotile_set_spacing = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_spacing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the spacing between subtiles of the atlas/autotile. autotile_set_spacing :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO () autotile_set_spacing cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_spacing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_spacing" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_spacing {-# NOINLINE bindTileSet_autotile_set_subtile_priority #-} -- | Sets the priority of the subtile from an autotile given its coordinates. -- When more than one subtile has the same bitmask value, one of them will be picked randomly for drawing. Its priority will define how often it will be picked. bindTileSet_autotile_set_subtile_priority :: MethodBind bindTileSet_autotile_set_subtile_priority = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_subtile_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the priority of the subtile from an autotile given its coordinates. -- When more than one subtile has the same bitmask value, one of them will be picked randomly for drawing. Its priority will define how often it will be picked. autotile_set_subtile_priority :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> Int -> IO () autotile_set_subtile_priority cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_subtile_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_subtile_priority" '[Int, Vector2, Int] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_subtile_priority {-# NOINLINE bindTileSet_autotile_set_z_index #-} -- | Sets the drawing index of the subtile from an atlas/autotile given its coordinates. bindTileSet_autotile_set_z_index :: MethodBind bindTileSet_autotile_set_z_index = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "autotile_set_z_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the drawing index of the subtile from an atlas/autotile given its coordinates. autotile_set_z_index :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> Int -> IO () autotile_set_z_index cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_autotile_set_z_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "autotile_set_z_index" '[Int, Vector2, Int] (IO ()) where nodeMethod = Godot.Core.TileSet.autotile_set_z_index {-# NOINLINE bindTileSet_clear #-} -- | Clears all tiles. bindTileSet_clear :: MethodBind bindTileSet_clear = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears all tiles. clear :: (TileSet :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "clear" '[] (IO ()) where nodeMethod = Godot.Core.TileSet.clear {-# NOINLINE bindTileSet_create_tile #-} -- | Creates a new tile with the given ID. bindTileSet_create_tile :: MethodBind bindTileSet_create_tile = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "create_tile" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new tile with the given ID. create_tile :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO () create_tile cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_create_tile (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "create_tile" '[Int] (IO ()) where nodeMethod = Godot.Core.TileSet.create_tile {-# NOINLINE bindTileSet_find_tile_by_name #-} -- | Returns the first tile matching the given name. bindTileSet_find_tile_by_name :: MethodBind bindTileSet_find_tile_by_name = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "find_tile_by_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the first tile matching the given name. find_tile_by_name :: (TileSet :< cls, Object :< cls) => cls -> GodotString -> IO Int find_tile_by_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_find_tile_by_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "find_tile_by_name" '[GodotString] (IO Int) where nodeMethod = Godot.Core.TileSet.find_tile_by_name {-# NOINLINE bindTileSet_get_last_unused_tile_id #-} -- | Returns the ID following the last currently used ID, useful when creating a new tile. bindTileSet_get_last_unused_tile_id :: MethodBind bindTileSet_get_last_unused_tile_id = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "get_last_unused_tile_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the ID following the last currently used ID, useful when creating a new tile. get_last_unused_tile_id :: (TileSet :< cls, Object :< cls) => cls -> IO Int get_last_unused_tile_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_get_last_unused_tile_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "get_last_unused_tile_id" '[] (IO Int) where nodeMethod = Godot.Core.TileSet.get_last_unused_tile_id {-# NOINLINE bindTileSet_get_tiles_ids #-} -- | Returns an array of all currently used tile IDs. bindTileSet_get_tiles_ids :: MethodBind bindTileSet_get_tiles_ids = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "get_tiles_ids" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of all currently used tile IDs. get_tiles_ids :: (TileSet :< cls, Object :< cls) => cls -> IO Array get_tiles_ids cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_get_tiles_ids (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "get_tiles_ids" '[] (IO Array) where nodeMethod = Godot.Core.TileSet.get_tiles_ids {-# NOINLINE bindTileSet_remove_tile #-} -- | Removes the given tile ID. bindTileSet_remove_tile :: MethodBind bindTileSet_remove_tile = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "remove_tile" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the given tile ID. remove_tile :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO () remove_tile cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_remove_tile (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "remove_tile" '[Int] (IO ()) where nodeMethod = Godot.Core.TileSet.remove_tile {-# NOINLINE bindTileSet_tile_add_shape #-} -- | Adds a shape to the tile. bindTileSet_tile_add_shape :: MethodBind bindTileSet_tile_add_shape = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_add_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a shape to the tile. tile_add_shape :: (TileSet :< cls, Object :< cls) => cls -> Int -> Shape2D -> Transform2d -> Maybe Bool -> Maybe Vector2 -> IO () tile_add_shape cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantBool False) toVariant arg4, defaultedVariant VariantVector2 (V2 0 0) arg5] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_add_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_add_shape" '[Int, Shape2D, Transform2d, Maybe Bool, Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_add_shape {-# NOINLINE bindTileSet_tile_get_light_occluder #-} -- | Returns the tile's light occluder. bindTileSet_tile_get_light_occluder :: MethodBind bindTileSet_tile_get_light_occluder = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_light_occluder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile's light occluder. tile_get_light_occluder :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO OccluderPolygon2D tile_get_light_occluder cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_light_occluder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_light_occluder" '[Int] (IO OccluderPolygon2D) where nodeMethod = Godot.Core.TileSet.tile_get_light_occluder {-# NOINLINE bindTileSet_tile_get_material #-} -- | Returns the tile's material. bindTileSet_tile_get_material :: MethodBind bindTileSet_tile_get_material = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile's material. tile_get_material :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO ShaderMaterial tile_get_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_material" '[Int] (IO ShaderMaterial) where nodeMethod = Godot.Core.TileSet.tile_get_material {-# NOINLINE bindTileSet_tile_get_modulate #-} -- | Returns the tile's modulation color. bindTileSet_tile_get_modulate :: MethodBind bindTileSet_tile_get_modulate = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile's modulation color. tile_get_modulate :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Color tile_get_modulate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_modulate" '[Int] (IO Color) where nodeMethod = Godot.Core.TileSet.tile_get_modulate {-# NOINLINE bindTileSet_tile_get_name #-} -- | Returns the tile's name. bindTileSet_tile_get_name :: MethodBind bindTileSet_tile_get_name = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile's name. tile_get_name :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO GodotString tile_get_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.TileSet.tile_get_name {-# NOINLINE bindTileSet_tile_get_navigation_polygon #-} -- | Returns the navigation polygon of the tile. bindTileSet_tile_get_navigation_polygon :: MethodBind bindTileSet_tile_get_navigation_polygon = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_navigation_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the navigation polygon of the tile. tile_get_navigation_polygon :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO NavigationPolygon tile_get_navigation_polygon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_navigation_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_navigation_polygon" '[Int] (IO NavigationPolygon) where nodeMethod = Godot.Core.TileSet.tile_get_navigation_polygon {-# NOINLINE bindTileSet_tile_get_navigation_polygon_offset #-} -- | Returns the offset of the tile's navigation polygon. bindTileSet_tile_get_navigation_polygon_offset :: MethodBind bindTileSet_tile_get_navigation_polygon_offset = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_navigation_polygon_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the offset of the tile's navigation polygon. tile_get_navigation_polygon_offset :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Vector2 tile_get_navigation_polygon_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_navigation_polygon_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_navigation_polygon_offset" '[Int] (IO Vector2) where nodeMethod = Godot.Core.TileSet.tile_get_navigation_polygon_offset {-# NOINLINE bindTileSet_tile_get_normal_map #-} -- | Returns the tile's normal map texture. bindTileSet_tile_get_normal_map :: MethodBind bindTileSet_tile_get_normal_map = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile's normal map texture. tile_get_normal_map :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Texture tile_get_normal_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_normal_map" '[Int] (IO Texture) where nodeMethod = Godot.Core.TileSet.tile_get_normal_map {-# NOINLINE bindTileSet_tile_get_occluder_offset #-} -- | Returns the offset of the tile's light occluder. bindTileSet_tile_get_occluder_offset :: MethodBind bindTileSet_tile_get_occluder_offset = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_occluder_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the offset of the tile's light occluder. tile_get_occluder_offset :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Vector2 tile_get_occluder_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_occluder_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_occluder_offset" '[Int] (IO Vector2) where nodeMethod = Godot.Core.TileSet.tile_get_occluder_offset {-# NOINLINE bindTileSet_tile_get_region #-} -- | Returns the tile sub-region in the texture. bindTileSet_tile_get_region :: MethodBind bindTileSet_tile_get_region = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile sub-region in the texture. tile_get_region :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Rect2 tile_get_region cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_region" '[Int] (IO Rect2) where nodeMethod = Godot.Core.TileSet.tile_get_region {-# NOINLINE bindTileSet_tile_get_shape #-} -- | Returns a tile's given shape. bindTileSet_tile_get_shape :: MethodBind bindTileSet_tile_get_shape = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a tile's given shape. tile_get_shape :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO Shape2D tile_get_shape cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_shape" '[Int, Int] (IO Shape2D) where nodeMethod = Godot.Core.TileSet.tile_get_shape {-# NOINLINE bindTileSet_tile_get_shape_count #-} -- | Returns the number of shapes assigned to a tile. bindTileSet_tile_get_shape_count :: MethodBind bindTileSet_tile_get_shape_count = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of shapes assigned to a tile. tile_get_shape_count :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Int tile_get_shape_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_shape_count" '[Int] (IO Int) where nodeMethod = Godot.Core.TileSet.tile_get_shape_count {-# NOINLINE bindTileSet_tile_get_shape_offset #-} -- | Returns the offset of a tile's shape. bindTileSet_tile_get_shape_offset :: MethodBind bindTileSet_tile_get_shape_offset = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_shape_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the offset of a tile's shape. tile_get_shape_offset :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO Vector2 tile_get_shape_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_shape_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_shape_offset" '[Int, Int] (IO Vector2) where nodeMethod = Godot.Core.TileSet.tile_get_shape_offset {-# NOINLINE bindTileSet_tile_get_shape_one_way #-} -- | Returns the one-way collision value of a tile's shape. bindTileSet_tile_get_shape_one_way :: MethodBind bindTileSet_tile_get_shape_one_way = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_shape_one_way" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the one-way collision value of a tile's shape. tile_get_shape_one_way :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool tile_get_shape_one_way cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_shape_one_way (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_shape_one_way" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.TileSet.tile_get_shape_one_way {-# NOINLINE bindTileSet_tile_get_shape_one_way_margin #-} bindTileSet_tile_get_shape_one_way_margin :: MethodBind bindTileSet_tile_get_shape_one_way_margin = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_shape_one_way_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr tile_get_shape_one_way_margin :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO Float tile_get_shape_one_way_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_shape_one_way_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_shape_one_way_margin" '[Int, Int] (IO Float) where nodeMethod = Godot.Core.TileSet.tile_get_shape_one_way_margin {-# NOINLINE bindTileSet_tile_get_shape_transform #-} -- | Returns the @Transform2D@ of a tile's shape. bindTileSet_tile_get_shape_transform :: MethodBind bindTileSet_tile_get_shape_transform = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Transform2D@ of a tile's shape. tile_get_shape_transform :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO Transform2d tile_get_shape_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_shape_transform" '[Int, Int] (IO Transform2d) where nodeMethod = Godot.Core.TileSet.tile_get_shape_transform {-# NOINLINE bindTileSet_tile_get_shapes #-} -- | Returns an array of dictionaries describing the tile's shapes. -- __Dictionary structure in the array returned by this method:__ -- -- @ -- -- { -- "autotile_coord": Vector2, -- "one_way": bool, -- "one_way_margin": int, -- "shape": CollisionShape2D, -- "shape_transform": Transform2D, -- } -- -- @ bindTileSet_tile_get_shapes :: MethodBind bindTileSet_tile_get_shapes = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of dictionaries describing the tile's shapes. -- __Dictionary structure in the array returned by this method:__ -- -- @ -- -- { -- "autotile_coord": Vector2, -- "one_way": bool, -- "one_way_margin": int, -- "shape": CollisionShape2D, -- "shape_transform": Transform2D, -- } -- -- @ tile_get_shapes :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Array tile_get_shapes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_shapes" '[Int] (IO Array) where nodeMethod = Godot.Core.TileSet.tile_get_shapes {-# NOINLINE bindTileSet_tile_get_texture #-} -- | Returns the tile's texture. bindTileSet_tile_get_texture :: MethodBind bindTileSet_tile_get_texture = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile's texture. tile_get_texture :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Texture tile_get_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_texture" '[Int] (IO Texture) where nodeMethod = Godot.Core.TileSet.tile_get_texture {-# NOINLINE bindTileSet_tile_get_texture_offset #-} -- | Returns the texture offset of the tile. bindTileSet_tile_get_texture_offset :: MethodBind bindTileSet_tile_get_texture_offset = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_texture_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the texture offset of the tile. tile_get_texture_offset :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Vector2 tile_get_texture_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_texture_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_texture_offset" '[Int] (IO Vector2) where nodeMethod = Godot.Core.TileSet.tile_get_texture_offset {-# NOINLINE bindTileSet_tile_get_tile_mode #-} -- | Returns the tile's @enum TileMode@. bindTileSet_tile_get_tile_mode :: MethodBind bindTileSet_tile_get_tile_mode = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_tile_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile's @enum TileMode@. tile_get_tile_mode :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Int tile_get_tile_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_tile_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_tile_mode" '[Int] (IO Int) where nodeMethod = Godot.Core.TileSet.tile_get_tile_mode {-# NOINLINE bindTileSet_tile_get_z_index #-} -- | Returns the tile's Z index (drawing layer). bindTileSet_tile_get_z_index :: MethodBind bindTileSet_tile_get_z_index = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_get_z_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tile's Z index (drawing layer). tile_get_z_index :: (TileSet :< cls, Object :< cls) => cls -> Int -> IO Int tile_get_z_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_get_z_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_get_z_index" '[Int] (IO Int) where nodeMethod = Godot.Core.TileSet.tile_get_z_index {-# NOINLINE bindTileSet_tile_set_light_occluder #-} -- | Sets a light occluder for the tile. bindTileSet_tile_set_light_occluder :: MethodBind bindTileSet_tile_set_light_occluder = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_light_occluder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a light occluder for the tile. tile_set_light_occluder :: (TileSet :< cls, Object :< cls) => cls -> Int -> OccluderPolygon2D -> IO () tile_set_light_occluder cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_light_occluder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_light_occluder" '[Int, OccluderPolygon2D] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_light_occluder {-# NOINLINE bindTileSet_tile_set_material #-} -- | Sets the tile's material. bindTileSet_tile_set_material :: MethodBind bindTileSet_tile_set_material = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's material. tile_set_material :: (TileSet :< cls, Object :< cls) => cls -> Int -> ShaderMaterial -> IO () tile_set_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_material" '[Int, ShaderMaterial] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_material {-# NOINLINE bindTileSet_tile_set_modulate #-} -- | Sets the tile's modulation color. bindTileSet_tile_set_modulate :: MethodBind bindTileSet_tile_set_modulate = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's modulation color. tile_set_modulate :: (TileSet :< cls, Object :< cls) => cls -> Int -> Color -> IO () tile_set_modulate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_modulate" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_modulate {-# NOINLINE bindTileSet_tile_set_name #-} -- | Sets the tile's name. bindTileSet_tile_set_name :: MethodBind bindTileSet_tile_set_name = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's name. tile_set_name :: (TileSet :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () tile_set_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_name" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_name {-# NOINLINE bindTileSet_tile_set_navigation_polygon #-} -- | Sets the tile's navigation polygon. bindTileSet_tile_set_navigation_polygon :: MethodBind bindTileSet_tile_set_navigation_polygon = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_navigation_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's navigation polygon. tile_set_navigation_polygon :: (TileSet :< cls, Object :< cls) => cls -> Int -> NavigationPolygon -> IO () tile_set_navigation_polygon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_navigation_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_navigation_polygon" '[Int, NavigationPolygon] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_navigation_polygon {-# NOINLINE bindTileSet_tile_set_navigation_polygon_offset #-} -- | Sets an offset for the tile's navigation polygon. bindTileSet_tile_set_navigation_polygon_offset :: MethodBind bindTileSet_tile_set_navigation_polygon_offset = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_navigation_polygon_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an offset for the tile's navigation polygon. tile_set_navigation_polygon_offset :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () tile_set_navigation_polygon_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_navigation_polygon_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_navigation_polygon_offset" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_navigation_polygon_offset {-# NOINLINE bindTileSet_tile_set_normal_map #-} -- | Sets the tile's normal map texture. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. bindTileSet_tile_set_normal_map :: MethodBind bindTileSet_tile_set_normal_map = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_normal_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's normal map texture. -- __Note:__ Godot expects the normal map to use X+, Y-, and Z+ coordinates. See @url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates@this page@/url@ for a comparison of normal map coordinates expected by popular engines. tile_set_normal_map :: (TileSet :< cls, Object :< cls) => cls -> Int -> Texture -> IO () tile_set_normal_map cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_normal_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_normal_map" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_normal_map {-# NOINLINE bindTileSet_tile_set_occluder_offset #-} -- | Sets an offset for the tile's light occluder. bindTileSet_tile_set_occluder_offset :: MethodBind bindTileSet_tile_set_occluder_offset = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_occluder_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an offset for the tile's light occluder. tile_set_occluder_offset :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () tile_set_occluder_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_occluder_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_occluder_offset" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_occluder_offset {-# NOINLINE bindTileSet_tile_set_region #-} -- | Sets the tile's sub-region in the texture. This is common in texture atlases. bindTileSet_tile_set_region :: MethodBind bindTileSet_tile_set_region = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's sub-region in the texture. This is common in texture atlases. tile_set_region :: (TileSet :< cls, Object :< cls) => cls -> Int -> Rect2 -> IO () tile_set_region cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_region" '[Int, Rect2] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_region {-# NOINLINE bindTileSet_tile_set_shape #-} -- | Sets a shape for the tile, enabling collision. bindTileSet_tile_set_shape :: MethodBind bindTileSet_tile_set_shape = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a shape for the tile, enabling collision. tile_set_shape :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> Shape2D -> IO () tile_set_shape cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_shape" '[Int, Int, Shape2D] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_shape {-# NOINLINE bindTileSet_tile_set_shape_offset #-} -- | Sets the offset of a tile's shape. bindTileSet_tile_set_shape_offset :: MethodBind bindTileSet_tile_set_shape_offset = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_shape_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the offset of a tile's shape. tile_set_shape_offset :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> Vector2 -> IO () tile_set_shape_offset cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_shape_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_shape_offset" '[Int, Int, Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_shape_offset {-# NOINLINE bindTileSet_tile_set_shape_one_way #-} -- | Enables one-way collision on a tile's shape. bindTileSet_tile_set_shape_one_way :: MethodBind bindTileSet_tile_set_shape_one_way = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_shape_one_way" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables one-way collision on a tile's shape. tile_set_shape_one_way :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> Bool -> IO () tile_set_shape_one_way cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_shape_one_way (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_shape_one_way" '[Int, Int, Bool] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_shape_one_way {-# NOINLINE bindTileSet_tile_set_shape_one_way_margin #-} bindTileSet_tile_set_shape_one_way_margin :: MethodBind bindTileSet_tile_set_shape_one_way_margin = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_shape_one_way_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr tile_set_shape_one_way_margin :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> Float -> IO () tile_set_shape_one_way_margin cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_shape_one_way_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_shape_one_way_margin" '[Int, Int, Float] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_shape_one_way_margin {-# NOINLINE bindTileSet_tile_set_shape_transform #-} -- | Sets a @Transform2D@ on a tile's shape. bindTileSet_tile_set_shape_transform :: MethodBind bindTileSet_tile_set_shape_transform = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_shape_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a @Transform2D@ on a tile's shape. tile_set_shape_transform :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> Transform2d -> IO () tile_set_shape_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_shape_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_shape_transform" '[Int, Int, Transform2d] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_shape_transform {-# NOINLINE bindTileSet_tile_set_shapes #-} -- | Sets an array of shapes for the tile, enabling collision. bindTileSet_tile_set_shapes :: MethodBind bindTileSet_tile_set_shapes = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_shapes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an array of shapes for the tile, enabling collision. tile_set_shapes :: (TileSet :< cls, Object :< cls) => cls -> Int -> Array -> IO () tile_set_shapes cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_shapes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_shapes" '[Int, Array] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_shapes {-# NOINLINE bindTileSet_tile_set_texture #-} -- | Sets the tile's texture. bindTileSet_tile_set_texture :: MethodBind bindTileSet_tile_set_texture = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's texture. tile_set_texture :: (TileSet :< cls, Object :< cls) => cls -> Int -> Texture -> IO () tile_set_texture cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_texture" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_texture {-# NOINLINE bindTileSet_tile_set_texture_offset #-} -- | Sets the tile's texture offset. bindTileSet_tile_set_texture_offset :: MethodBind bindTileSet_tile_set_texture_offset = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_texture_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's texture offset. tile_set_texture_offset :: (TileSet :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () tile_set_texture_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_texture_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_texture_offset" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_texture_offset {-# NOINLINE bindTileSet_tile_set_tile_mode #-} -- | Sets the tile's @enum TileMode@. bindTileSet_tile_set_tile_mode :: MethodBind bindTileSet_tile_set_tile_mode = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_tile_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's @enum TileMode@. tile_set_tile_mode :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO () tile_set_tile_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_tile_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_tile_mode" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_tile_mode {-# NOINLINE bindTileSet_tile_set_z_index #-} -- | Sets the tile's drawing index. bindTileSet_tile_set_z_index :: MethodBind bindTileSet_tile_set_z_index = unsafePerformIO $ withCString "TileSet" $ \ clsNamePtr -> withCString "tile_set_z_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tile's drawing index. tile_set_z_index :: (TileSet :< cls, Object :< cls) => cls -> Int -> Int -> IO () tile_set_z_index cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTileSet_tile_set_z_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TileSet "tile_set_z_index" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TileSet.tile_set_z_index ================================================ FILE: src/Godot/Core/Timer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Timer (Godot.Core.Timer._TIMER_PROCESS_PHYSICS, Godot.Core.Timer._TIMER_PROCESS_IDLE, Godot.Core.Timer.sig_timeout, Godot.Core.Timer.get_time_left, Godot.Core.Timer.get_timer_process_mode, Godot.Core.Timer.get_wait_time, Godot.Core.Timer.has_autostart, Godot.Core.Timer.is_one_shot, Godot.Core.Timer.is_paused, Godot.Core.Timer.is_stopped, Godot.Core.Timer.set_autostart, Godot.Core.Timer.set_one_shot, Godot.Core.Timer.set_paused, Godot.Core.Timer.set_timer_process_mode, Godot.Core.Timer.set_wait_time, Godot.Core.Timer.start, Godot.Core.Timer.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _TIMER_PROCESS_PHYSICS :: Int _TIMER_PROCESS_PHYSICS = 0 _TIMER_PROCESS_IDLE :: Int _TIMER_PROCESS_IDLE = 1 -- | Emitted when the timer reaches 0. sig_timeout :: Godot.Internal.Dispatch.Signal Timer sig_timeout = Godot.Internal.Dispatch.Signal "timeout" instance NodeSignal Timer "timeout" '[] instance NodeProperty Timer "autostart" Bool 'False where nodeProperty = (has_autostart, wrapDroppingSetter set_autostart, Nothing) instance NodeProperty Timer "one_shot" Bool 'False where nodeProperty = (is_one_shot, wrapDroppingSetter set_one_shot, Nothing) instance NodeProperty Timer "paused" Bool 'False where nodeProperty = (is_paused, wrapDroppingSetter set_paused, Nothing) instance NodeProperty Timer "process_mode" Int 'False where nodeProperty = (get_timer_process_mode, wrapDroppingSetter set_timer_process_mode, Nothing) instance NodeProperty Timer "time_left" Float 'True where nodeProperty = (get_time_left, (), Nothing) instance NodeProperty Timer "wait_time" Float 'False where nodeProperty = (get_wait_time, wrapDroppingSetter set_wait_time, Nothing) {-# NOINLINE bindTimer_get_time_left #-} -- | The timer's remaining time in seconds. Returns 0 if the timer is inactive. -- __Note:__ You cannot set this value. To change the timer's remaining time, use @method start@. bindTimer_get_time_left :: MethodBind bindTimer_get_time_left = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "get_time_left" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The timer's remaining time in seconds. Returns 0 if the timer is inactive. -- __Note:__ You cannot set this value. To change the timer's remaining time, use @method start@. get_time_left :: (Timer :< cls, Object :< cls) => cls -> IO Float get_time_left cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_get_time_left (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "get_time_left" '[] (IO Float) where nodeMethod = Godot.Core.Timer.get_time_left {-# NOINLINE bindTimer_get_timer_process_mode #-} -- | Processing mode. See @enum TimerProcessMode@. bindTimer_get_timer_process_mode :: MethodBind bindTimer_get_timer_process_mode = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "get_timer_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Processing mode. See @enum TimerProcessMode@. get_timer_process_mode :: (Timer :< cls, Object :< cls) => cls -> IO Int get_timer_process_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_get_timer_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "get_timer_process_mode" '[] (IO Int) where nodeMethod = Godot.Core.Timer.get_timer_process_mode {-# NOINLINE bindTimer_get_wait_time #-} -- | Wait time in seconds. bindTimer_get_wait_time :: MethodBind bindTimer_get_wait_time = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "get_wait_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Wait time in seconds. get_wait_time :: (Timer :< cls, Object :< cls) => cls -> IO Float get_wait_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_get_wait_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "get_wait_time" '[] (IO Float) where nodeMethod = Godot.Core.Timer.get_wait_time {-# NOINLINE bindTimer_has_autostart #-} -- | If @true@, the timer will automatically start when entering the scene tree. -- __Note:__ This property is automatically set to @false@ after the timer enters the scene tree and starts. bindTimer_has_autostart :: MethodBind bindTimer_has_autostart = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "has_autostart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the timer will automatically start when entering the scene tree. -- __Note:__ This property is automatically set to @false@ after the timer enters the scene tree and starts. has_autostart :: (Timer :< cls, Object :< cls) => cls -> IO Bool has_autostart cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_has_autostart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "has_autostart" '[] (IO Bool) where nodeMethod = Godot.Core.Timer.has_autostart {-# NOINLINE bindTimer_is_one_shot #-} -- | If @true@, the timer will stop when reaching 0. If @false@, it will restart. bindTimer_is_one_shot :: MethodBind bindTimer_is_one_shot = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "is_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the timer will stop when reaching 0. If @false@, it will restart. is_one_shot :: (Timer :< cls, Object :< cls) => cls -> IO Bool is_one_shot cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_is_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "is_one_shot" '[] (IO Bool) where nodeMethod = Godot.Core.Timer.is_one_shot {-# NOINLINE bindTimer_is_paused #-} -- | If @true@, the timer is paused and will not process until it is unpaused again, even if @method start@ is called. bindTimer_is_paused :: MethodBind bindTimer_is_paused = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "is_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the timer is paused and will not process until it is unpaused again, even if @method start@ is called. is_paused :: (Timer :< cls, Object :< cls) => cls -> IO Bool is_paused cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_is_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "is_paused" '[] (IO Bool) where nodeMethod = Godot.Core.Timer.is_paused {-# NOINLINE bindTimer_is_stopped #-} -- | Returns @true@ if the timer is stopped. bindTimer_is_stopped :: MethodBind bindTimer_is_stopped = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "is_stopped" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the timer is stopped. is_stopped :: (Timer :< cls, Object :< cls) => cls -> IO Bool is_stopped cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_is_stopped (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "is_stopped" '[] (IO Bool) where nodeMethod = Godot.Core.Timer.is_stopped {-# NOINLINE bindTimer_set_autostart #-} -- | If @true@, the timer will automatically start when entering the scene tree. -- __Note:__ This property is automatically set to @false@ after the timer enters the scene tree and starts. bindTimer_set_autostart :: MethodBind bindTimer_set_autostart = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "set_autostart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the timer will automatically start when entering the scene tree. -- __Note:__ This property is automatically set to @false@ after the timer enters the scene tree and starts. set_autostart :: (Timer :< cls, Object :< cls) => cls -> Bool -> IO () set_autostart cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_set_autostart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "set_autostart" '[Bool] (IO ()) where nodeMethod = Godot.Core.Timer.set_autostart {-# NOINLINE bindTimer_set_one_shot #-} -- | If @true@, the timer will stop when reaching 0. If @false@, it will restart. bindTimer_set_one_shot :: MethodBind bindTimer_set_one_shot = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "set_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the timer will stop when reaching 0. If @false@, it will restart. set_one_shot :: (Timer :< cls, Object :< cls) => cls -> Bool -> IO () set_one_shot cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_set_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "set_one_shot" '[Bool] (IO ()) where nodeMethod = Godot.Core.Timer.set_one_shot {-# NOINLINE bindTimer_set_paused #-} -- | If @true@, the timer is paused and will not process until it is unpaused again, even if @method start@ is called. bindTimer_set_paused :: MethodBind bindTimer_set_paused = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "set_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the timer is paused and will not process until it is unpaused again, even if @method start@ is called. set_paused :: (Timer :< cls, Object :< cls) => cls -> Bool -> IO () set_paused cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_set_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "set_paused" '[Bool] (IO ()) where nodeMethod = Godot.Core.Timer.set_paused {-# NOINLINE bindTimer_set_timer_process_mode #-} -- | Processing mode. See @enum TimerProcessMode@. bindTimer_set_timer_process_mode :: MethodBind bindTimer_set_timer_process_mode = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "set_timer_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Processing mode. See @enum TimerProcessMode@. set_timer_process_mode :: (Timer :< cls, Object :< cls) => cls -> Int -> IO () set_timer_process_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_set_timer_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "set_timer_process_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Timer.set_timer_process_mode {-# NOINLINE bindTimer_set_wait_time #-} -- | Wait time in seconds. bindTimer_set_wait_time :: MethodBind bindTimer_set_wait_time = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "set_wait_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Wait time in seconds. set_wait_time :: (Timer :< cls, Object :< cls) => cls -> Float -> IO () set_wait_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_set_wait_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "set_wait_time" '[Float] (IO ()) where nodeMethod = Godot.Core.Timer.set_wait_time {-# NOINLINE bindTimer_start #-} -- | Starts the timer. Sets @wait_time@ to @time_sec@ if @time_sec > 0@. This also resets the remaining time to @wait_time@. -- __Note:__ this method will not resume a paused timer. See @paused@. bindTimer_start :: MethodBind bindTimer_start = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts the timer. Sets @wait_time@ to @time_sec@ if @time_sec > 0@. This also resets the remaining time to @wait_time@. -- __Note:__ this method will not resume a paused timer. See @paused@. start :: (Timer :< cls, Object :< cls) => cls -> Maybe Float -> IO () start cls arg1 = withVariantArray [maybe (VariantReal (-1)) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "start" '[Maybe Float] (IO ()) where nodeMethod = Godot.Core.Timer.start {-# NOINLINE bindTimer_stop #-} -- | Stops the timer. bindTimer_stop :: MethodBind bindTimer_stop = unsafePerformIO $ withCString "Timer" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the timer. stop :: (Timer :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTimer_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Timer "stop" '[] (IO ()) where nodeMethod = Godot.Core.Timer.stop ================================================ FILE: src/Godot/Core/ToolButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ToolButton () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Button() ================================================ FILE: src/Godot/Core/TouchScreenButton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TouchScreenButton (Godot.Core.TouchScreenButton._VISIBILITY_ALWAYS, Godot.Core.TouchScreenButton._VISIBILITY_TOUCHSCREEN_ONLY, Godot.Core.TouchScreenButton.sig_pressed, Godot.Core.TouchScreenButton.sig_released, Godot.Core.TouchScreenButton._input, Godot.Core.TouchScreenButton.get_action, Godot.Core.TouchScreenButton.get_bitmask, Godot.Core.TouchScreenButton.get_shape, Godot.Core.TouchScreenButton.get_texture, Godot.Core.TouchScreenButton.get_texture_pressed, Godot.Core.TouchScreenButton.get_visibility_mode, Godot.Core.TouchScreenButton.is_passby_press_enabled, Godot.Core.TouchScreenButton.is_pressed, Godot.Core.TouchScreenButton.is_shape_centered, Godot.Core.TouchScreenButton.is_shape_visible, Godot.Core.TouchScreenButton.set_action, Godot.Core.TouchScreenButton.set_bitmask, Godot.Core.TouchScreenButton.set_passby_press, Godot.Core.TouchScreenButton.set_shape, Godot.Core.TouchScreenButton.set_shape_centered, Godot.Core.TouchScreenButton.set_shape_visible, Godot.Core.TouchScreenButton.set_texture, Godot.Core.TouchScreenButton.set_texture_pressed, Godot.Core.TouchScreenButton.set_visibility_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() _VISIBILITY_ALWAYS :: Int _VISIBILITY_ALWAYS = 0 _VISIBILITY_TOUCHSCREEN_ONLY :: Int _VISIBILITY_TOUCHSCREEN_ONLY = 1 -- | Emitted when the button is pressed (down). sig_pressed :: Godot.Internal.Dispatch.Signal TouchScreenButton sig_pressed = Godot.Internal.Dispatch.Signal "pressed" instance NodeSignal TouchScreenButton "pressed" '[] -- | Emitted when the button is released (up). sig_released :: Godot.Internal.Dispatch.Signal TouchScreenButton sig_released = Godot.Internal.Dispatch.Signal "released" instance NodeSignal TouchScreenButton "released" '[] instance NodeProperty TouchScreenButton "action" GodotString 'False where nodeProperty = (get_action, wrapDroppingSetter set_action, Nothing) instance NodeProperty TouchScreenButton "bitmask" BitMap 'False where nodeProperty = (get_bitmask, wrapDroppingSetter set_bitmask, Nothing) instance NodeProperty TouchScreenButton "normal" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) instance NodeProperty TouchScreenButton "passby_press" Bool 'False where nodeProperty = (is_passby_press_enabled, wrapDroppingSetter set_passby_press, Nothing) instance NodeProperty TouchScreenButton "pressed" Texture 'False where nodeProperty = (get_texture_pressed, wrapDroppingSetter set_texture_pressed, Nothing) instance NodeProperty TouchScreenButton "shape" Shape2D 'False where nodeProperty = (get_shape, wrapDroppingSetter set_shape, Nothing) instance NodeProperty TouchScreenButton "shape_centered" Bool 'False where nodeProperty = (is_shape_centered, wrapDroppingSetter set_shape_centered, Nothing) instance NodeProperty TouchScreenButton "shape_visible" Bool 'False where nodeProperty = (is_shape_visible, wrapDroppingSetter set_shape_visible, Nothing) instance NodeProperty TouchScreenButton "visibility_mode" Int 'False where nodeProperty = (get_visibility_mode, wrapDroppingSetter set_visibility_mode, Nothing) {-# NOINLINE bindTouchScreenButton__input #-} bindTouchScreenButton__input :: MethodBind bindTouchScreenButton__input = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _input :: (TouchScreenButton :< cls, Object :< cls) => cls -> InputEvent -> IO () _input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton__input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton._input {-# NOINLINE bindTouchScreenButton_get_action #-} -- | The button's action. Actions can be handled with @InputEventAction@. bindTouchScreenButton_get_action :: MethodBind bindTouchScreenButton_get_action = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "get_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's action. Actions can be handled with @InputEventAction@. get_action :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO GodotString get_action cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_get_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "get_action" '[] (IO GodotString) where nodeMethod = Godot.Core.TouchScreenButton.get_action {-# NOINLINE bindTouchScreenButton_get_bitmask #-} -- | The button's bitmask. bindTouchScreenButton_get_bitmask :: MethodBind bindTouchScreenButton_get_bitmask = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "get_bitmask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's bitmask. get_bitmask :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO BitMap get_bitmask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_get_bitmask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "get_bitmask" '[] (IO BitMap) where nodeMethod = Godot.Core.TouchScreenButton.get_bitmask {-# NOINLINE bindTouchScreenButton_get_shape #-} -- | The button's shape. bindTouchScreenButton_get_shape :: MethodBind bindTouchScreenButton_get_shape = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "get_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's shape. get_shape :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO Shape2D get_shape cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_get_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "get_shape" '[] (IO Shape2D) where nodeMethod = Godot.Core.TouchScreenButton.get_shape {-# NOINLINE bindTouchScreenButton_get_texture #-} -- | The button's texture for the normal state. bindTouchScreenButton_get_texture :: MethodBind bindTouchScreenButton_get_texture = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's texture for the normal state. get_texture :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.TouchScreenButton.get_texture {-# NOINLINE bindTouchScreenButton_get_texture_pressed #-} -- | The button's texture for the pressed state. bindTouchScreenButton_get_texture_pressed :: MethodBind bindTouchScreenButton_get_texture_pressed = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "get_texture_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's texture for the pressed state. get_texture_pressed :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO Texture get_texture_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_get_texture_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "get_texture_pressed" '[] (IO Texture) where nodeMethod = Godot.Core.TouchScreenButton.get_texture_pressed {-# NOINLINE bindTouchScreenButton_get_visibility_mode #-} -- | The button's visibility mode. See @enum VisibilityMode@ for possible values. bindTouchScreenButton_get_visibility_mode :: MethodBind bindTouchScreenButton_get_visibility_mode = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "get_visibility_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's visibility mode. See @enum VisibilityMode@ for possible values. get_visibility_mode :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO Int get_visibility_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_get_visibility_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "get_visibility_mode" '[] (IO Int) where nodeMethod = Godot.Core.TouchScreenButton.get_visibility_mode {-# NOINLINE bindTouchScreenButton_is_passby_press_enabled #-} -- | If @true@, pass-by presses are enabled. bindTouchScreenButton_is_passby_press_enabled :: MethodBind bindTouchScreenButton_is_passby_press_enabled = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "is_passby_press_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, pass-by presses are enabled. is_passby_press_enabled :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO Bool is_passby_press_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_is_passby_press_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "is_passby_press_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.TouchScreenButton.is_passby_press_enabled {-# NOINLINE bindTouchScreenButton_is_pressed #-} -- | Returns @true@ if this button is currently pressed. bindTouchScreenButton_is_pressed :: MethodBind bindTouchScreenButton_is_pressed = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "is_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this button is currently pressed. is_pressed :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO Bool is_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_is_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "is_pressed" '[] (IO Bool) where nodeMethod = Godot.Core.TouchScreenButton.is_pressed {-# NOINLINE bindTouchScreenButton_is_shape_centered #-} -- | If @true@, the button's shape is centered in the provided texture. If no texture is used, this property has no effect. bindTouchScreenButton_is_shape_centered :: MethodBind bindTouchScreenButton_is_shape_centered = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "is_shape_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button's shape is centered in the provided texture. If no texture is used, this property has no effect. is_shape_centered :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO Bool is_shape_centered cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_is_shape_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "is_shape_centered" '[] (IO Bool) where nodeMethod = Godot.Core.TouchScreenButton.is_shape_centered {-# NOINLINE bindTouchScreenButton_is_shape_visible #-} -- | If @true@, the button's shape is visible. bindTouchScreenButton_is_shape_visible :: MethodBind bindTouchScreenButton_is_shape_visible = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "is_shape_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button's shape is visible. is_shape_visible :: (TouchScreenButton :< cls, Object :< cls) => cls -> IO Bool is_shape_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_is_shape_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "is_shape_visible" '[] (IO Bool) where nodeMethod = Godot.Core.TouchScreenButton.is_shape_visible {-# NOINLINE bindTouchScreenButton_set_action #-} -- | The button's action. Actions can be handled with @InputEventAction@. bindTouchScreenButton_set_action :: MethodBind bindTouchScreenButton_set_action = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's action. Actions can be handled with @InputEventAction@. set_action :: (TouchScreenButton :< cls, Object :< cls) => cls -> GodotString -> IO () set_action cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_action" '[GodotString] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_action {-# NOINLINE bindTouchScreenButton_set_bitmask #-} -- | The button's bitmask. bindTouchScreenButton_set_bitmask :: MethodBind bindTouchScreenButton_set_bitmask = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_bitmask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's bitmask. set_bitmask :: (TouchScreenButton :< cls, Object :< cls) => cls -> BitMap -> IO () set_bitmask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_bitmask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_bitmask" '[BitMap] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_bitmask {-# NOINLINE bindTouchScreenButton_set_passby_press #-} -- | If @true@, pass-by presses are enabled. bindTouchScreenButton_set_passby_press :: MethodBind bindTouchScreenButton_set_passby_press = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_passby_press" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, pass-by presses are enabled. set_passby_press :: (TouchScreenButton :< cls, Object :< cls) => cls -> Bool -> IO () set_passby_press cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_passby_press (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_passby_press" '[Bool] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_passby_press {-# NOINLINE bindTouchScreenButton_set_shape #-} -- | The button's shape. bindTouchScreenButton_set_shape :: MethodBind bindTouchScreenButton_set_shape = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's shape. set_shape :: (TouchScreenButton :< cls, Object :< cls) => cls -> Shape2D -> IO () set_shape cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_shape" '[Shape2D] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_shape {-# NOINLINE bindTouchScreenButton_set_shape_centered #-} -- | If @true@, the button's shape is centered in the provided texture. If no texture is used, this property has no effect. bindTouchScreenButton_set_shape_centered :: MethodBind bindTouchScreenButton_set_shape_centered = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_shape_centered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button's shape is centered in the provided texture. If no texture is used, this property has no effect. set_shape_centered :: (TouchScreenButton :< cls, Object :< cls) => cls -> Bool -> IO () set_shape_centered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_shape_centered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_shape_centered" '[Bool] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_shape_centered {-# NOINLINE bindTouchScreenButton_set_shape_visible #-} -- | If @true@, the button's shape is visible. bindTouchScreenButton_set_shape_visible :: MethodBind bindTouchScreenButton_set_shape_visible = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_shape_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the button's shape is visible. set_shape_visible :: (TouchScreenButton :< cls, Object :< cls) => cls -> Bool -> IO () set_shape_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_shape_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_shape_visible" '[Bool] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_shape_visible {-# NOINLINE bindTouchScreenButton_set_texture #-} -- | The button's texture for the normal state. bindTouchScreenButton_set_texture :: MethodBind bindTouchScreenButton_set_texture = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's texture for the normal state. set_texture :: (TouchScreenButton :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_texture {-# NOINLINE bindTouchScreenButton_set_texture_pressed #-} -- | The button's texture for the pressed state. bindTouchScreenButton_set_texture_pressed :: MethodBind bindTouchScreenButton_set_texture_pressed = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_texture_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's texture for the pressed state. set_texture_pressed :: (TouchScreenButton :< cls, Object :< cls) => cls -> Texture -> IO () set_texture_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_texture_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_texture_pressed" '[Texture] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_texture_pressed {-# NOINLINE bindTouchScreenButton_set_visibility_mode #-} -- | The button's visibility mode. See @enum VisibilityMode@ for possible values. bindTouchScreenButton_set_visibility_mode :: MethodBind bindTouchScreenButton_set_visibility_mode = unsafePerformIO $ withCString "TouchScreenButton" $ \ clsNamePtr -> withCString "set_visibility_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The button's visibility mode. See @enum VisibilityMode@ for possible values. set_visibility_mode :: (TouchScreenButton :< cls, Object :< cls) => cls -> Int -> IO () set_visibility_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTouchScreenButton_set_visibility_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TouchScreenButton "set_visibility_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.TouchScreenButton.set_visibility_mode ================================================ FILE: src/Godot/Core/Translation.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Translation (Godot.Core.Translation._get_messages, Godot.Core.Translation._set_messages, Godot.Core.Translation.add_message, Godot.Core.Translation.erase_message, Godot.Core.Translation.get_locale, Godot.Core.Translation.get_message, Godot.Core.Translation.get_message_count, Godot.Core.Translation.get_message_list, Godot.Core.Translation.set_locale) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty Translation "locale" GodotString 'False where nodeProperty = (get_locale, wrapDroppingSetter set_locale, Nothing) instance NodeProperty Translation "messages" PoolStringArray 'False where nodeProperty = (_get_messages, wrapDroppingSetter _set_messages, Nothing) {-# NOINLINE bindTranslation__get_messages #-} bindTranslation__get_messages :: MethodBind bindTranslation__get_messages = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "_get_messages" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_messages :: (Translation :< cls, Object :< cls) => cls -> IO PoolStringArray _get_messages cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation__get_messages (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "_get_messages" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.Translation._get_messages {-# NOINLINE bindTranslation__set_messages #-} bindTranslation__set_messages :: MethodBind bindTranslation__set_messages = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "_set_messages" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_messages :: (Translation :< cls, Object :< cls) => cls -> PoolStringArray -> IO () _set_messages cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation__set_messages (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "_set_messages" '[PoolStringArray] (IO ()) where nodeMethod = Godot.Core.Translation._set_messages {-# NOINLINE bindTranslation_add_message #-} -- | Adds a message if nonexistent, followed by its translation. bindTranslation_add_message :: MethodBind bindTranslation_add_message = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "add_message" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a message if nonexistent, followed by its translation. add_message :: (Translation :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () add_message cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation_add_message (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "add_message" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.Translation.add_message {-# NOINLINE bindTranslation_erase_message #-} -- | Erases a message. bindTranslation_erase_message :: MethodBind bindTranslation_erase_message = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "erase_message" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Erases a message. erase_message :: (Translation :< cls, Object :< cls) => cls -> GodotString -> IO () erase_message cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation_erase_message (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "erase_message" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Translation.erase_message {-# NOINLINE bindTranslation_get_locale #-} -- | The locale of the translation. bindTranslation_get_locale :: MethodBind bindTranslation_get_locale = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "get_locale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The locale of the translation. get_locale :: (Translation :< cls, Object :< cls) => cls -> IO GodotString get_locale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation_get_locale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "get_locale" '[] (IO GodotString) where nodeMethod = Godot.Core.Translation.get_locale {-# NOINLINE bindTranslation_get_message #-} -- | Returns a message's translation. bindTranslation_get_message :: MethodBind bindTranslation_get_message = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "get_message" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a message's translation. get_message :: (Translation :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_message cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation_get_message (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "get_message" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.Translation.get_message {-# NOINLINE bindTranslation_get_message_count #-} -- | Returns the number of existing messages. bindTranslation_get_message_count :: MethodBind bindTranslation_get_message_count = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "get_message_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of existing messages. get_message_count :: (Translation :< cls, Object :< cls) => cls -> IO Int get_message_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation_get_message_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "get_message_count" '[] (IO Int) where nodeMethod = Godot.Core.Translation.get_message_count {-# NOINLINE bindTranslation_get_message_list #-} -- | Returns all the messages (keys). bindTranslation_get_message_list :: MethodBind bindTranslation_get_message_list = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "get_message_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns all the messages (keys). get_message_list :: (Translation :< cls, Object :< cls) => cls -> IO PoolStringArray get_message_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation_get_message_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "get_message_list" '[] (IO PoolStringArray) where nodeMethod = Godot.Core.Translation.get_message_list {-# NOINLINE bindTranslation_set_locale #-} -- | The locale of the translation. bindTranslation_set_locale :: MethodBind bindTranslation_set_locale = unsafePerformIO $ withCString "Translation" $ \ clsNamePtr -> withCString "set_locale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The locale of the translation. set_locale :: (Translation :< cls, Object :< cls) => cls -> GodotString -> IO () set_locale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslation_set_locale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Translation "set_locale" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Translation.set_locale ================================================ FILE: src/Godot/Core/TranslationServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TranslationServer (Godot.Core.TranslationServer.add_translation, Godot.Core.TranslationServer.clear, Godot.Core.TranslationServer.get_loaded_locales, Godot.Core.TranslationServer.get_locale, Godot.Core.TranslationServer.get_locale_name, Godot.Core.TranslationServer.remove_translation, Godot.Core.TranslationServer.set_locale, Godot.Core.TranslationServer.translate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindTranslationServer_add_translation #-} -- | Adds a @Translation@ resource. bindTranslationServer_add_translation :: MethodBind bindTranslationServer_add_translation = unsafePerformIO $ withCString "TranslationServer" $ \ clsNamePtr -> withCString "add_translation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @Translation@ resource. add_translation :: (TranslationServer :< cls, Object :< cls) => cls -> Translation -> IO () add_translation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslationServer_add_translation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TranslationServer "add_translation" '[Translation] (IO ()) where nodeMethod = Godot.Core.TranslationServer.add_translation {-# NOINLINE bindTranslationServer_clear #-} -- | Clears the server from all translations. bindTranslationServer_clear :: MethodBind bindTranslationServer_clear = unsafePerformIO $ withCString "TranslationServer" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the server from all translations. clear :: (TranslationServer :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTranslationServer_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TranslationServer "clear" '[] (IO ()) where nodeMethod = Godot.Core.TranslationServer.clear {-# NOINLINE bindTranslationServer_get_loaded_locales #-} -- | Returns an Array of all loaded locales of the game. bindTranslationServer_get_loaded_locales :: MethodBind bindTranslationServer_get_loaded_locales = unsafePerformIO $ withCString "TranslationServer" $ \ clsNamePtr -> withCString "get_loaded_locales" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an Array of all loaded locales of the game. get_loaded_locales :: (TranslationServer :< cls, Object :< cls) => cls -> IO Array get_loaded_locales cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTranslationServer_get_loaded_locales (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TranslationServer "get_loaded_locales" '[] (IO Array) where nodeMethod = Godot.Core.TranslationServer.get_loaded_locales {-# NOINLINE bindTranslationServer_get_locale #-} -- | Returns the current locale of the game. bindTranslationServer_get_locale :: MethodBind bindTranslationServer_get_locale = unsafePerformIO $ withCString "TranslationServer" $ \ clsNamePtr -> withCString "get_locale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current locale of the game. get_locale :: (TranslationServer :< cls, Object :< cls) => cls -> IO GodotString get_locale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTranslationServer_get_locale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TranslationServer "get_locale" '[] (IO GodotString) where nodeMethod = Godot.Core.TranslationServer.get_locale {-# NOINLINE bindTranslationServer_get_locale_name #-} -- | Returns a locale's language and its variant (e.g. @"en_US"@ would return @"English (United States)"@). bindTranslationServer_get_locale_name :: MethodBind bindTranslationServer_get_locale_name = unsafePerformIO $ withCString "TranslationServer" $ \ clsNamePtr -> withCString "get_locale_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a locale's language and its variant (e.g. @"en_US"@ would return @"English (United States)"@). get_locale_name :: (TranslationServer :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_locale_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslationServer_get_locale_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TranslationServer "get_locale_name" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.TranslationServer.get_locale_name {-# NOINLINE bindTranslationServer_remove_translation #-} -- | Removes the given translation from the server. bindTranslationServer_remove_translation :: MethodBind bindTranslationServer_remove_translation = unsafePerformIO $ withCString "TranslationServer" $ \ clsNamePtr -> withCString "remove_translation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the given translation from the server. remove_translation :: (TranslationServer :< cls, Object :< cls) => cls -> Translation -> IO () remove_translation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslationServer_remove_translation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TranslationServer "remove_translation" '[Translation] (IO ()) where nodeMethod = Godot.Core.TranslationServer.remove_translation {-# NOINLINE bindTranslationServer_set_locale #-} -- | Sets the locale of the game. bindTranslationServer_set_locale :: MethodBind bindTranslationServer_set_locale = unsafePerformIO $ withCString "TranslationServer" $ \ clsNamePtr -> withCString "set_locale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the locale of the game. set_locale :: (TranslationServer :< cls, Object :< cls) => cls -> GodotString -> IO () set_locale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslationServer_set_locale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TranslationServer "set_locale" '[GodotString] (IO ()) where nodeMethod = Godot.Core.TranslationServer.set_locale {-# NOINLINE bindTranslationServer_translate #-} -- | Returns the current locale's translation for the given message (key). bindTranslationServer_translate :: MethodBind bindTranslationServer_translate = unsafePerformIO $ withCString "TranslationServer" $ \ clsNamePtr -> withCString "translate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current locale's translation for the given message (key). translate :: (TranslationServer :< cls, Object :< cls) => cls -> GodotString -> IO GodotString translate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTranslationServer_translate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TranslationServer "translate" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.TranslationServer.translate ================================================ FILE: src/Godot/Core/Tree.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Tree (Godot.Core.Tree._DROP_MODE_DISABLED, Godot.Core.Tree._SELECT_ROW, Godot.Core.Tree._SELECT_MULTI, Godot.Core.Tree._DROP_MODE_ON_ITEM, Godot.Core.Tree._DROP_MODE_INBETWEEN, Godot.Core.Tree._SELECT_SINGLE, Godot.Core.Tree.sig_button_pressed, Godot.Core.Tree.sig_cell_selected, Godot.Core.Tree.sig_column_title_pressed, Godot.Core.Tree.sig_custom_popup_edited, Godot.Core.Tree.sig_empty_rmb, Godot.Core.Tree.sig_empty_tree_rmb_selected, Godot.Core.Tree.sig_item_activated, Godot.Core.Tree.sig_item_collapsed, Godot.Core.Tree.sig_item_custom_button_pressed, Godot.Core.Tree.sig_item_double_clicked, Godot.Core.Tree.sig_item_edited, Godot.Core.Tree.sig_item_rmb_edited, Godot.Core.Tree.sig_item_rmb_selected, Godot.Core.Tree.sig_item_selected, Godot.Core.Tree.sig_multi_selected, Godot.Core.Tree.sig_nothing_selected, Godot.Core.Tree._gui_input, Godot.Core.Tree._popup_select, Godot.Core.Tree._range_click_timeout, Godot.Core.Tree._scroll_moved, Godot.Core.Tree._text_editor_enter, Godot.Core.Tree._text_editor_modal_close, Godot.Core.Tree._value_editor_changed, Godot.Core.Tree.are_column_titles_visible, Godot.Core.Tree.clear, Godot.Core.Tree.create_item, Godot.Core.Tree.ensure_cursor_is_visible, Godot.Core.Tree.get_allow_reselect, Godot.Core.Tree.get_allow_rmb_select, Godot.Core.Tree.get_column_at_position, Godot.Core.Tree.get_column_title, Godot.Core.Tree.get_column_width, Godot.Core.Tree.get_columns, Godot.Core.Tree.get_custom_popup_rect, Godot.Core.Tree.get_drop_mode_flags, Godot.Core.Tree.get_drop_section_at_position, Godot.Core.Tree.get_edited, Godot.Core.Tree.get_edited_column, Godot.Core.Tree.get_item_area_rect, Godot.Core.Tree.get_item_at_position, Godot.Core.Tree.get_next_selected, Godot.Core.Tree.get_pressed_button, Godot.Core.Tree.get_root, Godot.Core.Tree.get_scroll, Godot.Core.Tree.get_select_mode, Godot.Core.Tree.get_selected, Godot.Core.Tree.get_selected_column, Godot.Core.Tree.is_folding_hidden, Godot.Core.Tree.is_root_hidden, Godot.Core.Tree.set_allow_reselect, Godot.Core.Tree.set_allow_rmb_select, Godot.Core.Tree.set_column_expand, Godot.Core.Tree.set_column_min_width, Godot.Core.Tree.set_column_title, Godot.Core.Tree.set_column_titles_visible, Godot.Core.Tree.set_columns, Godot.Core.Tree.set_drop_mode_flags, Godot.Core.Tree.set_hide_folding, Godot.Core.Tree.set_hide_root, Godot.Core.Tree.set_select_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() _DROP_MODE_DISABLED :: Int _DROP_MODE_DISABLED = 0 _SELECT_ROW :: Int _SELECT_ROW = 1 _SELECT_MULTI :: Int _SELECT_MULTI = 2 _DROP_MODE_ON_ITEM :: Int _DROP_MODE_ON_ITEM = 1 _DROP_MODE_INBETWEEN :: Int _DROP_MODE_INBETWEEN = 2 _SELECT_SINGLE :: Int _SELECT_SINGLE = 0 -- | Emitted when a button on the tree was pressed (see @method TreeItem.add_button@). sig_button_pressed :: Godot.Internal.Dispatch.Signal Tree sig_button_pressed = Godot.Internal.Dispatch.Signal "button_pressed" instance NodeSignal Tree "button_pressed" '[TreeItem, Int, Int] -- | Emitted when a cell is selected. sig_cell_selected :: Godot.Internal.Dispatch.Signal Tree sig_cell_selected = Godot.Internal.Dispatch.Signal "cell_selected" instance NodeSignal Tree "cell_selected" '[] -- | Emitted when a column's title is pressed. sig_column_title_pressed :: Godot.Internal.Dispatch.Signal Tree sig_column_title_pressed = Godot.Internal.Dispatch.Signal "column_title_pressed" instance NodeSignal Tree "column_title_pressed" '[Int] -- | Emitted when a cell with the @TreeItem.CELL_MODE_CUSTOM@ is clicked to be edited. sig_custom_popup_edited :: Godot.Internal.Dispatch.Signal Tree sig_custom_popup_edited = Godot.Internal.Dispatch.Signal "custom_popup_edited" instance NodeSignal Tree "custom_popup_edited" '[Bool] -- | Emitted when the right mouse button is pressed in the empty space of the tree. sig_empty_rmb :: Godot.Internal.Dispatch.Signal Tree sig_empty_rmb = Godot.Internal.Dispatch.Signal "empty_rmb" instance NodeSignal Tree "empty_rmb" '[Vector2] -- | Emitted when the right mouse button is pressed if right mouse button selection is active and the tree is empty. sig_empty_tree_rmb_selected :: Godot.Internal.Dispatch.Signal Tree sig_empty_tree_rmb_selected = Godot.Internal.Dispatch.Signal "empty_tree_rmb_selected" instance NodeSignal Tree "empty_tree_rmb_selected" '[Vector2] -- | Emitted when an item's label is double-clicked. sig_item_activated :: Godot.Internal.Dispatch.Signal Tree sig_item_activated = Godot.Internal.Dispatch.Signal "item_activated" instance NodeSignal Tree "item_activated" '[] -- | Emitted when an item is collapsed by a click on the folding arrow. sig_item_collapsed :: Godot.Internal.Dispatch.Signal Tree sig_item_collapsed = Godot.Internal.Dispatch.Signal "item_collapsed" instance NodeSignal Tree "item_collapsed" '[TreeItem] -- | Emitted when a custom button is pressed (i.e. in a @TreeItem.CELL_MODE_CUSTOM@ mode cell). sig_item_custom_button_pressed :: Godot.Internal.Dispatch.Signal Tree sig_item_custom_button_pressed = Godot.Internal.Dispatch.Signal "item_custom_button_pressed" instance NodeSignal Tree "item_custom_button_pressed" '[] -- | Emitted when an item's icon is double-clicked. sig_item_double_clicked :: Godot.Internal.Dispatch.Signal Tree sig_item_double_clicked = Godot.Internal.Dispatch.Signal "item_double_clicked" instance NodeSignal Tree "item_double_clicked" '[] -- | Emitted when an item is edited. sig_item_edited :: Godot.Internal.Dispatch.Signal Tree sig_item_edited = Godot.Internal.Dispatch.Signal "item_edited" instance NodeSignal Tree "item_edited" '[] -- | Emitted when an item is edited using the right mouse button. sig_item_rmb_edited :: Godot.Internal.Dispatch.Signal Tree sig_item_rmb_edited = Godot.Internal.Dispatch.Signal "item_rmb_edited" instance NodeSignal Tree "item_rmb_edited" '[] -- | Emitted when an item is selected with the right mouse button. sig_item_rmb_selected :: Godot.Internal.Dispatch.Signal Tree sig_item_rmb_selected = Godot.Internal.Dispatch.Signal "item_rmb_selected" instance NodeSignal Tree "item_rmb_selected" '[Vector2] -- | Emitted when an item is selected. sig_item_selected :: Godot.Internal.Dispatch.Signal Tree sig_item_selected = Godot.Internal.Dispatch.Signal "item_selected" instance NodeSignal Tree "item_selected" '[] -- | Emitted instead of @item_selected@ if @select_mode@ is @SELECT_MULTI@. sig_multi_selected :: Godot.Internal.Dispatch.Signal Tree sig_multi_selected = Godot.Internal.Dispatch.Signal "multi_selected" instance NodeSignal Tree "multi_selected" '[TreeItem, Int, Bool] -- | Emitted when a left mouse button click does not select any item. sig_nothing_selected :: Godot.Internal.Dispatch.Signal Tree sig_nothing_selected = Godot.Internal.Dispatch.Signal "nothing_selected" instance NodeSignal Tree "nothing_selected" '[] instance NodeProperty Tree "allow_reselect" Bool 'False where nodeProperty = (get_allow_reselect, wrapDroppingSetter set_allow_reselect, Nothing) instance NodeProperty Tree "allow_rmb_select" Bool 'False where nodeProperty = (get_allow_rmb_select, wrapDroppingSetter set_allow_rmb_select, Nothing) instance NodeProperty Tree "columns" Int 'False where nodeProperty = (get_columns, wrapDroppingSetter set_columns, Nothing) instance NodeProperty Tree "drop_mode_flags" Int 'False where nodeProperty = (get_drop_mode_flags, wrapDroppingSetter set_drop_mode_flags, Nothing) instance NodeProperty Tree "hide_folding" Bool 'False where nodeProperty = (is_folding_hidden, wrapDroppingSetter set_hide_folding, Nothing) instance NodeProperty Tree "hide_root" Bool 'False where nodeProperty = (is_root_hidden, wrapDroppingSetter set_hide_root, Nothing) instance NodeProperty Tree "select_mode" Int 'False where nodeProperty = (get_select_mode, wrapDroppingSetter set_select_mode, Nothing) {-# NOINLINE bindTree__gui_input #-} bindTree__gui_input :: MethodBind bindTree__gui_input = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (Tree :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Tree._gui_input {-# NOINLINE bindTree__popup_select #-} bindTree__popup_select :: MethodBind bindTree__popup_select = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "_popup_select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _popup_select :: (Tree :< cls, Object :< cls) => cls -> Int -> IO () _popup_select cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree__popup_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "_popup_select" '[Int] (IO ()) where nodeMethod = Godot.Core.Tree._popup_select {-# NOINLINE bindTree__range_click_timeout #-} bindTree__range_click_timeout :: MethodBind bindTree__range_click_timeout = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "_range_click_timeout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _range_click_timeout :: (Tree :< cls, Object :< cls) => cls -> IO () _range_click_timeout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree__range_click_timeout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "_range_click_timeout" '[] (IO ()) where nodeMethod = Godot.Core.Tree._range_click_timeout {-# NOINLINE bindTree__scroll_moved #-} bindTree__scroll_moved :: MethodBind bindTree__scroll_moved = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "_scroll_moved" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _scroll_moved :: (Tree :< cls, Object :< cls) => cls -> Float -> IO () _scroll_moved cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree__scroll_moved (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "_scroll_moved" '[Float] (IO ()) where nodeMethod = Godot.Core.Tree._scroll_moved {-# NOINLINE bindTree__text_editor_enter #-} bindTree__text_editor_enter :: MethodBind bindTree__text_editor_enter = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "_text_editor_enter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _text_editor_enter :: (Tree :< cls, Object :< cls) => cls -> GodotString -> IO () _text_editor_enter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree__text_editor_enter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "_text_editor_enter" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Tree._text_editor_enter {-# NOINLINE bindTree__text_editor_modal_close #-} bindTree__text_editor_modal_close :: MethodBind bindTree__text_editor_modal_close = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "_text_editor_modal_close" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _text_editor_modal_close :: (Tree :< cls, Object :< cls) => cls -> IO () _text_editor_modal_close cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree__text_editor_modal_close (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "_text_editor_modal_close" '[] (IO ()) where nodeMethod = Godot.Core.Tree._text_editor_modal_close {-# NOINLINE bindTree__value_editor_changed #-} bindTree__value_editor_changed :: MethodBind bindTree__value_editor_changed = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "_value_editor_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _value_editor_changed :: (Tree :< cls, Object :< cls) => cls -> Float -> IO () _value_editor_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree__value_editor_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "_value_editor_changed" '[Float] (IO ()) where nodeMethod = Godot.Core.Tree._value_editor_changed {-# NOINLINE bindTree_are_column_titles_visible #-} -- | Returns @true@ if the column titles are being shown. bindTree_are_column_titles_visible :: MethodBind bindTree_are_column_titles_visible = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "are_column_titles_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the column titles are being shown. are_column_titles_visible :: (Tree :< cls, Object :< cls) => cls -> IO Bool are_column_titles_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_are_column_titles_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "are_column_titles_visible" '[] (IO Bool) where nodeMethod = Godot.Core.Tree.are_column_titles_visible {-# NOINLINE bindTree_clear #-} -- | Clears the tree. This removes all items. bindTree_clear :: MethodBind bindTree_clear = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the tree. This removes all items. clear :: (Tree :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "clear" '[] (IO ()) where nodeMethod = Godot.Core.Tree.clear {-# NOINLINE bindTree_create_item #-} -- | Creates an item in the tree and adds it as a child of @parent@. -- If @parent@ is @null@, the root item will be the parent, or the new item will be the root itself if the tree is empty. -- The new item will be the @idx@th child of parent, or it will be the last child if there are not enough siblings. bindTree_create_item :: MethodBind bindTree_create_item = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "create_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an item in the tree and adds it as a child of @parent@. -- If @parent@ is @null@, the root item will be the parent, or the new item will be the root itself if the tree is empty. -- The new item will be the @idx@th child of parent, or it will be the last child if there are not enough siblings. create_item :: (Tree :< cls, Object :< cls) => cls -> Maybe Object -> Maybe Int -> IO TreeItem create_item cls arg1 arg2 = withVariantArray [maybe VariantNil toVariant arg1, maybe (VariantInt (-1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTree_create_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "create_item" '[Maybe Object, Maybe Int] (IO TreeItem) where nodeMethod = Godot.Core.Tree.create_item {-# NOINLINE bindTree_ensure_cursor_is_visible #-} -- | Makes the currently focused cell visible. -- This will scroll the tree if necessary. In @SELECT_ROW@ mode, this will not do horizontal scrolling, as all the cells in the selected row is focused logically. -- __Note:__ Despite the name of this method, the focus cursor itself is only visible in @SELECT_MULTI@ mode. bindTree_ensure_cursor_is_visible :: MethodBind bindTree_ensure_cursor_is_visible = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "ensure_cursor_is_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Makes the currently focused cell visible. -- This will scroll the tree if necessary. In @SELECT_ROW@ mode, this will not do horizontal scrolling, as all the cells in the selected row is focused logically. -- __Note:__ Despite the name of this method, the focus cursor itself is only visible in @SELECT_MULTI@ mode. ensure_cursor_is_visible :: (Tree :< cls, Object :< cls) => cls -> IO () ensure_cursor_is_visible cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_ensure_cursor_is_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "ensure_cursor_is_visible" '[] (IO ()) where nodeMethod = Godot.Core.Tree.ensure_cursor_is_visible {-# NOINLINE bindTree_get_allow_reselect #-} -- | If @true@, the currently selected cell may be selected again. bindTree_get_allow_reselect :: MethodBind bindTree_get_allow_reselect = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_allow_reselect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the currently selected cell may be selected again. get_allow_reselect :: (Tree :< cls, Object :< cls) => cls -> IO Bool get_allow_reselect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_allow_reselect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_allow_reselect" '[] (IO Bool) where nodeMethod = Godot.Core.Tree.get_allow_reselect {-# NOINLINE bindTree_get_allow_rmb_select #-} -- | If @true@, a right mouse button click can select items. bindTree_get_allow_rmb_select :: MethodBind bindTree_get_allow_rmb_select = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_allow_rmb_select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a right mouse button click can select items. get_allow_rmb_select :: (Tree :< cls, Object :< cls) => cls -> IO Bool get_allow_rmb_select cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_allow_rmb_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_allow_rmb_select" '[] (IO Bool) where nodeMethod = Godot.Core.Tree.get_allow_rmb_select {-# NOINLINE bindTree_get_column_at_position #-} -- | Returns the column index at @position@, or -1 if no item is there. bindTree_get_column_at_position :: MethodBind bindTree_get_column_at_position = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_column_at_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the column index at @position@, or -1 if no item is there. get_column_at_position :: (Tree :< cls, Object :< cls) => cls -> Vector2 -> IO Int get_column_at_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_column_at_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_column_at_position" '[Vector2] (IO Int) where nodeMethod = Godot.Core.Tree.get_column_at_position {-# NOINLINE bindTree_get_column_title #-} -- | Returns the column's title. bindTree_get_column_title :: MethodBind bindTree_get_column_title = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_column_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the column's title. get_column_title :: (Tree :< cls, Object :< cls) => cls -> Int -> IO GodotString get_column_title cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_column_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_column_title" '[Int] (IO GodotString) where nodeMethod = Godot.Core.Tree.get_column_title {-# NOINLINE bindTree_get_column_width #-} -- | Returns the column's width in pixels. bindTree_get_column_width :: MethodBind bindTree_get_column_width = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_column_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the column's width in pixels. get_column_width :: (Tree :< cls, Object :< cls) => cls -> Int -> IO Int get_column_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_column_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_column_width" '[Int] (IO Int) where nodeMethod = Godot.Core.Tree.get_column_width {-# NOINLINE bindTree_get_columns #-} -- | The number of columns. bindTree_get_columns :: MethodBind bindTree_get_columns = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_columns" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns. get_columns :: (Tree :< cls, Object :< cls) => cls -> IO Int get_columns cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_columns (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_columns" '[] (IO Int) where nodeMethod = Godot.Core.Tree.get_columns {-# NOINLINE bindTree_get_custom_popup_rect #-} -- | Returns the rectangle for custom popups. Helper to create custom cell controls that display a popup. See @method TreeItem.set_cell_mode@. bindTree_get_custom_popup_rect :: MethodBind bindTree_get_custom_popup_rect = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_custom_popup_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the rectangle for custom popups. Helper to create custom cell controls that display a popup. See @method TreeItem.set_cell_mode@. get_custom_popup_rect :: (Tree :< cls, Object :< cls) => cls -> IO Rect2 get_custom_popup_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_custom_popup_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_custom_popup_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Tree.get_custom_popup_rect {-# NOINLINE bindTree_get_drop_mode_flags #-} -- | The drop mode as an OR combination of flags. See @enum DropModeFlags@ constants. Once dropping is done, reverts to @DROP_MODE_DISABLED@. Setting this during @method Control.can_drop_data@ is recommended. -- This controls the drop sections, i.e. the decision and drawing of possible drop locations based on the mouse position. bindTree_get_drop_mode_flags :: MethodBind bindTree_get_drop_mode_flags = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_drop_mode_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drop mode as an OR combination of flags. See @enum DropModeFlags@ constants. Once dropping is done, reverts to @DROP_MODE_DISABLED@. Setting this during @method Control.can_drop_data@ is recommended. -- This controls the drop sections, i.e. the decision and drawing of possible drop locations based on the mouse position. get_drop_mode_flags :: (Tree :< cls, Object :< cls) => cls -> IO Int get_drop_mode_flags cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_drop_mode_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_drop_mode_flags" '[] (IO Int) where nodeMethod = Godot.Core.Tree.get_drop_mode_flags {-# NOINLINE bindTree_get_drop_section_at_position #-} -- | Returns the drop section at @position@, or -100 if no item is there. -- Values -1, 0, or 1 will be returned for the "above item", "on item", and "below item" drop sections, respectively. See @enum DropModeFlags@ for a description of each drop section. -- To get the item which the returned drop section is relative to, use @method get_item_at_position@. bindTree_get_drop_section_at_position :: MethodBind bindTree_get_drop_section_at_position = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_drop_section_at_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the drop section at @position@, or -100 if no item is there. -- Values -1, 0, or 1 will be returned for the "above item", "on item", and "below item" drop sections, respectively. See @enum DropModeFlags@ for a description of each drop section. -- To get the item which the returned drop section is relative to, use @method get_item_at_position@. get_drop_section_at_position :: (Tree :< cls, Object :< cls) => cls -> Vector2 -> IO Int get_drop_section_at_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_drop_section_at_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_drop_section_at_position" '[Vector2] (IO Int) where nodeMethod = Godot.Core.Tree.get_drop_section_at_position {-# NOINLINE bindTree_get_edited #-} -- | Returns the currently edited item. This is only available for custom cell mode. bindTree_get_edited :: MethodBind bindTree_get_edited = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_edited" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the currently edited item. This is only available for custom cell mode. get_edited :: (Tree :< cls, Object :< cls) => cls -> IO TreeItem get_edited cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_edited (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_edited" '[] (IO TreeItem) where nodeMethod = Godot.Core.Tree.get_edited {-# NOINLINE bindTree_get_edited_column #-} -- | Returns the column for the currently edited item. This is only available for custom cell mode. bindTree_get_edited_column :: MethodBind bindTree_get_edited_column = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_edited_column" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the column for the currently edited item. This is only available for custom cell mode. get_edited_column :: (Tree :< cls, Object :< cls) => cls -> IO Int get_edited_column cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_edited_column (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_edited_column" '[] (IO Int) where nodeMethod = Godot.Core.Tree.get_edited_column {-# NOINLINE bindTree_get_item_area_rect #-} -- | Returns the rectangle area for the specified item. If @column@ is specified, only get the position and size of that column, otherwise get the rectangle containing all columns. bindTree_get_item_area_rect :: MethodBind bindTree_get_item_area_rect = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_item_area_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the rectangle area for the specified item. If @column@ is specified, only get the position and size of that column, otherwise get the rectangle containing all columns. get_item_area_rect :: (Tree :< cls, Object :< cls) => cls -> Object -> Maybe Int -> IO Rect2 get_item_area_rect cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (-1)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_item_area_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_item_area_rect" '[Object, Maybe Int] (IO Rect2) where nodeMethod = Godot.Core.Tree.get_item_area_rect {-# NOINLINE bindTree_get_item_at_position #-} -- | Returns the tree item at the specified position (relative to the tree origin position). bindTree_get_item_at_position :: MethodBind bindTree_get_item_at_position = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_item_at_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tree item at the specified position (relative to the tree origin position). get_item_at_position :: (Tree :< cls, Object :< cls) => cls -> Vector2 -> IO TreeItem get_item_at_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_item_at_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_item_at_position" '[Vector2] (IO TreeItem) where nodeMethod = Godot.Core.Tree.get_item_at_position {-# NOINLINE bindTree_get_next_selected #-} -- | Returns the next selected item after the given one, or @null@ if the end is reached. -- If @from@ is @null@, this returns the first selected item. bindTree_get_next_selected :: MethodBind bindTree_get_next_selected = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_next_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next selected item after the given one, or @null@ if the end is reached. -- If @from@ is @null@, this returns the first selected item. get_next_selected :: (Tree :< cls, Object :< cls) => cls -> Object -> IO TreeItem get_next_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_next_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_next_selected" '[Object] (IO TreeItem) where nodeMethod = Godot.Core.Tree.get_next_selected {-# NOINLINE bindTree_get_pressed_button #-} -- | Returns the last pressed button's index. bindTree_get_pressed_button :: MethodBind bindTree_get_pressed_button = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_pressed_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the last pressed button's index. get_pressed_button :: (Tree :< cls, Object :< cls) => cls -> IO Int get_pressed_button cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_pressed_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_pressed_button" '[] (IO Int) where nodeMethod = Godot.Core.Tree.get_pressed_button {-# NOINLINE bindTree_get_root #-} -- | Returns the tree's root item, or @null@ if the tree is empty. bindTree_get_root :: MethodBind bindTree_get_root = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tree's root item, or @null@ if the tree is empty. get_root :: (Tree :< cls, Object :< cls) => cls -> IO TreeItem get_root cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_root" '[] (IO TreeItem) where nodeMethod = Godot.Core.Tree.get_root {-# NOINLINE bindTree_get_scroll #-} -- | Returns the current scrolling position. bindTree_get_scroll :: MethodBind bindTree_get_scroll = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current scrolling position. get_scroll :: (Tree :< cls, Object :< cls) => cls -> IO Vector2 get_scroll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_scroll" '[] (IO Vector2) where nodeMethod = Godot.Core.Tree.get_scroll {-# NOINLINE bindTree_get_select_mode #-} -- | Allows single or multiple selection. See the @enum SelectMode@ constants. bindTree_get_select_mode :: MethodBind bindTree_get_select_mode = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_select_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows single or multiple selection. See the @enum SelectMode@ constants. get_select_mode :: (Tree :< cls, Object :< cls) => cls -> IO Int get_select_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_select_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_select_mode" '[] (IO Int) where nodeMethod = Godot.Core.Tree.get_select_mode {-# NOINLINE bindTree_get_selected #-} -- | Returns the currently focused item, or @null@ if no item is focused. -- In @SELECT_ROW@ and @SELECT_SINGLE@ modes, the focused item is same as the selected item. In @SELECT_MULTI@ mode, the focused item is the item under the focus cursor, not necessarily selected. -- To get the currently selected item(s), use @method get_next_selected@. bindTree_get_selected :: MethodBind bindTree_get_selected = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the currently focused item, or @null@ if no item is focused. -- In @SELECT_ROW@ and @SELECT_SINGLE@ modes, the focused item is same as the selected item. In @SELECT_MULTI@ mode, the focused item is the item under the focus cursor, not necessarily selected. -- To get the currently selected item(s), use @method get_next_selected@. get_selected :: (Tree :< cls, Object :< cls) => cls -> IO TreeItem get_selected cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_selected" '[] (IO TreeItem) where nodeMethod = Godot.Core.Tree.get_selected {-# NOINLINE bindTree_get_selected_column #-} -- | Returns the currently focused column, or -1 if no column is focused. -- In @SELECT_SINGLE@ mode, the focused column is the selected column. In @SELECT_ROW@ mode, the focused column is always 0 if any item is selected. In @SELECT_MULTI@ mode, the focused column is the column under the focus cursor, and there are not necessarily any column selected. -- To tell whether a column of an item is selected, use @method TreeItem.is_selected@. bindTree_get_selected_column :: MethodBind bindTree_get_selected_column = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "get_selected_column" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the currently focused column, or -1 if no column is focused. -- In @SELECT_SINGLE@ mode, the focused column is the selected column. In @SELECT_ROW@ mode, the focused column is always 0 if any item is selected. In @SELECT_MULTI@ mode, the focused column is the column under the focus cursor, and there are not necessarily any column selected. -- To tell whether a column of an item is selected, use @method TreeItem.is_selected@. get_selected_column :: (Tree :< cls, Object :< cls) => cls -> IO Int get_selected_column cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_get_selected_column (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "get_selected_column" '[] (IO Int) where nodeMethod = Godot.Core.Tree.get_selected_column {-# NOINLINE bindTree_is_folding_hidden #-} -- | If @true@, the folding arrow is hidden. bindTree_is_folding_hidden :: MethodBind bindTree_is_folding_hidden = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "is_folding_hidden" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the folding arrow is hidden. is_folding_hidden :: (Tree :< cls, Object :< cls) => cls -> IO Bool is_folding_hidden cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_is_folding_hidden (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "is_folding_hidden" '[] (IO Bool) where nodeMethod = Godot.Core.Tree.is_folding_hidden {-# NOINLINE bindTree_is_root_hidden #-} -- | If @true@, the tree's root is hidden. bindTree_is_root_hidden :: MethodBind bindTree_is_root_hidden = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "is_root_hidden" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the tree's root is hidden. is_root_hidden :: (Tree :< cls, Object :< cls) => cls -> IO Bool is_root_hidden cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTree_is_root_hidden (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "is_root_hidden" '[] (IO Bool) where nodeMethod = Godot.Core.Tree.is_root_hidden {-# NOINLINE bindTree_set_allow_reselect #-} -- | If @true@, the currently selected cell may be selected again. bindTree_set_allow_reselect :: MethodBind bindTree_set_allow_reselect = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_allow_reselect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the currently selected cell may be selected again. set_allow_reselect :: (Tree :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_reselect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_allow_reselect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_allow_reselect" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tree.set_allow_reselect {-# NOINLINE bindTree_set_allow_rmb_select #-} -- | If @true@, a right mouse button click can select items. bindTree_set_allow_rmb_select :: MethodBind bindTree_set_allow_rmb_select = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_allow_rmb_select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a right mouse button click can select items. set_allow_rmb_select :: (Tree :< cls, Object :< cls) => cls -> Bool -> IO () set_allow_rmb_select cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_allow_rmb_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_allow_rmb_select" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tree.set_allow_rmb_select {-# NOINLINE bindTree_set_column_expand #-} -- | If @true@, the column will have the "Expand" flag of @Control@. Columns that have the "Expand" flag will use their "min_width" in a similar fashion to @Control.size_flags_stretch_ratio@. bindTree_set_column_expand :: MethodBind bindTree_set_column_expand = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_column_expand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the column will have the "Expand" flag of @Control@. Columns that have the "Expand" flag will use their "min_width" in a similar fashion to @Control.size_flags_stretch_ratio@. set_column_expand :: (Tree :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_column_expand cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_column_expand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_column_expand" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.Tree.set_column_expand {-# NOINLINE bindTree_set_column_min_width #-} -- | Sets the minimum width of a column. Columns that have the "Expand" flag will use their "min_width" in a similar fashion to @Control.size_flags_stretch_ratio@. bindTree_set_column_min_width :: MethodBind bindTree_set_column_min_width = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_column_min_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the minimum width of a column. Columns that have the "Expand" flag will use their "min_width" in a similar fashion to @Control.size_flags_stretch_ratio@. set_column_min_width :: (Tree :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_column_min_width cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_column_min_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_column_min_width" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Tree.set_column_min_width {-# NOINLINE bindTree_set_column_title #-} -- | Sets the title of a column. bindTree_set_column_title :: MethodBind bindTree_set_column_title = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_column_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the title of a column. set_column_title :: (Tree :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_column_title cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_column_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_column_title" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.Tree.set_column_title {-# NOINLINE bindTree_set_column_titles_visible #-} -- | If @true@, column titles are visible. bindTree_set_column_titles_visible :: MethodBind bindTree_set_column_titles_visible = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_column_titles_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, column titles are visible. set_column_titles_visible :: (Tree :< cls, Object :< cls) => cls -> Bool -> IO () set_column_titles_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_column_titles_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_column_titles_visible" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tree.set_column_titles_visible {-# NOINLINE bindTree_set_columns #-} -- | The number of columns. bindTree_set_columns :: MethodBind bindTree_set_columns = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_columns" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The number of columns. set_columns :: (Tree :< cls, Object :< cls) => cls -> Int -> IO () set_columns cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_columns (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_columns" '[Int] (IO ()) where nodeMethod = Godot.Core.Tree.set_columns {-# NOINLINE bindTree_set_drop_mode_flags #-} -- | The drop mode as an OR combination of flags. See @enum DropModeFlags@ constants. Once dropping is done, reverts to @DROP_MODE_DISABLED@. Setting this during @method Control.can_drop_data@ is recommended. -- This controls the drop sections, i.e. the decision and drawing of possible drop locations based on the mouse position. bindTree_set_drop_mode_flags :: MethodBind bindTree_set_drop_mode_flags = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_drop_mode_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The drop mode as an OR combination of flags. See @enum DropModeFlags@ constants. Once dropping is done, reverts to @DROP_MODE_DISABLED@. Setting this during @method Control.can_drop_data@ is recommended. -- This controls the drop sections, i.e. the decision and drawing of possible drop locations based on the mouse position. set_drop_mode_flags :: (Tree :< cls, Object :< cls) => cls -> Int -> IO () set_drop_mode_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_drop_mode_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_drop_mode_flags" '[Int] (IO ()) where nodeMethod = Godot.Core.Tree.set_drop_mode_flags {-# NOINLINE bindTree_set_hide_folding #-} -- | If @true@, the folding arrow is hidden. bindTree_set_hide_folding :: MethodBind bindTree_set_hide_folding = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_hide_folding" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the folding arrow is hidden. set_hide_folding :: (Tree :< cls, Object :< cls) => cls -> Bool -> IO () set_hide_folding cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_hide_folding (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_hide_folding" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tree.set_hide_folding {-# NOINLINE bindTree_set_hide_root #-} -- | If @true@, the tree's root is hidden. bindTree_set_hide_root :: MethodBind bindTree_set_hide_root = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_hide_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the tree's root is hidden. set_hide_root :: (Tree :< cls, Object :< cls) => cls -> Bool -> IO () set_hide_root cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_hide_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_hide_root" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tree.set_hide_root {-# NOINLINE bindTree_set_select_mode #-} -- | Allows single or multiple selection. See the @enum SelectMode@ constants. bindTree_set_select_mode :: MethodBind bindTree_set_select_mode = unsafePerformIO $ withCString "Tree" $ \ clsNamePtr -> withCString "set_select_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allows single or multiple selection. See the @enum SelectMode@ constants. set_select_mode :: (Tree :< cls, Object :< cls) => cls -> Int -> IO () set_select_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTree_set_select_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tree "set_select_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Tree.set_select_mode ================================================ FILE: src/Godot/Core/TreeItem.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TreeItem (Godot.Core.TreeItem._ALIGN_RIGHT, Godot.Core.TreeItem._CELL_MODE_CUSTOM, Godot.Core.TreeItem._CELL_MODE_ICON, Godot.Core.TreeItem._CELL_MODE_RANGE, Godot.Core.TreeItem._CELL_MODE_STRING, Godot.Core.TreeItem._CELL_MODE_CHECK, Godot.Core.TreeItem._ALIGN_LEFT, Godot.Core.TreeItem._ALIGN_CENTER, Godot.Core.TreeItem.add_button, Godot.Core.TreeItem.call_recursive, Godot.Core.TreeItem.clear_custom_bg_color, Godot.Core.TreeItem.clear_custom_color, Godot.Core.TreeItem.deselect, Godot.Core.TreeItem.erase_button, Godot.Core.TreeItem.get_button, Godot.Core.TreeItem.get_button_count, Godot.Core.TreeItem.get_button_tooltip, Godot.Core.TreeItem.get_cell_mode, Godot.Core.TreeItem.get_children, Godot.Core.TreeItem.get_custom_bg_color, Godot.Core.TreeItem.get_custom_color, Godot.Core.TreeItem.get_custom_minimum_height, Godot.Core.TreeItem.get_expand_right, Godot.Core.TreeItem.get_icon, Godot.Core.TreeItem.get_icon_max_width, Godot.Core.TreeItem.get_icon_modulate, Godot.Core.TreeItem.get_icon_region, Godot.Core.TreeItem.get_metadata, Godot.Core.TreeItem.get_next, Godot.Core.TreeItem.get_next_visible, Godot.Core.TreeItem.get_parent, Godot.Core.TreeItem.get_prev, Godot.Core.TreeItem.get_prev_visible, Godot.Core.TreeItem.get_range, Godot.Core.TreeItem.get_range_config, Godot.Core.TreeItem.get_text, Godot.Core.TreeItem.get_text_align, Godot.Core.TreeItem.get_tooltip, Godot.Core.TreeItem.is_button_disabled, Godot.Core.TreeItem.is_checked, Godot.Core.TreeItem.is_collapsed, Godot.Core.TreeItem.is_custom_set_as_button, Godot.Core.TreeItem.is_editable, Godot.Core.TreeItem.is_folding_disabled, Godot.Core.TreeItem.is_selectable, Godot.Core.TreeItem.is_selected, Godot.Core.TreeItem.move_to_bottom, Godot.Core.TreeItem.move_to_top, Godot.Core.TreeItem.remove_child, Godot.Core.TreeItem.select, Godot.Core.TreeItem.set_button, Godot.Core.TreeItem.set_button_disabled, Godot.Core.TreeItem.set_cell_mode, Godot.Core.TreeItem.set_checked, Godot.Core.TreeItem.set_collapsed, Godot.Core.TreeItem.set_custom_as_button, Godot.Core.TreeItem.set_custom_bg_color, Godot.Core.TreeItem.set_custom_color, Godot.Core.TreeItem.set_custom_draw, Godot.Core.TreeItem.set_custom_minimum_height, Godot.Core.TreeItem.set_disable_folding, Godot.Core.TreeItem.set_editable, Godot.Core.TreeItem.set_expand_right, Godot.Core.TreeItem.set_icon, Godot.Core.TreeItem.set_icon_max_width, Godot.Core.TreeItem.set_icon_modulate, Godot.Core.TreeItem.set_icon_region, Godot.Core.TreeItem.set_metadata, Godot.Core.TreeItem.set_range, Godot.Core.TreeItem.set_range_config, Godot.Core.TreeItem.set_selectable, Godot.Core.TreeItem.set_text, Godot.Core.TreeItem.set_text_align, Godot.Core.TreeItem.set_tooltip) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _ALIGN_RIGHT :: Int _ALIGN_RIGHT = 2 _CELL_MODE_CUSTOM :: Int _CELL_MODE_CUSTOM = 4 _CELL_MODE_ICON :: Int _CELL_MODE_ICON = 3 _CELL_MODE_RANGE :: Int _CELL_MODE_RANGE = 2 _CELL_MODE_STRING :: Int _CELL_MODE_STRING = 0 _CELL_MODE_CHECK :: Int _CELL_MODE_CHECK = 1 _ALIGN_LEFT :: Int _ALIGN_LEFT = 0 _ALIGN_CENTER :: Int _ALIGN_CENTER = 1 instance NodeProperty TreeItem "collapsed" Bool 'False where nodeProperty = (is_collapsed, wrapDroppingSetter set_collapsed, Nothing) instance NodeProperty TreeItem "custom_minimum_height" Int 'False where nodeProperty = (get_custom_minimum_height, wrapDroppingSetter set_custom_minimum_height, Nothing) instance NodeProperty TreeItem "disable_folding" Bool 'False where nodeProperty = (is_folding_disabled, wrapDroppingSetter set_disable_folding, Nothing) {-# NOINLINE bindTreeItem_add_button #-} -- | Adds a button with @Texture@ @button@ at column @column@. The @button_idx@ index is used to identify the button when calling other methods. If not specified, the next available index is used, which may be retrieved by calling @method get_button_count@ immediately after this method. Optionally, the button can be @disabled@ and have a @tooltip@. bindTreeItem_add_button :: MethodBind bindTreeItem_add_button = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "add_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a button with @Texture@ @button@ at column @column@. The @button_idx@ index is used to identify the button when calling other methods. If not specified, the next available index is used, which may be retrieved by calling @method get_button_count@ immediately after this method. Optionally, the button can be @disabled@ and have a @tooltip@. add_button :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Texture -> Maybe Int -> Maybe Bool -> Maybe GodotString -> IO () add_button cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (-1)) toVariant arg3, maybe (VariantBool False) toVariant arg4, defaultedVariant VariantString "" arg5] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_add_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "add_button" '[Int, Texture, Maybe Int, Maybe Bool, Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.TreeItem.add_button {-# NOINLINE bindTreeItem_call_recursive #-} -- | Calls the @method@ on the actual TreeItem and its children recursively. Pass parameters as a comma separated list. bindTreeItem_call_recursive :: MethodBind bindTreeItem_call_recursive = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "call_recursive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls the @method@ on the actual TreeItem and its children recursively. Pass parameters as a comma separated list. call_recursive :: (TreeItem :< cls, Object :< cls) => cls -> GodotString -> [Variant 'GodotTy] -> IO GodotVariant call_recursive cls arg1 varargs = withVariantArray ([toVariant arg1] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_call_recursive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "call_recursive" '[GodotString, [Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.TreeItem.call_recursive {-# NOINLINE bindTreeItem_clear_custom_bg_color #-} -- | Resets the background color for the given column to default. bindTreeItem_clear_custom_bg_color :: MethodBind bindTreeItem_clear_custom_bg_color = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "clear_custom_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resets the background color for the given column to default. clear_custom_bg_color :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO () clear_custom_bg_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_clear_custom_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "clear_custom_bg_color" '[Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.clear_custom_bg_color {-# NOINLINE bindTreeItem_clear_custom_color #-} -- | Resets the color for the given column to default. bindTreeItem_clear_custom_color :: MethodBind bindTreeItem_clear_custom_color = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "clear_custom_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resets the color for the given column to default. clear_custom_color :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO () clear_custom_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_clear_custom_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "clear_custom_color" '[Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.clear_custom_color {-# NOINLINE bindTreeItem_deselect #-} -- | Deselects the given column. bindTreeItem_deselect :: MethodBind bindTreeItem_deselect = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "deselect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Deselects the given column. deselect :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO () deselect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_deselect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "deselect" '[Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.deselect {-# NOINLINE bindTreeItem_erase_button #-} -- | Removes the button at index @button_idx@ in column @column@. bindTreeItem_erase_button :: MethodBind bindTreeItem_erase_button = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "erase_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the button at index @button_idx@ in column @column@. erase_button :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> IO () erase_button cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_erase_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "erase_button" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.erase_button {-# NOINLINE bindTreeItem_get_button #-} -- | Returns the @Texture@ of the button at index @button_idx@ in column @column@. bindTreeItem_get_button :: MethodBind bindTreeItem_get_button = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Texture@ of the button at index @button_idx@ in column @column@. get_button :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> IO Texture get_button cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_button" '[Int, Int] (IO Texture) where nodeMethod = Godot.Core.TreeItem.get_button {-# NOINLINE bindTreeItem_get_button_count #-} -- | Returns the number of buttons in column @column@. May be used to get the most recently added button's index, if no index was specified. bindTreeItem_get_button_count :: MethodBind bindTreeItem_get_button_count = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_button_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of buttons in column @column@. May be used to get the most recently added button's index, if no index was specified. get_button_count :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Int get_button_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_button_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_button_count" '[Int] (IO Int) where nodeMethod = Godot.Core.TreeItem.get_button_count {-# NOINLINE bindTreeItem_get_button_tooltip #-} -- | Returns the tooltip string for the button at index @button_idx@ in column @column@. bindTreeItem_get_button_tooltip :: MethodBind bindTreeItem_get_button_tooltip = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_button_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the tooltip string for the button at index @button_idx@ in column @column@. get_button_tooltip :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> IO GodotString get_button_tooltip cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_button_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_button_tooltip" '[Int, Int] (IO GodotString) where nodeMethod = Godot.Core.TreeItem.get_button_tooltip {-# NOINLINE bindTreeItem_get_cell_mode #-} -- | Returns the column's cell mode. bindTreeItem_get_cell_mode :: MethodBind bindTreeItem_get_cell_mode = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_cell_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the column's cell mode. get_cell_mode :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Int get_cell_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_cell_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_cell_mode" '[Int] (IO Int) where nodeMethod = Godot.Core.TreeItem.get_cell_mode {-# NOINLINE bindTreeItem_get_children #-} -- | Returns the TreeItem's first child item or a null object if there is none. bindTreeItem_get_children :: MethodBind bindTreeItem_get_children = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_children" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the TreeItem's first child item or a null object if there is none. get_children :: (TreeItem :< cls, Object :< cls) => cls -> IO TreeItem get_children cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_children (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_children" '[] (IO TreeItem) where nodeMethod = Godot.Core.TreeItem.get_children {-# NOINLINE bindTreeItem_get_custom_bg_color #-} -- | Returns the custom background color of column @column@. bindTreeItem_get_custom_bg_color :: MethodBind bindTreeItem_get_custom_bg_color = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_custom_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the custom background color of column @column@. get_custom_bg_color :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Color get_custom_bg_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_custom_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_custom_bg_color" '[Int] (IO Color) where nodeMethod = Godot.Core.TreeItem.get_custom_bg_color {-# NOINLINE bindTreeItem_get_custom_color #-} -- | Returns the custom color of column @column@. bindTreeItem_get_custom_color :: MethodBind bindTreeItem_get_custom_color = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_custom_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the custom color of column @column@. get_custom_color :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Color get_custom_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_custom_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_custom_color" '[Int] (IO Color) where nodeMethod = Godot.Core.TreeItem.get_custom_color {-# NOINLINE bindTreeItem_get_custom_minimum_height #-} -- | The custom minimum height. bindTreeItem_get_custom_minimum_height :: MethodBind bindTreeItem_get_custom_minimum_height = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_custom_minimum_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom minimum height. get_custom_minimum_height :: (TreeItem :< cls, Object :< cls) => cls -> IO Int get_custom_minimum_height cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_custom_minimum_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_custom_minimum_height" '[] (IO Int) where nodeMethod = Godot.Core.TreeItem.get_custom_minimum_height {-# NOINLINE bindTreeItem_get_expand_right #-} -- | Returns @true@ if @expand_right@ is set. bindTreeItem_get_expand_right :: MethodBind bindTreeItem_get_expand_right = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_expand_right" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @expand_right@ is set. get_expand_right :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Bool get_expand_right cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_expand_right (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_expand_right" '[Int] (IO Bool) where nodeMethod = Godot.Core.TreeItem.get_expand_right {-# NOINLINE bindTreeItem_get_icon #-} -- | Returns the given column's icon @Texture@. Error if no icon is set. bindTreeItem_get_icon :: MethodBind bindTreeItem_get_icon = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given column's icon @Texture@. Error if no icon is set. get_icon :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Texture get_icon cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_icon" '[Int] (IO Texture) where nodeMethod = Godot.Core.TreeItem.get_icon {-# NOINLINE bindTreeItem_get_icon_max_width #-} -- | Returns the column's icon's maximum width. bindTreeItem_get_icon_max_width :: MethodBind bindTreeItem_get_icon_max_width = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_icon_max_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the column's icon's maximum width. get_icon_max_width :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Int get_icon_max_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_icon_max_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_icon_max_width" '[Int] (IO Int) where nodeMethod = Godot.Core.TreeItem.get_icon_max_width {-# NOINLINE bindTreeItem_get_icon_modulate #-} -- | Returns the @Color@ modulating the column's icon. bindTreeItem_get_icon_modulate :: MethodBind bindTreeItem_get_icon_modulate = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_icon_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Color@ modulating the column's icon. get_icon_modulate :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Color get_icon_modulate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_icon_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_icon_modulate" '[Int] (IO Color) where nodeMethod = Godot.Core.TreeItem.get_icon_modulate {-# NOINLINE bindTreeItem_get_icon_region #-} -- | Returns the icon @Texture@ region as @Rect2@. bindTreeItem_get_icon_region :: MethodBind bindTreeItem_get_icon_region = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_icon_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the icon @Texture@ region as @Rect2@. get_icon_region :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Rect2 get_icon_region cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_icon_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_icon_region" '[Int] (IO Rect2) where nodeMethod = Godot.Core.TreeItem.get_icon_region {-# NOINLINE bindTreeItem_get_metadata #-} bindTreeItem_get_metadata :: MethodBind bindTreeItem_get_metadata = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_metadata :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_metadata cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_metadata" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.TreeItem.get_metadata {-# NOINLINE bindTreeItem_get_next #-} -- | Returns the next TreeItem in the tree or a null object if there is none. bindTreeItem_get_next :: MethodBind bindTreeItem_get_next = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_next" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next TreeItem in the tree or a null object if there is none. get_next :: (TreeItem :< cls, Object :< cls) => cls -> IO TreeItem get_next cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_next (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_next" '[] (IO TreeItem) where nodeMethod = Godot.Core.TreeItem.get_next {-# NOINLINE bindTreeItem_get_next_visible #-} -- | Returns the next visible TreeItem in the tree or a null object if there is none. -- If @wrap@ is enabled, the method will wrap around to the first visible element in the tree when called on the last visible element, otherwise it returns @null@. bindTreeItem_get_next_visible :: MethodBind bindTreeItem_get_next_visible = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_next_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the next visible TreeItem in the tree or a null object if there is none. -- If @wrap@ is enabled, the method will wrap around to the first visible element in the tree when called on the last visible element, otherwise it returns @null@. get_next_visible :: (TreeItem :< cls, Object :< cls) => cls -> Maybe Bool -> IO TreeItem get_next_visible cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_next_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_next_visible" '[Maybe Bool] (IO TreeItem) where nodeMethod = Godot.Core.TreeItem.get_next_visible {-# NOINLINE bindTreeItem_get_parent #-} -- | Returns the parent TreeItem or a null object if there is none. bindTreeItem_get_parent :: MethodBind bindTreeItem_get_parent = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parent TreeItem or a null object if there is none. get_parent :: (TreeItem :< cls, Object :< cls) => cls -> IO TreeItem get_parent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_parent" '[] (IO TreeItem) where nodeMethod = Godot.Core.TreeItem.get_parent {-# NOINLINE bindTreeItem_get_prev #-} -- | Returns the previous TreeItem in the tree or a null object if there is none. bindTreeItem_get_prev :: MethodBind bindTreeItem_get_prev = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_prev" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the previous TreeItem in the tree or a null object if there is none. get_prev :: (TreeItem :< cls, Object :< cls) => cls -> IO TreeItem get_prev cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_prev (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_prev" '[] (IO TreeItem) where nodeMethod = Godot.Core.TreeItem.get_prev {-# NOINLINE bindTreeItem_get_prev_visible #-} -- | Returns the previous visible TreeItem in the tree or a null object if there is none. -- If @wrap@ is enabled, the method will wrap around to the last visible element in the tree when called on the first visible element, otherwise it returns @null@. bindTreeItem_get_prev_visible :: MethodBind bindTreeItem_get_prev_visible = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_prev_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the previous visible TreeItem in the tree or a null object if there is none. -- If @wrap@ is enabled, the method will wrap around to the last visible element in the tree when called on the first visible element, otherwise it returns @null@. get_prev_visible :: (TreeItem :< cls, Object :< cls) => cls -> Maybe Bool -> IO TreeItem get_prev_visible cls arg1 = withVariantArray [maybe (VariantBool False) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_prev_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_prev_visible" '[Maybe Bool] (IO TreeItem) where nodeMethod = Godot.Core.TreeItem.get_prev_visible {-# NOINLINE bindTreeItem_get_range #-} bindTreeItem_get_range :: MethodBind bindTreeItem_get_range = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_range :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Float get_range cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_range" '[Int] (IO Float) where nodeMethod = Godot.Core.TreeItem.get_range {-# NOINLINE bindTreeItem_get_range_config #-} bindTreeItem_get_range_config :: MethodBind bindTreeItem_get_range_config = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_range_config" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_range_config :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Dictionary get_range_config cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_range_config (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_range_config" '[Int] (IO Dictionary) where nodeMethod = Godot.Core.TreeItem.get_range_config {-# NOINLINE bindTreeItem_get_text #-} -- | Returns the given column's text. bindTreeItem_get_text :: MethodBind bindTreeItem_get_text = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given column's text. get_text :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO GodotString get_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_text" '[Int] (IO GodotString) where nodeMethod = Godot.Core.TreeItem.get_text {-# NOINLINE bindTreeItem_get_text_align #-} -- | Returns the given column's text alignment. bindTreeItem_get_text_align :: MethodBind bindTreeItem_get_text_align = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_text_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given column's text alignment. get_text_align :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Int get_text_align cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_text_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_text_align" '[Int] (IO Int) where nodeMethod = Godot.Core.TreeItem.get_text_align {-# NOINLINE bindTreeItem_get_tooltip #-} -- | Returns the given column's tooltip. bindTreeItem_get_tooltip :: MethodBind bindTreeItem_get_tooltip = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "get_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the given column's tooltip. get_tooltip :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO GodotString get_tooltip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_get_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "get_tooltip" '[Int] (IO GodotString) where nodeMethod = Godot.Core.TreeItem.get_tooltip {-# NOINLINE bindTreeItem_is_button_disabled #-} -- | Returns @true@ if the button at index @button_idx@ for the given column is disabled. bindTreeItem_is_button_disabled :: MethodBind bindTreeItem_is_button_disabled = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "is_button_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the button at index @button_idx@ for the given column is disabled. is_button_disabled :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> IO Bool is_button_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_is_button_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "is_button_disabled" '[Int, Int] (IO Bool) where nodeMethod = Godot.Core.TreeItem.is_button_disabled {-# NOINLINE bindTreeItem_is_checked #-} -- | Returns @true@ if the given column is checked. bindTreeItem_is_checked :: MethodBind bindTreeItem_is_checked = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "is_checked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the given column is checked. is_checked :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Bool is_checked cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_is_checked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "is_checked" '[Int] (IO Bool) where nodeMethod = Godot.Core.TreeItem.is_checked {-# NOINLINE bindTreeItem_is_collapsed #-} -- | If @true@, the TreeItem is collapsed. bindTreeItem_is_collapsed :: MethodBind bindTreeItem_is_collapsed = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "is_collapsed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the TreeItem is collapsed. is_collapsed :: (TreeItem :< cls, Object :< cls) => cls -> IO Bool is_collapsed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_is_collapsed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "is_collapsed" '[] (IO Bool) where nodeMethod = Godot.Core.TreeItem.is_collapsed {-# NOINLINE bindTreeItem_is_custom_set_as_button #-} bindTreeItem_is_custom_set_as_button :: MethodBind bindTreeItem_is_custom_set_as_button = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "is_custom_set_as_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_custom_set_as_button :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Bool is_custom_set_as_button cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_is_custom_set_as_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "is_custom_set_as_button" '[Int] (IO Bool) where nodeMethod = Godot.Core.TreeItem.is_custom_set_as_button {-# NOINLINE bindTreeItem_is_editable #-} -- | Returns @true@ if column @column@ is editable. bindTreeItem_is_editable :: MethodBind bindTreeItem_is_editable = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "is_editable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if column @column@ is editable. is_editable :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Bool is_editable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_is_editable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "is_editable" '[Int] (IO Bool) where nodeMethod = Godot.Core.TreeItem.is_editable {-# NOINLINE bindTreeItem_is_folding_disabled #-} -- | If @true@, folding is disabled for this TreeItem. bindTreeItem_is_folding_disabled :: MethodBind bindTreeItem_is_folding_disabled = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "is_folding_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, folding is disabled for this TreeItem. is_folding_disabled :: (TreeItem :< cls, Object :< cls) => cls -> IO Bool is_folding_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_is_folding_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "is_folding_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.TreeItem.is_folding_disabled {-# NOINLINE bindTreeItem_is_selectable #-} -- | Returns @true@ if column @column@ is selectable. bindTreeItem_is_selectable :: MethodBind bindTreeItem_is_selectable = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "is_selectable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if column @column@ is selectable. is_selectable :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Bool is_selectable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_is_selectable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "is_selectable" '[Int] (IO Bool) where nodeMethod = Godot.Core.TreeItem.is_selectable {-# NOINLINE bindTreeItem_is_selected #-} -- | Returns @true@ if column @column@ is selected. bindTreeItem_is_selected :: MethodBind bindTreeItem_is_selected = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "is_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if column @column@ is selected. is_selected :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO Bool is_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_is_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "is_selected" '[Int] (IO Bool) where nodeMethod = Godot.Core.TreeItem.is_selected {-# NOINLINE bindTreeItem_move_to_bottom #-} -- | Moves this TreeItem to the bottom in the @Tree@ hierarchy. bindTreeItem_move_to_bottom :: MethodBind bindTreeItem_move_to_bottom = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "move_to_bottom" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves this TreeItem to the bottom in the @Tree@ hierarchy. move_to_bottom :: (TreeItem :< cls, Object :< cls) => cls -> IO () move_to_bottom cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_move_to_bottom (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "move_to_bottom" '[] (IO ()) where nodeMethod = Godot.Core.TreeItem.move_to_bottom {-# NOINLINE bindTreeItem_move_to_top #-} -- | Moves this TreeItem to the top in the @Tree@ hierarchy. bindTreeItem_move_to_top :: MethodBind bindTreeItem_move_to_top = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "move_to_top" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves this TreeItem to the top in the @Tree@ hierarchy. move_to_top :: (TreeItem :< cls, Object :< cls) => cls -> IO () move_to_top cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_move_to_top (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "move_to_top" '[] (IO ()) where nodeMethod = Godot.Core.TreeItem.move_to_top {-# NOINLINE bindTreeItem_remove_child #-} -- | Removes the given child @TreeItem@ and all its children from the @Tree@. Note that it doesn't free the item from memory, so it can be reused later. To completely remove a @TreeItem@ use @method Object.free@. bindTreeItem_remove_child :: MethodBind bindTreeItem_remove_child = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "remove_child" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the given child @TreeItem@ and all its children from the @Tree@. Note that it doesn't free the item from memory, so it can be reused later. To completely remove a @TreeItem@ use @method Object.free@. remove_child :: (TreeItem :< cls, Object :< cls) => cls -> Object -> IO () remove_child cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_remove_child (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "remove_child" '[Object] (IO ()) where nodeMethod = Godot.Core.TreeItem.remove_child {-# NOINLINE bindTreeItem_select #-} -- | Selects the column @column@. bindTreeItem_select :: MethodBind bindTreeItem_select = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "select" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Selects the column @column@. select :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO () select cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_select (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "select" '[Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.select {-# NOINLINE bindTreeItem_set_button #-} -- | Sets the given column's button @Texture@ at index @button_idx@ to @button@. bindTreeItem_set_button :: MethodBind bindTreeItem_set_button = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's button @Texture@ at index @button_idx@ to @button@. set_button :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> Texture -> IO () set_button cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_button" '[Int, Int, Texture] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_button {-# NOINLINE bindTreeItem_set_button_disabled #-} -- | If @true@, disables the button at index @button_idx@ in column @column@. bindTreeItem_set_button_disabled :: MethodBind bindTreeItem_set_button_disabled = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_button_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, disables the button at index @button_idx@ in column @column@. set_button_disabled :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> Bool -> IO () set_button_disabled cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_button_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_button_disabled" '[Int, Int, Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_button_disabled {-# NOINLINE bindTreeItem_set_cell_mode #-} -- | Sets the given column's cell mode to @mode@. See @enum TreeCellMode@ constants. bindTreeItem_set_cell_mode :: MethodBind bindTreeItem_set_cell_mode = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_cell_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's cell mode to @mode@. See @enum TreeCellMode@ constants. set_cell_mode :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_cell_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_cell_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_cell_mode" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_cell_mode {-# NOINLINE bindTreeItem_set_checked #-} -- | If @true@, the column @column@ is checked. bindTreeItem_set_checked :: MethodBind bindTreeItem_set_checked = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_checked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the column @column@ is checked. set_checked :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_checked cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_checked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_checked" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_checked {-# NOINLINE bindTreeItem_set_collapsed #-} -- | If @true@, the TreeItem is collapsed. bindTreeItem_set_collapsed :: MethodBind bindTreeItem_set_collapsed = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_collapsed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the TreeItem is collapsed. set_collapsed :: (TreeItem :< cls, Object :< cls) => cls -> Bool -> IO () set_collapsed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_collapsed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_collapsed" '[Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_collapsed {-# NOINLINE bindTreeItem_set_custom_as_button #-} bindTreeItem_set_custom_as_button :: MethodBind bindTreeItem_set_custom_as_button = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_custom_as_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_custom_as_button :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_custom_as_button cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_custom_as_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_custom_as_button" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_custom_as_button {-# NOINLINE bindTreeItem_set_custom_bg_color #-} -- | Sets the given column's custom background color and whether to just use it as an outline. bindTreeItem_set_custom_bg_color :: MethodBind bindTreeItem_set_custom_bg_color = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_custom_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's custom background color and whether to just use it as an outline. set_custom_bg_color :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Color -> Maybe Bool -> IO () set_custom_bg_color cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_custom_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_custom_bg_color" '[Int, Color, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_custom_bg_color {-# NOINLINE bindTreeItem_set_custom_color #-} -- | Sets the given column's custom color. bindTreeItem_set_custom_color :: MethodBind bindTreeItem_set_custom_color = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_custom_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's custom color. set_custom_color :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_custom_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_custom_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_custom_color" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_custom_color {-# NOINLINE bindTreeItem_set_custom_draw #-} -- | Sets the given column's custom draw callback to @callback@ method on @object@. -- The @callback@ should accept two arguments: the @TreeItem@ that is drawn and its position and size as a @Rect2@. bindTreeItem_set_custom_draw :: MethodBind bindTreeItem_set_custom_draw = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_custom_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's custom draw callback to @callback@ method on @object@. -- The @callback@ should accept two arguments: the @TreeItem@ that is drawn and its position and size as a @Rect2@. set_custom_draw :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Object -> GodotString -> IO () set_custom_draw cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_custom_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_custom_draw" '[Int, Object, GodotString] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_custom_draw {-# NOINLINE bindTreeItem_set_custom_minimum_height #-} -- | The custom minimum height. bindTreeItem_set_custom_minimum_height :: MethodBind bindTreeItem_set_custom_minimum_height = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_custom_minimum_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom minimum height. set_custom_minimum_height :: (TreeItem :< cls, Object :< cls) => cls -> Int -> IO () set_custom_minimum_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_custom_minimum_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_custom_minimum_height" '[Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_custom_minimum_height {-# NOINLINE bindTreeItem_set_disable_folding #-} -- | If @true@, folding is disabled for this TreeItem. bindTreeItem_set_disable_folding :: MethodBind bindTreeItem_set_disable_folding = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_disable_folding" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, folding is disabled for this TreeItem. set_disable_folding :: (TreeItem :< cls, Object :< cls) => cls -> Bool -> IO () set_disable_folding cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_disable_folding (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_disable_folding" '[Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_disable_folding {-# NOINLINE bindTreeItem_set_editable #-} -- | If @true@, column @column@ is editable. bindTreeItem_set_editable :: MethodBind bindTreeItem_set_editable = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_editable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, column @column@ is editable. set_editable :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_editable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_editable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_editable" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_editable {-# NOINLINE bindTreeItem_set_expand_right #-} -- | If @true@, column @column@ is expanded to the right. bindTreeItem_set_expand_right :: MethodBind bindTreeItem_set_expand_right = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_expand_right" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, column @column@ is expanded to the right. set_expand_right :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_expand_right cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_expand_right (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_expand_right" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_expand_right {-# NOINLINE bindTreeItem_set_icon #-} -- | Sets the given column's icon @Texture@. bindTreeItem_set_icon :: MethodBind bindTreeItem_set_icon = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's icon @Texture@. set_icon :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Texture -> IO () set_icon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_icon" '[Int, Texture] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_icon {-# NOINLINE bindTreeItem_set_icon_max_width #-} -- | Sets the given column's icon's maximum width. bindTreeItem_set_icon_max_width :: MethodBind bindTreeItem_set_icon_max_width = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_icon_max_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's icon's maximum width. set_icon_max_width :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_icon_max_width cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_icon_max_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_icon_max_width" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_icon_max_width {-# NOINLINE bindTreeItem_set_icon_modulate #-} -- | Modulates the given column's icon with @modulate@. bindTreeItem_set_icon_modulate :: MethodBind bindTreeItem_set_icon_modulate = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_icon_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Modulates the given column's icon with @modulate@. set_icon_modulate :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Color -> IO () set_icon_modulate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_icon_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_icon_modulate" '[Int, Color] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_icon_modulate {-# NOINLINE bindTreeItem_set_icon_region #-} -- | Sets the given column's icon's texture region. bindTreeItem_set_icon_region :: MethodBind bindTreeItem_set_icon_region = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_icon_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's icon's texture region. set_icon_region :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Rect2 -> IO () set_icon_region cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_icon_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_icon_region" '[Int, Rect2] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_icon_region {-# NOINLINE bindTreeItem_set_metadata #-} bindTreeItem_set_metadata :: MethodBind bindTreeItem_set_metadata = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_metadata :: (TreeItem :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_metadata cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_metadata" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_metadata {-# NOINLINE bindTreeItem_set_range #-} bindTreeItem_set_range :: MethodBind bindTreeItem_set_range = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_range :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Float -> IO () set_range cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_range" '[Int, Float] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_range {-# NOINLINE bindTreeItem_set_range_config #-} bindTreeItem_set_range_config :: MethodBind bindTreeItem_set_range_config = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_range_config" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_range_config :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Float -> Float -> Float -> Maybe Bool -> IO () set_range_config cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantBool False) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_range_config (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_range_config" '[Int, Float, Float, Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_range_config {-# NOINLINE bindTreeItem_set_selectable #-} -- | If @true@, the given column is selectable. bindTreeItem_set_selectable :: MethodBind bindTreeItem_set_selectable = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_selectable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the given column is selectable. set_selectable :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_selectable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_selectable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_selectable" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_selectable {-# NOINLINE bindTreeItem_set_text #-} bindTreeItem_set_text :: MethodBind bindTreeItem_set_text = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_text :: (TreeItem :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_text cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_text" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_text {-# NOINLINE bindTreeItem_set_text_align #-} -- | Sets the given column's text alignment. See @enum TextAlign@ for possible values. bindTreeItem_set_text_align :: MethodBind bindTreeItem_set_text_align = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_text_align" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's text alignment. See @enum TextAlign@ for possible values. set_text_align :: (TreeItem :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_text_align cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_text_align (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_text_align" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_text_align {-# NOINLINE bindTreeItem_set_tooltip #-} -- | Sets the given column's tooltip text. bindTreeItem_set_tooltip :: MethodBind bindTreeItem_set_tooltip = unsafePerformIO $ withCString "TreeItem" $ \ clsNamePtr -> withCString "set_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the given column's tooltip text. set_tooltip :: (TreeItem :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_tooltip cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTreeItem_set_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod TreeItem "set_tooltip" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.TreeItem.set_tooltip ================================================ FILE: src/Godot/Core/TriangleMesh.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.TriangleMesh () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() ================================================ FILE: src/Godot/Core/Tween.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Tween (Godot.Core.Tween._TRANS_SINE, Godot.Core.Tween._TWEEN_PROCESS_IDLE, Godot.Core.Tween._TWEEN_PROCESS_PHYSICS, Godot.Core.Tween._TRANS_LINEAR, Godot.Core.Tween._EASE_OUT_IN, Godot.Core.Tween._TRANS_QUAD, Godot.Core.Tween._TRANS_EXPO, Godot.Core.Tween._EASE_IN, Godot.Core.Tween._TRANS_QUINT, Godot.Core.Tween._TRANS_BOUNCE, Godot.Core.Tween._TRANS_ELASTIC, Godot.Core.Tween._TRANS_CUBIC, Godot.Core.Tween._EASE_OUT, Godot.Core.Tween._EASE_IN_OUT, Godot.Core.Tween._TRANS_QUART, Godot.Core.Tween._TRANS_BACK, Godot.Core.Tween._TRANS_CIRC, Godot.Core.Tween.sig_tween_all_completed, Godot.Core.Tween.sig_tween_completed, Godot.Core.Tween.sig_tween_started, Godot.Core.Tween.sig_tween_step, Godot.Core.Tween._remove_by_uid, Godot.Core.Tween.follow_method, Godot.Core.Tween.follow_property, Godot.Core.Tween.get_runtime, Godot.Core.Tween.get_speed_scale, Godot.Core.Tween.get_tween_process_mode, Godot.Core.Tween.interpolate_callback, Godot.Core.Tween.interpolate_deferred_callback, Godot.Core.Tween.interpolate_method, Godot.Core.Tween.interpolate_property, Godot.Core.Tween.is_active, Godot.Core.Tween.is_repeat, Godot.Core.Tween.remove, Godot.Core.Tween.remove_all, Godot.Core.Tween.reset, Godot.Core.Tween.reset_all, Godot.Core.Tween.resume, Godot.Core.Tween.resume_all, Godot.Core.Tween.seek, Godot.Core.Tween.set_active, Godot.Core.Tween.set_repeat, Godot.Core.Tween.set_speed_scale, Godot.Core.Tween.set_tween_process_mode, Godot.Core.Tween.start, Godot.Core.Tween.stop, Godot.Core.Tween.stop_all, Godot.Core.Tween.targeting_method, Godot.Core.Tween.targeting_property, Godot.Core.Tween.tell) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _TRANS_SINE :: Int _TRANS_SINE = 1 _TWEEN_PROCESS_IDLE :: Int _TWEEN_PROCESS_IDLE = 1 _TWEEN_PROCESS_PHYSICS :: Int _TWEEN_PROCESS_PHYSICS = 0 _TRANS_LINEAR :: Int _TRANS_LINEAR = 0 _EASE_OUT_IN :: Int _EASE_OUT_IN = 3 _TRANS_QUAD :: Int _TRANS_QUAD = 4 _TRANS_EXPO :: Int _TRANS_EXPO = 5 _EASE_IN :: Int _EASE_IN = 0 _TRANS_QUINT :: Int _TRANS_QUINT = 2 _TRANS_BOUNCE :: Int _TRANS_BOUNCE = 9 _TRANS_ELASTIC :: Int _TRANS_ELASTIC = 6 _TRANS_CUBIC :: Int _TRANS_CUBIC = 7 _EASE_OUT :: Int _EASE_OUT = 1 _EASE_IN_OUT :: Int _EASE_IN_OUT = 2 _TRANS_QUART :: Int _TRANS_QUART = 3 _TRANS_BACK :: Int _TRANS_BACK = 10 _TRANS_CIRC :: Int _TRANS_CIRC = 8 -- | Emitted when all processes in a tween end. sig_tween_all_completed :: Godot.Internal.Dispatch.Signal Tween sig_tween_all_completed = Godot.Internal.Dispatch.Signal "tween_all_completed" instance NodeSignal Tween "tween_all_completed" '[] -- | Emitted when a tween ends. sig_tween_completed :: Godot.Internal.Dispatch.Signal Tween sig_tween_completed = Godot.Internal.Dispatch.Signal "tween_completed" instance NodeSignal Tween "tween_completed" '[Object, NodePath] -- | Emitted when a tween starts. sig_tween_started :: Godot.Internal.Dispatch.Signal Tween sig_tween_started = Godot.Internal.Dispatch.Signal "tween_started" instance NodeSignal Tween "tween_started" '[Object, NodePath] -- | Emitted at each step of the animation. sig_tween_step :: Godot.Internal.Dispatch.Signal Tween sig_tween_step = Godot.Internal.Dispatch.Signal "tween_step" instance NodeSignal Tween "tween_step" '[Object, NodePath, Float, Object] instance NodeProperty Tween "playback_process_mode" Int 'False where nodeProperty = (get_tween_process_mode, wrapDroppingSetter set_tween_process_mode, Nothing) instance NodeProperty Tween "playback_speed" Float 'False where nodeProperty = (get_speed_scale, wrapDroppingSetter set_speed_scale, Nothing) instance NodeProperty Tween "repeat" Bool 'False where nodeProperty = (is_repeat, wrapDroppingSetter set_repeat, Nothing) {-# NOINLINE bindTween__remove_by_uid #-} bindTween__remove_by_uid :: MethodBind bindTween__remove_by_uid = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "_remove_by_uid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _remove_by_uid :: (Tween :< cls, Object :< cls) => cls -> Int -> IO () _remove_by_uid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTween__remove_by_uid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "_remove_by_uid" '[Int] (IO ()) where nodeMethod = Godot.Core.Tween._remove_by_uid {-# NOINLINE bindTween_follow_method #-} -- | Follows @method@ of @object@ and applies the returned value on @target_method@ of @target@, beginning from @initial_val@ for @duration@ seconds, @delay@ later. Methods are called with consecutive values. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. bindTween_follow_method :: MethodBind bindTween_follow_method = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "follow_method" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Follows @method@ of @object@ and applies the returned value on @target_method@ of @target@, beginning from @initial_val@ for @duration@ seconds, @delay@ later. Methods are called with consecutive values. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. follow_method :: (Tween :< cls, Object :< cls) => cls -> Object -> GodotString -> GodotVariant -> Object -> GodotString -> Float -> Maybe Int -> Maybe Int -> Maybe Float -> IO Bool follow_method cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, maybe (VariantInt (0)) toVariant arg7, maybe (VariantInt (2)) toVariant arg8, maybe (VariantReal (0)) toVariant arg9] (\ (arrPtr, len) -> godot_method_bind_call bindTween_follow_method (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "follow_method" '[Object, GodotString, GodotVariant, Object, GodotString, Float, Maybe Int, Maybe Int, Maybe Float] (IO Bool) where nodeMethod = Godot.Core.Tween.follow_method {-# NOINLINE bindTween_follow_property #-} -- | Follows @property@ of @object@ and applies it on @target_property@ of @target@, beginning from @initial_val@ for @duration@ seconds, @delay@ seconds later. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. bindTween_follow_property :: MethodBind bindTween_follow_property = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "follow_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Follows @property@ of @object@ and applies it on @target_property@ of @target@, beginning from @initial_val@ for @duration@ seconds, @delay@ seconds later. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. follow_property :: (Tween :< cls, Object :< cls) => cls -> Object -> NodePath -> GodotVariant -> Object -> NodePath -> Float -> Maybe Int -> Maybe Int -> Maybe Float -> IO Bool follow_property cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, maybe (VariantInt (0)) toVariant arg7, maybe (VariantInt (2)) toVariant arg8, maybe (VariantReal (0)) toVariant arg9] (\ (arrPtr, len) -> godot_method_bind_call bindTween_follow_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "follow_property" '[Object, NodePath, GodotVariant, Object, NodePath, Float, Maybe Int, Maybe Int, Maybe Float] (IO Bool) where nodeMethod = Godot.Core.Tween.follow_property {-# NOINLINE bindTween_get_runtime #-} -- | Returns the total time needed for all tweens to end. If you have two tweens, one lasting 10 seconds and the other 20 seconds, it would return 20 seconds, as by that time all tweens would have finished. bindTween_get_runtime :: MethodBind bindTween_get_runtime = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "get_runtime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total time needed for all tweens to end. If you have two tweens, one lasting 10 seconds and the other 20 seconds, it would return 20 seconds, as by that time all tweens would have finished. get_runtime :: (Tween :< cls, Object :< cls) => cls -> IO Float get_runtime cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_get_runtime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "get_runtime" '[] (IO Float) where nodeMethod = Godot.Core.Tween.get_runtime {-# NOINLINE bindTween_get_speed_scale #-} -- | The tween's speed multiplier. For example, set it to @1.0@ for normal speed, @2.0@ for two times normal speed, or @0.5@ for half of the normal speed. A value of @0@ pauses the animation, but see also @method set_active@ or @method stop_all@ for this. bindTween_get_speed_scale :: MethodBind bindTween_get_speed_scale = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "get_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The tween's speed multiplier. For example, set it to @1.0@ for normal speed, @2.0@ for two times normal speed, or @0.5@ for half of the normal speed. A value of @0@ pauses the animation, but see also @method set_active@ or @method stop_all@ for this. get_speed_scale :: (Tween :< cls, Object :< cls) => cls -> IO Float get_speed_scale cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_get_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "get_speed_scale" '[] (IO Float) where nodeMethod = Godot.Core.Tween.get_speed_scale {-# NOINLINE bindTween_get_tween_process_mode #-} -- | The tween's animation process thread. See @enum TweenProcessMode@. bindTween_get_tween_process_mode :: MethodBind bindTween_get_tween_process_mode = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "get_tween_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The tween's animation process thread. See @enum TweenProcessMode@. get_tween_process_mode :: (Tween :< cls, Object :< cls) => cls -> IO Int get_tween_process_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_get_tween_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "get_tween_process_mode" '[] (IO Int) where nodeMethod = Godot.Core.Tween.get_tween_process_mode {-# NOINLINE bindTween_interpolate_callback #-} -- | Calls @callback@ of @object@ after @duration@. @arg1@-@arg5@ are arguments to be passed to the callback. bindTween_interpolate_callback :: MethodBind bindTween_interpolate_callback = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "interpolate_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls @callback@ of @object@ after @duration@. @arg1@-@arg5@ are arguments to be passed to the callback. interpolate_callback :: (Tween :< cls, Object :< cls) => cls -> Object -> Float -> GodotString -> Maybe GodotVariant -> Maybe GodotVariant -> Maybe GodotVariant -> Maybe GodotVariant -> Maybe GodotVariant -> IO Bool interpolate_callback cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4, maybe VariantNil toVariant arg5, maybe VariantNil toVariant arg6, maybe VariantNil toVariant arg7, maybe VariantNil toVariant arg8] (\ (arrPtr, len) -> godot_method_bind_call bindTween_interpolate_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "interpolate_callback" '[Object, Float, GodotString, Maybe GodotVariant, Maybe GodotVariant, Maybe GodotVariant, Maybe GodotVariant, Maybe GodotVariant] (IO Bool) where nodeMethod = Godot.Core.Tween.interpolate_callback {-# NOINLINE bindTween_interpolate_deferred_callback #-} -- | Calls @callback@ of @object@ after @duration@ on the main thread (similar to @method Object.call_deferred@). @arg1@-@arg5@ are arguments to be passed to the callback. bindTween_interpolate_deferred_callback :: MethodBind bindTween_interpolate_deferred_callback = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "interpolate_deferred_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calls @callback@ of @object@ after @duration@ on the main thread (similar to @method Object.call_deferred@). @arg1@-@arg5@ are arguments to be passed to the callback. interpolate_deferred_callback :: (Tween :< cls, Object :< cls) => cls -> Object -> Float -> GodotString -> Maybe GodotVariant -> Maybe GodotVariant -> Maybe GodotVariant -> Maybe GodotVariant -> Maybe GodotVariant -> IO Bool interpolate_deferred_callback cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4, maybe VariantNil toVariant arg5, maybe VariantNil toVariant arg6, maybe VariantNil toVariant arg7, maybe VariantNil toVariant arg8] (\ (arrPtr, len) -> godot_method_bind_call bindTween_interpolate_deferred_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "interpolate_deferred_callback" '[Object, Float, GodotString, Maybe GodotVariant, Maybe GodotVariant, Maybe GodotVariant, Maybe GodotVariant, Maybe GodotVariant] (IO Bool) where nodeMethod = Godot.Core.Tween.interpolate_deferred_callback {-# NOINLINE bindTween_interpolate_method #-} -- | Animates @method@ of @object@ from @initial_val@ to @final_val@ for @duration@ seconds, @delay@ seconds later. Methods are called with consecutive values. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. bindTween_interpolate_method :: MethodBind bindTween_interpolate_method = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "interpolate_method" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Animates @method@ of @object@ from @initial_val@ to @final_val@ for @duration@ seconds, @delay@ seconds later. Methods are called with consecutive values. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. interpolate_method :: (Tween :< cls, Object :< cls) => cls -> Object -> GodotString -> GodotVariant -> GodotVariant -> Float -> Maybe Int -> Maybe Int -> Maybe Float -> IO Bool interpolate_method cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, maybe (VariantInt (0)) toVariant arg6, maybe (VariantInt (2)) toVariant arg7, maybe (VariantReal (0)) toVariant arg8] (\ (arrPtr, len) -> godot_method_bind_call bindTween_interpolate_method (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "interpolate_method" '[Object, GodotString, GodotVariant, GodotVariant, Float, Maybe Int, Maybe Int, Maybe Float] (IO Bool) where nodeMethod = Godot.Core.Tween.interpolate_method {-# NOINLINE bindTween_interpolate_property #-} -- | Animates @property@ of @object@ from @initial_val@ to @final_val@ for @duration@ seconds, @delay@ seconds later. Setting the initial value to @null@ uses the current value of the property. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. bindTween_interpolate_property :: MethodBind bindTween_interpolate_property = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "interpolate_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Animates @property@ of @object@ from @initial_val@ to @final_val@ for @duration@ seconds, @delay@ seconds later. Setting the initial value to @null@ uses the current value of the property. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. interpolate_property :: (Tween :< cls, Object :< cls) => cls -> Object -> NodePath -> GodotVariant -> GodotVariant -> Float -> Maybe Int -> Maybe Int -> Maybe Float -> IO Bool interpolate_property cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, maybe (VariantInt (0)) toVariant arg6, maybe (VariantInt (2)) toVariant arg7, maybe (VariantReal (0)) toVariant arg8] (\ (arrPtr, len) -> godot_method_bind_call bindTween_interpolate_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "interpolate_property" '[Object, NodePath, GodotVariant, GodotVariant, Float, Maybe Int, Maybe Int, Maybe Float] (IO Bool) where nodeMethod = Godot.Core.Tween.interpolate_property {-# NOINLINE bindTween_is_active #-} -- | Returns @true@ if any tweens are currently running. -- __Note:__ This method doesn't consider tweens that have ended. bindTween_is_active :: MethodBind bindTween_is_active = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "is_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if any tweens are currently running. -- __Note:__ This method doesn't consider tweens that have ended. is_active :: (Tween :< cls, Object :< cls) => cls -> IO Bool is_active cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_is_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "is_active" '[] (IO Bool) where nodeMethod = Godot.Core.Tween.is_active {-# NOINLINE bindTween_is_repeat #-} -- | If @true@, the tween loops. bindTween_is_repeat :: MethodBind bindTween_is_repeat = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "is_repeat" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the tween loops. is_repeat :: (Tween :< cls, Object :< cls) => cls -> IO Bool is_repeat cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_is_repeat (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "is_repeat" '[] (IO Bool) where nodeMethod = Godot.Core.Tween.is_repeat {-# NOINLINE bindTween_remove #-} -- | Stops animation and removes a tween, given its object and property/method pair. By default, all tweens are removed, unless @key@ is specified. bindTween_remove :: MethodBind bindTween_remove = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "remove" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops animation and removes a tween, given its object and property/method pair. By default, all tweens are removed, unless @key@ is specified. remove :: (Tween :< cls, Object :< cls) => cls -> Object -> Maybe GodotString -> IO Bool remove cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTween_remove (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "remove" '[Object, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Tween.remove {-# NOINLINE bindTween_remove_all #-} -- | Stops animation and removes all tweens. bindTween_remove_all :: MethodBind bindTween_remove_all = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "remove_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops animation and removes all tweens. remove_all :: (Tween :< cls, Object :< cls) => cls -> IO Bool remove_all cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_remove_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "remove_all" '[] (IO Bool) where nodeMethod = Godot.Core.Tween.remove_all {-# NOINLINE bindTween_reset #-} -- | Resets a tween to its initial value (the one given, not the one before the tween), given its object and property/method pair. By default, all tweens are removed, unless @key@ is specified. bindTween_reset :: MethodBind bindTween_reset = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "reset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resets a tween to its initial value (the one given, not the one before the tween), given its object and property/method pair. By default, all tweens are removed, unless @key@ is specified. reset :: (Tween :< cls, Object :< cls) => cls -> Object -> Maybe GodotString -> IO Bool reset cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTween_reset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "reset" '[Object, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Tween.reset {-# NOINLINE bindTween_reset_all #-} -- | Resets all tweens to their initial values (the ones given, not those before the tween). bindTween_reset_all :: MethodBind bindTween_reset_all = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "reset_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resets all tweens to their initial values (the ones given, not those before the tween). reset_all :: (Tween :< cls, Object :< cls) => cls -> IO Bool reset_all cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_reset_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "reset_all" '[] (IO Bool) where nodeMethod = Godot.Core.Tween.reset_all {-# NOINLINE bindTween_resume #-} -- | Continues animating a stopped tween, given its object and property/method pair. By default, all tweens are resumed, unless @key@ is specified. bindTween_resume :: MethodBind bindTween_resume = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "resume" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Continues animating a stopped tween, given its object and property/method pair. By default, all tweens are resumed, unless @key@ is specified. resume :: (Tween :< cls, Object :< cls) => cls -> Object -> Maybe GodotString -> IO Bool resume cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTween_resume (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "resume" '[Object, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Tween.resume {-# NOINLINE bindTween_resume_all #-} -- | Continues animating all stopped tweens. bindTween_resume_all :: MethodBind bindTween_resume_all = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "resume_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Continues animating all stopped tweens. resume_all :: (Tween :< cls, Object :< cls) => cls -> IO Bool resume_all cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_resume_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "resume_all" '[] (IO Bool) where nodeMethod = Godot.Core.Tween.resume_all {-# NOINLINE bindTween_seek #-} -- | Sets the interpolation to the given @time@ in seconds. bindTween_seek :: MethodBind bindTween_seek = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the interpolation to the given @time@ in seconds. seek :: (Tween :< cls, Object :< cls) => cls -> Float -> IO Bool seek cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTween_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "seek" '[Float] (IO Bool) where nodeMethod = Godot.Core.Tween.seek {-# NOINLINE bindTween_set_active #-} -- | Activates/deactivates the tween. See also @method stop_all@ and @method resume_all@. bindTween_set_active :: MethodBind bindTween_set_active = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Activates/deactivates the tween. See also @method stop_all@ and @method resume_all@. set_active :: (Tween :< cls, Object :< cls) => cls -> Bool -> IO () set_active cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTween_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "set_active" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tween.set_active {-# NOINLINE bindTween_set_repeat #-} -- | If @true@, the tween loops. bindTween_set_repeat :: MethodBind bindTween_set_repeat = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "set_repeat" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the tween loops. set_repeat :: (Tween :< cls, Object :< cls) => cls -> Bool -> IO () set_repeat cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTween_set_repeat (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "set_repeat" '[Bool] (IO ()) where nodeMethod = Godot.Core.Tween.set_repeat {-# NOINLINE bindTween_set_speed_scale #-} -- | The tween's speed multiplier. For example, set it to @1.0@ for normal speed, @2.0@ for two times normal speed, or @0.5@ for half of the normal speed. A value of @0@ pauses the animation, but see also @method set_active@ or @method stop_all@ for this. bindTween_set_speed_scale :: MethodBind bindTween_set_speed_scale = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "set_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The tween's speed multiplier. For example, set it to @1.0@ for normal speed, @2.0@ for two times normal speed, or @0.5@ for half of the normal speed. A value of @0@ pauses the animation, but see also @method set_active@ or @method stop_all@ for this. set_speed_scale :: (Tween :< cls, Object :< cls) => cls -> Float -> IO () set_speed_scale cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTween_set_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "set_speed_scale" '[Float] (IO ()) where nodeMethod = Godot.Core.Tween.set_speed_scale {-# NOINLINE bindTween_set_tween_process_mode #-} -- | The tween's animation process thread. See @enum TweenProcessMode@. bindTween_set_tween_process_mode :: MethodBind bindTween_set_tween_process_mode = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "set_tween_process_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The tween's animation process thread. See @enum TweenProcessMode@. set_tween_process_mode :: (Tween :< cls, Object :< cls) => cls -> Int -> IO () set_tween_process_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindTween_set_tween_process_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "set_tween_process_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Tween.set_tween_process_mode {-# NOINLINE bindTween_start #-} -- | Starts the tween. You can define animations both before and after this. bindTween_start :: MethodBind bindTween_start = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "start" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts the tween. You can define animations both before and after this. start :: (Tween :< cls, Object :< cls) => cls -> IO Bool start cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_start (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "start" '[] (IO Bool) where nodeMethod = Godot.Core.Tween.start {-# NOINLINE bindTween_stop #-} -- | Stops a tween, given its object and property/method pair. By default, all tweens are stopped, unless @key@ is specified. bindTween_stop :: MethodBind bindTween_stop = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops a tween, given its object and property/method pair. By default, all tweens are stopped, unless @key@ is specified. stop :: (Tween :< cls, Object :< cls) => cls -> Object -> Maybe GodotString -> IO Bool stop cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindTween_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "stop" '[Object, Maybe GodotString] (IO Bool) where nodeMethod = Godot.Core.Tween.stop {-# NOINLINE bindTween_stop_all #-} -- | Stops animating all tweens. bindTween_stop_all :: MethodBind bindTween_stop_all = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "stop_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops animating all tweens. stop_all :: (Tween :< cls, Object :< cls) => cls -> IO Bool stop_all cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_stop_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "stop_all" '[] (IO Bool) where nodeMethod = Godot.Core.Tween.stop_all {-# NOINLINE bindTween_targeting_method #-} -- | Animates @method@ of @object@ from the value returned by @initial_method@ to @final_val@ for @duration@ seconds, @delay@ seconds later. Methods are animated by calling them with consecutive values. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. bindTween_targeting_method :: MethodBind bindTween_targeting_method = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "targeting_method" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Animates @method@ of @object@ from the value returned by @initial_method@ to @final_val@ for @duration@ seconds, @delay@ seconds later. Methods are animated by calling them with consecutive values. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. targeting_method :: (Tween :< cls, Object :< cls) => cls -> Object -> GodotString -> Object -> GodotString -> GodotVariant -> Float -> Maybe Int -> Maybe Int -> Maybe Float -> IO Bool targeting_method cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, maybe (VariantInt (0)) toVariant arg7, maybe (VariantInt (2)) toVariant arg8, maybe (VariantReal (0)) toVariant arg9] (\ (arrPtr, len) -> godot_method_bind_call bindTween_targeting_method (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "targeting_method" '[Object, GodotString, Object, GodotString, GodotVariant, Float, Maybe Int, Maybe Int, Maybe Float] (IO Bool) where nodeMethod = Godot.Core.Tween.targeting_method {-# NOINLINE bindTween_targeting_property #-} -- | Animates @property@ of @object@ from the current value of the @initial_val@ property of @initial@ to @final_val@ for @duration@ seconds, @delay@ seconds later. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. bindTween_targeting_property :: MethodBind bindTween_targeting_property = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "targeting_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Animates @property@ of @object@ from the current value of the @initial_val@ property of @initial@ to @final_val@ for @duration@ seconds, @delay@ seconds later. -- Use @enum TransitionType@ for @trans_type@ and @enum EaseType@ for @ease_type@ parameters. These values control the timing and direction of the interpolation. See the class description for more information. targeting_property :: (Tween :< cls, Object :< cls) => cls -> Object -> NodePath -> Object -> NodePath -> GodotVariant -> Float -> Maybe Int -> Maybe Int -> Maybe Float -> IO Bool targeting_property cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, maybe (VariantInt (0)) toVariant arg7, maybe (VariantInt (2)) toVariant arg8, maybe (VariantReal (0)) toVariant arg9] (\ (arrPtr, len) -> godot_method_bind_call bindTween_targeting_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "targeting_property" '[Object, NodePath, Object, NodePath, GodotVariant, Float, Maybe Int, Maybe Int, Maybe Float] (IO Bool) where nodeMethod = Godot.Core.Tween.targeting_property {-# NOINLINE bindTween_tell #-} -- | Returns the current time of the tween. bindTween_tell :: MethodBind bindTween_tell = unsafePerformIO $ withCString "Tween" $ \ clsNamePtr -> withCString "tell" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current time of the tween. tell :: (Tween :< cls, Object :< cls) => cls -> IO Float tell cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindTween_tell (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Tween "tell" '[] (IO Float) where nodeMethod = Godot.Core.Tween.tell ================================================ FILE: src/Godot/Core/UPNP.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.UPNP (Godot.Core.UPNP._UPNP_RESULT_NO_SUCH_ENTRY_IN_ARRAY, Godot.Core.UPNP._UPNP_RESULT_NO_DEVICES, Godot.Core.UPNP._UPNP_RESULT_EXT_PORT_WILDCARD_NOT_PERMITTED, Godot.Core.UPNP._UPNP_RESULT_SAME_PORT_VALUES_REQUIRED, Godot.Core.UPNP._UPNP_RESULT_MEM_ALLOC_ERROR, Godot.Core.UPNP._UPNP_RESULT_INVALID_PROTOCOL, Godot.Core.UPNP._UPNP_RESULT_HTTP_ERROR, Godot.Core.UPNP._UPNP_RESULT_INT_PORT_WILDCARD_NOT_PERMITTED, Godot.Core.UPNP._UPNP_RESULT_INVALID_PORT, Godot.Core.UPNP._UPNP_RESULT_ACTION_FAILED, Godot.Core.UPNP._UPNP_RESULT_PORT_MAPPING_NOT_FOUND, Godot.Core.UPNP._UPNP_RESULT_INVALID_PARAM, Godot.Core.UPNP._UPNP_RESULT_REMOTE_HOST_MUST_BE_WILDCARD, Godot.Core.UPNP._UPNP_RESULT_SRC_IP_WILDCARD_NOT_PERMITTED, Godot.Core.UPNP._UPNP_RESULT_NO_GATEWAY, Godot.Core.UPNP._UPNP_RESULT_INVALID_GATEWAY, Godot.Core.UPNP._UPNP_RESULT_NOT_AUTHORIZED, Godot.Core.UPNP._UPNP_RESULT_INVALID_RESPONSE, Godot.Core.UPNP._UPNP_RESULT_INVALID_DURATION, Godot.Core.UPNP._UPNP_RESULT_UNKNOWN_ERROR, Godot.Core.UPNP._UPNP_RESULT_INCONSISTENT_PARAMETERS, Godot.Core.UPNP._UPNP_RESULT_EXT_PORT_MUST_BE_WILDCARD, Godot.Core.UPNP._UPNP_RESULT_SOCKET_ERROR, Godot.Core.UPNP._UPNP_RESULT_NO_PORT_MAPS_AVAILABLE, Godot.Core.UPNP._UPNP_RESULT_ONLY_PERMANENT_LEASE_SUPPORTED, Godot.Core.UPNP._UPNP_RESULT_INVALID_ARGS, Godot.Core.UPNP._UPNP_RESULT_CONFLICT_WITH_OTHER_MECHANISM, Godot.Core.UPNP._UPNP_RESULT_SUCCESS, Godot.Core.UPNP._UPNP_RESULT_CONFLICT_WITH_OTHER_MAPPING, Godot.Core.UPNP.add_device, Godot.Core.UPNP.add_port_mapping, Godot.Core.UPNP.clear_devices, Godot.Core.UPNP.delete_port_mapping, Godot.Core.UPNP.discover, Godot.Core.UPNP.get_device, Godot.Core.UPNP.get_device_count, Godot.Core.UPNP.get_discover_local_port, Godot.Core.UPNP.get_discover_multicast_if, Godot.Core.UPNP.get_gateway, Godot.Core.UPNP.is_discover_ipv6, Godot.Core.UPNP.query_external_address, Godot.Core.UPNP.remove_device, Godot.Core.UPNP.set_device, Godot.Core.UPNP.set_discover_ipv6, Godot.Core.UPNP.set_discover_local_port, Godot.Core.UPNP.set_discover_multicast_if) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _UPNP_RESULT_NO_SUCH_ENTRY_IN_ARRAY :: Int _UPNP_RESULT_NO_SUCH_ENTRY_IN_ARRAY = 4 _UPNP_RESULT_NO_DEVICES :: Int _UPNP_RESULT_NO_DEVICES = 27 _UPNP_RESULT_EXT_PORT_WILDCARD_NOT_PERMITTED :: Int _UPNP_RESULT_EXT_PORT_WILDCARD_NOT_PERMITTED = 7 _UPNP_RESULT_SAME_PORT_VALUES_REQUIRED :: Int _UPNP_RESULT_SAME_PORT_VALUES_REQUIRED = 14 _UPNP_RESULT_MEM_ALLOC_ERROR :: Int _UPNP_RESULT_MEM_ALLOC_ERROR = 25 _UPNP_RESULT_INVALID_PROTOCOL :: Int _UPNP_RESULT_INVALID_PROTOCOL = 18 _UPNP_RESULT_HTTP_ERROR :: Int _UPNP_RESULT_HTTP_ERROR = 23 _UPNP_RESULT_INT_PORT_WILDCARD_NOT_PERMITTED :: Int _UPNP_RESULT_INT_PORT_WILDCARD_NOT_PERMITTED = 8 _UPNP_RESULT_INVALID_PORT :: Int _UPNP_RESULT_INVALID_PORT = 17 _UPNP_RESULT_ACTION_FAILED :: Int _UPNP_RESULT_ACTION_FAILED = 5 _UPNP_RESULT_PORT_MAPPING_NOT_FOUND :: Int _UPNP_RESULT_PORT_MAPPING_NOT_FOUND = 2 _UPNP_RESULT_INVALID_PARAM :: Int _UPNP_RESULT_INVALID_PARAM = 22 _UPNP_RESULT_REMOTE_HOST_MUST_BE_WILDCARD :: Int _UPNP_RESULT_REMOTE_HOST_MUST_BE_WILDCARD = 9 _UPNP_RESULT_SRC_IP_WILDCARD_NOT_PERMITTED :: Int _UPNP_RESULT_SRC_IP_WILDCARD_NOT_PERMITTED = 6 _UPNP_RESULT_NO_GATEWAY :: Int _UPNP_RESULT_NO_GATEWAY = 26 _UPNP_RESULT_INVALID_GATEWAY :: Int _UPNP_RESULT_INVALID_GATEWAY = 16 _UPNP_RESULT_NOT_AUTHORIZED :: Int _UPNP_RESULT_NOT_AUTHORIZED = 1 _UPNP_RESULT_INVALID_RESPONSE :: Int _UPNP_RESULT_INVALID_RESPONSE = 21 _UPNP_RESULT_INVALID_DURATION :: Int _UPNP_RESULT_INVALID_DURATION = 19 _UPNP_RESULT_UNKNOWN_ERROR :: Int _UPNP_RESULT_UNKNOWN_ERROR = 28 _UPNP_RESULT_INCONSISTENT_PARAMETERS :: Int _UPNP_RESULT_INCONSISTENT_PARAMETERS = 3 _UPNP_RESULT_EXT_PORT_MUST_BE_WILDCARD :: Int _UPNP_RESULT_EXT_PORT_MUST_BE_WILDCARD = 10 _UPNP_RESULT_SOCKET_ERROR :: Int _UPNP_RESULT_SOCKET_ERROR = 24 _UPNP_RESULT_NO_PORT_MAPS_AVAILABLE :: Int _UPNP_RESULT_NO_PORT_MAPS_AVAILABLE = 11 _UPNP_RESULT_ONLY_PERMANENT_LEASE_SUPPORTED :: Int _UPNP_RESULT_ONLY_PERMANENT_LEASE_SUPPORTED = 15 _UPNP_RESULT_INVALID_ARGS :: Int _UPNP_RESULT_INVALID_ARGS = 20 _UPNP_RESULT_CONFLICT_WITH_OTHER_MECHANISM :: Int _UPNP_RESULT_CONFLICT_WITH_OTHER_MECHANISM = 12 _UPNP_RESULT_SUCCESS :: Int _UPNP_RESULT_SUCCESS = 0 _UPNP_RESULT_CONFLICT_WITH_OTHER_MAPPING :: Int _UPNP_RESULT_CONFLICT_WITH_OTHER_MAPPING = 13 instance NodeProperty UPNP "discover_ipv6" Bool 'False where nodeProperty = (is_discover_ipv6, wrapDroppingSetter set_discover_ipv6, Nothing) instance NodeProperty UPNP "discover_local_port" Int 'False where nodeProperty = (get_discover_local_port, wrapDroppingSetter set_discover_local_port, Nothing) instance NodeProperty UPNP "discover_multicast_if" GodotString 'False where nodeProperty = (get_discover_multicast_if, wrapDroppingSetter set_discover_multicast_if, Nothing) {-# NOINLINE bindUPNP_add_device #-} bindUPNP_add_device :: MethodBind bindUPNP_add_device = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "add_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_device :: (UPNP :< cls, Object :< cls) => cls -> UPNPDevice -> IO () add_device cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_add_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "add_device" '[UPNPDevice] (IO ()) where nodeMethod = Godot.Core.UPNP.add_device {-# NOINLINE bindUPNP_add_port_mapping #-} bindUPNP_add_port_mapping :: MethodBind bindUPNP_add_port_mapping = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "add_port_mapping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_port_mapping :: (UPNP :< cls, Object :< cls) => cls -> Int -> Maybe Int -> Maybe GodotString -> Maybe GodotString -> Maybe Int -> IO Int add_port_mapping cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, defaultedVariant VariantString "" arg3, defaultedVariant VariantString "UDP" arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_add_port_mapping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "add_port_mapping" '[Int, Maybe Int, Maybe GodotString, Maybe GodotString, Maybe Int] (IO Int) where nodeMethod = Godot.Core.UPNP.add_port_mapping {-# NOINLINE bindUPNP_clear_devices #-} bindUPNP_clear_devices :: MethodBind bindUPNP_clear_devices = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "clear_devices" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear_devices :: (UPNP :< cls, Object :< cls) => cls -> IO () clear_devices cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_clear_devices (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "clear_devices" '[] (IO ()) where nodeMethod = Godot.Core.UPNP.clear_devices {-# NOINLINE bindUPNP_delete_port_mapping #-} bindUPNP_delete_port_mapping :: MethodBind bindUPNP_delete_port_mapping = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "delete_port_mapping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr delete_port_mapping :: (UPNP :< cls, Object :< cls) => cls -> Int -> Maybe GodotString -> IO Int delete_port_mapping cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "UDP" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_delete_port_mapping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "delete_port_mapping" '[Int, Maybe GodotString] (IO Int) where nodeMethod = Godot.Core.UPNP.delete_port_mapping {-# NOINLINE bindUPNP_discover #-} bindUPNP_discover :: MethodBind bindUPNP_discover = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "discover" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr discover :: (UPNP :< cls, Object :< cls) => cls -> Maybe Int -> Maybe Int -> Maybe GodotString -> IO Int discover cls arg1 arg2 arg3 = withVariantArray [maybe (VariantInt (2000)) toVariant arg1, maybe (VariantInt (2)) toVariant arg2, defaultedVariant VariantString "InternetGatewayDevice" arg3] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_discover (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "discover" '[Maybe Int, Maybe Int, Maybe GodotString] (IO Int) where nodeMethod = Godot.Core.UPNP.discover {-# NOINLINE bindUPNP_get_device #-} bindUPNP_get_device :: MethodBind bindUPNP_get_device = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "get_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_device :: (UPNP :< cls, Object :< cls) => cls -> Int -> IO UPNPDevice get_device cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_get_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "get_device" '[Int] (IO UPNPDevice) where nodeMethod = Godot.Core.UPNP.get_device {-# NOINLINE bindUPNP_get_device_count #-} bindUPNP_get_device_count :: MethodBind bindUPNP_get_device_count = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "get_device_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_device_count :: (UPNP :< cls, Object :< cls) => cls -> IO Int get_device_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_get_device_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "get_device_count" '[] (IO Int) where nodeMethod = Godot.Core.UPNP.get_device_count {-# NOINLINE bindUPNP_get_discover_local_port #-} bindUPNP_get_discover_local_port :: MethodBind bindUPNP_get_discover_local_port = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "get_discover_local_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_discover_local_port :: (UPNP :< cls, Object :< cls) => cls -> IO Int get_discover_local_port cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_get_discover_local_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "get_discover_local_port" '[] (IO Int) where nodeMethod = Godot.Core.UPNP.get_discover_local_port {-# NOINLINE bindUPNP_get_discover_multicast_if #-} bindUPNP_get_discover_multicast_if :: MethodBind bindUPNP_get_discover_multicast_if = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "get_discover_multicast_if" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_discover_multicast_if :: (UPNP :< cls, Object :< cls) => cls -> IO GodotString get_discover_multicast_if cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_get_discover_multicast_if (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "get_discover_multicast_if" '[] (IO GodotString) where nodeMethod = Godot.Core.UPNP.get_discover_multicast_if {-# NOINLINE bindUPNP_get_gateway #-} bindUPNP_get_gateway :: MethodBind bindUPNP_get_gateway = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "get_gateway" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_gateway :: (UPNP :< cls, Object :< cls) => cls -> IO UPNPDevice get_gateway cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_get_gateway (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "get_gateway" '[] (IO UPNPDevice) where nodeMethod = Godot.Core.UPNP.get_gateway {-# NOINLINE bindUPNP_is_discover_ipv6 #-} bindUPNP_is_discover_ipv6 :: MethodBind bindUPNP_is_discover_ipv6 = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "is_discover_ipv6" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_discover_ipv6 :: (UPNP :< cls, Object :< cls) => cls -> IO Bool is_discover_ipv6 cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_is_discover_ipv6 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "is_discover_ipv6" '[] (IO Bool) where nodeMethod = Godot.Core.UPNP.is_discover_ipv6 {-# NOINLINE bindUPNP_query_external_address #-} bindUPNP_query_external_address :: MethodBind bindUPNP_query_external_address = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "query_external_address" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr query_external_address :: (UPNP :< cls, Object :< cls) => cls -> IO GodotString query_external_address cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_query_external_address (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "query_external_address" '[] (IO GodotString) where nodeMethod = Godot.Core.UPNP.query_external_address {-# NOINLINE bindUPNP_remove_device #-} bindUPNP_remove_device :: MethodBind bindUPNP_remove_device = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "remove_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_device :: (UPNP :< cls, Object :< cls) => cls -> Int -> IO () remove_device cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_remove_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "remove_device" '[Int] (IO ()) where nodeMethod = Godot.Core.UPNP.remove_device {-# NOINLINE bindUPNP_set_device #-} bindUPNP_set_device :: MethodBind bindUPNP_set_device = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "set_device" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_device :: (UPNP :< cls, Object :< cls) => cls -> Int -> UPNPDevice -> IO () set_device cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_set_device (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "set_device" '[Int, UPNPDevice] (IO ()) where nodeMethod = Godot.Core.UPNP.set_device {-# NOINLINE bindUPNP_set_discover_ipv6 #-} bindUPNP_set_discover_ipv6 :: MethodBind bindUPNP_set_discover_ipv6 = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "set_discover_ipv6" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_discover_ipv6 :: (UPNP :< cls, Object :< cls) => cls -> Bool -> IO () set_discover_ipv6 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_set_discover_ipv6 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "set_discover_ipv6" '[Bool] (IO ()) where nodeMethod = Godot.Core.UPNP.set_discover_ipv6 {-# NOINLINE bindUPNP_set_discover_local_port #-} bindUPNP_set_discover_local_port :: MethodBind bindUPNP_set_discover_local_port = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "set_discover_local_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_discover_local_port :: (UPNP :< cls, Object :< cls) => cls -> Int -> IO () set_discover_local_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_set_discover_local_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "set_discover_local_port" '[Int] (IO ()) where nodeMethod = Godot.Core.UPNP.set_discover_local_port {-# NOINLINE bindUPNP_set_discover_multicast_if #-} bindUPNP_set_discover_multicast_if :: MethodBind bindUPNP_set_discover_multicast_if = unsafePerformIO $ withCString "UPNP" $ \ clsNamePtr -> withCString "set_discover_multicast_if" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_discover_multicast_if :: (UPNP :< cls, Object :< cls) => cls -> GodotString -> IO () set_discover_multicast_if cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNP_set_discover_multicast_if (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNP "set_discover_multicast_if" '[GodotString] (IO ()) where nodeMethod = Godot.Core.UPNP.set_discover_multicast_if ================================================ FILE: src/Godot/Core/UPNPDevice.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.UPNPDevice (Godot.Core.UPNPDevice._IGD_STATUS_INVALID_CONTROL, Godot.Core.UPNPDevice._IGD_STATUS_DISCONNECTED, Godot.Core.UPNPDevice._IGD_STATUS_OK, Godot.Core.UPNPDevice._IGD_STATUS_NO_URLS, Godot.Core.UPNPDevice._IGD_STATUS_MALLOC_ERROR, Godot.Core.UPNPDevice._IGD_STATUS_UNKNOWN_ERROR, Godot.Core.UPNPDevice._IGD_STATUS_HTTP_EMPTY, Godot.Core.UPNPDevice._IGD_STATUS_NO_IGD, Godot.Core.UPNPDevice._IGD_STATUS_UNKNOWN_DEVICE, Godot.Core.UPNPDevice._IGD_STATUS_HTTP_ERROR, Godot.Core.UPNPDevice.add_port_mapping, Godot.Core.UPNPDevice.delete_port_mapping, Godot.Core.UPNPDevice.get_description_url, Godot.Core.UPNPDevice.get_igd_control_url, Godot.Core.UPNPDevice.get_igd_our_addr, Godot.Core.UPNPDevice.get_igd_service_type, Godot.Core.UPNPDevice.get_igd_status, Godot.Core.UPNPDevice.get_service_type, Godot.Core.UPNPDevice.is_valid_gateway, Godot.Core.UPNPDevice.query_external_address, Godot.Core.UPNPDevice.set_description_url, Godot.Core.UPNPDevice.set_igd_control_url, Godot.Core.UPNPDevice.set_igd_our_addr, Godot.Core.UPNPDevice.set_igd_service_type, Godot.Core.UPNPDevice.set_igd_status, Godot.Core.UPNPDevice.set_service_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _IGD_STATUS_INVALID_CONTROL :: Int _IGD_STATUS_INVALID_CONTROL = 7 _IGD_STATUS_DISCONNECTED :: Int _IGD_STATUS_DISCONNECTED = 5 _IGD_STATUS_OK :: Int _IGD_STATUS_OK = 0 _IGD_STATUS_NO_URLS :: Int _IGD_STATUS_NO_URLS = 3 _IGD_STATUS_MALLOC_ERROR :: Int _IGD_STATUS_MALLOC_ERROR = 8 _IGD_STATUS_UNKNOWN_ERROR :: Int _IGD_STATUS_UNKNOWN_ERROR = 9 _IGD_STATUS_HTTP_EMPTY :: Int _IGD_STATUS_HTTP_EMPTY = 2 _IGD_STATUS_NO_IGD :: Int _IGD_STATUS_NO_IGD = 4 _IGD_STATUS_UNKNOWN_DEVICE :: Int _IGD_STATUS_UNKNOWN_DEVICE = 6 _IGD_STATUS_HTTP_ERROR :: Int _IGD_STATUS_HTTP_ERROR = 1 instance NodeProperty UPNPDevice "description_url" GodotString 'False where nodeProperty = (get_description_url, wrapDroppingSetter set_description_url, Nothing) instance NodeProperty UPNPDevice "igd_control_url" GodotString 'False where nodeProperty = (get_igd_control_url, wrapDroppingSetter set_igd_control_url, Nothing) instance NodeProperty UPNPDevice "igd_our_addr" GodotString 'False where nodeProperty = (get_igd_our_addr, wrapDroppingSetter set_igd_our_addr, Nothing) instance NodeProperty UPNPDevice "igd_service_type" GodotString 'False where nodeProperty = (get_igd_service_type, wrapDroppingSetter set_igd_service_type, Nothing) instance NodeProperty UPNPDevice "igd_status" Int 'False where nodeProperty = (get_igd_status, wrapDroppingSetter set_igd_status, Nothing) instance NodeProperty UPNPDevice "service_type" GodotString 'False where nodeProperty = (get_service_type, wrapDroppingSetter set_service_type, Nothing) {-# NOINLINE bindUPNPDevice_add_port_mapping #-} bindUPNPDevice_add_port_mapping :: MethodBind bindUPNPDevice_add_port_mapping = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "add_port_mapping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_port_mapping :: (UPNPDevice :< cls, Object :< cls) => cls -> Int -> Maybe Int -> Maybe GodotString -> Maybe GodotString -> Maybe Int -> IO Int add_port_mapping cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2, defaultedVariant VariantString "" arg3, defaultedVariant VariantString "UDP" arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_add_port_mapping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "add_port_mapping" '[Int, Maybe Int, Maybe GodotString, Maybe GodotString, Maybe Int] (IO Int) where nodeMethod = Godot.Core.UPNPDevice.add_port_mapping {-# NOINLINE bindUPNPDevice_delete_port_mapping #-} bindUPNPDevice_delete_port_mapping :: MethodBind bindUPNPDevice_delete_port_mapping = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "delete_port_mapping" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr delete_port_mapping :: (UPNPDevice :< cls, Object :< cls) => cls -> Int -> Maybe GodotString -> IO Int delete_port_mapping cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "UDP" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_delete_port_mapping (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "delete_port_mapping" '[Int, Maybe GodotString] (IO Int) where nodeMethod = Godot.Core.UPNPDevice.delete_port_mapping {-# NOINLINE bindUPNPDevice_get_description_url #-} bindUPNPDevice_get_description_url :: MethodBind bindUPNPDevice_get_description_url = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "get_description_url" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_description_url :: (UPNPDevice :< cls, Object :< cls) => cls -> IO GodotString get_description_url cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_get_description_url (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "get_description_url" '[] (IO GodotString) where nodeMethod = Godot.Core.UPNPDevice.get_description_url {-# NOINLINE bindUPNPDevice_get_igd_control_url #-} bindUPNPDevice_get_igd_control_url :: MethodBind bindUPNPDevice_get_igd_control_url = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "get_igd_control_url" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_igd_control_url :: (UPNPDevice :< cls, Object :< cls) => cls -> IO GodotString get_igd_control_url cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_get_igd_control_url (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "get_igd_control_url" '[] (IO GodotString) where nodeMethod = Godot.Core.UPNPDevice.get_igd_control_url {-# NOINLINE bindUPNPDevice_get_igd_our_addr #-} bindUPNPDevice_get_igd_our_addr :: MethodBind bindUPNPDevice_get_igd_our_addr = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "get_igd_our_addr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_igd_our_addr :: (UPNPDevice :< cls, Object :< cls) => cls -> IO GodotString get_igd_our_addr cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_get_igd_our_addr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "get_igd_our_addr" '[] (IO GodotString) where nodeMethod = Godot.Core.UPNPDevice.get_igd_our_addr {-# NOINLINE bindUPNPDevice_get_igd_service_type #-} bindUPNPDevice_get_igd_service_type :: MethodBind bindUPNPDevice_get_igd_service_type = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "get_igd_service_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_igd_service_type :: (UPNPDevice :< cls, Object :< cls) => cls -> IO GodotString get_igd_service_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_get_igd_service_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "get_igd_service_type" '[] (IO GodotString) where nodeMethod = Godot.Core.UPNPDevice.get_igd_service_type {-# NOINLINE bindUPNPDevice_get_igd_status #-} bindUPNPDevice_get_igd_status :: MethodBind bindUPNPDevice_get_igd_status = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "get_igd_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_igd_status :: (UPNPDevice :< cls, Object :< cls) => cls -> IO Int get_igd_status cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_get_igd_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "get_igd_status" '[] (IO Int) where nodeMethod = Godot.Core.UPNPDevice.get_igd_status {-# NOINLINE bindUPNPDevice_get_service_type #-} bindUPNPDevice_get_service_type :: MethodBind bindUPNPDevice_get_service_type = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "get_service_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_service_type :: (UPNPDevice :< cls, Object :< cls) => cls -> IO GodotString get_service_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_get_service_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "get_service_type" '[] (IO GodotString) where nodeMethod = Godot.Core.UPNPDevice.get_service_type {-# NOINLINE bindUPNPDevice_is_valid_gateway #-} bindUPNPDevice_is_valid_gateway :: MethodBind bindUPNPDevice_is_valid_gateway = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "is_valid_gateway" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_valid_gateway :: (UPNPDevice :< cls, Object :< cls) => cls -> IO Bool is_valid_gateway cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_is_valid_gateway (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "is_valid_gateway" '[] (IO Bool) where nodeMethod = Godot.Core.UPNPDevice.is_valid_gateway {-# NOINLINE bindUPNPDevice_query_external_address #-} bindUPNPDevice_query_external_address :: MethodBind bindUPNPDevice_query_external_address = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "query_external_address" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr query_external_address :: (UPNPDevice :< cls, Object :< cls) => cls -> IO GodotString query_external_address cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_query_external_address (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "query_external_address" '[] (IO GodotString) where nodeMethod = Godot.Core.UPNPDevice.query_external_address {-# NOINLINE bindUPNPDevice_set_description_url #-} bindUPNPDevice_set_description_url :: MethodBind bindUPNPDevice_set_description_url = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "set_description_url" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_description_url :: (UPNPDevice :< cls, Object :< cls) => cls -> GodotString -> IO () set_description_url cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_set_description_url (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "set_description_url" '[GodotString] (IO ()) where nodeMethod = Godot.Core.UPNPDevice.set_description_url {-# NOINLINE bindUPNPDevice_set_igd_control_url #-} bindUPNPDevice_set_igd_control_url :: MethodBind bindUPNPDevice_set_igd_control_url = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "set_igd_control_url" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_igd_control_url :: (UPNPDevice :< cls, Object :< cls) => cls -> GodotString -> IO () set_igd_control_url cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_set_igd_control_url (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "set_igd_control_url" '[GodotString] (IO ()) where nodeMethod = Godot.Core.UPNPDevice.set_igd_control_url {-# NOINLINE bindUPNPDevice_set_igd_our_addr #-} bindUPNPDevice_set_igd_our_addr :: MethodBind bindUPNPDevice_set_igd_our_addr = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "set_igd_our_addr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_igd_our_addr :: (UPNPDevice :< cls, Object :< cls) => cls -> GodotString -> IO () set_igd_our_addr cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_set_igd_our_addr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "set_igd_our_addr" '[GodotString] (IO ()) where nodeMethod = Godot.Core.UPNPDevice.set_igd_our_addr {-# NOINLINE bindUPNPDevice_set_igd_service_type #-} bindUPNPDevice_set_igd_service_type :: MethodBind bindUPNPDevice_set_igd_service_type = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "set_igd_service_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_igd_service_type :: (UPNPDevice :< cls, Object :< cls) => cls -> GodotString -> IO () set_igd_service_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_set_igd_service_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "set_igd_service_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.UPNPDevice.set_igd_service_type {-# NOINLINE bindUPNPDevice_set_igd_status #-} bindUPNPDevice_set_igd_status :: MethodBind bindUPNPDevice_set_igd_status = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "set_igd_status" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_igd_status :: (UPNPDevice :< cls, Object :< cls) => cls -> Int -> IO () set_igd_status cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_set_igd_status (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "set_igd_status" '[Int] (IO ()) where nodeMethod = Godot.Core.UPNPDevice.set_igd_status {-# NOINLINE bindUPNPDevice_set_service_type #-} bindUPNPDevice_set_service_type :: MethodBind bindUPNPDevice_set_service_type = unsafePerformIO $ withCString "UPNPDevice" $ \ clsNamePtr -> withCString "set_service_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_service_type :: (UPNPDevice :< cls, Object :< cls) => cls -> GodotString -> IO () set_service_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUPNPDevice_set_service_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UPNPDevice "set_service_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.UPNPDevice.set_service_type ================================================ FILE: src/Godot/Core/UndoRedo.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.UndoRedo (Godot.Core.UndoRedo._MERGE_DISABLE, Godot.Core.UndoRedo._MERGE_ALL, Godot.Core.UndoRedo._MERGE_ENDS, Godot.Core.UndoRedo.sig_version_changed, Godot.Core.UndoRedo.add_do_method, Godot.Core.UndoRedo.add_do_property, Godot.Core.UndoRedo.add_do_reference, Godot.Core.UndoRedo.add_undo_method, Godot.Core.UndoRedo.add_undo_property, Godot.Core.UndoRedo.add_undo_reference, Godot.Core.UndoRedo.clear_history, Godot.Core.UndoRedo.commit_action, Godot.Core.UndoRedo.create_action, Godot.Core.UndoRedo.get_current_action_name, Godot.Core.UndoRedo.get_version, Godot.Core.UndoRedo.has_redo, Godot.Core.UndoRedo.has_undo, Godot.Core.UndoRedo.is_commiting_action, Godot.Core.UndoRedo.redo, Godot.Core.UndoRedo.undo) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _MERGE_DISABLE :: Int _MERGE_DISABLE = 0 _MERGE_ALL :: Int _MERGE_ALL = 2 _MERGE_ENDS :: Int _MERGE_ENDS = 1 -- | Called when @method undo@ or @method redo@ was called. sig_version_changed :: Godot.Internal.Dispatch.Signal UndoRedo sig_version_changed = Godot.Internal.Dispatch.Signal "version_changed" instance NodeSignal UndoRedo "version_changed" '[] {-# NOINLINE bindUndoRedo_add_do_method #-} -- | Register a method that will be called when the action is committed. bindUndoRedo_add_do_method :: MethodBind bindUndoRedo_add_do_method = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "add_do_method" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Register a method that will be called when the action is committed. add_do_method :: (UndoRedo :< cls, Object :< cls) => cls -> Object -> GodotString -> [Variant 'GodotTy] -> IO () add_do_method cls arg1 arg2 varargs = withVariantArray ([toVariant arg1, toVariant arg2] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_add_do_method (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "add_do_method" '[Object, GodotString, [Variant 'GodotTy]] (IO ()) where nodeMethod = Godot.Core.UndoRedo.add_do_method {-# NOINLINE bindUndoRedo_add_do_property #-} -- | Register a property value change for "do". bindUndoRedo_add_do_property :: MethodBind bindUndoRedo_add_do_property = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "add_do_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Register a property value change for "do". add_do_property :: (UndoRedo :< cls, Object :< cls) => cls -> Object -> GodotString -> GodotVariant -> IO () add_do_property cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_add_do_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "add_do_property" '[Object, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.UndoRedo.add_do_property {-# NOINLINE bindUndoRedo_add_do_reference #-} -- | Register a reference for "do" that will be erased if the "do" history is lost. This is useful mostly for new nodes created for the "do" call. Do not use for resources. bindUndoRedo_add_do_reference :: MethodBind bindUndoRedo_add_do_reference = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "add_do_reference" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Register a reference for "do" that will be erased if the "do" history is lost. This is useful mostly for new nodes created for the "do" call. Do not use for resources. add_do_reference :: (UndoRedo :< cls, Object :< cls) => cls -> Object -> IO () add_do_reference cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_add_do_reference (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "add_do_reference" '[Object] (IO ()) where nodeMethod = Godot.Core.UndoRedo.add_do_reference {-# NOINLINE bindUndoRedo_add_undo_method #-} -- | Register a method that will be called when the action is undone. bindUndoRedo_add_undo_method :: MethodBind bindUndoRedo_add_undo_method = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "add_undo_method" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Register a method that will be called when the action is undone. add_undo_method :: (UndoRedo :< cls, Object :< cls) => cls -> Object -> GodotString -> [Variant 'GodotTy] -> IO () add_undo_method cls arg1 arg2 varargs = withVariantArray ([toVariant arg1, toVariant arg2] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_add_undo_method (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "add_undo_method" '[Object, GodotString, [Variant 'GodotTy]] (IO ()) where nodeMethod = Godot.Core.UndoRedo.add_undo_method {-# NOINLINE bindUndoRedo_add_undo_property #-} -- | Register a property value change for "undo". bindUndoRedo_add_undo_property :: MethodBind bindUndoRedo_add_undo_property = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "add_undo_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Register a property value change for "undo". add_undo_property :: (UndoRedo :< cls, Object :< cls) => cls -> Object -> GodotString -> GodotVariant -> IO () add_undo_property cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_add_undo_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "add_undo_property" '[Object, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.UndoRedo.add_undo_property {-# NOINLINE bindUndoRedo_add_undo_reference #-} -- | Register a reference for "undo" that will be erased if the "undo" history is lost. This is useful mostly for nodes removed with the "do" call (not the "undo" call!). bindUndoRedo_add_undo_reference :: MethodBind bindUndoRedo_add_undo_reference = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "add_undo_reference" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Register a reference for "undo" that will be erased if the "undo" history is lost. This is useful mostly for nodes removed with the "do" call (not the "undo" call!). add_undo_reference :: (UndoRedo :< cls, Object :< cls) => cls -> Object -> IO () add_undo_reference cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_add_undo_reference (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "add_undo_reference" '[Object] (IO ()) where nodeMethod = Godot.Core.UndoRedo.add_undo_reference {-# NOINLINE bindUndoRedo_clear_history #-} -- | Clear the undo/redo history and associated references. -- Passing @false@ to @increase_version@ will prevent the version number to be increased from this. bindUndoRedo_clear_history :: MethodBind bindUndoRedo_clear_history = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "clear_history" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear the undo/redo history and associated references. -- Passing @false@ to @increase_version@ will prevent the version number to be increased from this. clear_history :: (UndoRedo :< cls, Object :< cls) => cls -> Maybe Bool -> IO () clear_history cls arg1 = withVariantArray [maybe (VariantBool True) toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_clear_history (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "clear_history" '[Maybe Bool] (IO ()) where nodeMethod = Godot.Core.UndoRedo.clear_history {-# NOINLINE bindUndoRedo_commit_action #-} -- | Commit the action. All "do" methods/properties are called/set when this function is called. bindUndoRedo_commit_action :: MethodBind bindUndoRedo_commit_action = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "commit_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Commit the action. All "do" methods/properties are called/set when this function is called. commit_action :: (UndoRedo :< cls, Object :< cls) => cls -> IO () commit_action cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_commit_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "commit_action" '[] (IO ()) where nodeMethod = Godot.Core.UndoRedo.commit_action {-# NOINLINE bindUndoRedo_create_action #-} -- | Create a new action. After this is called, do all your calls to @method add_do_method@, @method add_undo_method@, @method add_do_property@, and @method add_undo_property@, then commit the action with @method commit_action@. -- The way actions are merged is dictated by the @merge_mode@ argument. See @enum MergeMode@ for details. bindUndoRedo_create_action :: MethodBind bindUndoRedo_create_action = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "create_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Create a new action. After this is called, do all your calls to @method add_do_method@, @method add_undo_method@, @method add_do_property@, and @method add_undo_property@, then commit the action with @method commit_action@. -- The way actions are merged is dictated by the @merge_mode@ argument. See @enum MergeMode@ for details. create_action :: (UndoRedo :< cls, Object :< cls) => cls -> GodotString -> Maybe Int -> IO () create_action cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_create_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "create_action" '[GodotString, Maybe Int] (IO ()) where nodeMethod = Godot.Core.UndoRedo.create_action {-# NOINLINE bindUndoRedo_get_current_action_name #-} -- | Gets the name of the current action. bindUndoRedo_get_current_action_name :: MethodBind bindUndoRedo_get_current_action_name = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "get_current_action_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the name of the current action. get_current_action_name :: (UndoRedo :< cls, Object :< cls) => cls -> IO GodotString get_current_action_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_get_current_action_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "get_current_action_name" '[] (IO GodotString) where nodeMethod = Godot.Core.UndoRedo.get_current_action_name {-# NOINLINE bindUndoRedo_get_version #-} -- | Gets the version. Every time a new action is committed, the @UndoRedo@'s version number is increased automatically. -- This is useful mostly to check if something changed from a saved version. bindUndoRedo_get_version :: MethodBind bindUndoRedo_get_version = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "get_version" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the version. Every time a new action is committed, the @UndoRedo@'s version number is increased automatically. -- This is useful mostly to check if something changed from a saved version. get_version :: (UndoRedo :< cls, Object :< cls) => cls -> IO Int get_version cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_get_version (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "get_version" '[] (IO Int) where nodeMethod = Godot.Core.UndoRedo.get_version {-# NOINLINE bindUndoRedo_has_redo #-} -- | Returns @true@ if a "redo" action is available. bindUndoRedo_has_redo :: MethodBind bindUndoRedo_has_redo = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "has_redo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if a "redo" action is available. has_redo :: (UndoRedo :< cls, Object :< cls) => cls -> IO Bool has_redo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_has_redo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "has_redo" '[] (IO Bool) where nodeMethod = Godot.Core.UndoRedo.has_redo {-# NOINLINE bindUndoRedo_has_undo #-} -- | Returns @true@ if an "undo" action is available. bindUndoRedo_has_undo :: MethodBind bindUndoRedo_has_undo = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "has_undo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if an "undo" action is available. has_undo :: (UndoRedo :< cls, Object :< cls) => cls -> IO Bool has_undo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_has_undo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "has_undo" '[] (IO Bool) where nodeMethod = Godot.Core.UndoRedo.has_undo {-# NOINLINE bindUndoRedo_is_commiting_action #-} -- | Returns @true@ if the @UndoRedo@ is currently committing the action, i.e. running its "do" method or property change (see @method commit_action@). bindUndoRedo_is_commiting_action :: MethodBind bindUndoRedo_is_commiting_action = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "is_commiting_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the @UndoRedo@ is currently committing the action, i.e. running its "do" method or property change (see @method commit_action@). is_commiting_action :: (UndoRedo :< cls, Object :< cls) => cls -> IO Bool is_commiting_action cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_is_commiting_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "is_commiting_action" '[] (IO Bool) where nodeMethod = Godot.Core.UndoRedo.is_commiting_action {-# NOINLINE bindUndoRedo_redo #-} -- | Redo the last action. bindUndoRedo_redo :: MethodBind bindUndoRedo_redo = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "redo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Redo the last action. redo :: (UndoRedo :< cls, Object :< cls) => cls -> IO Bool redo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_redo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "redo" '[] (IO Bool) where nodeMethod = Godot.Core.UndoRedo.redo {-# NOINLINE bindUndoRedo_undo #-} -- | Undo the last action. bindUndoRedo_undo :: MethodBind bindUndoRedo_undo = unsafePerformIO $ withCString "UndoRedo" $ \ clsNamePtr -> withCString "undo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Undo the last action. undo :: (UndoRedo :< cls, Object :< cls) => cls -> IO Bool undo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindUndoRedo_undo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod UndoRedo "undo" '[] (IO Bool) where nodeMethod = Godot.Core.UndoRedo.undo ================================================ FILE: src/Godot/Core/VBoxContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VBoxContainer () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.BoxContainer() ================================================ FILE: src/Godot/Core/VScrollBar.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VScrollBar () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ScrollBar() ================================================ FILE: src/Godot/Core/VSeparator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VSeparator () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Separator() ================================================ FILE: src/Godot/Core/VSlider.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VSlider () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Slider() ================================================ FILE: src/Godot/Core/VSplitContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VSplitContainer () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.SplitContainer() ================================================ FILE: src/Godot/Core/VehicleBody.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VehicleBody (Godot.Core.VehicleBody.get_brake, Godot.Core.VehicleBody.get_engine_force, Godot.Core.VehicleBody.get_steering, Godot.Core.VehicleBody.set_brake, Godot.Core.VehicleBody.set_engine_force, Godot.Core.VehicleBody.set_steering) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.RigidBody() instance NodeProperty VehicleBody "brake" Float 'False where nodeProperty = (get_brake, wrapDroppingSetter set_brake, Nothing) instance NodeProperty VehicleBody "engine_force" Float 'False where nodeProperty = (get_engine_force, wrapDroppingSetter set_engine_force, Nothing) instance NodeProperty VehicleBody "steering" Float 'False where nodeProperty = (get_steering, wrapDroppingSetter set_steering, Nothing) {-# NOINLINE bindVehicleBody_get_brake #-} -- | Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the @RigidBody.mass@ of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking. bindVehicleBody_get_brake :: MethodBind bindVehicleBody_get_brake = unsafePerformIO $ withCString "VehicleBody" $ \ clsNamePtr -> withCString "get_brake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the @RigidBody.mass@ of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking. get_brake :: (VehicleBody :< cls, Object :< cls) => cls -> IO Float get_brake cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleBody_get_brake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleBody "get_brake" '[] (IO Float) where nodeMethod = Godot.Core.VehicleBody.get_brake {-# NOINLINE bindVehicleBody_get_engine_force #-} -- | Accelerates the vehicle by applying an engine force. The vehicle is only speed up if the wheels that have @VehicleWheel.use_as_traction@ set to @true@ and are in contact with a surface. The @RigidBody.mass@ of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. -- __Note:__ The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears. -- A negative value will result in the vehicle reversing. bindVehicleBody_get_engine_force :: MethodBind bindVehicleBody_get_engine_force = unsafePerformIO $ withCString "VehicleBody" $ \ clsNamePtr -> withCString "get_engine_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Accelerates the vehicle by applying an engine force. The vehicle is only speed up if the wheels that have @VehicleWheel.use_as_traction@ set to @true@ and are in contact with a surface. The @RigidBody.mass@ of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. -- __Note:__ The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears. -- A negative value will result in the vehicle reversing. get_engine_force :: (VehicleBody :< cls, Object :< cls) => cls -> IO Float get_engine_force cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleBody_get_engine_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleBody "get_engine_force" '[] (IO Float) where nodeMethod = Godot.Core.VehicleBody.get_engine_force {-# NOINLINE bindVehicleBody_get_steering #-} -- | The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have @VehicleWheel.use_as_steering@ set to @true@ will automatically be rotated. bindVehicleBody_get_steering :: MethodBind bindVehicleBody_get_steering = unsafePerformIO $ withCString "VehicleBody" $ \ clsNamePtr -> withCString "get_steering" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have @VehicleWheel.use_as_steering@ set to @true@ will automatically be rotated. get_steering :: (VehicleBody :< cls, Object :< cls) => cls -> IO Float get_steering cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleBody_get_steering (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleBody "get_steering" '[] (IO Float) where nodeMethod = Godot.Core.VehicleBody.get_steering {-# NOINLINE bindVehicleBody_set_brake #-} -- | Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the @RigidBody.mass@ of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking. bindVehicleBody_set_brake :: MethodBind bindVehicleBody_set_brake = unsafePerformIO $ withCString "VehicleBody" $ \ clsNamePtr -> withCString "set_brake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the @RigidBody.mass@ of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking. set_brake :: (VehicleBody :< cls, Object :< cls) => cls -> Float -> IO () set_brake cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleBody_set_brake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleBody "set_brake" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleBody.set_brake {-# NOINLINE bindVehicleBody_set_engine_force #-} -- | Accelerates the vehicle by applying an engine force. The vehicle is only speed up if the wheels that have @VehicleWheel.use_as_traction@ set to @true@ and are in contact with a surface. The @RigidBody.mass@ of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. -- __Note:__ The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears. -- A negative value will result in the vehicle reversing. bindVehicleBody_set_engine_force :: MethodBind bindVehicleBody_set_engine_force = unsafePerformIO $ withCString "VehicleBody" $ \ clsNamePtr -> withCString "set_engine_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Accelerates the vehicle by applying an engine force. The vehicle is only speed up if the wheels that have @VehicleWheel.use_as_traction@ set to @true@ and are in contact with a surface. The @RigidBody.mass@ of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. -- __Note:__ The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears. -- A negative value will result in the vehicle reversing. set_engine_force :: (VehicleBody :< cls, Object :< cls) => cls -> Float -> IO () set_engine_force cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleBody_set_engine_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleBody "set_engine_force" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleBody.set_engine_force {-# NOINLINE bindVehicleBody_set_steering #-} -- | The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have @VehicleWheel.use_as_steering@ set to @true@ will automatically be rotated. bindVehicleBody_set_steering :: MethodBind bindVehicleBody_set_steering = unsafePerformIO $ withCString "VehicleBody" $ \ clsNamePtr -> withCString "set_steering" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have @VehicleWheel.use_as_steering@ set to @true@ will automatically be rotated. set_steering :: (VehicleBody :< cls, Object :< cls) => cls -> Float -> IO () set_steering cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleBody_set_steering (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleBody "set_steering" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleBody.set_steering ================================================ FILE: src/Godot/Core/VehicleWheel.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VehicleWheel (Godot.Core.VehicleWheel.get_brake, Godot.Core.VehicleWheel.get_damping_compression, Godot.Core.VehicleWheel.get_damping_relaxation, Godot.Core.VehicleWheel.get_engine_force, Godot.Core.VehicleWheel.get_friction_slip, Godot.Core.VehicleWheel.get_radius, Godot.Core.VehicleWheel.get_roll_influence, Godot.Core.VehicleWheel.get_rpm, Godot.Core.VehicleWheel.get_skidinfo, Godot.Core.VehicleWheel.get_steering, Godot.Core.VehicleWheel.get_suspension_max_force, Godot.Core.VehicleWheel.get_suspension_rest_length, Godot.Core.VehicleWheel.get_suspension_stiffness, Godot.Core.VehicleWheel.get_suspension_travel, Godot.Core.VehicleWheel.is_in_contact, Godot.Core.VehicleWheel.is_used_as_steering, Godot.Core.VehicleWheel.is_used_as_traction, Godot.Core.VehicleWheel.set_brake, Godot.Core.VehicleWheel.set_damping_compression, Godot.Core.VehicleWheel.set_damping_relaxation, Godot.Core.VehicleWheel.set_engine_force, Godot.Core.VehicleWheel.set_friction_slip, Godot.Core.VehicleWheel.set_radius, Godot.Core.VehicleWheel.set_roll_influence, Godot.Core.VehicleWheel.set_steering, Godot.Core.VehicleWheel.set_suspension_max_force, Godot.Core.VehicleWheel.set_suspension_rest_length, Godot.Core.VehicleWheel.set_suspension_stiffness, Godot.Core.VehicleWheel.set_suspension_travel, Godot.Core.VehicleWheel.set_use_as_steering, Godot.Core.VehicleWheel.set_use_as_traction) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty VehicleWheel "brake" Float 'False where nodeProperty = (get_brake, wrapDroppingSetter set_brake, Nothing) instance NodeProperty VehicleWheel "damping_compression" Float 'False where nodeProperty = (get_damping_compression, wrapDroppingSetter set_damping_compression, Nothing) instance NodeProperty VehicleWheel "damping_relaxation" Float 'False where nodeProperty = (get_damping_relaxation, wrapDroppingSetter set_damping_relaxation, Nothing) instance NodeProperty VehicleWheel "engine_force" Float 'False where nodeProperty = (get_engine_force, wrapDroppingSetter set_engine_force, Nothing) instance NodeProperty VehicleWheel "steering" Float 'False where nodeProperty = (get_steering, wrapDroppingSetter set_steering, Nothing) instance NodeProperty VehicleWheel "suspension_max_force" Float 'False where nodeProperty = (get_suspension_max_force, wrapDroppingSetter set_suspension_max_force, Nothing) instance NodeProperty VehicleWheel "suspension_stiffness" Float 'False where nodeProperty = (get_suspension_stiffness, wrapDroppingSetter set_suspension_stiffness, Nothing) instance NodeProperty VehicleWheel "suspension_travel" Float 'False where nodeProperty = (get_suspension_travel, wrapDroppingSetter set_suspension_travel, Nothing) instance NodeProperty VehicleWheel "use_as_steering" Bool 'False where nodeProperty = (is_used_as_steering, wrapDroppingSetter set_use_as_steering, Nothing) instance NodeProperty VehicleWheel "use_as_traction" Bool 'False where nodeProperty = (is_used_as_traction, wrapDroppingSetter set_use_as_traction, Nothing) instance NodeProperty VehicleWheel "wheel_friction_slip" Float 'False where nodeProperty = (get_friction_slip, wrapDroppingSetter set_friction_slip, Nothing) instance NodeProperty VehicleWheel "wheel_radius" Float 'False where nodeProperty = (get_radius, wrapDroppingSetter set_radius, Nothing) instance NodeProperty VehicleWheel "wheel_rest_length" Float 'False where nodeProperty = (get_suspension_rest_length, wrapDroppingSetter set_suspension_rest_length, Nothing) instance NodeProperty VehicleWheel "wheel_roll_influence" Float 'False where nodeProperty = (get_roll_influence, wrapDroppingSetter set_roll_influence, Nothing) {-# NOINLINE bindVehicleWheel_get_brake #-} -- | Slows down the wheel by applying a braking force. The wheel is only slowed down if it is in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the @RigidBody.mass@ of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking. bindVehicleWheel_get_brake :: MethodBind bindVehicleWheel_get_brake = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_brake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Slows down the wheel by applying a braking force. The wheel is only slowed down if it is in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the @RigidBody.mass@ of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking. get_brake :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_brake cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_brake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_brake" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_brake {-# NOINLINE bindVehicleWheel_get_damping_compression #-} -- | The damping applied to the spring when the spring is being compressed. This value should be between 0.0 (no damping) and 1.0. A value of 0.0 means the car will keep bouncing as the spring keeps its energy. A good value for this is around 0.3 for a normal car, 0.5 for a race car. bindVehicleWheel_get_damping_compression :: MethodBind bindVehicleWheel_get_damping_compression = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_damping_compression" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The damping applied to the spring when the spring is being compressed. This value should be between 0.0 (no damping) and 1.0. A value of 0.0 means the car will keep bouncing as the spring keeps its energy. A good value for this is around 0.3 for a normal car, 0.5 for a race car. get_damping_compression :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_damping_compression cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_damping_compression (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_damping_compression" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_damping_compression {-# NOINLINE bindVehicleWheel_get_damping_relaxation #-} -- | The damping applied to the spring when relaxing. This value should be between 0.0 (no damping) and 1.0. This value should always be slightly higher than the @damping_compression@ property. For a @damping_compression@ value of 0.3, try a relaxation value of 0.5. bindVehicleWheel_get_damping_relaxation :: MethodBind bindVehicleWheel_get_damping_relaxation = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_damping_relaxation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The damping applied to the spring when relaxing. This value should be between 0.0 (no damping) and 1.0. This value should always be slightly higher than the @damping_compression@ property. For a @damping_compression@ value of 0.3, try a relaxation value of 0.5. get_damping_relaxation :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_damping_relaxation cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_damping_relaxation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_damping_relaxation" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_damping_relaxation {-# NOINLINE bindVehicleWheel_get_engine_force #-} -- | Accelerates the wheel by applying an engine force. The wheel is only speed up if it is in contact with a surface. The @RigidBody.mass@ of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. -- __Note:__ The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears. -- A negative value will result in the wheel reversing. bindVehicleWheel_get_engine_force :: MethodBind bindVehicleWheel_get_engine_force = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_engine_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Accelerates the wheel by applying an engine force. The wheel is only speed up if it is in contact with a surface. The @RigidBody.mass@ of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. -- __Note:__ The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears. -- A negative value will result in the wheel reversing. get_engine_force :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_engine_force cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_engine_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_engine_force" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_engine_force {-# NOINLINE bindVehicleWheel_get_friction_slip #-} -- | This determines how much grip this wheel has. It is combined with the friction setting of the surface the wheel is in contact with. 0.0 means no grip, 1.0 is normal grip. For a drift car setup, try setting the grip of the rear wheels slightly lower than the front wheels, or use a lower value to simulate tire wear. -- It's best to set this to 1.0 when starting out. bindVehicleWheel_get_friction_slip :: MethodBind bindVehicleWheel_get_friction_slip = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_friction_slip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This determines how much grip this wheel has. It is combined with the friction setting of the surface the wheel is in contact with. 0.0 means no grip, 1.0 is normal grip. For a drift car setup, try setting the grip of the rear wheels slightly lower than the front wheels, or use a lower value to simulate tire wear. -- It's best to set this to 1.0 when starting out. get_friction_slip :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_friction_slip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_friction_slip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_friction_slip" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_friction_slip {-# NOINLINE bindVehicleWheel_get_radius #-} -- | The radius of the wheel in meters. bindVehicleWheel_get_radius :: MethodBind bindVehicleWheel_get_radius = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The radius of the wheel in meters. get_radius :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_radius cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_radius" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_radius {-# NOINLINE bindVehicleWheel_get_roll_influence #-} -- | This value affects the roll of your vehicle. If set to 1.0 for all wheels, your vehicle will be prone to rolling over, while a value of 0.0 will resist body roll. bindVehicleWheel_get_roll_influence :: MethodBind bindVehicleWheel_get_roll_influence = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_roll_influence" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This value affects the roll of your vehicle. If set to 1.0 for all wheels, your vehicle will be prone to rolling over, while a value of 0.0 will resist body roll. get_roll_influence :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_roll_influence cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_roll_influence (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_roll_influence" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_roll_influence {-# NOINLINE bindVehicleWheel_get_rpm #-} -- | Returns the rotational speed of the wheel in revolutions per minute. bindVehicleWheel_get_rpm :: MethodBind bindVehicleWheel_get_rpm = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_rpm" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the rotational speed of the wheel in revolutions per minute. get_rpm :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_rpm cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_rpm (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_rpm" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_rpm {-# NOINLINE bindVehicleWheel_get_skidinfo #-} -- | Returns a value between 0.0 and 1.0 that indicates whether this wheel is skidding. 0.0 is skidding (the wheel has lost grip, e.g. icy terrain), 1.0 means not skidding (the wheel has full grip, e.g. dry asphalt road). bindVehicleWheel_get_skidinfo :: MethodBind bindVehicleWheel_get_skidinfo = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_skidinfo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a value between 0.0 and 1.0 that indicates whether this wheel is skidding. 0.0 is skidding (the wheel has lost grip, e.g. icy terrain), 1.0 means not skidding (the wheel has full grip, e.g. dry asphalt road). get_skidinfo :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_skidinfo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_skidinfo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_skidinfo" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_skidinfo {-# NOINLINE bindVehicleWheel_get_steering #-} -- | The steering angle for the wheel. Setting this to a non-zero value will result in the vehicle turning when it's moving. bindVehicleWheel_get_steering :: MethodBind bindVehicleWheel_get_steering = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_steering" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The steering angle for the wheel. Setting this to a non-zero value will result in the vehicle turning when it's moving. get_steering :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_steering cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_steering (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_steering" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_steering {-# NOINLINE bindVehicleWheel_get_suspension_max_force #-} -- | The maximum force the spring can resist. This value should be higher than a quarter of the @RigidBody.mass@ of the @VehicleBody@ or the spring will not carry the weight of the vehicle. Good results are often obtained by a value that is about 3× to 4× this number. bindVehicleWheel_get_suspension_max_force :: MethodBind bindVehicleWheel_get_suspension_max_force = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_suspension_max_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum force the spring can resist. This value should be higher than a quarter of the @RigidBody.mass@ of the @VehicleBody@ or the spring will not carry the weight of the vehicle. Good results are often obtained by a value that is about 3× to 4× this number. get_suspension_max_force :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_suspension_max_force cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_suspension_max_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_suspension_max_force" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_suspension_max_force {-# NOINLINE bindVehicleWheel_get_suspension_rest_length #-} -- | This is the distance in meters the wheel is lowered from its origin point. Don't set this to 0.0 and move the wheel into position, instead move the origin point of your wheel (the gizmo in Godot) to the position the wheel will take when bottoming out, then use the rest length to move the wheel down to the position it should be in when the car is in rest. bindVehicleWheel_get_suspension_rest_length :: MethodBind bindVehicleWheel_get_suspension_rest_length = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_suspension_rest_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This is the distance in meters the wheel is lowered from its origin point. Don't set this to 0.0 and move the wheel into position, instead move the origin point of your wheel (the gizmo in Godot) to the position the wheel will take when bottoming out, then use the rest length to move the wheel down to the position it should be in when the car is in rest. get_suspension_rest_length :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_suspension_rest_length cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_suspension_rest_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_suspension_rest_length" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_suspension_rest_length {-# NOINLINE bindVehicleWheel_get_suspension_stiffness #-} -- | This value defines the stiffness of the suspension. Use a value lower than 50 for an off-road car, a value between 50 and 100 for a race car and try something around 200 for something like a Formula 1 car. bindVehicleWheel_get_suspension_stiffness :: MethodBind bindVehicleWheel_get_suspension_stiffness = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_suspension_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This value defines the stiffness of the suspension. Use a value lower than 50 for an off-road car, a value between 50 and 100 for a race car and try something around 200 for something like a Formula 1 car. get_suspension_stiffness :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_suspension_stiffness cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_suspension_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_suspension_stiffness" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_suspension_stiffness {-# NOINLINE bindVehicleWheel_get_suspension_travel #-} -- | This is the distance the suspension can travel. As Godot units are equivalent to meters, keep this setting relatively low. Try a value between 0.1 and 0.3 depending on the type of car. bindVehicleWheel_get_suspension_travel :: MethodBind bindVehicleWheel_get_suspension_travel = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "get_suspension_travel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This is the distance the suspension can travel. As Godot units are equivalent to meters, keep this setting relatively low. Try a value between 0.1 and 0.3 depending on the type of car. get_suspension_travel :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Float get_suspension_travel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_get_suspension_travel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "get_suspension_travel" '[] (IO Float) where nodeMethod = Godot.Core.VehicleWheel.get_suspension_travel {-# NOINLINE bindVehicleWheel_is_in_contact #-} -- | Returns @true@ if this wheel is in contact with a surface. bindVehicleWheel_is_in_contact :: MethodBind bindVehicleWheel_is_in_contact = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "is_in_contact" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this wheel is in contact with a surface. is_in_contact :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Bool is_in_contact cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_is_in_contact (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "is_in_contact" '[] (IO Bool) where nodeMethod = Godot.Core.VehicleWheel.is_in_contact {-# NOINLINE bindVehicleWheel_is_used_as_steering #-} -- | If @true@, this wheel will be turned when the car steers. This value is used in conjunction with @VehicleBody.steering@ and ignored if you are using the per-wheel @steering@ value instead. bindVehicleWheel_is_used_as_steering :: MethodBind bindVehicleWheel_is_used_as_steering = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "is_used_as_steering" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this wheel will be turned when the car steers. This value is used in conjunction with @VehicleBody.steering@ and ignored if you are using the per-wheel @steering@ value instead. is_used_as_steering :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Bool is_used_as_steering cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_is_used_as_steering (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "is_used_as_steering" '[] (IO Bool) where nodeMethod = Godot.Core.VehicleWheel.is_used_as_steering {-# NOINLINE bindVehicleWheel_is_used_as_traction #-} -- | If @true@, this wheel transfers engine force to the ground to propel the vehicle forward. This value is used in conjunction with @VehicleBody.engine_force@ and ignored if you are using the per-wheel @engine_force@ value instead. bindVehicleWheel_is_used_as_traction :: MethodBind bindVehicleWheel_is_used_as_traction = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "is_used_as_traction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this wheel transfers engine force to the ground to propel the vehicle forward. This value is used in conjunction with @VehicleBody.engine_force@ and ignored if you are using the per-wheel @engine_force@ value instead. is_used_as_traction :: (VehicleWheel :< cls, Object :< cls) => cls -> IO Bool is_used_as_traction cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_is_used_as_traction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "is_used_as_traction" '[] (IO Bool) where nodeMethod = Godot.Core.VehicleWheel.is_used_as_traction {-# NOINLINE bindVehicleWheel_set_brake #-} -- | Slows down the wheel by applying a braking force. The wheel is only slowed down if it is in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the @RigidBody.mass@ of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking. bindVehicleWheel_set_brake :: MethodBind bindVehicleWheel_set_brake = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_brake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Slows down the wheel by applying a braking force. The wheel is only slowed down if it is in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the @RigidBody.mass@ of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking. set_brake :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_brake cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_brake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_brake" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_brake {-# NOINLINE bindVehicleWheel_set_damping_compression #-} -- | The damping applied to the spring when the spring is being compressed. This value should be between 0.0 (no damping) and 1.0. A value of 0.0 means the car will keep bouncing as the spring keeps its energy. A good value for this is around 0.3 for a normal car, 0.5 for a race car. bindVehicleWheel_set_damping_compression :: MethodBind bindVehicleWheel_set_damping_compression = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_damping_compression" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The damping applied to the spring when the spring is being compressed. This value should be between 0.0 (no damping) and 1.0. A value of 0.0 means the car will keep bouncing as the spring keeps its energy. A good value for this is around 0.3 for a normal car, 0.5 for a race car. set_damping_compression :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_damping_compression cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_damping_compression (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_damping_compression" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_damping_compression {-# NOINLINE bindVehicleWheel_set_damping_relaxation #-} -- | The damping applied to the spring when relaxing. This value should be between 0.0 (no damping) and 1.0. This value should always be slightly higher than the @damping_compression@ property. For a @damping_compression@ value of 0.3, try a relaxation value of 0.5. bindVehicleWheel_set_damping_relaxation :: MethodBind bindVehicleWheel_set_damping_relaxation = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_damping_relaxation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The damping applied to the spring when relaxing. This value should be between 0.0 (no damping) and 1.0. This value should always be slightly higher than the @damping_compression@ property. For a @damping_compression@ value of 0.3, try a relaxation value of 0.5. set_damping_relaxation :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_damping_relaxation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_damping_relaxation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_damping_relaxation" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_damping_relaxation {-# NOINLINE bindVehicleWheel_set_engine_force #-} -- | Accelerates the wheel by applying an engine force. The wheel is only speed up if it is in contact with a surface. The @RigidBody.mass@ of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. -- __Note:__ The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears. -- A negative value will result in the wheel reversing. bindVehicleWheel_set_engine_force :: MethodBind bindVehicleWheel_set_engine_force = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_engine_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Accelerates the wheel by applying an engine force. The wheel is only speed up if it is in contact with a surface. The @RigidBody.mass@ of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. -- __Note:__ The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears. -- A negative value will result in the wheel reversing. set_engine_force :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_engine_force cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_engine_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_engine_force" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_engine_force {-# NOINLINE bindVehicleWheel_set_friction_slip #-} -- | This determines how much grip this wheel has. It is combined with the friction setting of the surface the wheel is in contact with. 0.0 means no grip, 1.0 is normal grip. For a drift car setup, try setting the grip of the rear wheels slightly lower than the front wheels, or use a lower value to simulate tire wear. -- It's best to set this to 1.0 when starting out. bindVehicleWheel_set_friction_slip :: MethodBind bindVehicleWheel_set_friction_slip = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_friction_slip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This determines how much grip this wheel has. It is combined with the friction setting of the surface the wheel is in contact with. 0.0 means no grip, 1.0 is normal grip. For a drift car setup, try setting the grip of the rear wheels slightly lower than the front wheels, or use a lower value to simulate tire wear. -- It's best to set this to 1.0 when starting out. set_friction_slip :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_friction_slip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_friction_slip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_friction_slip" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_friction_slip {-# NOINLINE bindVehicleWheel_set_radius #-} -- | The radius of the wheel in meters. bindVehicleWheel_set_radius :: MethodBind bindVehicleWheel_set_radius = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_radius" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The radius of the wheel in meters. set_radius :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_radius cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_radius (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_radius" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_radius {-# NOINLINE bindVehicleWheel_set_roll_influence #-} -- | This value affects the roll of your vehicle. If set to 1.0 for all wheels, your vehicle will be prone to rolling over, while a value of 0.0 will resist body roll. bindVehicleWheel_set_roll_influence :: MethodBind bindVehicleWheel_set_roll_influence = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_roll_influence" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This value affects the roll of your vehicle. If set to 1.0 for all wheels, your vehicle will be prone to rolling over, while a value of 0.0 will resist body roll. set_roll_influence :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_roll_influence cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_roll_influence (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_roll_influence" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_roll_influence {-# NOINLINE bindVehicleWheel_set_steering #-} -- | The steering angle for the wheel. Setting this to a non-zero value will result in the vehicle turning when it's moving. bindVehicleWheel_set_steering :: MethodBind bindVehicleWheel_set_steering = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_steering" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The steering angle for the wheel. Setting this to a non-zero value will result in the vehicle turning when it's moving. set_steering :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_steering cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_steering (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_steering" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_steering {-# NOINLINE bindVehicleWheel_set_suspension_max_force #-} -- | The maximum force the spring can resist. This value should be higher than a quarter of the @RigidBody.mass@ of the @VehicleBody@ or the spring will not carry the weight of the vehicle. Good results are often obtained by a value that is about 3× to 4× this number. bindVehicleWheel_set_suspension_max_force :: MethodBind bindVehicleWheel_set_suspension_max_force = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_suspension_max_force" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The maximum force the spring can resist. This value should be higher than a quarter of the @RigidBody.mass@ of the @VehicleBody@ or the spring will not carry the weight of the vehicle. Good results are often obtained by a value that is about 3× to 4× this number. set_suspension_max_force :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_suspension_max_force cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_suspension_max_force (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_suspension_max_force" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_suspension_max_force {-# NOINLINE bindVehicleWheel_set_suspension_rest_length #-} -- | This is the distance in meters the wheel is lowered from its origin point. Don't set this to 0.0 and move the wheel into position, instead move the origin point of your wheel (the gizmo in Godot) to the position the wheel will take when bottoming out, then use the rest length to move the wheel down to the position it should be in when the car is in rest. bindVehicleWheel_set_suspension_rest_length :: MethodBind bindVehicleWheel_set_suspension_rest_length = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_suspension_rest_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This is the distance in meters the wheel is lowered from its origin point. Don't set this to 0.0 and move the wheel into position, instead move the origin point of your wheel (the gizmo in Godot) to the position the wheel will take when bottoming out, then use the rest length to move the wheel down to the position it should be in when the car is in rest. set_suspension_rest_length :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_suspension_rest_length cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_suspension_rest_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_suspension_rest_length" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_suspension_rest_length {-# NOINLINE bindVehicleWheel_set_suspension_stiffness #-} -- | This value defines the stiffness of the suspension. Use a value lower than 50 for an off-road car, a value between 50 and 100 for a race car and try something around 200 for something like a Formula 1 car. bindVehicleWheel_set_suspension_stiffness :: MethodBind bindVehicleWheel_set_suspension_stiffness = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_suspension_stiffness" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This value defines the stiffness of the suspension. Use a value lower than 50 for an off-road car, a value between 50 and 100 for a race car and try something around 200 for something like a Formula 1 car. set_suspension_stiffness :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_suspension_stiffness cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_suspension_stiffness (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_suspension_stiffness" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_suspension_stiffness {-# NOINLINE bindVehicleWheel_set_suspension_travel #-} -- | This is the distance the suspension can travel. As Godot units are equivalent to meters, keep this setting relatively low. Try a value between 0.1 and 0.3 depending on the type of car. bindVehicleWheel_set_suspension_travel :: MethodBind bindVehicleWheel_set_suspension_travel = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_suspension_travel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This is the distance the suspension can travel. As Godot units are equivalent to meters, keep this setting relatively low. Try a value between 0.1 and 0.3 depending on the type of car. set_suspension_travel :: (VehicleWheel :< cls, Object :< cls) => cls -> Float -> IO () set_suspension_travel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_suspension_travel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_suspension_travel" '[Float] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_suspension_travel {-# NOINLINE bindVehicleWheel_set_use_as_steering #-} -- | If @true@, this wheel will be turned when the car steers. This value is used in conjunction with @VehicleBody.steering@ and ignored if you are using the per-wheel @steering@ value instead. bindVehicleWheel_set_use_as_steering :: MethodBind bindVehicleWheel_set_use_as_steering = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_use_as_steering" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this wheel will be turned when the car steers. This value is used in conjunction with @VehicleBody.steering@ and ignored if you are using the per-wheel @steering@ value instead. set_use_as_steering :: (VehicleWheel :< cls, Object :< cls) => cls -> Bool -> IO () set_use_as_steering cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_use_as_steering (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_use_as_steering" '[Bool] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_use_as_steering {-# NOINLINE bindVehicleWheel_set_use_as_traction #-} -- | If @true@, this wheel transfers engine force to the ground to propel the vehicle forward. This value is used in conjunction with @VehicleBody.engine_force@ and ignored if you are using the per-wheel @engine_force@ value instead. bindVehicleWheel_set_use_as_traction :: MethodBind bindVehicleWheel_set_use_as_traction = unsafePerformIO $ withCString "VehicleWheel" $ \ clsNamePtr -> withCString "set_use_as_traction" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this wheel transfers engine force to the ground to propel the vehicle forward. This value is used in conjunction with @VehicleBody.engine_force@ and ignored if you are using the per-wheel @engine_force@ value instead. set_use_as_traction :: (VehicleWheel :< cls, Object :< cls) => cls -> Bool -> IO () set_use_as_traction cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVehicleWheel_set_use_as_traction (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VehicleWheel "set_use_as_traction" '[Bool] (IO ()) where nodeMethod = Godot.Core.VehicleWheel.set_use_as_traction ================================================ FILE: src/Godot/Core/VideoPlayer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VideoPlayer (Godot.Core.VideoPlayer.sig_finished, Godot.Core.VideoPlayer.get_audio_track, Godot.Core.VideoPlayer.get_buffering_msec, Godot.Core.VideoPlayer.get_bus, Godot.Core.VideoPlayer.get_stream, Godot.Core.VideoPlayer.get_stream_name, Godot.Core.VideoPlayer.get_stream_position, Godot.Core.VideoPlayer.get_video_texture, Godot.Core.VideoPlayer.get_volume, Godot.Core.VideoPlayer.get_volume_db, Godot.Core.VideoPlayer.has_autoplay, Godot.Core.VideoPlayer.has_expand, Godot.Core.VideoPlayer.is_paused, Godot.Core.VideoPlayer.is_playing, Godot.Core.VideoPlayer.play, Godot.Core.VideoPlayer.set_audio_track, Godot.Core.VideoPlayer.set_autoplay, Godot.Core.VideoPlayer.set_buffering_msec, Godot.Core.VideoPlayer.set_bus, Godot.Core.VideoPlayer.set_expand, Godot.Core.VideoPlayer.set_paused, Godot.Core.VideoPlayer.set_stream, Godot.Core.VideoPlayer.set_stream_position, Godot.Core.VideoPlayer.set_volume, Godot.Core.VideoPlayer.set_volume_db, Godot.Core.VideoPlayer.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Control() -- | Emitted when playback is finished. sig_finished :: Godot.Internal.Dispatch.Signal VideoPlayer sig_finished = Godot.Internal.Dispatch.Signal "finished" instance NodeSignal VideoPlayer "finished" '[] instance NodeProperty VideoPlayer "audio_track" Int 'False where nodeProperty = (get_audio_track, wrapDroppingSetter set_audio_track, Nothing) instance NodeProperty VideoPlayer "autoplay" Bool 'False where nodeProperty = (has_autoplay, wrapDroppingSetter set_autoplay, Nothing) instance NodeProperty VideoPlayer "buffering_msec" Int 'False where nodeProperty = (get_buffering_msec, wrapDroppingSetter set_buffering_msec, Nothing) instance NodeProperty VideoPlayer "bus" GodotString 'False where nodeProperty = (get_bus, wrapDroppingSetter set_bus, Nothing) instance NodeProperty VideoPlayer "expand" Bool 'False where nodeProperty = (has_expand, wrapDroppingSetter set_expand, Nothing) instance NodeProperty VideoPlayer "paused" Bool 'False where nodeProperty = (is_paused, wrapDroppingSetter set_paused, Nothing) instance NodeProperty VideoPlayer "stream" VideoStream 'False where nodeProperty = (get_stream, wrapDroppingSetter set_stream, Nothing) instance NodeProperty VideoPlayer "stream_position" Float 'False where nodeProperty = (get_stream_position, wrapDroppingSetter set_stream_position, Nothing) instance NodeProperty VideoPlayer "volume" Float 'False where nodeProperty = (get_volume, wrapDroppingSetter set_volume, Nothing) instance NodeProperty VideoPlayer "volume_db" Float 'False where nodeProperty = (get_volume_db, wrapDroppingSetter set_volume_db, Nothing) {-# NOINLINE bindVideoPlayer_get_audio_track #-} -- | The embedded audio track to play. bindVideoPlayer_get_audio_track :: MethodBind bindVideoPlayer_get_audio_track = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_audio_track" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The embedded audio track to play. get_audio_track :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Int get_audio_track cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_audio_track (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_audio_track" '[] (IO Int) where nodeMethod = Godot.Core.VideoPlayer.get_audio_track {-# NOINLINE bindVideoPlayer_get_buffering_msec #-} -- | Amount of time in milliseconds to store in buffer while playing. bindVideoPlayer_get_buffering_msec :: MethodBind bindVideoPlayer_get_buffering_msec = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_buffering_msec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time in milliseconds to store in buffer while playing. get_buffering_msec :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Int get_buffering_msec cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_buffering_msec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_buffering_msec" '[] (IO Int) where nodeMethod = Godot.Core.VideoPlayer.get_buffering_msec {-# NOINLINE bindVideoPlayer_get_bus #-} -- | Audio bus to use for sound playback. bindVideoPlayer_get_bus :: MethodBind bindVideoPlayer_get_bus = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Audio bus to use for sound playback. get_bus :: (VideoPlayer :< cls, Object :< cls) => cls -> IO GodotString get_bus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_bus" '[] (IO GodotString) where nodeMethod = Godot.Core.VideoPlayer.get_bus {-# NOINLINE bindVideoPlayer_get_stream #-} -- | The assigned video stream. See description for supported formats. bindVideoPlayer_get_stream :: MethodBind bindVideoPlayer_get_stream = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The assigned video stream. See description for supported formats. get_stream :: (VideoPlayer :< cls, Object :< cls) => cls -> IO VideoStream get_stream cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_stream" '[] (IO VideoStream) where nodeMethod = Godot.Core.VideoPlayer.get_stream {-# NOINLINE bindVideoPlayer_get_stream_name #-} -- | Returns the video stream's name, or @""@ if no video stream is assigned. bindVideoPlayer_get_stream_name :: MethodBind bindVideoPlayer_get_stream_name = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_stream_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the video stream's name, or @""@ if no video stream is assigned. get_stream_name :: (VideoPlayer :< cls, Object :< cls) => cls -> IO GodotString get_stream_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_stream_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_stream_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VideoPlayer.get_stream_name {-# NOINLINE bindVideoPlayer_get_stream_position #-} -- | The current position of the stream, in seconds. bindVideoPlayer_get_stream_position :: MethodBind bindVideoPlayer_get_stream_position = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_stream_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current position of the stream, in seconds. get_stream_position :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Float get_stream_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_stream_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_stream_position" '[] (IO Float) where nodeMethod = Godot.Core.VideoPlayer.get_stream_position {-# NOINLINE bindVideoPlayer_get_video_texture #-} -- | Returns the current frame as a @Texture@. bindVideoPlayer_get_video_texture :: MethodBind bindVideoPlayer_get_video_texture = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_video_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current frame as a @Texture@. get_video_texture :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Texture get_video_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_video_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_video_texture" '[] (IO Texture) where nodeMethod = Godot.Core.VideoPlayer.get_video_texture {-# NOINLINE bindVideoPlayer_get_volume #-} -- | Audio volume as a linear value. bindVideoPlayer_get_volume :: MethodBind bindVideoPlayer_get_volume = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_volume" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Audio volume as a linear value. get_volume :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Float get_volume cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_volume (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_volume" '[] (IO Float) where nodeMethod = Godot.Core.VideoPlayer.get_volume {-# NOINLINE bindVideoPlayer_get_volume_db #-} -- | Audio volume in dB. bindVideoPlayer_get_volume_db :: MethodBind bindVideoPlayer_get_volume_db = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "get_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Audio volume in dB. get_volume_db :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Float get_volume_db cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_get_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "get_volume_db" '[] (IO Float) where nodeMethod = Godot.Core.VideoPlayer.get_volume_db {-# NOINLINE bindVideoPlayer_has_autoplay #-} -- | If @true@, playback starts when the scene loads. bindVideoPlayer_has_autoplay :: MethodBind bindVideoPlayer_has_autoplay = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "has_autoplay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, playback starts when the scene loads. has_autoplay :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Bool has_autoplay cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_has_autoplay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "has_autoplay" '[] (IO Bool) where nodeMethod = Godot.Core.VideoPlayer.has_autoplay {-# NOINLINE bindVideoPlayer_has_expand #-} -- | If @true@, the video scales to the control size. Otherwise, the control minimum size will be automatically adjusted to match the video stream's dimensions. bindVideoPlayer_has_expand :: MethodBind bindVideoPlayer_has_expand = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "has_expand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the video scales to the control size. Otherwise, the control minimum size will be automatically adjusted to match the video stream's dimensions. has_expand :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Bool has_expand cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_has_expand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "has_expand" '[] (IO Bool) where nodeMethod = Godot.Core.VideoPlayer.has_expand {-# NOINLINE bindVideoPlayer_is_paused #-} -- | If @true@, the video is paused. bindVideoPlayer_is_paused :: MethodBind bindVideoPlayer_is_paused = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "is_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the video is paused. is_paused :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Bool is_paused cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_is_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "is_paused" '[] (IO Bool) where nodeMethod = Godot.Core.VideoPlayer.is_paused {-# NOINLINE bindVideoPlayer_is_playing #-} -- | Returns @true@ if the video is playing. -- __Note:__ The video is still considered playing if paused during playback. bindVideoPlayer_is_playing :: MethodBind bindVideoPlayer_is_playing = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "is_playing" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the video is playing. -- __Note:__ The video is still considered playing if paused during playback. is_playing :: (VideoPlayer :< cls, Object :< cls) => cls -> IO Bool is_playing cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_is_playing (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "is_playing" '[] (IO Bool) where nodeMethod = Godot.Core.VideoPlayer.is_playing {-# NOINLINE bindVideoPlayer_play #-} -- | Starts the video playback from the beginning. If the video is paused, this will not unpause the video. bindVideoPlayer_play :: MethodBind bindVideoPlayer_play = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Starts the video playback from the beginning. If the video is paused, this will not unpause the video. play :: (VideoPlayer :< cls, Object :< cls) => cls -> IO () play cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "play" '[] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.play {-# NOINLINE bindVideoPlayer_set_audio_track #-} -- | The embedded audio track to play. bindVideoPlayer_set_audio_track :: MethodBind bindVideoPlayer_set_audio_track = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_audio_track" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The embedded audio track to play. set_audio_track :: (VideoPlayer :< cls, Object :< cls) => cls -> Int -> IO () set_audio_track cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_audio_track (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_audio_track" '[Int] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_audio_track {-# NOINLINE bindVideoPlayer_set_autoplay #-} -- | If @true@, playback starts when the scene loads. bindVideoPlayer_set_autoplay :: MethodBind bindVideoPlayer_set_autoplay = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_autoplay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, playback starts when the scene loads. set_autoplay :: (VideoPlayer :< cls, Object :< cls) => cls -> Bool -> IO () set_autoplay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_autoplay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_autoplay" '[Bool] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_autoplay {-# NOINLINE bindVideoPlayer_set_buffering_msec #-} -- | Amount of time in milliseconds to store in buffer while playing. bindVideoPlayer_set_buffering_msec :: MethodBind bindVideoPlayer_set_buffering_msec = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_buffering_msec" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Amount of time in milliseconds to store in buffer while playing. set_buffering_msec :: (VideoPlayer :< cls, Object :< cls) => cls -> Int -> IO () set_buffering_msec cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_buffering_msec (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_buffering_msec" '[Int] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_buffering_msec {-# NOINLINE bindVideoPlayer_set_bus #-} -- | Audio bus to use for sound playback. bindVideoPlayer_set_bus :: MethodBind bindVideoPlayer_set_bus = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_bus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Audio bus to use for sound playback. set_bus :: (VideoPlayer :< cls, Object :< cls) => cls -> GodotString -> IO () set_bus cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_bus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_bus" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_bus {-# NOINLINE bindVideoPlayer_set_expand #-} -- | If @true@, the video scales to the control size. Otherwise, the control minimum size will be automatically adjusted to match the video stream's dimensions. bindVideoPlayer_set_expand :: MethodBind bindVideoPlayer_set_expand = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_expand" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the video scales to the control size. Otherwise, the control minimum size will be automatically adjusted to match the video stream's dimensions. set_expand :: (VideoPlayer :< cls, Object :< cls) => cls -> Bool -> IO () set_expand cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_expand (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_expand" '[Bool] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_expand {-# NOINLINE bindVideoPlayer_set_paused #-} -- | If @true@, the video is paused. bindVideoPlayer_set_paused :: MethodBind bindVideoPlayer_set_paused = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_paused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the video is paused. set_paused :: (VideoPlayer :< cls, Object :< cls) => cls -> Bool -> IO () set_paused cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_paused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_paused" '[Bool] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_paused {-# NOINLINE bindVideoPlayer_set_stream #-} -- | The assigned video stream. See description for supported formats. bindVideoPlayer_set_stream :: MethodBind bindVideoPlayer_set_stream = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_stream" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The assigned video stream. See description for supported formats. set_stream :: (VideoPlayer :< cls, Object :< cls) => cls -> VideoStream -> IO () set_stream cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_stream (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_stream" '[VideoStream] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_stream {-# NOINLINE bindVideoPlayer_set_stream_position #-} -- | The current position of the stream, in seconds. bindVideoPlayer_set_stream_position :: MethodBind bindVideoPlayer_set_stream_position = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_stream_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The current position of the stream, in seconds. set_stream_position :: (VideoPlayer :< cls, Object :< cls) => cls -> Float -> IO () set_stream_position cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_stream_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_stream_position" '[Float] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_stream_position {-# NOINLINE bindVideoPlayer_set_volume #-} -- | Audio volume as a linear value. bindVideoPlayer_set_volume :: MethodBind bindVideoPlayer_set_volume = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_volume" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Audio volume as a linear value. set_volume :: (VideoPlayer :< cls, Object :< cls) => cls -> Float -> IO () set_volume cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_volume (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_volume" '[Float] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_volume {-# NOINLINE bindVideoPlayer_set_volume_db #-} -- | Audio volume in dB. bindVideoPlayer_set_volume_db :: MethodBind bindVideoPlayer_set_volume_db = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "set_volume_db" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Audio volume in dB. set_volume_db :: (VideoPlayer :< cls, Object :< cls) => cls -> Float -> IO () set_volume_db cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_set_volume_db (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "set_volume_db" '[Float] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.set_volume_db {-# NOINLINE bindVideoPlayer_stop #-} -- | Stops the video playback and sets the stream position to 0. -- __Note:__ Although the stream position will be set to 0, the first frame of the video stream won't become the current frame. bindVideoPlayer_stop :: MethodBind bindVideoPlayer_stop = unsafePerformIO $ withCString "VideoPlayer" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the video playback and sets the stream position to 0. -- __Note:__ Although the stream position will be set to 0, the first frame of the video stream won't become the current frame. stop :: (VideoPlayer :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoPlayer_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoPlayer "stop" '[] (IO ()) where nodeMethod = Godot.Core.VideoPlayer.stop ================================================ FILE: src/Godot/Core/VideoStream.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VideoStream () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() ================================================ FILE: src/Godot/Core/VideoStreamGDNative.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VideoStreamGDNative (Godot.Core.VideoStreamGDNative.get_file, Godot.Core.VideoStreamGDNative.set_file) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VideoStream() instance NodeProperty VideoStreamGDNative "file" GodotString 'False where nodeProperty = (get_file, wrapDroppingSetter set_file, Nothing) {-# NOINLINE bindVideoStreamGDNative_get_file #-} bindVideoStreamGDNative_get_file :: MethodBind bindVideoStreamGDNative_get_file = unsafePerformIO $ withCString "VideoStreamGDNative" $ \ clsNamePtr -> withCString "get_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_file :: (VideoStreamGDNative :< cls, Object :< cls) => cls -> IO GodotString get_file cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoStreamGDNative_get_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoStreamGDNative "get_file" '[] (IO GodotString) where nodeMethod = Godot.Core.VideoStreamGDNative.get_file {-# NOINLINE bindVideoStreamGDNative_set_file #-} bindVideoStreamGDNative_set_file :: MethodBind bindVideoStreamGDNative_set_file = unsafePerformIO $ withCString "VideoStreamGDNative" $ \ clsNamePtr -> withCString "set_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_file :: (VideoStreamGDNative :< cls, Object :< cls) => cls -> GodotString -> IO () set_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoStreamGDNative_set_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoStreamGDNative "set_file" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VideoStreamGDNative.set_file ================================================ FILE: src/Godot/Core/VideoStreamTheora.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VideoStreamTheora (Godot.Core.VideoStreamTheora.get_file, Godot.Core.VideoStreamTheora.set_file) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VideoStream() instance NodeProperty VideoStreamTheora "file" GodotString 'False where nodeProperty = (get_file, wrapDroppingSetter set_file, Nothing) {-# NOINLINE bindVideoStreamTheora_get_file #-} bindVideoStreamTheora_get_file :: MethodBind bindVideoStreamTheora_get_file = unsafePerformIO $ withCString "VideoStreamTheora" $ \ clsNamePtr -> withCString "get_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_file :: (VideoStreamTheora :< cls, Object :< cls) => cls -> IO GodotString get_file cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoStreamTheora_get_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoStreamTheora "get_file" '[] (IO GodotString) where nodeMethod = Godot.Core.VideoStreamTheora.get_file {-# NOINLINE bindVideoStreamTheora_set_file #-} bindVideoStreamTheora_set_file :: MethodBind bindVideoStreamTheora_set_file = unsafePerformIO $ withCString "VideoStreamTheora" $ \ clsNamePtr -> withCString "set_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_file :: (VideoStreamTheora :< cls, Object :< cls) => cls -> GodotString -> IO () set_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoStreamTheora_set_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoStreamTheora "set_file" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VideoStreamTheora.set_file ================================================ FILE: src/Godot/Core/VideoStreamWebm.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VideoStreamWebm (Godot.Core.VideoStreamWebm.get_file, Godot.Core.VideoStreamWebm.set_file) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VideoStream() instance NodeProperty VideoStreamWebm "file" GodotString 'False where nodeProperty = (get_file, wrapDroppingSetter set_file, Nothing) {-# NOINLINE bindVideoStreamWebm_get_file #-} bindVideoStreamWebm_get_file :: MethodBind bindVideoStreamWebm_get_file = unsafePerformIO $ withCString "VideoStreamWebm" $ \ clsNamePtr -> withCString "get_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_file :: (VideoStreamWebm :< cls, Object :< cls) => cls -> IO GodotString get_file cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVideoStreamWebm_get_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoStreamWebm "get_file" '[] (IO GodotString) where nodeMethod = Godot.Core.VideoStreamWebm.get_file {-# NOINLINE bindVideoStreamWebm_set_file #-} bindVideoStreamWebm_set_file :: MethodBind bindVideoStreamWebm_set_file = unsafePerformIO $ withCString "VideoStreamWebm" $ \ clsNamePtr -> withCString "set_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_file :: (VideoStreamWebm :< cls, Object :< cls) => cls -> GodotString -> IO () set_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVideoStreamWebm_set_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VideoStreamWebm "set_file" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VideoStreamWebm.set_file ================================================ FILE: src/Godot/Core/Viewport.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.Viewport (Godot.Core.Viewport._CLEAR_MODE_ONLY_NEXT_FRAME, Godot.Core.Viewport._DEBUG_DRAW_OVERDRAW, Godot.Core.Viewport._UPDATE_ALWAYS, Godot.Core.Viewport._RENDER_INFO_MATERIAL_CHANGES_IN_FRAME, Godot.Core.Viewport._USAGE_3D, Godot.Core.Viewport._MSAA_4X, Godot.Core.Viewport._SHADOW_ATLAS_QUADRANT_SUBDIV_1024, Godot.Core.Viewport._SHADOW_ATLAS_QUADRANT_SUBDIV_16, Godot.Core.Viewport._RENDER_INFO_SHADER_CHANGES_IN_FRAME, Godot.Core.Viewport._RENDER_INFO_MAX, Godot.Core.Viewport._CLEAR_MODE_NEVER, Godot.Core.Viewport._SHADOW_ATLAS_QUADRANT_SUBDIV_64, Godot.Core.Viewport._USAGE_3D_NO_EFFECTS, Godot.Core.Viewport._RENDER_INFO_OBJECTS_IN_FRAME, Godot.Core.Viewport._MSAA_2X, Godot.Core.Viewport._SHADOW_ATLAS_QUADRANT_SUBDIV_256, Godot.Core.Viewport._SHADOW_ATLAS_QUADRANT_SUBDIV_MAX, Godot.Core.Viewport._UPDATE_DISABLED, Godot.Core.Viewport._MSAA_DISABLED, Godot.Core.Viewport._DEBUG_DRAW_DISABLED, Godot.Core.Viewport._MSAA_8X, Godot.Core.Viewport._USAGE_2D, Godot.Core.Viewport._RENDER_INFO_VERTICES_IN_FRAME, Godot.Core.Viewport._SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED, Godot.Core.Viewport._DEBUG_DRAW_UNSHADED, Godot.Core.Viewport._DEBUG_DRAW_WIREFRAME, Godot.Core.Viewport._RENDER_INFO_DRAW_CALLS_IN_FRAME, Godot.Core.Viewport._UPDATE_WHEN_VISIBLE, Godot.Core.Viewport._CLEAR_MODE_ALWAYS, Godot.Core.Viewport._SHADOW_ATLAS_QUADRANT_SUBDIV_1, Godot.Core.Viewport._MSAA_16X, Godot.Core.Viewport._SHADOW_ATLAS_QUADRANT_SUBDIV_4, Godot.Core.Viewport._USAGE_2D_NO_SAMPLING, Godot.Core.Viewport._UPDATE_ONCE, Godot.Core.Viewport._RENDER_INFO_SURFACE_CHANGES_IN_FRAME, Godot.Core.Viewport.sig_gui_focus_changed, Godot.Core.Viewport.sig_size_changed, Godot.Core.Viewport._gui_remove_focus, Godot.Core.Viewport._gui_show_tooltip, Godot.Core.Viewport._own_world_changed, Godot.Core.Viewport._post_gui_grab_click_focus, Godot.Core.Viewport._subwindow_visibility_changed, Godot.Core.Viewport._vp_input, Godot.Core.Viewport._vp_input_text, Godot.Core.Viewport._vp_unhandled_input, Godot.Core.Viewport.find_world, Godot.Core.Viewport.find_world_2d, Godot.Core.Viewport.get_camera, Godot.Core.Viewport.get_canvas_transform, Godot.Core.Viewport.get_clear_mode, Godot.Core.Viewport.get_debug_draw, Godot.Core.Viewport.get_final_transform, Godot.Core.Viewport.get_global_canvas_transform, Godot.Core.Viewport.get_hdr, Godot.Core.Viewport.get_keep_3d_linear, Godot.Core.Viewport.get_modal_stack_top, Godot.Core.Viewport.get_mouse_position, Godot.Core.Viewport.get_msaa, Godot.Core.Viewport.get_physics_object_picking, Godot.Core.Viewport.get_render_info, Godot.Core.Viewport.get_shadow_atlas_quadrant_subdiv, Godot.Core.Viewport.get_shadow_atlas_size, Godot.Core.Viewport.get_size, Godot.Core.Viewport.get_size_override, Godot.Core.Viewport.get_texture, Godot.Core.Viewport.get_update_mode, Godot.Core.Viewport.get_usage, Godot.Core.Viewport.get_vflip, Godot.Core.Viewport.get_viewport_rid, Godot.Core.Viewport.get_visible_rect, Godot.Core.Viewport.get_world, Godot.Core.Viewport.get_world_2d, Godot.Core.Viewport.gui_get_drag_data, Godot.Core.Viewport.gui_has_modal_stack, Godot.Core.Viewport.gui_is_dragging, Godot.Core.Viewport.has_transparent_background, Godot.Core.Viewport.input, Godot.Core.Viewport.is_3d_disabled, Godot.Core.Viewport.is_audio_listener, Godot.Core.Viewport.is_audio_listener_2d, Godot.Core.Viewport.is_handling_input_locally, Godot.Core.Viewport.is_input_disabled, Godot.Core.Viewport.is_input_handled, Godot.Core.Viewport.is_size_override_enabled, Godot.Core.Viewport.is_size_override_stretch_enabled, Godot.Core.Viewport.is_snap_controls_to_pixels_enabled, Godot.Core.Viewport.is_using_own_world, Godot.Core.Viewport.is_using_render_direct_to_screen, Godot.Core.Viewport.set_as_audio_listener, Godot.Core.Viewport.set_as_audio_listener_2d, Godot.Core.Viewport.set_attach_to_screen_rect, Godot.Core.Viewport.set_canvas_transform, Godot.Core.Viewport.set_clear_mode, Godot.Core.Viewport.set_debug_draw, Godot.Core.Viewport.set_disable_3d, Godot.Core.Viewport.set_disable_input, Godot.Core.Viewport.set_global_canvas_transform, Godot.Core.Viewport.set_handle_input_locally, Godot.Core.Viewport.set_hdr, Godot.Core.Viewport.set_input_as_handled, Godot.Core.Viewport.set_keep_3d_linear, Godot.Core.Viewport.set_msaa, Godot.Core.Viewport.set_physics_object_picking, Godot.Core.Viewport.set_shadow_atlas_quadrant_subdiv, Godot.Core.Viewport.set_shadow_atlas_size, Godot.Core.Viewport.set_size, Godot.Core.Viewport.set_size_override, Godot.Core.Viewport.set_size_override_stretch, Godot.Core.Viewport.set_snap_controls_to_pixels, Godot.Core.Viewport.set_transparent_background, Godot.Core.Viewport.set_update_mode, Godot.Core.Viewport.set_usage, Godot.Core.Viewport.set_use_arvr, Godot.Core.Viewport.set_use_own_world, Godot.Core.Viewport.set_use_render_direct_to_screen, Godot.Core.Viewport.set_vflip, Godot.Core.Viewport.set_world, Godot.Core.Viewport.set_world_2d, Godot.Core.Viewport.unhandled_input, Godot.Core.Viewport.update_worlds, Godot.Core.Viewport.use_arvr, Godot.Core.Viewport.warp_mouse) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _CLEAR_MODE_ONLY_NEXT_FRAME :: Int _CLEAR_MODE_ONLY_NEXT_FRAME = 2 _DEBUG_DRAW_OVERDRAW :: Int _DEBUG_DRAW_OVERDRAW = 2 _UPDATE_ALWAYS :: Int _UPDATE_ALWAYS = 3 _RENDER_INFO_MATERIAL_CHANGES_IN_FRAME :: Int _RENDER_INFO_MATERIAL_CHANGES_IN_FRAME = 2 _USAGE_3D :: Int _USAGE_3D = 2 _MSAA_4X :: Int _MSAA_4X = 2 _SHADOW_ATLAS_QUADRANT_SUBDIV_1024 :: Int _SHADOW_ATLAS_QUADRANT_SUBDIV_1024 = 6 _SHADOW_ATLAS_QUADRANT_SUBDIV_16 :: Int _SHADOW_ATLAS_QUADRANT_SUBDIV_16 = 3 _RENDER_INFO_SHADER_CHANGES_IN_FRAME :: Int _RENDER_INFO_SHADER_CHANGES_IN_FRAME = 3 _RENDER_INFO_MAX :: Int _RENDER_INFO_MAX = 6 _CLEAR_MODE_NEVER :: Int _CLEAR_MODE_NEVER = 1 _SHADOW_ATLAS_QUADRANT_SUBDIV_64 :: Int _SHADOW_ATLAS_QUADRANT_SUBDIV_64 = 4 _USAGE_3D_NO_EFFECTS :: Int _USAGE_3D_NO_EFFECTS = 3 _RENDER_INFO_OBJECTS_IN_FRAME :: Int _RENDER_INFO_OBJECTS_IN_FRAME = 0 _MSAA_2X :: Int _MSAA_2X = 1 _SHADOW_ATLAS_QUADRANT_SUBDIV_256 :: Int _SHADOW_ATLAS_QUADRANT_SUBDIV_256 = 5 _SHADOW_ATLAS_QUADRANT_SUBDIV_MAX :: Int _SHADOW_ATLAS_QUADRANT_SUBDIV_MAX = 7 _UPDATE_DISABLED :: Int _UPDATE_DISABLED = 0 _MSAA_DISABLED :: Int _MSAA_DISABLED = 0 _DEBUG_DRAW_DISABLED :: Int _DEBUG_DRAW_DISABLED = 0 _MSAA_8X :: Int _MSAA_8X = 3 _USAGE_2D :: Int _USAGE_2D = 0 _RENDER_INFO_VERTICES_IN_FRAME :: Int _RENDER_INFO_VERTICES_IN_FRAME = 1 _SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED :: Int _SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED = 0 _DEBUG_DRAW_UNSHADED :: Int _DEBUG_DRAW_UNSHADED = 1 _DEBUG_DRAW_WIREFRAME :: Int _DEBUG_DRAW_WIREFRAME = 3 _RENDER_INFO_DRAW_CALLS_IN_FRAME :: Int _RENDER_INFO_DRAW_CALLS_IN_FRAME = 5 _UPDATE_WHEN_VISIBLE :: Int _UPDATE_WHEN_VISIBLE = 2 _CLEAR_MODE_ALWAYS :: Int _CLEAR_MODE_ALWAYS = 0 _SHADOW_ATLAS_QUADRANT_SUBDIV_1 :: Int _SHADOW_ATLAS_QUADRANT_SUBDIV_1 = 1 _MSAA_16X :: Int _MSAA_16X = 4 _SHADOW_ATLAS_QUADRANT_SUBDIV_4 :: Int _SHADOW_ATLAS_QUADRANT_SUBDIV_4 = 2 _USAGE_2D_NO_SAMPLING :: Int _USAGE_2D_NO_SAMPLING = 1 _UPDATE_ONCE :: Int _UPDATE_ONCE = 1 _RENDER_INFO_SURFACE_CHANGES_IN_FRAME :: Int _RENDER_INFO_SURFACE_CHANGES_IN_FRAME = 4 -- | Emitted when a Control node grabs keyboard focus. sig_gui_focus_changed :: Godot.Internal.Dispatch.Signal Viewport sig_gui_focus_changed = Godot.Internal.Dispatch.Signal "gui_focus_changed" instance NodeSignal Viewport "gui_focus_changed" '[Control] -- | Emitted when the size of the viewport is changed, whether by @method set_size_override@, resize of window, or some other means. sig_size_changed :: Godot.Internal.Dispatch.Signal Viewport sig_size_changed = Godot.Internal.Dispatch.Signal "size_changed" instance NodeSignal Viewport "size_changed" '[] instance NodeProperty Viewport "arvr" Bool 'False where nodeProperty = (use_arvr, wrapDroppingSetter set_use_arvr, Nothing) instance NodeProperty Viewport "audio_listener_enable_2d" Bool 'False where nodeProperty = (is_audio_listener_2d, wrapDroppingSetter set_as_audio_listener_2d, Nothing) instance NodeProperty Viewport "audio_listener_enable_3d" Bool 'False where nodeProperty = (is_audio_listener, wrapDroppingSetter set_as_audio_listener, Nothing) instance NodeProperty Viewport "canvas_transform" Transform2d 'False where nodeProperty = (get_canvas_transform, wrapDroppingSetter set_canvas_transform, Nothing) instance NodeProperty Viewport "debug_draw" Int 'False where nodeProperty = (get_debug_draw, wrapDroppingSetter set_debug_draw, Nothing) instance NodeProperty Viewport "disable_3d" Bool 'False where nodeProperty = (is_3d_disabled, wrapDroppingSetter set_disable_3d, Nothing) instance NodeProperty Viewport "global_canvas_transform" Transform2d 'False where nodeProperty = (get_global_canvas_transform, wrapDroppingSetter set_global_canvas_transform, Nothing) instance NodeProperty Viewport "gui_disable_input" Bool 'False where nodeProperty = (is_input_disabled, wrapDroppingSetter set_disable_input, Nothing) instance NodeProperty Viewport "gui_snap_controls_to_pixels" Bool 'False where nodeProperty = (is_snap_controls_to_pixels_enabled, wrapDroppingSetter set_snap_controls_to_pixels, Nothing) instance NodeProperty Viewport "handle_input_locally" Bool 'False where nodeProperty = (is_handling_input_locally, wrapDroppingSetter set_handle_input_locally, Nothing) instance NodeProperty Viewport "hdr" Bool 'False where nodeProperty = (get_hdr, wrapDroppingSetter set_hdr, Nothing) instance NodeProperty Viewport "keep_3d_linear" Bool 'False where nodeProperty = (get_keep_3d_linear, wrapDroppingSetter set_keep_3d_linear, Nothing) instance NodeProperty Viewport "msaa" Int 'False where nodeProperty = (get_msaa, wrapDroppingSetter set_msaa, Nothing) instance NodeProperty Viewport "own_world" Bool 'False where nodeProperty = (is_using_own_world, wrapDroppingSetter set_use_own_world, Nothing) instance NodeProperty Viewport "physics_object_picking" Bool 'False where nodeProperty = (get_physics_object_picking, wrapDroppingSetter set_physics_object_picking, Nothing) instance NodeProperty Viewport "render_direct_to_screen" Bool 'False where nodeProperty = (is_using_render_direct_to_screen, wrapDroppingSetter set_use_render_direct_to_screen, Nothing) instance NodeProperty Viewport "render_target_clear_mode" Int 'False where nodeProperty = (get_clear_mode, wrapDroppingSetter set_clear_mode, Nothing) instance NodeProperty Viewport "render_target_update_mode" Int 'False where nodeProperty = (get_update_mode, wrapDroppingSetter set_update_mode, Nothing) instance NodeProperty Viewport "render_target_v_flip" Bool 'False where nodeProperty = (get_vflip, wrapDroppingSetter set_vflip, Nothing) instance NodeProperty Viewport "shadow_atlas_quad_0" Int 'False where nodeProperty = (wrapIndexedGetter 0 get_shadow_atlas_quadrant_subdiv, wrapIndexedSetter 0 set_shadow_atlas_quadrant_subdiv, Nothing) instance NodeProperty Viewport "shadow_atlas_quad_1" Int 'False where nodeProperty = (wrapIndexedGetter 1 get_shadow_atlas_quadrant_subdiv, wrapIndexedSetter 1 set_shadow_atlas_quadrant_subdiv, Nothing) instance NodeProperty Viewport "shadow_atlas_quad_2" Int 'False where nodeProperty = (wrapIndexedGetter 2 get_shadow_atlas_quadrant_subdiv, wrapIndexedSetter 2 set_shadow_atlas_quadrant_subdiv, Nothing) instance NodeProperty Viewport "shadow_atlas_quad_3" Int 'False where nodeProperty = (wrapIndexedGetter 3 get_shadow_atlas_quadrant_subdiv, wrapIndexedSetter 3 set_shadow_atlas_quadrant_subdiv, Nothing) instance NodeProperty Viewport "shadow_atlas_size" Int 'False where nodeProperty = (get_shadow_atlas_size, wrapDroppingSetter set_shadow_atlas_size, Nothing) instance NodeProperty Viewport "size" Vector2 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) instance NodeProperty Viewport "size_override_stretch" Bool 'False where nodeProperty = (is_size_override_stretch_enabled, wrapDroppingSetter set_size_override_stretch, Nothing) instance NodeProperty Viewport "transparent_bg" Bool 'False where nodeProperty = (has_transparent_background, wrapDroppingSetter set_transparent_background, Nothing) instance NodeProperty Viewport "usage" Int 'False where nodeProperty = (get_usage, wrapDroppingSetter set_usage, Nothing) instance NodeProperty Viewport "world" World 'False where nodeProperty = (get_world, wrapDroppingSetter set_world, Nothing) instance NodeProperty Viewport "world_2d" World2D 'False where nodeProperty = (get_world_2d, wrapDroppingSetter set_world_2d, Nothing) {-# NOINLINE bindViewport__gui_remove_focus #-} bindViewport__gui_remove_focus :: MethodBind bindViewport__gui_remove_focus = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "_gui_remove_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_remove_focus :: (Viewport :< cls, Object :< cls) => cls -> IO () _gui_remove_focus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport__gui_remove_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "_gui_remove_focus" '[] (IO ()) where nodeMethod = Godot.Core.Viewport._gui_remove_focus {-# NOINLINE bindViewport__gui_show_tooltip #-} bindViewport__gui_show_tooltip :: MethodBind bindViewport__gui_show_tooltip = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "_gui_show_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_show_tooltip :: (Viewport :< cls, Object :< cls) => cls -> IO () _gui_show_tooltip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport__gui_show_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "_gui_show_tooltip" '[] (IO ()) where nodeMethod = Godot.Core.Viewport._gui_show_tooltip {-# NOINLINE bindViewport__own_world_changed #-} bindViewport__own_world_changed :: MethodBind bindViewport__own_world_changed = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "_own_world_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _own_world_changed :: (Viewport :< cls, Object :< cls) => cls -> IO () _own_world_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport__own_world_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "_own_world_changed" '[] (IO ()) where nodeMethod = Godot.Core.Viewport._own_world_changed {-# NOINLINE bindViewport__post_gui_grab_click_focus #-} bindViewport__post_gui_grab_click_focus :: MethodBind bindViewport__post_gui_grab_click_focus = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "_post_gui_grab_click_focus" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _post_gui_grab_click_focus :: (Viewport :< cls, Object :< cls) => cls -> IO () _post_gui_grab_click_focus cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport__post_gui_grab_click_focus (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "_post_gui_grab_click_focus" '[] (IO ()) where nodeMethod = Godot.Core.Viewport._post_gui_grab_click_focus {-# NOINLINE bindViewport__subwindow_visibility_changed #-} bindViewport__subwindow_visibility_changed :: MethodBind bindViewport__subwindow_visibility_changed = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "_subwindow_visibility_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _subwindow_visibility_changed :: (Viewport :< cls, Object :< cls) => cls -> IO () _subwindow_visibility_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport__subwindow_visibility_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "_subwindow_visibility_changed" '[] (IO ()) where nodeMethod = Godot.Core.Viewport._subwindow_visibility_changed {-# NOINLINE bindViewport__vp_input #-} bindViewport__vp_input :: MethodBind bindViewport__vp_input = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "_vp_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _vp_input :: (Viewport :< cls, Object :< cls) => cls -> InputEvent -> IO () _vp_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport__vp_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "_vp_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Viewport._vp_input {-# NOINLINE bindViewport__vp_input_text #-} bindViewport__vp_input_text :: MethodBind bindViewport__vp_input_text = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "_vp_input_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _vp_input_text :: (Viewport :< cls, Object :< cls) => cls -> GodotString -> IO () _vp_input_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport__vp_input_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "_vp_input_text" '[GodotString] (IO ()) where nodeMethod = Godot.Core.Viewport._vp_input_text {-# NOINLINE bindViewport__vp_unhandled_input #-} bindViewport__vp_unhandled_input :: MethodBind bindViewport__vp_unhandled_input = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "_vp_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _vp_unhandled_input :: (Viewport :< cls, Object :< cls) => cls -> InputEvent -> IO () _vp_unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport__vp_unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "_vp_unhandled_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Viewport._vp_unhandled_input {-# NOINLINE bindViewport_find_world #-} -- | Returns the 3D world of the viewport, or if none the world of the parent viewport. bindViewport_find_world :: MethodBind bindViewport_find_world = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "find_world" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the 3D world of the viewport, or if none the world of the parent viewport. find_world :: (Viewport :< cls, Object :< cls) => cls -> IO World find_world cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_find_world (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "find_world" '[] (IO World) where nodeMethod = Godot.Core.Viewport.find_world {-# NOINLINE bindViewport_find_world_2d #-} -- | Returns the 2D world of the viewport. bindViewport_find_world_2d :: MethodBind bindViewport_find_world_2d = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "find_world_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the 2D world of the viewport. find_world_2d :: (Viewport :< cls, Object :< cls) => cls -> IO World2D find_world_2d cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_find_world_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "find_world_2d" '[] (IO World2D) where nodeMethod = Godot.Core.Viewport.find_world_2d {-# NOINLINE bindViewport_get_camera #-} -- | Returns the active 3D camera. bindViewport_get_camera :: MethodBind bindViewport_get_camera = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_camera" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the active 3D camera. get_camera :: (Viewport :< cls, Object :< cls) => cls -> IO Camera get_camera cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_camera (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_camera" '[] (IO Camera) where nodeMethod = Godot.Core.Viewport.get_camera {-# NOINLINE bindViewport_get_canvas_transform #-} -- | The canvas transform of the viewport, useful for changing the on-screen positions of all child @CanvasItem@s. This is relative to the global canvas transform of the viewport. bindViewport_get_canvas_transform :: MethodBind bindViewport_get_canvas_transform = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_canvas_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The canvas transform of the viewport, useful for changing the on-screen positions of all child @CanvasItem@s. This is relative to the global canvas transform of the viewport. get_canvas_transform :: (Viewport :< cls, Object :< cls) => cls -> IO Transform2d get_canvas_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_canvas_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_canvas_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.Viewport.get_canvas_transform {-# NOINLINE bindViewport_get_clear_mode #-} -- | The clear mode when viewport used as a render target. -- __Note:__ This property is intended for 2D usage. bindViewport_get_clear_mode :: MethodBind bindViewport_get_clear_mode = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_clear_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The clear mode when viewport used as a render target. -- __Note:__ This property is intended for 2D usage. get_clear_mode :: (Viewport :< cls, Object :< cls) => cls -> IO Int get_clear_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_clear_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_clear_mode" '[] (IO Int) where nodeMethod = Godot.Core.Viewport.get_clear_mode {-# NOINLINE bindViewport_get_debug_draw #-} -- | The overlay mode for test rendered geometry in debug purposes. bindViewport_get_debug_draw :: MethodBind bindViewport_get_debug_draw = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_debug_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The overlay mode for test rendered geometry in debug purposes. get_debug_draw :: (Viewport :< cls, Object :< cls) => cls -> IO Int get_debug_draw cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_debug_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_debug_draw" '[] (IO Int) where nodeMethod = Godot.Core.Viewport.get_debug_draw {-# NOINLINE bindViewport_get_final_transform #-} -- | Returns the total transform of the viewport. bindViewport_get_final_transform :: MethodBind bindViewport_get_final_transform = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_final_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the total transform of the viewport. get_final_transform :: (Viewport :< cls, Object :< cls) => cls -> IO Transform2d get_final_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_final_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_final_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.Viewport.get_final_transform {-# NOINLINE bindViewport_get_global_canvas_transform #-} -- | The global canvas transform of the viewport. The canvas transform is relative to this. bindViewport_get_global_canvas_transform :: MethodBind bindViewport_get_global_canvas_transform = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_global_canvas_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global canvas transform of the viewport. The canvas transform is relative to this. get_global_canvas_transform :: (Viewport :< cls, Object :< cls) => cls -> IO Transform2d get_global_canvas_transform cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_global_canvas_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_global_canvas_transform" '[] (IO Transform2d) where nodeMethod = Godot.Core.Viewport.get_global_canvas_transform {-# NOINLINE bindViewport_get_hdr #-} -- | If @true@, the viewport rendering will receive benefits from High Dynamic Range algorithm. High Dynamic Range allows the viewport to receive values that are outside the 0-1 range. In Godot HDR uses 16 bits, meaning it does not store the full range of a floating point number. -- __Note:__ Requires @usage@ to be set to @USAGE_3D@ or @USAGE_3D_NO_EFFECTS@, since HDR is not supported for 2D. bindViewport_get_hdr :: MethodBind bindViewport_get_hdr = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_hdr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport rendering will receive benefits from High Dynamic Range algorithm. High Dynamic Range allows the viewport to receive values that are outside the 0-1 range. In Godot HDR uses 16 bits, meaning it does not store the full range of a floating point number. -- __Note:__ Requires @usage@ to be set to @USAGE_3D@ or @USAGE_3D_NO_EFFECTS@, since HDR is not supported for 2D. get_hdr :: (Viewport :< cls, Object :< cls) => cls -> IO Bool get_hdr cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_hdr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_hdr" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.get_hdr {-# NOINLINE bindViewport_get_keep_3d_linear #-} -- | If @true@, the result after 3D rendering will not have a linear to sRGB color conversion applied. This is important when the viewport is used as a render target where the result is used as a texture on a 3D object rendered in another viewport. It is also important if the viewport is used to create data that is not color based (noise, heightmaps, pickmaps, etc.). Do not enable this when the viewport is used as a texture on a 2D object or if the viewport is your final output. bindViewport_get_keep_3d_linear :: MethodBind bindViewport_get_keep_3d_linear = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_keep_3d_linear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the result after 3D rendering will not have a linear to sRGB color conversion applied. This is important when the viewport is used as a render target where the result is used as a texture on a 3D object rendered in another viewport. It is also important if the viewport is used to create data that is not color based (noise, heightmaps, pickmaps, etc.). Do not enable this when the viewport is used as a texture on a 2D object or if the viewport is your final output. get_keep_3d_linear :: (Viewport :< cls, Object :< cls) => cls -> IO Bool get_keep_3d_linear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_keep_3d_linear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_keep_3d_linear" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.get_keep_3d_linear {-# NOINLINE bindViewport_get_modal_stack_top #-} -- | Returns the topmost modal in the stack. bindViewport_get_modal_stack_top :: MethodBind bindViewport_get_modal_stack_top = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_modal_stack_top" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the topmost modal in the stack. get_modal_stack_top :: (Viewport :< cls, Object :< cls) => cls -> IO Control get_modal_stack_top cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_modal_stack_top (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_modal_stack_top" '[] (IO Control) where nodeMethod = Godot.Core.Viewport.get_modal_stack_top {-# NOINLINE bindViewport_get_mouse_position #-} -- | Returns the mouse position relative to the viewport. bindViewport_get_mouse_position :: MethodBind bindViewport_get_mouse_position = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_mouse_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the mouse position relative to the viewport. get_mouse_position :: (Viewport :< cls, Object :< cls) => cls -> IO Vector2 get_mouse_position cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_mouse_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_mouse_position" '[] (IO Vector2) where nodeMethod = Godot.Core.Viewport.get_mouse_position {-# NOINLINE bindViewport_get_msaa #-} -- | The multisample anti-aliasing mode. A higher number results in smoother edges at the cost of significantly worse performance. A value of 4 is best unless targeting very high-end systems. bindViewport_get_msaa :: MethodBind bindViewport_get_msaa = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_msaa" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The multisample anti-aliasing mode. A higher number results in smoother edges at the cost of significantly worse performance. A value of 4 is best unless targeting very high-end systems. get_msaa :: (Viewport :< cls, Object :< cls) => cls -> IO Int get_msaa cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_msaa (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_msaa" '[] (IO Int) where nodeMethod = Godot.Core.Viewport.get_msaa {-# NOINLINE bindViewport_get_physics_object_picking #-} -- | If @true@, the objects rendered by viewport become subjects of mouse picking process. bindViewport_get_physics_object_picking :: MethodBind bindViewport_get_physics_object_picking = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_physics_object_picking" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the objects rendered by viewport become subjects of mouse picking process. get_physics_object_picking :: (Viewport :< cls, Object :< cls) => cls -> IO Bool get_physics_object_picking cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_physics_object_picking (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_physics_object_picking" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.get_physics_object_picking {-# NOINLINE bindViewport_get_render_info #-} -- | Returns information about the viewport from the rendering pipeline. bindViewport_get_render_info :: MethodBind bindViewport_get_render_info = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_render_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns information about the viewport from the rendering pipeline. get_render_info :: (Viewport :< cls, Object :< cls) => cls -> Int -> IO Int get_render_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_render_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_render_info" '[Int] (IO Int) where nodeMethod = Godot.Core.Viewport.get_render_info {-# NOINLINE bindViewport_get_shadow_atlas_quadrant_subdiv #-} -- | Returns the @enum ShadowAtlasQuadrantSubdiv@ of the specified quadrant. bindViewport_get_shadow_atlas_quadrant_subdiv :: MethodBind bindViewport_get_shadow_atlas_quadrant_subdiv = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_shadow_atlas_quadrant_subdiv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @enum ShadowAtlasQuadrantSubdiv@ of the specified quadrant. get_shadow_atlas_quadrant_subdiv :: (Viewport :< cls, Object :< cls) => cls -> Int -> IO Int get_shadow_atlas_quadrant_subdiv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_shadow_atlas_quadrant_subdiv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_shadow_atlas_quadrant_subdiv" '[Int] (IO Int) where nodeMethod = Godot.Core.Viewport.get_shadow_atlas_quadrant_subdiv {-# NOINLINE bindViewport_get_shadow_atlas_size #-} -- | The shadow atlas' resolution (used for omni and spot lights). The value will be rounded up to the nearest power of 2. -- __Note:__ If this is set to 0, shadows won't be visible. Since user-created viewports default to a value of 0, this value must be set above 0 manually. bindViewport_get_shadow_atlas_size :: MethodBind bindViewport_get_shadow_atlas_size = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_shadow_atlas_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shadow atlas' resolution (used for omni and spot lights). The value will be rounded up to the nearest power of 2. -- __Note:__ If this is set to 0, shadows won't be visible. Since user-created viewports default to a value of 0, this value must be set above 0 manually. get_shadow_atlas_size :: (Viewport :< cls, Object :< cls) => cls -> IO Int get_shadow_atlas_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_shadow_atlas_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_shadow_atlas_size" '[] (IO Int) where nodeMethod = Godot.Core.Viewport.get_shadow_atlas_size {-# NOINLINE bindViewport_get_size #-} -- | The width and height of viewport. bindViewport_get_size :: MethodBind bindViewport_get_size = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The width and height of viewport. get_size :: (Viewport :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.Viewport.get_size {-# NOINLINE bindViewport_get_size_override #-} -- | Returns the size override set with @method set_size_override@. bindViewport_get_size_override :: MethodBind bindViewport_get_size_override = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_size_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size override set with @method set_size_override@. get_size_override :: (Viewport :< cls, Object :< cls) => cls -> IO Vector2 get_size_override cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_size_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_size_override" '[] (IO Vector2) where nodeMethod = Godot.Core.Viewport.get_size_override {-# NOINLINE bindViewport_get_texture #-} -- | Returns the viewport's texture. -- __Note:__ Due to the way OpenGL works, the resulting @ViewportTexture@ is flipped vertically. You can use @method Image.flip_y@ on the result of @method Texture.get_data@ to flip it back, for example: -- -- @ -- -- var img = get_viewport().get_texture().get_data() -- img.flip_y() -- -- @ bindViewport_get_texture :: MethodBind bindViewport_get_texture = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the viewport's texture. -- __Note:__ Due to the way OpenGL works, the resulting @ViewportTexture@ is flipped vertically. You can use @method Image.flip_y@ on the result of @method Texture.get_data@ to flip it back, for example: -- -- @ -- -- var img = get_viewport().get_texture().get_data() -- img.flip_y() -- -- @ get_texture :: (Viewport :< cls, Object :< cls) => cls -> IO ViewportTexture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_texture" '[] (IO ViewportTexture) where nodeMethod = Godot.Core.Viewport.get_texture {-# NOINLINE bindViewport_get_update_mode #-} -- | The update mode when viewport used as a render target. bindViewport_get_update_mode :: MethodBind bindViewport_get_update_mode = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_update_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The update mode when viewport used as a render target. get_update_mode :: (Viewport :< cls, Object :< cls) => cls -> IO Int get_update_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_update_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_update_mode" '[] (IO Int) where nodeMethod = Godot.Core.Viewport.get_update_mode {-# NOINLINE bindViewport_get_usage #-} -- | The rendering mode of viewport. bindViewport_get_usage :: MethodBind bindViewport_get_usage = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_usage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rendering mode of viewport. get_usage :: (Viewport :< cls, Object :< cls) => cls -> IO Int get_usage cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_usage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_usage" '[] (IO Int) where nodeMethod = Godot.Core.Viewport.get_usage {-# NOINLINE bindViewport_get_vflip #-} -- | If @true@, the result of rendering will be flipped vertically. bindViewport_get_vflip :: MethodBind bindViewport_get_vflip = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_vflip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the result of rendering will be flipped vertically. get_vflip :: (Viewport :< cls, Object :< cls) => cls -> IO Bool get_vflip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_vflip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_vflip" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.get_vflip {-# NOINLINE bindViewport_get_viewport_rid #-} -- | Returns the viewport's RID from the @VisualServer@. bindViewport_get_viewport_rid :: MethodBind bindViewport_get_viewport_rid = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_viewport_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the viewport's RID from the @VisualServer@. get_viewport_rid :: (Viewport :< cls, Object :< cls) => cls -> IO Rid get_viewport_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_viewport_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_viewport_rid" '[] (IO Rid) where nodeMethod = Godot.Core.Viewport.get_viewport_rid {-# NOINLINE bindViewport_get_visible_rect #-} -- | Returns the visible rectangle in global screen coordinates. bindViewport_get_visible_rect :: MethodBind bindViewport_get_visible_rect = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_visible_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the visible rectangle in global screen coordinates. get_visible_rect :: (Viewport :< cls, Object :< cls) => cls -> IO Rect2 get_visible_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_visible_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_visible_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.Viewport.get_visible_rect {-# NOINLINE bindViewport_get_world #-} -- | The custom @World@ which can be used as 3D environment source. bindViewport_get_world :: MethodBind bindViewport_get_world = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_world" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @World@ which can be used as 3D environment source. get_world :: (Viewport :< cls, Object :< cls) => cls -> IO World get_world cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_world (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_world" '[] (IO World) where nodeMethod = Godot.Core.Viewport.get_world {-# NOINLINE bindViewport_get_world_2d #-} -- | The custom @World2D@ which can be used as 2D environment source. bindViewport_get_world_2d :: MethodBind bindViewport_get_world_2d = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "get_world_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @World2D@ which can be used as 2D environment source. get_world_2d :: (Viewport :< cls, Object :< cls) => cls -> IO World2D get_world_2d cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_get_world_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "get_world_2d" '[] (IO World2D) where nodeMethod = Godot.Core.Viewport.get_world_2d {-# NOINLINE bindViewport_gui_get_drag_data #-} -- | Returns the drag data from the GUI, that was previously returned by @method Control.get_drag_data@. bindViewport_gui_get_drag_data :: MethodBind bindViewport_gui_get_drag_data = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "gui_get_drag_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the drag data from the GUI, that was previously returned by @method Control.get_drag_data@. gui_get_drag_data :: (Viewport :< cls, Object :< cls) => cls -> IO GodotVariant gui_get_drag_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_gui_get_drag_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "gui_get_drag_data" '[] (IO GodotVariant) where nodeMethod = Godot.Core.Viewport.gui_get_drag_data {-# NOINLINE bindViewport_gui_has_modal_stack #-} -- | Returns @true@ if there are visible modals on-screen. bindViewport_gui_has_modal_stack :: MethodBind bindViewport_gui_has_modal_stack = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "gui_has_modal_stack" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if there are visible modals on-screen. gui_has_modal_stack :: (Viewport :< cls, Object :< cls) => cls -> IO Bool gui_has_modal_stack cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_gui_has_modal_stack (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "gui_has_modal_stack" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.gui_has_modal_stack {-# NOINLINE bindViewport_gui_is_dragging #-} -- | Returns @true@ if the viewport is currently performing a drag operation. bindViewport_gui_is_dragging :: MethodBind bindViewport_gui_is_dragging = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "gui_is_dragging" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the viewport is currently performing a drag operation. gui_is_dragging :: (Viewport :< cls, Object :< cls) => cls -> IO Bool gui_is_dragging cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_gui_is_dragging (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "gui_is_dragging" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.gui_is_dragging {-# NOINLINE bindViewport_has_transparent_background #-} -- | If @true@, the viewport should render its background as transparent. bindViewport_has_transparent_background :: MethodBind bindViewport_has_transparent_background = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "has_transparent_background" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport should render its background as transparent. has_transparent_background :: (Viewport :< cls, Object :< cls) => cls -> IO Bool has_transparent_background cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_has_transparent_background (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "has_transparent_background" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.has_transparent_background {-# NOINLINE bindViewport_input #-} bindViewport_input :: MethodBind bindViewport_input = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr input :: (Viewport :< cls, Object :< cls) => cls -> InputEvent -> IO () input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Viewport.input {-# NOINLINE bindViewport_is_3d_disabled #-} -- | If @true@, the viewport will disable 3D rendering. For actual disabling use @usage@. bindViewport_is_3d_disabled :: MethodBind bindViewport_is_3d_disabled = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_3d_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will disable 3D rendering. For actual disabling use @usage@. is_3d_disabled :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_3d_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_3d_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_3d_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_3d_disabled {-# NOINLINE bindViewport_is_audio_listener #-} -- | If @true@, the viewport will process 3D audio streams. bindViewport_is_audio_listener :: MethodBind bindViewport_is_audio_listener = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_audio_listener" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will process 3D audio streams. is_audio_listener :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_audio_listener cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_audio_listener (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_audio_listener" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_audio_listener {-# NOINLINE bindViewport_is_audio_listener_2d #-} -- | If @true@, the viewport will process 2D audio streams. bindViewport_is_audio_listener_2d :: MethodBind bindViewport_is_audio_listener_2d = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_audio_listener_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will process 2D audio streams. is_audio_listener_2d :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_audio_listener_2d cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_audio_listener_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_audio_listener_2d" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_audio_listener_2d {-# NOINLINE bindViewport_is_handling_input_locally #-} bindViewport_is_handling_input_locally :: MethodBind bindViewport_is_handling_input_locally = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_handling_input_locally" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_handling_input_locally :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_handling_input_locally cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_handling_input_locally (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_handling_input_locally" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_handling_input_locally {-# NOINLINE bindViewport_is_input_disabled #-} -- | If @true@, the viewport will not receive input event. bindViewport_is_input_disabled :: MethodBind bindViewport_is_input_disabled = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_input_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will not receive input event. is_input_disabled :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_input_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_input_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_input_disabled" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_input_disabled {-# NOINLINE bindViewport_is_input_handled #-} bindViewport_is_input_handled :: MethodBind bindViewport_is_input_handled = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_input_handled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_input_handled :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_input_handled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_input_handled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_input_handled" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_input_handled {-# NOINLINE bindViewport_is_size_override_enabled #-} -- | Returns @true@ if the size override is enabled. See @method set_size_override@. bindViewport_is_size_override_enabled :: MethodBind bindViewport_is_size_override_enabled = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_size_override_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the size override is enabled. See @method set_size_override@. is_size_override_enabled :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_size_override_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_size_override_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_size_override_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_size_override_enabled {-# NOINLINE bindViewport_is_size_override_stretch_enabled #-} -- | If @true@, the size override affects stretch as well. bindViewport_is_size_override_stretch_enabled :: MethodBind bindViewport_is_size_override_stretch_enabled = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_size_override_stretch_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the size override affects stretch as well. is_size_override_stretch_enabled :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_size_override_stretch_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_size_override_stretch_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_size_override_stretch_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_size_override_stretch_enabled {-# NOINLINE bindViewport_is_snap_controls_to_pixels_enabled #-} -- | If @true@, the GUI controls on the viewport will lay pixel perfectly. bindViewport_is_snap_controls_to_pixels_enabled :: MethodBind bindViewport_is_snap_controls_to_pixels_enabled = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_snap_controls_to_pixels_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the GUI controls on the viewport will lay pixel perfectly. is_snap_controls_to_pixels_enabled :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_snap_controls_to_pixels_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_snap_controls_to_pixels_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_snap_controls_to_pixels_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_snap_controls_to_pixels_enabled {-# NOINLINE bindViewport_is_using_own_world #-} -- | If @true@, the viewport will use @World@ defined in @world@ property. bindViewport_is_using_own_world :: MethodBind bindViewport_is_using_own_world = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_using_own_world" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will use @World@ defined in @world@ property. is_using_own_world :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_using_own_world cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_using_own_world (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_using_own_world" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_using_own_world {-# NOINLINE bindViewport_is_using_render_direct_to_screen #-} -- | If @true@, renders the Viewport directly to the screen instead of to the root viewport. Only available in GLES2. This is a low-level optimization and should not be used in most cases. If used, reading from the Viewport or from @SCREEN_TEXTURE@ becomes unavailable. For more information see @method VisualServer.viewport_set_render_direct_to_screen@. bindViewport_is_using_render_direct_to_screen :: MethodBind bindViewport_is_using_render_direct_to_screen = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "is_using_render_direct_to_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, renders the Viewport directly to the screen instead of to the root viewport. Only available in GLES2. This is a low-level optimization and should not be used in most cases. If used, reading from the Viewport or from @SCREEN_TEXTURE@ becomes unavailable. For more information see @method VisualServer.viewport_set_render_direct_to_screen@. is_using_render_direct_to_screen :: (Viewport :< cls, Object :< cls) => cls -> IO Bool is_using_render_direct_to_screen cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_is_using_render_direct_to_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "is_using_render_direct_to_screen" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.is_using_render_direct_to_screen {-# NOINLINE bindViewport_set_as_audio_listener #-} -- | If @true@, the viewport will process 3D audio streams. bindViewport_set_as_audio_listener :: MethodBind bindViewport_set_as_audio_listener = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_as_audio_listener" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will process 3D audio streams. set_as_audio_listener :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_as_audio_listener cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_as_audio_listener (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_as_audio_listener" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_as_audio_listener {-# NOINLINE bindViewport_set_as_audio_listener_2d #-} -- | If @true@, the viewport will process 2D audio streams. bindViewport_set_as_audio_listener_2d :: MethodBind bindViewport_set_as_audio_listener_2d = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_as_audio_listener_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will process 2D audio streams. set_as_audio_listener_2d :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_as_audio_listener_2d cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_as_audio_listener_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_as_audio_listener_2d" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_as_audio_listener_2d {-# NOINLINE bindViewport_set_attach_to_screen_rect #-} -- | Attaches this @Viewport@ to the root @Viewport@ with the specified rectangle. This bypasses the need for another node to display this @Viewport@ but makes you responsible for updating the position of this @Viewport@ manually. bindViewport_set_attach_to_screen_rect :: MethodBind bindViewport_set_attach_to_screen_rect = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_attach_to_screen_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Attaches this @Viewport@ to the root @Viewport@ with the specified rectangle. This bypasses the need for another node to display this @Viewport@ but makes you responsible for updating the position of this @Viewport@ manually. set_attach_to_screen_rect :: (Viewport :< cls, Object :< cls) => cls -> Rect2 -> IO () set_attach_to_screen_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_attach_to_screen_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_attach_to_screen_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.Viewport.set_attach_to_screen_rect {-# NOINLINE bindViewport_set_canvas_transform #-} -- | The canvas transform of the viewport, useful for changing the on-screen positions of all child @CanvasItem@s. This is relative to the global canvas transform of the viewport. bindViewport_set_canvas_transform :: MethodBind bindViewport_set_canvas_transform = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_canvas_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The canvas transform of the viewport, useful for changing the on-screen positions of all child @CanvasItem@s. This is relative to the global canvas transform of the viewport. set_canvas_transform :: (Viewport :< cls, Object :< cls) => cls -> Transform2d -> IO () set_canvas_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_canvas_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_canvas_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.Viewport.set_canvas_transform {-# NOINLINE bindViewport_set_clear_mode #-} -- | The clear mode when viewport used as a render target. -- __Note:__ This property is intended for 2D usage. bindViewport_set_clear_mode :: MethodBind bindViewport_set_clear_mode = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_clear_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The clear mode when viewport used as a render target. -- __Note:__ This property is intended for 2D usage. set_clear_mode :: (Viewport :< cls, Object :< cls) => cls -> Int -> IO () set_clear_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_clear_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_clear_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Viewport.set_clear_mode {-# NOINLINE bindViewport_set_debug_draw #-} -- | The overlay mode for test rendered geometry in debug purposes. bindViewport_set_debug_draw :: MethodBind bindViewport_set_debug_draw = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_debug_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The overlay mode for test rendered geometry in debug purposes. set_debug_draw :: (Viewport :< cls, Object :< cls) => cls -> Int -> IO () set_debug_draw cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_debug_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_debug_draw" '[Int] (IO ()) where nodeMethod = Godot.Core.Viewport.set_debug_draw {-# NOINLINE bindViewport_set_disable_3d #-} -- | If @true@, the viewport will disable 3D rendering. For actual disabling use @usage@. bindViewport_set_disable_3d :: MethodBind bindViewport_set_disable_3d = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_disable_3d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will disable 3D rendering. For actual disabling use @usage@. set_disable_3d :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_disable_3d cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_disable_3d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_disable_3d" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_disable_3d {-# NOINLINE bindViewport_set_disable_input #-} -- | If @true@, the viewport will not receive input event. bindViewport_set_disable_input :: MethodBind bindViewport_set_disable_input = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_disable_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will not receive input event. set_disable_input :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_disable_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_disable_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_disable_input" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_disable_input {-# NOINLINE bindViewport_set_global_canvas_transform #-} -- | The global canvas transform of the viewport. The canvas transform is relative to this. bindViewport_set_global_canvas_transform :: MethodBind bindViewport_set_global_canvas_transform = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_global_canvas_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The global canvas transform of the viewport. The canvas transform is relative to this. set_global_canvas_transform :: (Viewport :< cls, Object :< cls) => cls -> Transform2d -> IO () set_global_canvas_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_global_canvas_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_global_canvas_transform" '[Transform2d] (IO ()) where nodeMethod = Godot.Core.Viewport.set_global_canvas_transform {-# NOINLINE bindViewport_set_handle_input_locally #-} bindViewport_set_handle_input_locally :: MethodBind bindViewport_set_handle_input_locally = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_handle_input_locally" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_handle_input_locally :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_handle_input_locally cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_handle_input_locally (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_handle_input_locally" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_handle_input_locally {-# NOINLINE bindViewport_set_hdr #-} -- | If @true@, the viewport rendering will receive benefits from High Dynamic Range algorithm. High Dynamic Range allows the viewport to receive values that are outside the 0-1 range. In Godot HDR uses 16 bits, meaning it does not store the full range of a floating point number. -- __Note:__ Requires @usage@ to be set to @USAGE_3D@ or @USAGE_3D_NO_EFFECTS@, since HDR is not supported for 2D. bindViewport_set_hdr :: MethodBind bindViewport_set_hdr = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_hdr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport rendering will receive benefits from High Dynamic Range algorithm. High Dynamic Range allows the viewport to receive values that are outside the 0-1 range. In Godot HDR uses 16 bits, meaning it does not store the full range of a floating point number. -- __Note:__ Requires @usage@ to be set to @USAGE_3D@ or @USAGE_3D_NO_EFFECTS@, since HDR is not supported for 2D. set_hdr :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_hdr cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_hdr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_hdr" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_hdr {-# NOINLINE bindViewport_set_input_as_handled #-} -- | Stops the input from propagating further down the @SceneTree@. bindViewport_set_input_as_handled :: MethodBind bindViewport_set_input_as_handled = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_input_as_handled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stops the input from propagating further down the @SceneTree@. set_input_as_handled :: (Viewport :< cls, Object :< cls) => cls -> IO () set_input_as_handled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_input_as_handled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_input_as_handled" '[] (IO ()) where nodeMethod = Godot.Core.Viewport.set_input_as_handled {-# NOINLINE bindViewport_set_keep_3d_linear #-} -- | If @true@, the result after 3D rendering will not have a linear to sRGB color conversion applied. This is important when the viewport is used as a render target where the result is used as a texture on a 3D object rendered in another viewport. It is also important if the viewport is used to create data that is not color based (noise, heightmaps, pickmaps, etc.). Do not enable this when the viewport is used as a texture on a 2D object or if the viewport is your final output. bindViewport_set_keep_3d_linear :: MethodBind bindViewport_set_keep_3d_linear = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_keep_3d_linear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the result after 3D rendering will not have a linear to sRGB color conversion applied. This is important when the viewport is used as a render target where the result is used as a texture on a 3D object rendered in another viewport. It is also important if the viewport is used to create data that is not color based (noise, heightmaps, pickmaps, etc.). Do not enable this when the viewport is used as a texture on a 2D object or if the viewport is your final output. set_keep_3d_linear :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_keep_3d_linear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_keep_3d_linear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_keep_3d_linear" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_keep_3d_linear {-# NOINLINE bindViewport_set_msaa #-} -- | The multisample anti-aliasing mode. A higher number results in smoother edges at the cost of significantly worse performance. A value of 4 is best unless targeting very high-end systems. bindViewport_set_msaa :: MethodBind bindViewport_set_msaa = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_msaa" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The multisample anti-aliasing mode. A higher number results in smoother edges at the cost of significantly worse performance. A value of 4 is best unless targeting very high-end systems. set_msaa :: (Viewport :< cls, Object :< cls) => cls -> Int -> IO () set_msaa cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_msaa (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_msaa" '[Int] (IO ()) where nodeMethod = Godot.Core.Viewport.set_msaa {-# NOINLINE bindViewport_set_physics_object_picking #-} -- | If @true@, the objects rendered by viewport become subjects of mouse picking process. bindViewport_set_physics_object_picking :: MethodBind bindViewport_set_physics_object_picking = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_physics_object_picking" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the objects rendered by viewport become subjects of mouse picking process. set_physics_object_picking :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_physics_object_picking cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_physics_object_picking (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_physics_object_picking" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_physics_object_picking {-# NOINLINE bindViewport_set_shadow_atlas_quadrant_subdiv #-} -- | Sets the number of subdivisions to use in the specified quadrant. A higher number of subdivisions allows you to have more shadows in the scene at once, but reduces the quality of the shadows. A good practice is to have quadrants with a varying number of subdivisions and to have as few subdivisions as possible. bindViewport_set_shadow_atlas_quadrant_subdiv :: MethodBind bindViewport_set_shadow_atlas_quadrant_subdiv = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_shadow_atlas_quadrant_subdiv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the number of subdivisions to use in the specified quadrant. A higher number of subdivisions allows you to have more shadows in the scene at once, but reduces the quality of the shadows. A good practice is to have quadrants with a varying number of subdivisions and to have as few subdivisions as possible. set_shadow_atlas_quadrant_subdiv :: (Viewport :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_shadow_atlas_quadrant_subdiv cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_shadow_atlas_quadrant_subdiv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_shadow_atlas_quadrant_subdiv" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.Viewport.set_shadow_atlas_quadrant_subdiv {-# NOINLINE bindViewport_set_shadow_atlas_size #-} -- | The shadow atlas' resolution (used for omni and spot lights). The value will be rounded up to the nearest power of 2. -- __Note:__ If this is set to 0, shadows won't be visible. Since user-created viewports default to a value of 0, this value must be set above 0 manually. bindViewport_set_shadow_atlas_size :: MethodBind bindViewport_set_shadow_atlas_size = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_shadow_atlas_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The shadow atlas' resolution (used for omni and spot lights). The value will be rounded up to the nearest power of 2. -- __Note:__ If this is set to 0, shadows won't be visible. Since user-created viewports default to a value of 0, this value must be set above 0 manually. set_shadow_atlas_size :: (Viewport :< cls, Object :< cls) => cls -> Int -> IO () set_shadow_atlas_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_shadow_atlas_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_shadow_atlas_size" '[Int] (IO ()) where nodeMethod = Godot.Core.Viewport.set_shadow_atlas_size {-# NOINLINE bindViewport_set_size #-} -- | The width and height of viewport. bindViewport_set_size :: MethodBind bindViewport_set_size = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The width and height of viewport. set_size :: (Viewport :< cls, Object :< cls) => cls -> Vector2 -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Viewport.set_size {-# NOINLINE bindViewport_set_size_override #-} -- | Sets the size override of the viewport. If the @enable@ parameter is @true@ the override is used, otherwise it uses the default size. If the size parameter is @(-1, -1)@, it won't update the size. bindViewport_set_size_override :: MethodBind bindViewport_set_size_override = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_size_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size override of the viewport. If the @enable@ parameter is @true@ the override is used, otherwise it uses the default size. If the size parameter is @(-1, -1)@, it won't update the size. set_size_override :: (Viewport :< cls, Object :< cls) => cls -> Bool -> Maybe Vector2 -> Maybe Vector2 -> IO () set_size_override cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, defaultedVariant VariantVector2 (V2 (-1) (-1)) arg2, defaultedVariant VariantVector2 (V2 0 0) arg3] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_size_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_size_override" '[Bool, Maybe Vector2, Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.Viewport.set_size_override {-# NOINLINE bindViewport_set_size_override_stretch #-} -- | If @true@, the size override affects stretch as well. bindViewport_set_size_override_stretch :: MethodBind bindViewport_set_size_override_stretch = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_size_override_stretch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the size override affects stretch as well. set_size_override_stretch :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_size_override_stretch cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_size_override_stretch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_size_override_stretch" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_size_override_stretch {-# NOINLINE bindViewport_set_snap_controls_to_pixels #-} -- | If @true@, the GUI controls on the viewport will lay pixel perfectly. bindViewport_set_snap_controls_to_pixels :: MethodBind bindViewport_set_snap_controls_to_pixels = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_snap_controls_to_pixels" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the GUI controls on the viewport will lay pixel perfectly. set_snap_controls_to_pixels :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_snap_controls_to_pixels cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_snap_controls_to_pixels (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_snap_controls_to_pixels" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_snap_controls_to_pixels {-# NOINLINE bindViewport_set_transparent_background #-} -- | If @true@, the viewport should render its background as transparent. bindViewport_set_transparent_background :: MethodBind bindViewport_set_transparent_background = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_transparent_background" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport should render its background as transparent. set_transparent_background :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_transparent_background cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_transparent_background (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_transparent_background" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_transparent_background {-# NOINLINE bindViewport_set_update_mode #-} -- | The update mode when viewport used as a render target. bindViewport_set_update_mode :: MethodBind bindViewport_set_update_mode = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_update_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The update mode when viewport used as a render target. set_update_mode :: (Viewport :< cls, Object :< cls) => cls -> Int -> IO () set_update_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_update_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_update_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.Viewport.set_update_mode {-# NOINLINE bindViewport_set_usage #-} -- | The rendering mode of viewport. bindViewport_set_usage :: MethodBind bindViewport_set_usage = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_usage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The rendering mode of viewport. set_usage :: (Viewport :< cls, Object :< cls) => cls -> Int -> IO () set_usage cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_usage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_usage" '[Int] (IO ()) where nodeMethod = Godot.Core.Viewport.set_usage {-# NOINLINE bindViewport_set_use_arvr #-} -- | If @true@, the viewport will be used in AR/VR process. bindViewport_set_use_arvr :: MethodBind bindViewport_set_use_arvr = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_use_arvr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will be used in AR/VR process. set_use_arvr :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_use_arvr cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_use_arvr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_use_arvr" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_use_arvr {-# NOINLINE bindViewport_set_use_own_world #-} -- | If @true@, the viewport will use @World@ defined in @world@ property. bindViewport_set_use_own_world :: MethodBind bindViewport_set_use_own_world = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_use_own_world" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will use @World@ defined in @world@ property. set_use_own_world :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_use_own_world cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_use_own_world (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_use_own_world" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_use_own_world {-# NOINLINE bindViewport_set_use_render_direct_to_screen #-} -- | If @true@, renders the Viewport directly to the screen instead of to the root viewport. Only available in GLES2. This is a low-level optimization and should not be used in most cases. If used, reading from the Viewport or from @SCREEN_TEXTURE@ becomes unavailable. For more information see @method VisualServer.viewport_set_render_direct_to_screen@. bindViewport_set_use_render_direct_to_screen :: MethodBind bindViewport_set_use_render_direct_to_screen = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_use_render_direct_to_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, renders the Viewport directly to the screen instead of to the root viewport. Only available in GLES2. This is a low-level optimization and should not be used in most cases. If used, reading from the Viewport or from @SCREEN_TEXTURE@ becomes unavailable. For more information see @method VisualServer.viewport_set_render_direct_to_screen@. set_use_render_direct_to_screen :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_use_render_direct_to_screen cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_use_render_direct_to_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_use_render_direct_to_screen" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_use_render_direct_to_screen {-# NOINLINE bindViewport_set_vflip #-} -- | If @true@, the result of rendering will be flipped vertically. bindViewport_set_vflip :: MethodBind bindViewport_set_vflip = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_vflip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the result of rendering will be flipped vertically. set_vflip :: (Viewport :< cls, Object :< cls) => cls -> Bool -> IO () set_vflip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_vflip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_vflip" '[Bool] (IO ()) where nodeMethod = Godot.Core.Viewport.set_vflip {-# NOINLINE bindViewport_set_world #-} -- | The custom @World@ which can be used as 3D environment source. bindViewport_set_world :: MethodBind bindViewport_set_world = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_world" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @World@ which can be used as 3D environment source. set_world :: (Viewport :< cls, Object :< cls) => cls -> World -> IO () set_world cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_world (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_world" '[World] (IO ()) where nodeMethod = Godot.Core.Viewport.set_world {-# NOINLINE bindViewport_set_world_2d #-} -- | The custom @World2D@ which can be used as 2D environment source. bindViewport_set_world_2d :: MethodBind bindViewport_set_world_2d = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "set_world_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The custom @World2D@ which can be used as 2D environment source. set_world_2d :: (Viewport :< cls, Object :< cls) => cls -> World2D -> IO () set_world_2d cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_set_world_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "set_world_2d" '[World2D] (IO ()) where nodeMethod = Godot.Core.Viewport.set_world_2d {-# NOINLINE bindViewport_unhandled_input #-} bindViewport_unhandled_input :: MethodBind bindViewport_unhandled_input = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr unhandled_input :: (Viewport :< cls, Object :< cls) => cls -> InputEvent -> IO () unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "unhandled_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.Viewport.unhandled_input {-# NOINLINE bindViewport_update_worlds #-} -- | Forces update of the 2D and 3D worlds. bindViewport_update_worlds :: MethodBind bindViewport_update_worlds = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "update_worlds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Forces update of the 2D and 3D worlds. update_worlds :: (Viewport :< cls, Object :< cls) => cls -> IO () update_worlds cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_update_worlds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "update_worlds" '[] (IO ()) where nodeMethod = Godot.Core.Viewport.update_worlds {-# NOINLINE bindViewport_use_arvr #-} -- | If @true@, the viewport will be used in AR/VR process. bindViewport_use_arvr :: MethodBind bindViewport_use_arvr = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "use_arvr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will be used in AR/VR process. use_arvr :: (Viewport :< cls, Object :< cls) => cls -> IO Bool use_arvr cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_use_arvr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "use_arvr" '[] (IO Bool) where nodeMethod = Godot.Core.Viewport.use_arvr {-# NOINLINE bindViewport_warp_mouse #-} -- | Warps the mouse to a position relative to the viewport. bindViewport_warp_mouse :: MethodBind bindViewport_warp_mouse = unsafePerformIO $ withCString "Viewport" $ \ clsNamePtr -> withCString "warp_mouse" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Warps the mouse to a position relative to the viewport. warp_mouse :: (Viewport :< cls, Object :< cls) => cls -> Vector2 -> IO () warp_mouse cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewport_warp_mouse (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod Viewport "warp_mouse" '[Vector2] (IO ()) where nodeMethod = Godot.Core.Viewport.warp_mouse ================================================ FILE: src/Godot/Core/ViewportContainer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ViewportContainer (Godot.Core.ViewportContainer._input, Godot.Core.ViewportContainer._unhandled_input, Godot.Core.ViewportContainer.get_stretch_shrink, Godot.Core.ViewportContainer.is_stretch_enabled, Godot.Core.ViewportContainer.set_stretch, Godot.Core.ViewportContainer.set_stretch_shrink) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() instance NodeProperty ViewportContainer "stretch" Bool 'False where nodeProperty = (is_stretch_enabled, wrapDroppingSetter set_stretch, Nothing) instance NodeProperty ViewportContainer "stretch_shrink" Int 'False where nodeProperty = (get_stretch_shrink, wrapDroppingSetter set_stretch_shrink, Nothing) {-# NOINLINE bindViewportContainer__input #-} bindViewportContainer__input :: MethodBind bindViewportContainer__input = unsafePerformIO $ withCString "ViewportContainer" $ \ clsNamePtr -> withCString "_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _input :: (ViewportContainer :< cls, Object :< cls) => cls -> InputEvent -> IO () _input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewportContainer__input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ViewportContainer "_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ViewportContainer._input {-# NOINLINE bindViewportContainer__unhandled_input #-} bindViewportContainer__unhandled_input :: MethodBind bindViewportContainer__unhandled_input = unsafePerformIO $ withCString "ViewportContainer" $ \ clsNamePtr -> withCString "_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _unhandled_input :: (ViewportContainer :< cls, Object :< cls) => cls -> InputEvent -> IO () _unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewportContainer__unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ViewportContainer "_unhandled_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.ViewportContainer._unhandled_input {-# NOINLINE bindViewportContainer_get_stretch_shrink #-} -- | Divides the viewport's effective resolution by this value while preserving its scale. This can be used to speed up rendering. -- For example, a 1280×720 viewport with @stretch_shrink@ set to @2@ will be rendered at 640×360 while occupying the same size in the container. -- __Note:__ @stretch@ must be @true@ for this property to work. bindViewportContainer_get_stretch_shrink :: MethodBind bindViewportContainer_get_stretch_shrink = unsafePerformIO $ withCString "ViewportContainer" $ \ clsNamePtr -> withCString "get_stretch_shrink" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Divides the viewport's effective resolution by this value while preserving its scale. This can be used to speed up rendering. -- For example, a 1280×720 viewport with @stretch_shrink@ set to @2@ will be rendered at 640×360 while occupying the same size in the container. -- __Note:__ @stretch@ must be @true@ for this property to work. get_stretch_shrink :: (ViewportContainer :< cls, Object :< cls) => cls -> IO Int get_stretch_shrink cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewportContainer_get_stretch_shrink (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ViewportContainer "get_stretch_shrink" '[] (IO Int) where nodeMethod = Godot.Core.ViewportContainer.get_stretch_shrink {-# NOINLINE bindViewportContainer_is_stretch_enabled #-} -- | If @true@, the viewport will be scaled to the control's size. bindViewportContainer_is_stretch_enabled :: MethodBind bindViewportContainer_is_stretch_enabled = unsafePerformIO $ withCString "ViewportContainer" $ \ clsNamePtr -> withCString "is_stretch_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will be scaled to the control's size. is_stretch_enabled :: (ViewportContainer :< cls, Object :< cls) => cls -> IO Bool is_stretch_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewportContainer_is_stretch_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ViewportContainer "is_stretch_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.ViewportContainer.is_stretch_enabled {-# NOINLINE bindViewportContainer_set_stretch #-} -- | If @true@, the viewport will be scaled to the control's size. bindViewportContainer_set_stretch :: MethodBind bindViewportContainer_set_stretch = unsafePerformIO $ withCString "ViewportContainer" $ \ clsNamePtr -> withCString "set_stretch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport will be scaled to the control's size. set_stretch :: (ViewportContainer :< cls, Object :< cls) => cls -> Bool -> IO () set_stretch cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewportContainer_set_stretch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ViewportContainer "set_stretch" '[Bool] (IO ()) where nodeMethod = Godot.Core.ViewportContainer.set_stretch {-# NOINLINE bindViewportContainer_set_stretch_shrink #-} -- | Divides the viewport's effective resolution by this value while preserving its scale. This can be used to speed up rendering. -- For example, a 1280×720 viewport with @stretch_shrink@ set to @2@ will be rendered at 640×360 while occupying the same size in the container. -- __Note:__ @stretch@ must be @true@ for this property to work. bindViewportContainer_set_stretch_shrink :: MethodBind bindViewportContainer_set_stretch_shrink = unsafePerformIO $ withCString "ViewportContainer" $ \ clsNamePtr -> withCString "set_stretch_shrink" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Divides the viewport's effective resolution by this value while preserving its scale. This can be used to speed up rendering. -- For example, a 1280×720 viewport with @stretch_shrink@ set to @2@ will be rendered at 640×360 while occupying the same size in the container. -- __Note:__ @stretch@ must be @true@ for this property to work. set_stretch_shrink :: (ViewportContainer :< cls, Object :< cls) => cls -> Int -> IO () set_stretch_shrink cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewportContainer_set_stretch_shrink (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ViewportContainer "set_stretch_shrink" '[Int] (IO ()) where nodeMethod = Godot.Core.ViewportContainer.set_stretch_shrink ================================================ FILE: src/Godot/Core/ViewportTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.ViewportTexture (Godot.Core.ViewportTexture.get_viewport_path_in_scene, Godot.Core.ViewportTexture.set_viewport_path_in_scene) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Texture() instance NodeProperty ViewportTexture "viewport_path" NodePath 'False where nodeProperty = (get_viewport_path_in_scene, wrapDroppingSetter set_viewport_path_in_scene, Nothing) {-# NOINLINE bindViewportTexture_get_viewport_path_in_scene #-} -- | The path to the @Viewport@ node to display. This is relative to the scene root, not to the node which uses the texture. bindViewportTexture_get_viewport_path_in_scene :: MethodBind bindViewportTexture_get_viewport_path_in_scene = unsafePerformIO $ withCString "ViewportTexture" $ \ clsNamePtr -> withCString "get_viewport_path_in_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the @Viewport@ node to display. This is relative to the scene root, not to the node which uses the texture. get_viewport_path_in_scene :: (ViewportTexture :< cls, Object :< cls) => cls -> IO NodePath get_viewport_path_in_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindViewportTexture_get_viewport_path_in_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ViewportTexture "get_viewport_path_in_scene" '[] (IO NodePath) where nodeMethod = Godot.Core.ViewportTexture.get_viewport_path_in_scene {-# NOINLINE bindViewportTexture_set_viewport_path_in_scene #-} -- | The path to the @Viewport@ node to display. This is relative to the scene root, not to the node which uses the texture. bindViewportTexture_set_viewport_path_in_scene :: MethodBind bindViewportTexture_set_viewport_path_in_scene = unsafePerformIO $ withCString "ViewportTexture" $ \ clsNamePtr -> withCString "set_viewport_path_in_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The path to the @Viewport@ node to display. This is relative to the scene root, not to the node which uses the texture. set_viewport_path_in_scene :: (ViewportTexture :< cls, Object :< cls) => cls -> NodePath -> IO () set_viewport_path_in_scene cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindViewportTexture_set_viewport_path_in_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ViewportTexture "set_viewport_path_in_scene" '[NodePath] (IO ()) where nodeMethod = Godot.Core.ViewportTexture.set_viewport_path_in_scene ================================================ FILE: src/Godot/Core/VisibilityEnabler.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisibilityEnabler (Godot.Core.VisibilityEnabler._ENABLER_MAX, Godot.Core.VisibilityEnabler._ENABLER_PAUSE_ANIMATIONS, Godot.Core.VisibilityEnabler._ENABLER_FREEZE_BODIES, Godot.Core.VisibilityEnabler._node_removed, Godot.Core.VisibilityEnabler.is_enabler_enabled, Godot.Core.VisibilityEnabler.set_enabler) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisibilityNotifier() _ENABLER_MAX :: Int _ENABLER_MAX = 2 _ENABLER_PAUSE_ANIMATIONS :: Int _ENABLER_PAUSE_ANIMATIONS = 0 _ENABLER_FREEZE_BODIES :: Int _ENABLER_FREEZE_BODIES = 1 instance NodeProperty VisibilityEnabler "freeze_bodies" Bool 'False where nodeProperty = (wrapIndexedGetter 1 is_enabler_enabled, wrapIndexedSetter 1 set_enabler, Nothing) instance NodeProperty VisibilityEnabler "pause_animations" Bool 'False where nodeProperty = (wrapIndexedGetter 0 is_enabler_enabled, wrapIndexedSetter 0 set_enabler, Nothing) {-# NOINLINE bindVisibilityEnabler__node_removed #-} bindVisibilityEnabler__node_removed :: MethodBind bindVisibilityEnabler__node_removed = unsafePerformIO $ withCString "VisibilityEnabler" $ \ clsNamePtr -> withCString "_node_removed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _node_removed :: (VisibilityEnabler :< cls, Object :< cls) => cls -> Node -> IO () _node_removed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityEnabler__node_removed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityEnabler "_node_removed" '[Node] (IO ()) where nodeMethod = Godot.Core.VisibilityEnabler._node_removed {-# NOINLINE bindVisibilityEnabler_is_enabler_enabled #-} -- | Returns whether the enabler identified by given @enum Enabler@ constant is active. bindVisibilityEnabler_is_enabler_enabled :: MethodBind bindVisibilityEnabler_is_enabler_enabled = unsafePerformIO $ withCString "VisibilityEnabler" $ \ clsNamePtr -> withCString "is_enabler_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the enabler identified by given @enum Enabler@ constant is active. is_enabler_enabled :: (VisibilityEnabler :< cls, Object :< cls) => cls -> Int -> IO Bool is_enabler_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityEnabler_is_enabler_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityEnabler "is_enabler_enabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.VisibilityEnabler.is_enabler_enabled {-# NOINLINE bindVisibilityEnabler_set_enabler #-} -- | Sets active state of the enabler identified by given @enum Enabler@ constant. bindVisibilityEnabler_set_enabler :: MethodBind bindVisibilityEnabler_set_enabler = unsafePerformIO $ withCString "VisibilityEnabler" $ \ clsNamePtr -> withCString "set_enabler" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets active state of the enabler identified by given @enum Enabler@ constant. set_enabler :: (VisibilityEnabler :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_enabler cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityEnabler_set_enabler (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityEnabler "set_enabler" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.VisibilityEnabler.set_enabler ================================================ FILE: src/Godot/Core/VisibilityEnabler2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisibilityEnabler2D (Godot.Core.VisibilityEnabler2D._ENABLER_PARENT_PROCESS, Godot.Core.VisibilityEnabler2D._ENABLER_MAX, Godot.Core.VisibilityEnabler2D._ENABLER_PARENT_PHYSICS_PROCESS, Godot.Core.VisibilityEnabler2D._ENABLER_PAUSE_ANIMATIONS, Godot.Core.VisibilityEnabler2D._ENABLER_PAUSE_ANIMATED_SPRITES, Godot.Core.VisibilityEnabler2D._ENABLER_PAUSE_PARTICLES, Godot.Core.VisibilityEnabler2D._ENABLER_FREEZE_BODIES, Godot.Core.VisibilityEnabler2D._node_removed, Godot.Core.VisibilityEnabler2D.is_enabler_enabled, Godot.Core.VisibilityEnabler2D.set_enabler) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisibilityNotifier2D() _ENABLER_PARENT_PROCESS :: Int _ENABLER_PARENT_PROCESS = 3 _ENABLER_MAX :: Int _ENABLER_MAX = 6 _ENABLER_PARENT_PHYSICS_PROCESS :: Int _ENABLER_PARENT_PHYSICS_PROCESS = 4 _ENABLER_PAUSE_ANIMATIONS :: Int _ENABLER_PAUSE_ANIMATIONS = 0 _ENABLER_PAUSE_ANIMATED_SPRITES :: Int _ENABLER_PAUSE_ANIMATED_SPRITES = 5 _ENABLER_PAUSE_PARTICLES :: Int _ENABLER_PAUSE_PARTICLES = 2 _ENABLER_FREEZE_BODIES :: Int _ENABLER_FREEZE_BODIES = 1 instance NodeProperty VisibilityEnabler2D "freeze_bodies" Bool 'False where nodeProperty = (wrapIndexedGetter 1 is_enabler_enabled, wrapIndexedSetter 1 set_enabler, Nothing) instance NodeProperty VisibilityEnabler2D "pause_animated_sprites" Bool 'False where nodeProperty = (wrapIndexedGetter 5 is_enabler_enabled, wrapIndexedSetter 5 set_enabler, Nothing) instance NodeProperty VisibilityEnabler2D "pause_animations" Bool 'False where nodeProperty = (wrapIndexedGetter 0 is_enabler_enabled, wrapIndexedSetter 0 set_enabler, Nothing) instance NodeProperty VisibilityEnabler2D "pause_particles" Bool 'False where nodeProperty = (wrapIndexedGetter 2 is_enabler_enabled, wrapIndexedSetter 2 set_enabler, Nothing) instance NodeProperty VisibilityEnabler2D "physics_process_parent" Bool 'False where nodeProperty = (wrapIndexedGetter 4 is_enabler_enabled, wrapIndexedSetter 4 set_enabler, Nothing) instance NodeProperty VisibilityEnabler2D "process_parent" Bool 'False where nodeProperty = (wrapIndexedGetter 3 is_enabler_enabled, wrapIndexedSetter 3 set_enabler, Nothing) {-# NOINLINE bindVisibilityEnabler2D__node_removed #-} bindVisibilityEnabler2D__node_removed :: MethodBind bindVisibilityEnabler2D__node_removed = unsafePerformIO $ withCString "VisibilityEnabler2D" $ \ clsNamePtr -> withCString "_node_removed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _node_removed :: (VisibilityEnabler2D :< cls, Object :< cls) => cls -> Node -> IO () _node_removed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityEnabler2D__node_removed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityEnabler2D "_node_removed" '[Node] (IO ()) where nodeMethod = Godot.Core.VisibilityEnabler2D._node_removed {-# NOINLINE bindVisibilityEnabler2D_is_enabler_enabled #-} -- | Returns whether the enabler identified by given @enum Enabler@ constant is active. bindVisibilityEnabler2D_is_enabler_enabled :: MethodBind bindVisibilityEnabler2D_is_enabler_enabled = unsafePerformIO $ withCString "VisibilityEnabler2D" $ \ clsNamePtr -> withCString "is_enabler_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns whether the enabler identified by given @enum Enabler@ constant is active. is_enabler_enabled :: (VisibilityEnabler2D :< cls, Object :< cls) => cls -> Int -> IO Bool is_enabler_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityEnabler2D_is_enabler_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityEnabler2D "is_enabler_enabled" '[Int] (IO Bool) where nodeMethod = Godot.Core.VisibilityEnabler2D.is_enabler_enabled {-# NOINLINE bindVisibilityEnabler2D_set_enabler #-} -- | Sets active state of the enabler identified by given @enum Enabler@ constant. bindVisibilityEnabler2D_set_enabler :: MethodBind bindVisibilityEnabler2D_set_enabler = unsafePerformIO $ withCString "VisibilityEnabler2D" $ \ clsNamePtr -> withCString "set_enabler" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets active state of the enabler identified by given @enum Enabler@ constant. set_enabler :: (VisibilityEnabler2D :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_enabler cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityEnabler2D_set_enabler (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityEnabler2D "set_enabler" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.VisibilityEnabler2D.set_enabler ================================================ FILE: src/Godot/Core/VisibilityNotifier.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisibilityNotifier (Godot.Core.VisibilityNotifier.sig_camera_entered, Godot.Core.VisibilityNotifier.sig_camera_exited, Godot.Core.VisibilityNotifier.sig_screen_entered, Godot.Core.VisibilityNotifier.sig_screen_exited, Godot.Core.VisibilityNotifier.get_aabb, Godot.Core.VisibilityNotifier.is_on_screen, Godot.Core.VisibilityNotifier.set_aabb) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() -- | Emitted when the VisibilityNotifier enters a @Camera@'s view. sig_camera_entered :: Godot.Internal.Dispatch.Signal VisibilityNotifier sig_camera_entered = Godot.Internal.Dispatch.Signal "camera_entered" instance NodeSignal VisibilityNotifier "camera_entered" '[Camera] -- | Emitted when the VisibilityNotifier exits a @Camera@'s view. sig_camera_exited :: Godot.Internal.Dispatch.Signal VisibilityNotifier sig_camera_exited = Godot.Internal.Dispatch.Signal "camera_exited" instance NodeSignal VisibilityNotifier "camera_exited" '[Camera] -- | Emitted when the VisibilityNotifier enters the screen. sig_screen_entered :: Godot.Internal.Dispatch.Signal VisibilityNotifier sig_screen_entered = Godot.Internal.Dispatch.Signal "screen_entered" instance NodeSignal VisibilityNotifier "screen_entered" '[] -- | Emitted when the VisibilityNotifier exits the screen. sig_screen_exited :: Godot.Internal.Dispatch.Signal VisibilityNotifier sig_screen_exited = Godot.Internal.Dispatch.Signal "screen_exited" instance NodeSignal VisibilityNotifier "screen_exited" '[] instance NodeProperty VisibilityNotifier "aabb" Aabb 'False where nodeProperty = (get_aabb, wrapDroppingSetter set_aabb, Nothing) {-# NOINLINE bindVisibilityNotifier_get_aabb #-} -- | The VisibilityNotifier's bounding box. bindVisibilityNotifier_get_aabb :: MethodBind bindVisibilityNotifier_get_aabb = unsafePerformIO $ withCString "VisibilityNotifier" $ \ clsNamePtr -> withCString "get_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The VisibilityNotifier's bounding box. get_aabb :: (VisibilityNotifier :< cls, Object :< cls) => cls -> IO Aabb get_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityNotifier_get_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityNotifier "get_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.VisibilityNotifier.get_aabb {-# NOINLINE bindVisibilityNotifier_is_on_screen #-} -- | If @true@, the bounding box is on the screen. -- __Note:__ It takes one frame for the node's visibility to be assessed once added to the scene tree, so this method will return @false@ right after it is instantiated, even if it will be on screen in the draw pass. bindVisibilityNotifier_is_on_screen :: MethodBind bindVisibilityNotifier_is_on_screen = unsafePerformIO $ withCString "VisibilityNotifier" $ \ clsNamePtr -> withCString "is_on_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the bounding box is on the screen. -- __Note:__ It takes one frame for the node's visibility to be assessed once added to the scene tree, so this method will return @false@ right after it is instantiated, even if it will be on screen in the draw pass. is_on_screen :: (VisibilityNotifier :< cls, Object :< cls) => cls -> IO Bool is_on_screen cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityNotifier_is_on_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityNotifier "is_on_screen" '[] (IO Bool) where nodeMethod = Godot.Core.VisibilityNotifier.is_on_screen {-# NOINLINE bindVisibilityNotifier_set_aabb #-} -- | The VisibilityNotifier's bounding box. bindVisibilityNotifier_set_aabb :: MethodBind bindVisibilityNotifier_set_aabb = unsafePerformIO $ withCString "VisibilityNotifier" $ \ clsNamePtr -> withCString "set_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The VisibilityNotifier's bounding box. set_aabb :: (VisibilityNotifier :< cls, Object :< cls) => cls -> Aabb -> IO () set_aabb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityNotifier_set_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityNotifier "set_aabb" '[Aabb] (IO ()) where nodeMethod = Godot.Core.VisibilityNotifier.set_aabb ================================================ FILE: src/Godot/Core/VisibilityNotifier2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisibilityNotifier2D (Godot.Core.VisibilityNotifier2D.sig_screen_entered, Godot.Core.VisibilityNotifier2D.sig_screen_exited, Godot.Core.VisibilityNotifier2D.sig_viewport_entered, Godot.Core.VisibilityNotifier2D.sig_viewport_exited, Godot.Core.VisibilityNotifier2D.get_rect, Godot.Core.VisibilityNotifier2D.is_on_screen, Godot.Core.VisibilityNotifier2D.set_rect) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() -- | Emitted when the VisibilityNotifier2D enters the screen. sig_screen_entered :: Godot.Internal.Dispatch.Signal VisibilityNotifier2D sig_screen_entered = Godot.Internal.Dispatch.Signal "screen_entered" instance NodeSignal VisibilityNotifier2D "screen_entered" '[] -- | Emitted when the VisibilityNotifier2D exits the screen. sig_screen_exited :: Godot.Internal.Dispatch.Signal VisibilityNotifier2D sig_screen_exited = Godot.Internal.Dispatch.Signal "screen_exited" instance NodeSignal VisibilityNotifier2D "screen_exited" '[] -- | Emitted when the VisibilityNotifier2D enters a @Viewport@'s view. sig_viewport_entered :: Godot.Internal.Dispatch.Signal VisibilityNotifier2D sig_viewport_entered = Godot.Internal.Dispatch.Signal "viewport_entered" instance NodeSignal VisibilityNotifier2D "viewport_entered" '[Viewport] -- | Emitted when the VisibilityNotifier2D exits a @Viewport@'s view. sig_viewport_exited :: Godot.Internal.Dispatch.Signal VisibilityNotifier2D sig_viewport_exited = Godot.Internal.Dispatch.Signal "viewport_exited" instance NodeSignal VisibilityNotifier2D "viewport_exited" '[Viewport] instance NodeProperty VisibilityNotifier2D "rect" Rect2 'False where nodeProperty = (get_rect, wrapDroppingSetter set_rect, Nothing) {-# NOINLINE bindVisibilityNotifier2D_get_rect #-} -- | The VisibilityNotifier2D's bounding rectangle. bindVisibilityNotifier2D_get_rect :: MethodBind bindVisibilityNotifier2D_get_rect = unsafePerformIO $ withCString "VisibilityNotifier2D" $ \ clsNamePtr -> withCString "get_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The VisibilityNotifier2D's bounding rectangle. get_rect :: (VisibilityNotifier2D :< cls, Object :< cls) => cls -> IO Rect2 get_rect cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityNotifier2D_get_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityNotifier2D "get_rect" '[] (IO Rect2) where nodeMethod = Godot.Core.VisibilityNotifier2D.get_rect {-# NOINLINE bindVisibilityNotifier2D_is_on_screen #-} -- | If @true@, the bounding rectangle is on the screen. -- __Note:__ It takes one frame for the node's visibility to be assessed once added to the scene tree, so this method will return @false@ right after it is instantiated, even if it will be on screen in the draw pass. bindVisibilityNotifier2D_is_on_screen :: MethodBind bindVisibilityNotifier2D_is_on_screen = unsafePerformIO $ withCString "VisibilityNotifier2D" $ \ clsNamePtr -> withCString "is_on_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the bounding rectangle is on the screen. -- __Note:__ It takes one frame for the node's visibility to be assessed once added to the scene tree, so this method will return @false@ right after it is instantiated, even if it will be on screen in the draw pass. is_on_screen :: (VisibilityNotifier2D :< cls, Object :< cls) => cls -> IO Bool is_on_screen cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityNotifier2D_is_on_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityNotifier2D "is_on_screen" '[] (IO Bool) where nodeMethod = Godot.Core.VisibilityNotifier2D.is_on_screen {-# NOINLINE bindVisibilityNotifier2D_set_rect #-} -- | The VisibilityNotifier2D's bounding rectangle. bindVisibilityNotifier2D_set_rect :: MethodBind bindVisibilityNotifier2D_set_rect = unsafePerformIO $ withCString "VisibilityNotifier2D" $ \ clsNamePtr -> withCString "set_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The VisibilityNotifier2D's bounding rectangle. set_rect :: (VisibilityNotifier2D :< cls, Object :< cls) => cls -> Rect2 -> IO () set_rect cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisibilityNotifier2D_set_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisibilityNotifier2D "set_rect" '[Rect2] (IO ()) where nodeMethod = Godot.Core.VisibilityNotifier2D.set_rect ================================================ FILE: src/Godot/Core/VisualInstance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualInstance (Godot.Core.VisualInstance._get_visual_instance_rid, Godot.Core.VisualInstance.get_aabb, Godot.Core.VisualInstance.get_base, Godot.Core.VisualInstance.get_instance, Godot.Core.VisualInstance.get_layer_mask, Godot.Core.VisualInstance.get_layer_mask_bit, Godot.Core.VisualInstance.get_transformed_aabb, Godot.Core.VisualInstance.set_base, Godot.Core.VisualInstance.set_layer_mask, Godot.Core.VisualInstance.set_layer_mask_bit) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Spatial() instance NodeProperty VisualInstance "layers" Int 'False where nodeProperty = (get_layer_mask, wrapDroppingSetter set_layer_mask, Nothing) {-# NOINLINE bindVisualInstance__get_visual_instance_rid #-} bindVisualInstance__get_visual_instance_rid :: MethodBind bindVisualInstance__get_visual_instance_rid = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "_get_visual_instance_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_visual_instance_rid :: (VisualInstance :< cls, Object :< cls) => cls -> IO Rid _get_visual_instance_rid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance__get_visual_instance_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "_get_visual_instance_rid" '[] (IO Rid) where nodeMethod = Godot.Core.VisualInstance._get_visual_instance_rid {-# NOINLINE bindVisualInstance_get_aabb #-} -- | Returns the @AABB@ (also known as the bounding box) for this @VisualInstance@. See also @method get_transformed_aabb@. bindVisualInstance_get_aabb :: MethodBind bindVisualInstance_get_aabb = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "get_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @AABB@ (also known as the bounding box) for this @VisualInstance@. See also @method get_transformed_aabb@. get_aabb :: (VisualInstance :< cls, Object :< cls) => cls -> IO Aabb get_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_get_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "get_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.VisualInstance.get_aabb {-# NOINLINE bindVisualInstance_get_base #-} -- | Returns the RID of the resource associated with this @VisualInstance@. For example, if the Node is a @MeshInstance@, this will return the RID of the associated @Mesh@. bindVisualInstance_get_base :: MethodBind bindVisualInstance_get_base = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "get_base" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the RID of the resource associated with this @VisualInstance@. For example, if the Node is a @MeshInstance@, this will return the RID of the associated @Mesh@. get_base :: (VisualInstance :< cls, Object :< cls) => cls -> IO Rid get_base cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_get_base (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "get_base" '[] (IO Rid) where nodeMethod = Godot.Core.VisualInstance.get_base {-# NOINLINE bindVisualInstance_get_instance #-} -- | Returns the RID of this instance. This RID is the same as the RID returned by @method VisualServer.instance_create@. This RID is needed if you want to call @VisualServer@ functions directly on this @VisualInstance@. bindVisualInstance_get_instance :: MethodBind bindVisualInstance_get_instance = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "get_instance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the RID of this instance. This RID is the same as the RID returned by @method VisualServer.instance_create@. This RID is needed if you want to call @VisualServer@ functions directly on this @VisualInstance@. get_instance :: (VisualInstance :< cls, Object :< cls) => cls -> IO Rid get_instance cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_get_instance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "get_instance" '[] (IO Rid) where nodeMethod = Godot.Core.VisualInstance.get_instance {-# NOINLINE bindVisualInstance_get_layer_mask #-} -- | The render layer(s) this @VisualInstance@ is drawn on. -- This object will only be visible for @Camera@s whose cull mask includes the render object this @VisualInstance@ is set to. bindVisualInstance_get_layer_mask :: MethodBind bindVisualInstance_get_layer_mask = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "get_layer_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The render layer(s) this @VisualInstance@ is drawn on. -- This object will only be visible for @Camera@s whose cull mask includes the render object this @VisualInstance@ is set to. get_layer_mask :: (VisualInstance :< cls, Object :< cls) => cls -> IO Int get_layer_mask cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_get_layer_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "get_layer_mask" '[] (IO Int) where nodeMethod = Godot.Core.VisualInstance.get_layer_mask {-# NOINLINE bindVisualInstance_get_layer_mask_bit #-} -- | Returns @true@ when the specified layer is enabled in @layers@ and @false@ otherwise. bindVisualInstance_get_layer_mask_bit :: MethodBind bindVisualInstance_get_layer_mask_bit = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "get_layer_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ when the specified layer is enabled in @layers@ and @false@ otherwise. get_layer_mask_bit :: (VisualInstance :< cls, Object :< cls) => cls -> Int -> IO Bool get_layer_mask_bit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_get_layer_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "get_layer_mask_bit" '[Int] (IO Bool) where nodeMethod = Godot.Core.VisualInstance.get_layer_mask_bit {-# NOINLINE bindVisualInstance_get_transformed_aabb #-} -- | Returns the transformed @AABB@ (also known as the bounding box) for this @VisualInstance@. -- Transformed in this case means the @AABB@ plus the position, rotation, and scale of the @Spatial@'s @Transform@. See also @method get_aabb@. bindVisualInstance_get_transformed_aabb :: MethodBind bindVisualInstance_get_transformed_aabb = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "get_transformed_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the transformed @AABB@ (also known as the bounding box) for this @VisualInstance@. -- Transformed in this case means the @AABB@ plus the position, rotation, and scale of the @Spatial@'s @Transform@. See also @method get_aabb@. get_transformed_aabb :: (VisualInstance :< cls, Object :< cls) => cls -> IO Aabb get_transformed_aabb cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_get_transformed_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "get_transformed_aabb" '[] (IO Aabb) where nodeMethod = Godot.Core.VisualInstance.get_transformed_aabb {-# NOINLINE bindVisualInstance_set_base #-} -- | Sets the resource that is instantiated by this @VisualInstance@, which changes how the engine handles the @VisualInstance@ under the hood. Equivalent to @method VisualServer.instance_set_base@. bindVisualInstance_set_base :: MethodBind bindVisualInstance_set_base = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "set_base" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the resource that is instantiated by this @VisualInstance@, which changes how the engine handles the @VisualInstance@ under the hood. Equivalent to @method VisualServer.instance_set_base@. set_base :: (VisualInstance :< cls, Object :< cls) => cls -> Rid -> IO () set_base cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_set_base (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "set_base" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualInstance.set_base {-# NOINLINE bindVisualInstance_set_layer_mask #-} -- | The render layer(s) this @VisualInstance@ is drawn on. -- This object will only be visible for @Camera@s whose cull mask includes the render object this @VisualInstance@ is set to. bindVisualInstance_set_layer_mask :: MethodBind bindVisualInstance_set_layer_mask = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "set_layer_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The render layer(s) this @VisualInstance@ is drawn on. -- This object will only be visible for @Camera@s whose cull mask includes the render object this @VisualInstance@ is set to. set_layer_mask :: (VisualInstance :< cls, Object :< cls) => cls -> Int -> IO () set_layer_mask cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_set_layer_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "set_layer_mask" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualInstance.set_layer_mask {-# NOINLINE bindVisualInstance_set_layer_mask_bit #-} -- | Enables a particular layer in @layers@. bindVisualInstance_set_layer_mask_bit :: MethodBind bindVisualInstance_set_layer_mask_bit = unsafePerformIO $ withCString "VisualInstance" $ \ clsNamePtr -> withCString "set_layer_mask_bit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables a particular layer in @layers@. set_layer_mask_bit :: (VisualInstance :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_layer_mask_bit cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualInstance_set_layer_mask_bit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualInstance "set_layer_mask_bit" '[Int, Bool] (IO ()) where nodeMethod = Godot.Core.VisualInstance.set_layer_mask_bit ================================================ FILE: src/Godot/Core/VisualScript.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScript (Godot.Core.VisualScript.sig_node_ports_changed, Godot.Core.VisualScript._get_data, Godot.Core.VisualScript._node_ports_changed, Godot.Core.VisualScript._set_data, Godot.Core.VisualScript.add_custom_signal, Godot.Core.VisualScript.add_function, Godot.Core.VisualScript.add_node, Godot.Core.VisualScript.add_variable, Godot.Core.VisualScript.custom_signal_add_argument, Godot.Core.VisualScript.custom_signal_get_argument_count, Godot.Core.VisualScript.custom_signal_get_argument_name, Godot.Core.VisualScript.custom_signal_get_argument_type, Godot.Core.VisualScript.custom_signal_remove_argument, Godot.Core.VisualScript.custom_signal_set_argument_name, Godot.Core.VisualScript.custom_signal_set_argument_type, Godot.Core.VisualScript.custom_signal_swap_argument, Godot.Core.VisualScript.data_connect, Godot.Core.VisualScript.data_disconnect, Godot.Core.VisualScript.get_function_node_id, Godot.Core.VisualScript.get_function_scroll, Godot.Core.VisualScript.get_node, Godot.Core.VisualScript.get_node_position, Godot.Core.VisualScript.get_variable_default_value, Godot.Core.VisualScript.get_variable_export, Godot.Core.VisualScript.get_variable_info, Godot.Core.VisualScript.has_custom_signal, Godot.Core.VisualScript.has_data_connection, Godot.Core.VisualScript.has_function, Godot.Core.VisualScript.has_node, Godot.Core.VisualScript.has_sequence_connection, Godot.Core.VisualScript.has_variable, Godot.Core.VisualScript.remove_custom_signal, Godot.Core.VisualScript.remove_function, Godot.Core.VisualScript.remove_node, Godot.Core.VisualScript.remove_variable, Godot.Core.VisualScript.rename_custom_signal, Godot.Core.VisualScript.rename_function, Godot.Core.VisualScript.rename_variable, Godot.Core.VisualScript.sequence_connect, Godot.Core.VisualScript.sequence_disconnect, Godot.Core.VisualScript.set_function_scroll, Godot.Core.VisualScript.set_instance_base_type, Godot.Core.VisualScript.set_node_position, Godot.Core.VisualScript.set_variable_default_value, Godot.Core.VisualScript.set_variable_export, Godot.Core.VisualScript.set_variable_info) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Script() sig_node_ports_changed :: Godot.Internal.Dispatch.Signal VisualScript sig_node_ports_changed = Godot.Internal.Dispatch.Signal "node_ports_changed" instance NodeSignal VisualScript "node_ports_changed" '[GodotString, Int] instance NodeProperty VisualScript "data" Dictionary 'False where nodeProperty = (_get_data, wrapDroppingSetter _set_data, Nothing) {-# NOINLINE bindVisualScript__get_data #-} bindVisualScript__get_data :: MethodBind bindVisualScript__get_data = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_data :: (VisualScript :< cls, Object :< cls) => cls -> IO Dictionary _get_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript__get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "_get_data" '[] (IO Dictionary) where nodeMethod = Godot.Core.VisualScript._get_data {-# NOINLINE bindVisualScript__node_ports_changed #-} bindVisualScript__node_ports_changed :: MethodBind bindVisualScript__node_ports_changed = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "_node_ports_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _node_ports_changed :: (VisualScript :< cls, Object :< cls) => cls -> Int -> IO () _node_ports_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript__node_ports_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "_node_ports_changed" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScript._node_ports_changed {-# NOINLINE bindVisualScript__set_data #-} bindVisualScript__set_data :: MethodBind bindVisualScript__set_data = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_data :: (VisualScript :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript__set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "_set_data" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.VisualScript._set_data {-# NOINLINE bindVisualScript_add_custom_signal #-} bindVisualScript_add_custom_signal :: MethodBind bindVisualScript_add_custom_signal = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "add_custom_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_custom_signal :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO () add_custom_signal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_add_custom_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "add_custom_signal" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.add_custom_signal {-# NOINLINE bindVisualScript_add_function #-} bindVisualScript_add_function :: MethodBind bindVisualScript_add_function = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "add_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_function :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO () add_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_add_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "add_function" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.add_function {-# NOINLINE bindVisualScript_add_node #-} bindVisualScript_add_node :: MethodBind bindVisualScript_add_node = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "add_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_node :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> VisualScriptNode -> Maybe Vector2 -> IO () add_node cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantVector2 (V2 0 0) arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_add_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "add_node" '[GodotString, Int, VisualScriptNode, Maybe Vector2] (IO ()) where nodeMethod = Godot.Core.VisualScript.add_node {-# NOINLINE bindVisualScript_add_variable #-} bindVisualScript_add_variable :: MethodBind bindVisualScript_add_variable = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "add_variable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_variable :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Maybe GodotVariant -> Maybe Bool -> IO () add_variable cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe VariantNil toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_add_variable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "add_variable" '[GodotString, Maybe GodotVariant, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.VisualScript.add_variable {-# NOINLINE bindVisualScript_custom_signal_add_argument #-} bindVisualScript_custom_signal_add_argument :: MethodBind bindVisualScript_custom_signal_add_argument = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "custom_signal_add_argument" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr custom_signal_add_argument :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> Maybe Int -> IO () custom_signal_add_argument cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantInt (-1)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_custom_signal_add_argument (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "custom_signal_add_argument" '[GodotString, Int, GodotString, Maybe Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.custom_signal_add_argument {-# NOINLINE bindVisualScript_custom_signal_get_argument_count #-} bindVisualScript_custom_signal_get_argument_count :: MethodBind bindVisualScript_custom_signal_get_argument_count = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "custom_signal_get_argument_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr custom_signal_get_argument_count :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO Int custom_signal_get_argument_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_custom_signal_get_argument_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "custom_signal_get_argument_count" '[GodotString] (IO Int) where nodeMethod = Godot.Core.VisualScript.custom_signal_get_argument_count {-# NOINLINE bindVisualScript_custom_signal_get_argument_name #-} bindVisualScript_custom_signal_get_argument_name :: MethodBind bindVisualScript_custom_signal_get_argument_name = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "custom_signal_get_argument_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr custom_signal_get_argument_name :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> IO GodotString custom_signal_get_argument_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_custom_signal_get_argument_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "custom_signal_get_argument_name" '[GodotString, Int] (IO GodotString) where nodeMethod = Godot.Core.VisualScript.custom_signal_get_argument_name {-# NOINLINE bindVisualScript_custom_signal_get_argument_type #-} bindVisualScript_custom_signal_get_argument_type :: MethodBind bindVisualScript_custom_signal_get_argument_type = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "custom_signal_get_argument_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr custom_signal_get_argument_type :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> IO Int custom_signal_get_argument_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_custom_signal_get_argument_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "custom_signal_get_argument_type" '[GodotString, Int] (IO Int) where nodeMethod = Godot.Core.VisualScript.custom_signal_get_argument_type {-# NOINLINE bindVisualScript_custom_signal_remove_argument #-} bindVisualScript_custom_signal_remove_argument :: MethodBind bindVisualScript_custom_signal_remove_argument = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "custom_signal_remove_argument" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr custom_signal_remove_argument :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () custom_signal_remove_argument cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_custom_signal_remove_argument (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "custom_signal_remove_argument" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.custom_signal_remove_argument {-# NOINLINE bindVisualScript_custom_signal_set_argument_name #-} bindVisualScript_custom_signal_set_argument_name :: MethodBind bindVisualScript_custom_signal_set_argument_name = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "custom_signal_set_argument_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr custom_signal_set_argument_name :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> IO () custom_signal_set_argument_name cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_custom_signal_set_argument_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "custom_signal_set_argument_name" '[GodotString, Int, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.custom_signal_set_argument_name {-# NOINLINE bindVisualScript_custom_signal_set_argument_type #-} bindVisualScript_custom_signal_set_argument_type :: MethodBind bindVisualScript_custom_signal_set_argument_type = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "custom_signal_set_argument_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr custom_signal_set_argument_type :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> IO () custom_signal_set_argument_type cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_custom_signal_set_argument_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "custom_signal_set_argument_type" '[GodotString, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.custom_signal_set_argument_type {-# NOINLINE bindVisualScript_custom_signal_swap_argument #-} bindVisualScript_custom_signal_swap_argument :: MethodBind bindVisualScript_custom_signal_swap_argument = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "custom_signal_swap_argument" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr custom_signal_swap_argument :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> IO () custom_signal_swap_argument cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_custom_signal_swap_argument (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "custom_signal_swap_argument" '[GodotString, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.custom_signal_swap_argument {-# NOINLINE bindVisualScript_data_connect #-} bindVisualScript_data_connect :: MethodBind bindVisualScript_data_connect = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "data_connect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr data_connect :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> Int -> Int -> IO () data_connect cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_data_connect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "data_connect" '[GodotString, Int, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.data_connect {-# NOINLINE bindVisualScript_data_disconnect #-} bindVisualScript_data_disconnect :: MethodBind bindVisualScript_data_disconnect = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "data_disconnect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr data_disconnect :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> Int -> Int -> IO () data_disconnect cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_data_disconnect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "data_disconnect" '[GodotString, Int, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.data_disconnect {-# NOINLINE bindVisualScript_get_function_node_id #-} bindVisualScript_get_function_node_id :: MethodBind bindVisualScript_get_function_node_id = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "get_function_node_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_function_node_id :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO Int get_function_node_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_get_function_node_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "get_function_node_id" '[GodotString] (IO Int) where nodeMethod = Godot.Core.VisualScript.get_function_node_id {-# NOINLINE bindVisualScript_get_function_scroll #-} bindVisualScript_get_function_scroll :: MethodBind bindVisualScript_get_function_scroll = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "get_function_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_function_scroll :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO Vector2 get_function_scroll cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_get_function_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "get_function_scroll" '[GodotString] (IO Vector2) where nodeMethod = Godot.Core.VisualScript.get_function_scroll {-# NOINLINE bindVisualScript_get_node #-} bindVisualScript_get_node :: MethodBind bindVisualScript_get_node = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "get_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_node :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> IO VisualScriptNode get_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_get_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "get_node" '[GodotString, Int] (IO VisualScriptNode) where nodeMethod = Godot.Core.VisualScript.get_node {-# NOINLINE bindVisualScript_get_node_position #-} bindVisualScript_get_node_position :: MethodBind bindVisualScript_get_node_position = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "get_node_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_node_position :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> IO Vector2 get_node_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_get_node_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "get_node_position" '[GodotString, Int] (IO Vector2) where nodeMethod = Godot.Core.VisualScript.get_node_position {-# NOINLINE bindVisualScript_get_variable_default_value #-} bindVisualScript_get_variable_default_value :: MethodBind bindVisualScript_get_variable_default_value = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "get_variable_default_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_variable_default_value :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get_variable_default_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_get_variable_default_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "get_variable_default_value" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.VisualScript.get_variable_default_value {-# NOINLINE bindVisualScript_get_variable_export #-} bindVisualScript_get_variable_export :: MethodBind bindVisualScript_get_variable_export = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "get_variable_export" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_variable_export :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO Bool get_variable_export cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_get_variable_export (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "get_variable_export" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.VisualScript.get_variable_export {-# NOINLINE bindVisualScript_get_variable_info #-} bindVisualScript_get_variable_info :: MethodBind bindVisualScript_get_variable_info = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "get_variable_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_variable_info :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO Dictionary get_variable_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_get_variable_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "get_variable_info" '[GodotString] (IO Dictionary) where nodeMethod = Godot.Core.VisualScript.get_variable_info {-# NOINLINE bindVisualScript_has_custom_signal #-} bindVisualScript_has_custom_signal :: MethodBind bindVisualScript_has_custom_signal = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "has_custom_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_custom_signal :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_custom_signal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_has_custom_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "has_custom_signal" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.VisualScript.has_custom_signal {-# NOINLINE bindVisualScript_has_data_connection #-} bindVisualScript_has_data_connection :: MethodBind bindVisualScript_has_data_connection = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "has_data_connection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_data_connection :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> Int -> Int -> IO Bool has_data_connection cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_has_data_connection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "has_data_connection" '[GodotString, Int, Int, Int, Int] (IO Bool) where nodeMethod = Godot.Core.VisualScript.has_data_connection {-# NOINLINE bindVisualScript_has_function #-} bindVisualScript_has_function :: MethodBind bindVisualScript_has_function = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "has_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_function :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_has_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "has_function" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.VisualScript.has_function {-# NOINLINE bindVisualScript_has_node #-} bindVisualScript_has_node :: MethodBind bindVisualScript_has_node = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "has_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_node :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> IO Bool has_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_has_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "has_node" '[GodotString, Int] (IO Bool) where nodeMethod = Godot.Core.VisualScript.has_node {-# NOINLINE bindVisualScript_has_sequence_connection #-} bindVisualScript_has_sequence_connection :: MethodBind bindVisualScript_has_sequence_connection = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "has_sequence_connection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_sequence_connection :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> Int -> IO Bool has_sequence_connection cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_has_sequence_connection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "has_sequence_connection" '[GodotString, Int, Int, Int] (IO Bool) where nodeMethod = Godot.Core.VisualScript.has_sequence_connection {-# NOINLINE bindVisualScript_has_variable #-} bindVisualScript_has_variable :: MethodBind bindVisualScript_has_variable = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "has_variable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_variable :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_variable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_has_variable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "has_variable" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.VisualScript.has_variable {-# NOINLINE bindVisualScript_remove_custom_signal #-} bindVisualScript_remove_custom_signal :: MethodBind bindVisualScript_remove_custom_signal = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "remove_custom_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_custom_signal :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO () remove_custom_signal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_remove_custom_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "remove_custom_signal" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.remove_custom_signal {-# NOINLINE bindVisualScript_remove_function #-} bindVisualScript_remove_function :: MethodBind bindVisualScript_remove_function = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "remove_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_function :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO () remove_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_remove_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "remove_function" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.remove_function {-# NOINLINE bindVisualScript_remove_node #-} bindVisualScript_remove_node :: MethodBind bindVisualScript_remove_node = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "remove_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_node :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () remove_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_remove_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "remove_node" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.remove_node {-# NOINLINE bindVisualScript_remove_variable #-} bindVisualScript_remove_variable :: MethodBind bindVisualScript_remove_variable = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "remove_variable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_variable :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO () remove_variable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_remove_variable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "remove_variable" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.remove_variable {-# NOINLINE bindVisualScript_rename_custom_signal #-} bindVisualScript_rename_custom_signal :: MethodBind bindVisualScript_rename_custom_signal = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "rename_custom_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr rename_custom_signal :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_custom_signal cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_rename_custom_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "rename_custom_signal" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.rename_custom_signal {-# NOINLINE bindVisualScript_rename_function #-} bindVisualScript_rename_function :: MethodBind bindVisualScript_rename_function = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "rename_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr rename_function :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_function cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_rename_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "rename_function" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.rename_function {-# NOINLINE bindVisualScript_rename_variable #-} bindVisualScript_rename_variable :: MethodBind bindVisualScript_rename_variable = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "rename_variable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr rename_variable :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () rename_variable cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_rename_variable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "rename_variable" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.rename_variable {-# NOINLINE bindVisualScript_sequence_connect #-} bindVisualScript_sequence_connect :: MethodBind bindVisualScript_sequence_connect = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "sequence_connect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr sequence_connect :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> Int -> IO () sequence_connect cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_sequence_connect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "sequence_connect" '[GodotString, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.sequence_connect {-# NOINLINE bindVisualScript_sequence_disconnect #-} bindVisualScript_sequence_disconnect :: MethodBind bindVisualScript_sequence_disconnect = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "sequence_disconnect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr sequence_disconnect :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> Int -> IO () sequence_disconnect cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_sequence_disconnect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "sequence_disconnect" '[GodotString, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualScript.sequence_disconnect {-# NOINLINE bindVisualScript_set_function_scroll #-} bindVisualScript_set_function_scroll :: MethodBind bindVisualScript_set_function_scroll = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "set_function_scroll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_function_scroll :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Vector2 -> IO () set_function_scroll cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_set_function_scroll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "set_function_scroll" '[GodotString, Vector2] (IO ()) where nodeMethod = Godot.Core.VisualScript.set_function_scroll {-# NOINLINE bindVisualScript_set_instance_base_type #-} bindVisualScript_set_instance_base_type :: MethodBind bindVisualScript_set_instance_base_type = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "set_instance_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_instance_base_type :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> IO () set_instance_base_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_set_instance_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "set_instance_base_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScript.set_instance_base_type {-# NOINLINE bindVisualScript_set_node_position #-} bindVisualScript_set_node_position :: MethodBind bindVisualScript_set_node_position = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "set_node_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_node_position :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Int -> Vector2 -> IO () set_node_position cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_set_node_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "set_node_position" '[GodotString, Int, Vector2] (IO ()) where nodeMethod = Godot.Core.VisualScript.set_node_position {-# NOINLINE bindVisualScript_set_variable_default_value #-} bindVisualScript_set_variable_default_value :: MethodBind bindVisualScript_set_variable_default_value = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "set_variable_default_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_variable_default_value :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set_variable_default_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_set_variable_default_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "set_variable_default_value" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.VisualScript.set_variable_default_value {-# NOINLINE bindVisualScript_set_variable_export #-} bindVisualScript_set_variable_export :: MethodBind bindVisualScript_set_variable_export = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "set_variable_export" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_variable_export :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Bool -> IO () set_variable_export cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_set_variable_export (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "set_variable_export" '[GodotString, Bool] (IO ()) where nodeMethod = Godot.Core.VisualScript.set_variable_export {-# NOINLINE bindVisualScript_set_variable_info #-} bindVisualScript_set_variable_info :: MethodBind bindVisualScript_set_variable_info = unsafePerformIO $ withCString "VisualScript" $ \ clsNamePtr -> withCString "set_variable_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_variable_info :: (VisualScript :< cls, Object :< cls) => cls -> GodotString -> Dictionary -> IO () set_variable_info cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScript_set_variable_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScript "set_variable_info" '[GodotString, Dictionary] (IO ()) where nodeMethod = Godot.Core.VisualScript.set_variable_info ================================================ FILE: src/Godot/Core/VisualScriptBasicTypeConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptBasicTypeConstant (Godot.Core.VisualScriptBasicTypeConstant.get_basic_type, Godot.Core.VisualScriptBasicTypeConstant.get_basic_type_constant, Godot.Core.VisualScriptBasicTypeConstant.set_basic_type, Godot.Core.VisualScriptBasicTypeConstant.set_basic_type_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptBasicTypeConstant "basic_type" Int 'False where nodeProperty = (get_basic_type, wrapDroppingSetter set_basic_type, Nothing) instance NodeProperty VisualScriptBasicTypeConstant "constant" GodotString 'False where nodeProperty = (get_basic_type_constant, wrapDroppingSetter set_basic_type_constant, Nothing) {-# NOINLINE bindVisualScriptBasicTypeConstant_get_basic_type #-} bindVisualScriptBasicTypeConstant_get_basic_type :: MethodBind bindVisualScriptBasicTypeConstant_get_basic_type = unsafePerformIO $ withCString "VisualScriptBasicTypeConstant" $ \ clsNamePtr -> withCString "get_basic_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_basic_type :: (VisualScriptBasicTypeConstant :< cls, Object :< cls) => cls -> IO Int get_basic_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptBasicTypeConstant_get_basic_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptBasicTypeConstant "get_basic_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptBasicTypeConstant.get_basic_type {-# NOINLINE bindVisualScriptBasicTypeConstant_get_basic_type_constant #-} bindVisualScriptBasicTypeConstant_get_basic_type_constant :: MethodBind bindVisualScriptBasicTypeConstant_get_basic_type_constant = unsafePerformIO $ withCString "VisualScriptBasicTypeConstant" $ \ clsNamePtr -> withCString "get_basic_type_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_basic_type_constant :: (VisualScriptBasicTypeConstant :< cls, Object :< cls) => cls -> IO GodotString get_basic_type_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptBasicTypeConstant_get_basic_type_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptBasicTypeConstant "get_basic_type_constant" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptBasicTypeConstant.get_basic_type_constant {-# NOINLINE bindVisualScriptBasicTypeConstant_set_basic_type #-} bindVisualScriptBasicTypeConstant_set_basic_type :: MethodBind bindVisualScriptBasicTypeConstant_set_basic_type = unsafePerformIO $ withCString "VisualScriptBasicTypeConstant" $ \ clsNamePtr -> withCString "set_basic_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_basic_type :: (VisualScriptBasicTypeConstant :< cls, Object :< cls) => cls -> Int -> IO () set_basic_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptBasicTypeConstant_set_basic_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptBasicTypeConstant "set_basic_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptBasicTypeConstant.set_basic_type {-# NOINLINE bindVisualScriptBasicTypeConstant_set_basic_type_constant #-} bindVisualScriptBasicTypeConstant_set_basic_type_constant :: MethodBind bindVisualScriptBasicTypeConstant_set_basic_type_constant = unsafePerformIO $ withCString "VisualScriptBasicTypeConstant" $ \ clsNamePtr -> withCString "set_basic_type_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_basic_type_constant :: (VisualScriptBasicTypeConstant :< cls, Object :< cls) => cls -> GodotString -> IO () set_basic_type_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptBasicTypeConstant_set_basic_type_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptBasicTypeConstant "set_basic_type_constant" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptBasicTypeConstant.set_basic_type_constant ================================================ FILE: src/Godot/Core/VisualScriptBuiltinFunc.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptBuiltinFunc (Godot.Core.VisualScriptBuiltinFunc._MATH_RAD2DEG, Godot.Core.VisualScriptBuiltinFunc._MATH_TAN, Godot.Core.VisualScriptBuiltinFunc._MATH_DEG2RAD, Godot.Core.VisualScriptBuiltinFunc._MATH_LERP, Godot.Core.VisualScriptBuiltinFunc._MATH_ISINF, Godot.Core.VisualScriptBuiltinFunc._MATH_ATAN2, Godot.Core.VisualScriptBuiltinFunc._TYPE_EXISTS, Godot.Core.VisualScriptBuiltinFunc._MATH_SMOOTHSTEP, Godot.Core.VisualScriptBuiltinFunc._MATH_LERP_ANGLE, Godot.Core.VisualScriptBuiltinFunc._MATH_WRAPF, Godot.Core.VisualScriptBuiltinFunc._MATH_ATAN, Godot.Core.VisualScriptBuiltinFunc._MATH_POSMOD, Godot.Core.VisualScriptBuiltinFunc._MATH_COSH, Godot.Core.VisualScriptBuiltinFunc._MATH_SEED, Godot.Core.VisualScriptBuiltinFunc._TYPE_CONVERT, Godot.Core.VisualScriptBuiltinFunc._LOGIC_MIN, Godot.Core.VisualScriptBuiltinFunc._MATH_STEPIFY, Godot.Core.VisualScriptBuiltinFunc._COLORN, Godot.Core.VisualScriptBuiltinFunc._MATH_SQRT, Godot.Core.VisualScriptBuiltinFunc._TEXT_PRINT, Godot.Core.VisualScriptBuiltinFunc._MATH_DB2LINEAR, Godot.Core.VisualScriptBuiltinFunc._MATH_RAND, Godot.Core.VisualScriptBuiltinFunc._FUNC_FUNCREF, Godot.Core.VisualScriptBuiltinFunc._LOGIC_NEAREST_PO2, Godot.Core.VisualScriptBuiltinFunc._OBJ_WEAKREF, Godot.Core.VisualScriptBuiltinFunc._MATH_CARTESIAN2POLAR, Godot.Core.VisualScriptBuiltinFunc._MATH_POLAR2CARTESIAN, Godot.Core.VisualScriptBuiltinFunc._MATH_ISNAN, Godot.Core.VisualScriptBuiltinFunc._MATH_CEIL, Godot.Core.VisualScriptBuiltinFunc._MATH_SIGN, Godot.Core.VisualScriptBuiltinFunc._MATH_TANH, Godot.Core.VisualScriptBuiltinFunc._MATH_RANDOM, Godot.Core.VisualScriptBuiltinFunc._MATH_RANGE_LERP, Godot.Core.VisualScriptBuiltinFunc._MATH_FMOD, Godot.Core.VisualScriptBuiltinFunc._MATH_DECIMALS, Godot.Core.VisualScriptBuiltinFunc._VAR_TO_BYTES, Godot.Core.VisualScriptBuiltinFunc._MATH_ABS, Godot.Core.VisualScriptBuiltinFunc._TEXT_STR, Godot.Core.VisualScriptBuiltinFunc._BYTES_TO_VAR, Godot.Core.VisualScriptBuiltinFunc._MATH_FLOOR, Godot.Core.VisualScriptBuiltinFunc._TEXT_PRINTRAW, Godot.Core.VisualScriptBuiltinFunc._MATH_POW, Godot.Core.VisualScriptBuiltinFunc._LOGIC_CLAMP, Godot.Core.VisualScriptBuiltinFunc._MATH_MOVE_TOWARD, Godot.Core.VisualScriptBuiltinFunc._MATH_EXP, Godot.Core.VisualScriptBuiltinFunc._TEXT_CHAR, Godot.Core.VisualScriptBuiltinFunc._MATH_RANDOMIZE, Godot.Core.VisualScriptBuiltinFunc._MATH_ASIN, Godot.Core.VisualScriptBuiltinFunc._FUNC_MAX, Godot.Core.VisualScriptBuiltinFunc._LOGIC_MAX, Godot.Core.VisualScriptBuiltinFunc._MATH_EASE, Godot.Core.VisualScriptBuiltinFunc._MATH_ROUND, Godot.Core.VisualScriptBuiltinFunc._MATH_RANDF, Godot.Core.VisualScriptBuiltinFunc._MATH_DECTIME, Godot.Core.VisualScriptBuiltinFunc._MATH_COS, Godot.Core.VisualScriptBuiltinFunc._MATH_SIN, Godot.Core.VisualScriptBuiltinFunc._VAR_TO_STR, Godot.Core.VisualScriptBuiltinFunc._MATH_SINH, Godot.Core.VisualScriptBuiltinFunc._TEXT_ORD, Godot.Core.VisualScriptBuiltinFunc._STR_TO_VAR, Godot.Core.VisualScriptBuiltinFunc._MATH_INVERSE_LERP, Godot.Core.VisualScriptBuiltinFunc._MATH_FPOSMOD, Godot.Core.VisualScriptBuiltinFunc._MATH_WRAP, Godot.Core.VisualScriptBuiltinFunc._MATH_LOG, Godot.Core.VisualScriptBuiltinFunc._TYPE_OF, Godot.Core.VisualScriptBuiltinFunc._TEXT_PRINTERR, Godot.Core.VisualScriptBuiltinFunc._MATH_LINEAR2DB, Godot.Core.VisualScriptBuiltinFunc._MATH_ACOS, Godot.Core.VisualScriptBuiltinFunc._MATH_RANDSEED, Godot.Core.VisualScriptBuiltinFunc.get_func, Godot.Core.VisualScriptBuiltinFunc.set_func) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _MATH_RAD2DEG :: Int _MATH_RAD2DEG = 38 _MATH_TAN :: Int _MATH_TAN = 2 _MATH_DEG2RAD :: Int _MATH_DEG2RAD = 37 _MATH_LERP :: Int _MATH_LERP = 26 _MATH_ISINF :: Int _MATH_ISINF = 22 _MATH_ATAN2 :: Int _MATH_ATAN2 = 9 _TYPE_EXISTS :: Int _TYPE_EXISTS = 53 _MATH_SMOOTHSTEP :: Int _MATH_SMOOTHSTEP = 64 _MATH_LERP_ANGLE :: Int _MATH_LERP_ANGLE = 66 _MATH_WRAPF :: Int _MATH_WRAPF = 44 _MATH_ATAN :: Int _MATH_ATAN = 8 _MATH_POSMOD :: Int _MATH_POSMOD = 65 _MATH_COSH :: Int _MATH_COSH = 4 _MATH_SEED :: Int _MATH_SEED = 35 _TYPE_CONVERT :: Int _TYPE_CONVERT = 51 _LOGIC_MIN :: Int _LOGIC_MIN = 46 _MATH_STEPIFY :: Int _MATH_STEPIFY = 25 _COLORN :: Int _COLORN = 63 _MATH_SQRT :: Int _MATH_SQRT = 10 _TEXT_PRINT :: Int _TEXT_PRINT = 56 _MATH_DB2LINEAR :: Int _MATH_DB2LINEAR = 40 _MATH_RAND :: Int _MATH_RAND = 32 _FUNC_FUNCREF :: Int _FUNC_FUNCREF = 50 _LOGIC_NEAREST_PO2 :: Int _LOGIC_NEAREST_PO2 = 48 _OBJ_WEAKREF :: Int _OBJ_WEAKREF = 49 _MATH_CARTESIAN2POLAR :: Int _MATH_CARTESIAN2POLAR = 42 _MATH_POLAR2CARTESIAN :: Int _MATH_POLAR2CARTESIAN = 41 _MATH_ISNAN :: Int _MATH_ISNAN = 21 _MATH_CEIL :: Int _MATH_CEIL = 14 _MATH_SIGN :: Int _MATH_SIGN = 17 _MATH_TANH :: Int _MATH_TANH = 5 _MATH_RANDOM :: Int _MATH_RANDOM = 34 _MATH_RANGE_LERP :: Int _MATH_RANGE_LERP = 28 _MATH_FMOD :: Int _MATH_FMOD = 11 _MATH_DECIMALS :: Int _MATH_DECIMALS = 24 _VAR_TO_BYTES :: Int _VAR_TO_BYTES = 61 _MATH_ABS :: Int _MATH_ABS = 16 _TEXT_STR :: Int _TEXT_STR = 55 _BYTES_TO_VAR :: Int _BYTES_TO_VAR = 62 _MATH_FLOOR :: Int _MATH_FLOOR = 13 _TEXT_PRINTRAW :: Int _TEXT_PRINTRAW = 58 _MATH_POW :: Int _MATH_POW = 18 _LOGIC_CLAMP :: Int _LOGIC_CLAMP = 47 _MATH_MOVE_TOWARD :: Int _MATH_MOVE_TOWARD = 29 _MATH_EXP :: Int _MATH_EXP = 20 _TEXT_CHAR :: Int _TEXT_CHAR = 54 _MATH_RANDOMIZE :: Int _MATH_RANDOMIZE = 31 _MATH_ASIN :: Int _MATH_ASIN = 6 _FUNC_MAX :: Int _FUNC_MAX = 68 _LOGIC_MAX :: Int _LOGIC_MAX = 45 _MATH_EASE :: Int _MATH_EASE = 23 _MATH_ROUND :: Int _MATH_ROUND = 15 _MATH_RANDF :: Int _MATH_RANDF = 33 _MATH_DECTIME :: Int _MATH_DECTIME = 30 _MATH_COS :: Int _MATH_COS = 1 _MATH_SIN :: Int _MATH_SIN = 0 _VAR_TO_STR :: Int _VAR_TO_STR = 59 _MATH_SINH :: Int _MATH_SINH = 3 _TEXT_ORD :: Int _TEXT_ORD = 67 _STR_TO_VAR :: Int _STR_TO_VAR = 60 _MATH_INVERSE_LERP :: Int _MATH_INVERSE_LERP = 27 _MATH_FPOSMOD :: Int _MATH_FPOSMOD = 12 _MATH_WRAP :: Int _MATH_WRAP = 43 _MATH_LOG :: Int _MATH_LOG = 19 _TYPE_OF :: Int _TYPE_OF = 52 _TEXT_PRINTERR :: Int _TEXT_PRINTERR = 57 _MATH_LINEAR2DB :: Int _MATH_LINEAR2DB = 39 _MATH_ACOS :: Int _MATH_ACOS = 7 _MATH_RANDSEED :: Int _MATH_RANDSEED = 36 instance NodeProperty VisualScriptBuiltinFunc "function" Int 'False where nodeProperty = (get_func, wrapDroppingSetter set_func, Nothing) {-# NOINLINE bindVisualScriptBuiltinFunc_get_func #-} bindVisualScriptBuiltinFunc_get_func :: MethodBind bindVisualScriptBuiltinFunc_get_func = unsafePerformIO $ withCString "VisualScriptBuiltinFunc" $ \ clsNamePtr -> withCString "get_func" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_func :: (VisualScriptBuiltinFunc :< cls, Object :< cls) => cls -> IO Int get_func cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptBuiltinFunc_get_func (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptBuiltinFunc "get_func" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptBuiltinFunc.get_func {-# NOINLINE bindVisualScriptBuiltinFunc_set_func #-} bindVisualScriptBuiltinFunc_set_func :: MethodBind bindVisualScriptBuiltinFunc_set_func = unsafePerformIO $ withCString "VisualScriptBuiltinFunc" $ \ clsNamePtr -> withCString "set_func" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_func :: (VisualScriptBuiltinFunc :< cls, Object :< cls) => cls -> Int -> IO () set_func cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptBuiltinFunc_set_func (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptBuiltinFunc "set_func" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptBuiltinFunc.set_func ================================================ FILE: src/Godot/Core/VisualScriptClassConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptClassConstant (Godot.Core.VisualScriptClassConstant.get_base_type, Godot.Core.VisualScriptClassConstant.get_class_constant, Godot.Core.VisualScriptClassConstant.set_base_type, Godot.Core.VisualScriptClassConstant.set_class_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptClassConstant "base_type" GodotString 'False where nodeProperty = (get_base_type, wrapDroppingSetter set_base_type, Nothing) instance NodeProperty VisualScriptClassConstant "constant" GodotString 'False where nodeProperty = (get_class_constant, wrapDroppingSetter set_class_constant, Nothing) {-# NOINLINE bindVisualScriptClassConstant_get_base_type #-} bindVisualScriptClassConstant_get_base_type :: MethodBind bindVisualScriptClassConstant_get_base_type = unsafePerformIO $ withCString "VisualScriptClassConstant" $ \ clsNamePtr -> withCString "get_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_type :: (VisualScriptClassConstant :< cls, Object :< cls) => cls -> IO GodotString get_base_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptClassConstant_get_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptClassConstant "get_base_type" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptClassConstant.get_base_type {-# NOINLINE bindVisualScriptClassConstant_get_class_constant #-} bindVisualScriptClassConstant_get_class_constant :: MethodBind bindVisualScriptClassConstant_get_class_constant = unsafePerformIO $ withCString "VisualScriptClassConstant" $ \ clsNamePtr -> withCString "get_class_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_class_constant :: (VisualScriptClassConstant :< cls, Object :< cls) => cls -> IO GodotString get_class_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptClassConstant_get_class_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptClassConstant "get_class_constant" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptClassConstant.get_class_constant {-# NOINLINE bindVisualScriptClassConstant_set_base_type #-} bindVisualScriptClassConstant_set_base_type :: MethodBind bindVisualScriptClassConstant_set_base_type = unsafePerformIO $ withCString "VisualScriptClassConstant" $ \ clsNamePtr -> withCString "set_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_type :: (VisualScriptClassConstant :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptClassConstant_set_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptClassConstant "set_base_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptClassConstant.set_base_type {-# NOINLINE bindVisualScriptClassConstant_set_class_constant #-} bindVisualScriptClassConstant_set_class_constant :: MethodBind bindVisualScriptClassConstant_set_class_constant = unsafePerformIO $ withCString "VisualScriptClassConstant" $ \ clsNamePtr -> withCString "set_class_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_class_constant :: (VisualScriptClassConstant :< cls, Object :< cls) => cls -> GodotString -> IO () set_class_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptClassConstant_set_class_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptClassConstant "set_class_constant" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptClassConstant.set_class_constant ================================================ FILE: src/Godot/Core/VisualScriptComment.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptComment (Godot.Core.VisualScriptComment.get_description, Godot.Core.VisualScriptComment.get_size, Godot.Core.VisualScriptComment.get_title, Godot.Core.VisualScriptComment.set_description, Godot.Core.VisualScriptComment.set_size, Godot.Core.VisualScriptComment.set_title) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptComment "description" GodotString 'False where nodeProperty = (get_description, wrapDroppingSetter set_description, Nothing) instance NodeProperty VisualScriptComment "size" Vector2 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) instance NodeProperty VisualScriptComment "title" GodotString 'False where nodeProperty = (get_title, wrapDroppingSetter set_title, Nothing) {-# NOINLINE bindVisualScriptComment_get_description #-} bindVisualScriptComment_get_description :: MethodBind bindVisualScriptComment_get_description = unsafePerformIO $ withCString "VisualScriptComment" $ \ clsNamePtr -> withCString "get_description" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_description :: (VisualScriptComment :< cls, Object :< cls) => cls -> IO GodotString get_description cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptComment_get_description (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptComment "get_description" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptComment.get_description {-# NOINLINE bindVisualScriptComment_get_size #-} bindVisualScriptComment_get_size :: MethodBind bindVisualScriptComment_get_size = unsafePerformIO $ withCString "VisualScriptComment" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_size :: (VisualScriptComment :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptComment_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptComment "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.VisualScriptComment.get_size {-# NOINLINE bindVisualScriptComment_get_title #-} bindVisualScriptComment_get_title :: MethodBind bindVisualScriptComment_get_title = unsafePerformIO $ withCString "VisualScriptComment" $ \ clsNamePtr -> withCString "get_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_title :: (VisualScriptComment :< cls, Object :< cls) => cls -> IO GodotString get_title cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptComment_get_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptComment "get_title" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptComment.get_title {-# NOINLINE bindVisualScriptComment_set_description #-} bindVisualScriptComment_set_description :: MethodBind bindVisualScriptComment_set_description = unsafePerformIO $ withCString "VisualScriptComment" $ \ clsNamePtr -> withCString "set_description" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_description :: (VisualScriptComment :< cls, Object :< cls) => cls -> GodotString -> IO () set_description cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptComment_set_description (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptComment "set_description" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptComment.set_description {-# NOINLINE bindVisualScriptComment_set_size #-} bindVisualScriptComment_set_size :: MethodBind bindVisualScriptComment_set_size = unsafePerformIO $ withCString "VisualScriptComment" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_size :: (VisualScriptComment :< cls, Object :< cls) => cls -> Vector2 -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptComment_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptComment "set_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.VisualScriptComment.set_size {-# NOINLINE bindVisualScriptComment_set_title #-} bindVisualScriptComment_set_title :: MethodBind bindVisualScriptComment_set_title = unsafePerformIO $ withCString "VisualScriptComment" $ \ clsNamePtr -> withCString "set_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_title :: (VisualScriptComment :< cls, Object :< cls) => cls -> GodotString -> IO () set_title cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptComment_set_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptComment "set_title" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptComment.set_title ================================================ FILE: src/Godot/Core/VisualScriptComposeArray.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptComposeArray () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptLists() ================================================ FILE: src/Godot/Core/VisualScriptCondition.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptCondition () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptConstant (Godot.Core.VisualScriptConstant.get_constant_type, Godot.Core.VisualScriptConstant.get_constant_value, Godot.Core.VisualScriptConstant.set_constant_type, Godot.Core.VisualScriptConstant.set_constant_value) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptConstant "type" Int 'False where nodeProperty = (get_constant_type, wrapDroppingSetter set_constant_type, Nothing) instance NodeProperty VisualScriptConstant "value" GodotVariant 'False where nodeProperty = (get_constant_value, wrapDroppingSetter set_constant_value, Nothing) {-# NOINLINE bindVisualScriptConstant_get_constant_type #-} bindVisualScriptConstant_get_constant_type :: MethodBind bindVisualScriptConstant_get_constant_type = unsafePerformIO $ withCString "VisualScriptConstant" $ \ clsNamePtr -> withCString "get_constant_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_constant_type :: (VisualScriptConstant :< cls, Object :< cls) => cls -> IO Int get_constant_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptConstant_get_constant_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptConstant "get_constant_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptConstant.get_constant_type {-# NOINLINE bindVisualScriptConstant_get_constant_value #-} bindVisualScriptConstant_get_constant_value :: MethodBind bindVisualScriptConstant_get_constant_value = unsafePerformIO $ withCString "VisualScriptConstant" $ \ clsNamePtr -> withCString "get_constant_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_constant_value :: (VisualScriptConstant :< cls, Object :< cls) => cls -> IO GodotVariant get_constant_value cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptConstant_get_constant_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptConstant "get_constant_value" '[] (IO GodotVariant) where nodeMethod = Godot.Core.VisualScriptConstant.get_constant_value {-# NOINLINE bindVisualScriptConstant_set_constant_type #-} bindVisualScriptConstant_set_constant_type :: MethodBind bindVisualScriptConstant_set_constant_type = unsafePerformIO $ withCString "VisualScriptConstant" $ \ clsNamePtr -> withCString "set_constant_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_constant_type :: (VisualScriptConstant :< cls, Object :< cls) => cls -> Int -> IO () set_constant_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptConstant_set_constant_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptConstant "set_constant_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptConstant.set_constant_type {-# NOINLINE bindVisualScriptConstant_set_constant_value #-} bindVisualScriptConstant_set_constant_value :: MethodBind bindVisualScriptConstant_set_constant_value = unsafePerformIO $ withCString "VisualScriptConstant" $ \ clsNamePtr -> withCString "set_constant_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_constant_value :: (VisualScriptConstant :< cls, Object :< cls) => cls -> GodotVariant -> IO () set_constant_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptConstant_set_constant_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptConstant "set_constant_value" '[GodotVariant] (IO ()) where nodeMethod = Godot.Core.VisualScriptConstant.set_constant_value ================================================ FILE: src/Godot/Core/VisualScriptConstructor.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptConstructor (Godot.Core.VisualScriptConstructor.get_constructor, Godot.Core.VisualScriptConstructor.get_constructor_type, Godot.Core.VisualScriptConstructor.set_constructor, Godot.Core.VisualScriptConstructor.set_constructor_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptConstructor "constructor" Dictionary 'False where nodeProperty = (get_constructor, wrapDroppingSetter set_constructor, Nothing) instance NodeProperty VisualScriptConstructor "type" Int 'False where nodeProperty = (get_constructor_type, wrapDroppingSetter set_constructor_type, Nothing) {-# NOINLINE bindVisualScriptConstructor_get_constructor #-} bindVisualScriptConstructor_get_constructor :: MethodBind bindVisualScriptConstructor_get_constructor = unsafePerformIO $ withCString "VisualScriptConstructor" $ \ clsNamePtr -> withCString "get_constructor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_constructor :: (VisualScriptConstructor :< cls, Object :< cls) => cls -> IO Dictionary get_constructor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptConstructor_get_constructor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptConstructor "get_constructor" '[] (IO Dictionary) where nodeMethod = Godot.Core.VisualScriptConstructor.get_constructor {-# NOINLINE bindVisualScriptConstructor_get_constructor_type #-} bindVisualScriptConstructor_get_constructor_type :: MethodBind bindVisualScriptConstructor_get_constructor_type = unsafePerformIO $ withCString "VisualScriptConstructor" $ \ clsNamePtr -> withCString "get_constructor_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_constructor_type :: (VisualScriptConstructor :< cls, Object :< cls) => cls -> IO Int get_constructor_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptConstructor_get_constructor_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptConstructor "get_constructor_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptConstructor.get_constructor_type {-# NOINLINE bindVisualScriptConstructor_set_constructor #-} bindVisualScriptConstructor_set_constructor :: MethodBind bindVisualScriptConstructor_set_constructor = unsafePerformIO $ withCString "VisualScriptConstructor" $ \ clsNamePtr -> withCString "set_constructor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_constructor :: (VisualScriptConstructor :< cls, Object :< cls) => cls -> Dictionary -> IO () set_constructor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptConstructor_set_constructor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptConstructor "set_constructor" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.VisualScriptConstructor.set_constructor {-# NOINLINE bindVisualScriptConstructor_set_constructor_type #-} bindVisualScriptConstructor_set_constructor_type :: MethodBind bindVisualScriptConstructor_set_constructor_type = unsafePerformIO $ withCString "VisualScriptConstructor" $ \ clsNamePtr -> withCString "set_constructor_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_constructor_type :: (VisualScriptConstructor :< cls, Object :< cls) => cls -> Int -> IO () set_constructor_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptConstructor_set_constructor_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptConstructor "set_constructor_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptConstructor.set_constructor_type ================================================ FILE: src/Godot/Core/VisualScriptCustomNode.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptCustomNode (Godot.Core.VisualScriptCustomNode._STEP_PUSH_STACK_BIT, Godot.Core.VisualScriptCustomNode._START_MODE_RESUME_YIELD, Godot.Core.VisualScriptCustomNode._STEP_EXIT_FUNCTION_BIT, Godot.Core.VisualScriptCustomNode._STEP_YIELD_BIT, Godot.Core.VisualScriptCustomNode._STEP_NO_ADVANCE_BIT, Godot.Core.VisualScriptCustomNode._START_MODE_BEGIN_SEQUENCE, Godot.Core.VisualScriptCustomNode._START_MODE_CONTINUE_SEQUENCE, Godot.Core.VisualScriptCustomNode._STEP_GO_BACK_BIT, Godot.Core.VisualScriptCustomNode._get_caption, Godot.Core.VisualScriptCustomNode._get_category, Godot.Core.VisualScriptCustomNode._get_input_value_port_count, Godot.Core.VisualScriptCustomNode._get_input_value_port_name, Godot.Core.VisualScriptCustomNode._get_input_value_port_type, Godot.Core.VisualScriptCustomNode._get_output_sequence_port_count, Godot.Core.VisualScriptCustomNode._get_output_sequence_port_text, Godot.Core.VisualScriptCustomNode._get_output_value_port_count, Godot.Core.VisualScriptCustomNode._get_output_value_port_name, Godot.Core.VisualScriptCustomNode._get_output_value_port_type, Godot.Core.VisualScriptCustomNode._get_text, Godot.Core.VisualScriptCustomNode._get_working_memory_size, Godot.Core.VisualScriptCustomNode._has_input_sequence_port, Godot.Core.VisualScriptCustomNode._script_changed, Godot.Core.VisualScriptCustomNode._step) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _STEP_PUSH_STACK_BIT :: Int _STEP_PUSH_STACK_BIT = 16777216 _START_MODE_RESUME_YIELD :: Int _START_MODE_RESUME_YIELD = 2 _STEP_EXIT_FUNCTION_BIT :: Int _STEP_EXIT_FUNCTION_BIT = 134217728 _STEP_YIELD_BIT :: Int _STEP_YIELD_BIT = 268435456 _STEP_NO_ADVANCE_BIT :: Int _STEP_NO_ADVANCE_BIT = 67108864 _START_MODE_BEGIN_SEQUENCE :: Int _START_MODE_BEGIN_SEQUENCE = 0 _START_MODE_CONTINUE_SEQUENCE :: Int _START_MODE_CONTINUE_SEQUENCE = 1 _STEP_GO_BACK_BIT :: Int _STEP_GO_BACK_BIT = 33554432 {-# NOINLINE bindVisualScriptCustomNode__get_caption #-} bindVisualScriptCustomNode__get_caption :: MethodBind bindVisualScriptCustomNode__get_caption = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_caption" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_caption :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO GodotString _get_caption cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_caption (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_caption" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_caption {-# NOINLINE bindVisualScriptCustomNode__get_category #-} bindVisualScriptCustomNode__get_category :: MethodBind bindVisualScriptCustomNode__get_category = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_category" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_category :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO GodotString _get_category cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_category (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_category" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_category {-# NOINLINE bindVisualScriptCustomNode__get_input_value_port_count #-} bindVisualScriptCustomNode__get_input_value_port_count :: MethodBind bindVisualScriptCustomNode__get_input_value_port_count = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_input_value_port_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_input_value_port_count :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO Int _get_input_value_port_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_input_value_port_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_input_value_port_count" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_input_value_port_count {-# NOINLINE bindVisualScriptCustomNode__get_input_value_port_name #-} bindVisualScriptCustomNode__get_input_value_port_name :: MethodBind bindVisualScriptCustomNode__get_input_value_port_name = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_input_value_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_input_value_port_name :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> Int -> IO GodotString _get_input_value_port_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_input_value_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_input_value_port_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_input_value_port_name {-# NOINLINE bindVisualScriptCustomNode__get_input_value_port_type #-} bindVisualScriptCustomNode__get_input_value_port_type :: MethodBind bindVisualScriptCustomNode__get_input_value_port_type = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_input_value_port_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_input_value_port_type :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> Int -> IO Int _get_input_value_port_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_input_value_port_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_input_value_port_type" '[Int] (IO Int) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_input_value_port_type {-# NOINLINE bindVisualScriptCustomNode__get_output_sequence_port_count #-} bindVisualScriptCustomNode__get_output_sequence_port_count :: MethodBind bindVisualScriptCustomNode__get_output_sequence_port_count = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_output_sequence_port_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_output_sequence_port_count :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO Int _get_output_sequence_port_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_output_sequence_port_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_output_sequence_port_count" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_output_sequence_port_count {-# NOINLINE bindVisualScriptCustomNode__get_output_sequence_port_text #-} bindVisualScriptCustomNode__get_output_sequence_port_text :: MethodBind bindVisualScriptCustomNode__get_output_sequence_port_text = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_output_sequence_port_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_output_sequence_port_text :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> Int -> IO GodotString _get_output_sequence_port_text cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_output_sequence_port_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_output_sequence_port_text" '[Int] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_output_sequence_port_text {-# NOINLINE bindVisualScriptCustomNode__get_output_value_port_count #-} bindVisualScriptCustomNode__get_output_value_port_count :: MethodBind bindVisualScriptCustomNode__get_output_value_port_count = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_output_value_port_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_output_value_port_count :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO Int _get_output_value_port_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_output_value_port_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_output_value_port_count" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_output_value_port_count {-# NOINLINE bindVisualScriptCustomNode__get_output_value_port_name #-} bindVisualScriptCustomNode__get_output_value_port_name :: MethodBind bindVisualScriptCustomNode__get_output_value_port_name = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_output_value_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_output_value_port_name :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> Int -> IO GodotString _get_output_value_port_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_output_value_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_output_value_port_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_output_value_port_name {-# NOINLINE bindVisualScriptCustomNode__get_output_value_port_type #-} bindVisualScriptCustomNode__get_output_value_port_type :: MethodBind bindVisualScriptCustomNode__get_output_value_port_type = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_output_value_port_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_output_value_port_type :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> Int -> IO Int _get_output_value_port_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_output_value_port_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_output_value_port_type" '[Int] (IO Int) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_output_value_port_type {-# NOINLINE bindVisualScriptCustomNode__get_text #-} bindVisualScriptCustomNode__get_text :: MethodBind bindVisualScriptCustomNode__get_text = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_text :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO GodotString _get_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_text" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_text {-# NOINLINE bindVisualScriptCustomNode__get_working_memory_size #-} bindVisualScriptCustomNode__get_working_memory_size :: MethodBind bindVisualScriptCustomNode__get_working_memory_size = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_get_working_memory_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_working_memory_size :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO Int _get_working_memory_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__get_working_memory_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_get_working_memory_size" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptCustomNode._get_working_memory_size {-# NOINLINE bindVisualScriptCustomNode__has_input_sequence_port #-} bindVisualScriptCustomNode__has_input_sequence_port :: MethodBind bindVisualScriptCustomNode__has_input_sequence_port = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_has_input_sequence_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _has_input_sequence_port :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO Bool _has_input_sequence_port cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__has_input_sequence_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_has_input_sequence_port" '[] (IO Bool) where nodeMethod = Godot.Core.VisualScriptCustomNode._has_input_sequence_port {-# NOINLINE bindVisualScriptCustomNode__script_changed #-} bindVisualScriptCustomNode__script_changed :: MethodBind bindVisualScriptCustomNode__script_changed = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_script_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _script_changed :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> IO () _script_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__script_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_script_changed" '[] (IO ()) where nodeMethod = Godot.Core.VisualScriptCustomNode._script_changed {-# NOINLINE bindVisualScriptCustomNode__step #-} bindVisualScriptCustomNode__step :: MethodBind bindVisualScriptCustomNode__step = unsafePerformIO $ withCString "VisualScriptCustomNode" $ \ clsNamePtr -> withCString "_step" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _step :: (VisualScriptCustomNode :< cls, Object :< cls) => cls -> Array -> Array -> Int -> Array -> IO GodotVariant _step cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptCustomNode__step (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptCustomNode "_step" '[Array, Array, Int, Array] (IO GodotVariant) where nodeMethod = Godot.Core.VisualScriptCustomNode._step ================================================ FILE: src/Godot/Core/VisualScriptDeconstruct.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptDeconstruct (Godot.Core.VisualScriptDeconstruct._get_elem_cache, Godot.Core.VisualScriptDeconstruct._set_elem_cache, Godot.Core.VisualScriptDeconstruct.get_deconstruct_type, Godot.Core.VisualScriptDeconstruct.set_deconstruct_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptDeconstruct "elem_cache" Array 'False where nodeProperty = (_get_elem_cache, wrapDroppingSetter _set_elem_cache, Nothing) instance NodeProperty VisualScriptDeconstruct "type" Int 'False where nodeProperty = (get_deconstruct_type, wrapDroppingSetter set_deconstruct_type, Nothing) {-# NOINLINE bindVisualScriptDeconstruct__get_elem_cache #-} bindVisualScriptDeconstruct__get_elem_cache :: MethodBind bindVisualScriptDeconstruct__get_elem_cache = unsafePerformIO $ withCString "VisualScriptDeconstruct" $ \ clsNamePtr -> withCString "_get_elem_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_elem_cache :: (VisualScriptDeconstruct :< cls, Object :< cls) => cls -> IO Array _get_elem_cache cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptDeconstruct__get_elem_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptDeconstruct "_get_elem_cache" '[] (IO Array) where nodeMethod = Godot.Core.VisualScriptDeconstruct._get_elem_cache {-# NOINLINE bindVisualScriptDeconstruct__set_elem_cache #-} bindVisualScriptDeconstruct__set_elem_cache :: MethodBind bindVisualScriptDeconstruct__set_elem_cache = unsafePerformIO $ withCString "VisualScriptDeconstruct" $ \ clsNamePtr -> withCString "_set_elem_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_elem_cache :: (VisualScriptDeconstruct :< cls, Object :< cls) => cls -> Array -> IO () _set_elem_cache cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptDeconstruct__set_elem_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptDeconstruct "_set_elem_cache" '[Array] (IO ()) where nodeMethod = Godot.Core.VisualScriptDeconstruct._set_elem_cache {-# NOINLINE bindVisualScriptDeconstruct_get_deconstruct_type #-} bindVisualScriptDeconstruct_get_deconstruct_type :: MethodBind bindVisualScriptDeconstruct_get_deconstruct_type = unsafePerformIO $ withCString "VisualScriptDeconstruct" $ \ clsNamePtr -> withCString "get_deconstruct_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_deconstruct_type :: (VisualScriptDeconstruct :< cls, Object :< cls) => cls -> IO Int get_deconstruct_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptDeconstruct_get_deconstruct_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptDeconstruct "get_deconstruct_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptDeconstruct.get_deconstruct_type {-# NOINLINE bindVisualScriptDeconstruct_set_deconstruct_type #-} bindVisualScriptDeconstruct_set_deconstruct_type :: MethodBind bindVisualScriptDeconstruct_set_deconstruct_type = unsafePerformIO $ withCString "VisualScriptDeconstruct" $ \ clsNamePtr -> withCString "set_deconstruct_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_deconstruct_type :: (VisualScriptDeconstruct :< cls, Object :< cls) => cls -> Int -> IO () set_deconstruct_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptDeconstruct_set_deconstruct_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptDeconstruct "set_deconstruct_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptDeconstruct.set_deconstruct_type ================================================ FILE: src/Godot/Core/VisualScriptEmitSignal.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptEmitSignal (Godot.Core.VisualScriptEmitSignal.get_signal, Godot.Core.VisualScriptEmitSignal.set_signal) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptEmitSignal "signal" GodotString 'False where nodeProperty = (get_signal, wrapDroppingSetter set_signal, Nothing) {-# NOINLINE bindVisualScriptEmitSignal_get_signal #-} bindVisualScriptEmitSignal_get_signal :: MethodBind bindVisualScriptEmitSignal_get_signal = unsafePerformIO $ withCString "VisualScriptEmitSignal" $ \ clsNamePtr -> withCString "get_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_signal :: (VisualScriptEmitSignal :< cls, Object :< cls) => cls -> IO GodotString get_signal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptEmitSignal_get_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptEmitSignal "get_signal" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptEmitSignal.get_signal {-# NOINLINE bindVisualScriptEmitSignal_set_signal #-} bindVisualScriptEmitSignal_set_signal :: MethodBind bindVisualScriptEmitSignal_set_signal = unsafePerformIO $ withCString "VisualScriptEmitSignal" $ \ clsNamePtr -> withCString "set_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_signal :: (VisualScriptEmitSignal :< cls, Object :< cls) => cls -> GodotString -> IO () set_signal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptEmitSignal_set_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptEmitSignal "set_signal" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptEmitSignal.set_signal ================================================ FILE: src/Godot/Core/VisualScriptEngineSingleton.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptEngineSingleton (Godot.Core.VisualScriptEngineSingleton.get_singleton, Godot.Core.VisualScriptEngineSingleton.set_singleton) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptEngineSingleton "constant" GodotString 'False where nodeProperty = (get_singleton, wrapDroppingSetter set_singleton, Nothing) {-# NOINLINE bindVisualScriptEngineSingleton_get_singleton #-} bindVisualScriptEngineSingleton_get_singleton :: MethodBind bindVisualScriptEngineSingleton_get_singleton = unsafePerformIO $ withCString "VisualScriptEngineSingleton" $ \ clsNamePtr -> withCString "get_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_singleton :: (VisualScriptEngineSingleton :< cls, Object :< cls) => cls -> IO GodotString get_singleton cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptEngineSingleton_get_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptEngineSingleton "get_singleton" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptEngineSingleton.get_singleton {-# NOINLINE bindVisualScriptEngineSingleton_set_singleton #-} bindVisualScriptEngineSingleton_set_singleton :: MethodBind bindVisualScriptEngineSingleton_set_singleton = unsafePerformIO $ withCString "VisualScriptEngineSingleton" $ \ clsNamePtr -> withCString "set_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_singleton :: (VisualScriptEngineSingleton :< cls, Object :< cls) => cls -> GodotString -> IO () set_singleton cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptEngineSingleton_set_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptEngineSingleton "set_singleton" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptEngineSingleton.set_singleton ================================================ FILE: src/Godot/Core/VisualScriptExpression.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptExpression () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptFunction.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptFunction () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptFunctionCall.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptFunctionCall (Godot.Core.VisualScriptFunctionCall._CALL_MODE_BASIC_TYPE, Godot.Core.VisualScriptFunctionCall._RPC_UNRELIABLE_TO_ID, Godot.Core.VisualScriptFunctionCall._CALL_MODE_NODE_PATH, Godot.Core.VisualScriptFunctionCall._RPC_UNRELIABLE, Godot.Core.VisualScriptFunctionCall._CALL_MODE_SELF, Godot.Core.VisualScriptFunctionCall._RPC_RELIABLE_TO_ID, Godot.Core.VisualScriptFunctionCall._CALL_MODE_INSTANCE, Godot.Core.VisualScriptFunctionCall._CALL_MODE_SINGLETON, Godot.Core.VisualScriptFunctionCall._RPC_DISABLED, Godot.Core.VisualScriptFunctionCall._RPC_RELIABLE, Godot.Core.VisualScriptFunctionCall._get_argument_cache, Godot.Core.VisualScriptFunctionCall._set_argument_cache, Godot.Core.VisualScriptFunctionCall.get_base_path, Godot.Core.VisualScriptFunctionCall.get_base_script, Godot.Core.VisualScriptFunctionCall.get_base_type, Godot.Core.VisualScriptFunctionCall.get_basic_type, Godot.Core.VisualScriptFunctionCall.get_call_mode, Godot.Core.VisualScriptFunctionCall.get_function, Godot.Core.VisualScriptFunctionCall.get_rpc_call_mode, Godot.Core.VisualScriptFunctionCall.get_singleton, Godot.Core.VisualScriptFunctionCall.get_use_default_args, Godot.Core.VisualScriptFunctionCall.get_validate, Godot.Core.VisualScriptFunctionCall.set_base_path, Godot.Core.VisualScriptFunctionCall.set_base_script, Godot.Core.VisualScriptFunctionCall.set_base_type, Godot.Core.VisualScriptFunctionCall.set_basic_type, Godot.Core.VisualScriptFunctionCall.set_call_mode, Godot.Core.VisualScriptFunctionCall.set_function, Godot.Core.VisualScriptFunctionCall.set_rpc_call_mode, Godot.Core.VisualScriptFunctionCall.set_singleton, Godot.Core.VisualScriptFunctionCall.set_use_default_args, Godot.Core.VisualScriptFunctionCall.set_validate) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _CALL_MODE_BASIC_TYPE :: Int _CALL_MODE_BASIC_TYPE = 3 _RPC_UNRELIABLE_TO_ID :: Int _RPC_UNRELIABLE_TO_ID = 4 _CALL_MODE_NODE_PATH :: Int _CALL_MODE_NODE_PATH = 1 _RPC_UNRELIABLE :: Int _RPC_UNRELIABLE = 2 _CALL_MODE_SELF :: Int _CALL_MODE_SELF = 0 _RPC_RELIABLE_TO_ID :: Int _RPC_RELIABLE_TO_ID = 3 _CALL_MODE_INSTANCE :: Int _CALL_MODE_INSTANCE = 2 _CALL_MODE_SINGLETON :: Int _CALL_MODE_SINGLETON = 4 _RPC_DISABLED :: Int _RPC_DISABLED = 0 _RPC_RELIABLE :: Int _RPC_RELIABLE = 1 instance NodeProperty VisualScriptFunctionCall "argument_cache" Dictionary 'False where nodeProperty = (_get_argument_cache, wrapDroppingSetter _set_argument_cache, Nothing) instance NodeProperty VisualScriptFunctionCall "base_script" GodotString 'False where nodeProperty = (get_base_script, wrapDroppingSetter set_base_script, Nothing) instance NodeProperty VisualScriptFunctionCall "base_type" GodotString 'False where nodeProperty = (get_base_type, wrapDroppingSetter set_base_type, Nothing) instance NodeProperty VisualScriptFunctionCall "basic_type" Int 'False where nodeProperty = (get_basic_type, wrapDroppingSetter set_basic_type, Nothing) instance NodeProperty VisualScriptFunctionCall "call_mode" Int 'False where nodeProperty = (get_call_mode, wrapDroppingSetter set_call_mode, Nothing) instance NodeProperty VisualScriptFunctionCall "function" GodotString 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) instance NodeProperty VisualScriptFunctionCall "node_path" NodePath 'False where nodeProperty = (get_base_path, wrapDroppingSetter set_base_path, Nothing) instance NodeProperty VisualScriptFunctionCall "rpc_call_mode" Int 'False where nodeProperty = (get_rpc_call_mode, wrapDroppingSetter set_rpc_call_mode, Nothing) instance NodeProperty VisualScriptFunctionCall "singleton" GodotString 'False where nodeProperty = (get_singleton, wrapDroppingSetter set_singleton, Nothing) instance NodeProperty VisualScriptFunctionCall "use_default_args" Int 'False where nodeProperty = (get_use_default_args, wrapDroppingSetter set_use_default_args, Nothing) instance NodeProperty VisualScriptFunctionCall "validate" Bool 'False where nodeProperty = (get_validate, wrapDroppingSetter set_validate, Nothing) {-# NOINLINE bindVisualScriptFunctionCall__get_argument_cache #-} bindVisualScriptFunctionCall__get_argument_cache :: MethodBind bindVisualScriptFunctionCall__get_argument_cache = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "_get_argument_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_argument_cache :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO Dictionary _get_argument_cache cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall__get_argument_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "_get_argument_cache" '[] (IO Dictionary) where nodeMethod = Godot.Core.VisualScriptFunctionCall._get_argument_cache {-# NOINLINE bindVisualScriptFunctionCall__set_argument_cache #-} bindVisualScriptFunctionCall__set_argument_cache :: MethodBind bindVisualScriptFunctionCall__set_argument_cache = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "_set_argument_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_argument_cache :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_argument_cache cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall__set_argument_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "_set_argument_cache" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall._set_argument_cache {-# NOINLINE bindVisualScriptFunctionCall_get_base_path #-} bindVisualScriptFunctionCall_get_base_path :: MethodBind bindVisualScriptFunctionCall_get_base_path = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_path :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO NodePath get_base_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_base_path" '[] (IO NodePath) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_base_path {-# NOINLINE bindVisualScriptFunctionCall_get_base_script #-} bindVisualScriptFunctionCall_get_base_script :: MethodBind bindVisualScriptFunctionCall_get_base_script = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_script :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO GodotString get_base_script cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_base_script" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_base_script {-# NOINLINE bindVisualScriptFunctionCall_get_base_type #-} bindVisualScriptFunctionCall_get_base_type :: MethodBind bindVisualScriptFunctionCall_get_base_type = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_type :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO GodotString get_base_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_base_type" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_base_type {-# NOINLINE bindVisualScriptFunctionCall_get_basic_type #-} bindVisualScriptFunctionCall_get_basic_type :: MethodBind bindVisualScriptFunctionCall_get_basic_type = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_basic_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_basic_type :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO Int get_basic_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_basic_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_basic_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_basic_type {-# NOINLINE bindVisualScriptFunctionCall_get_call_mode #-} bindVisualScriptFunctionCall_get_call_mode :: MethodBind bindVisualScriptFunctionCall_get_call_mode = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_call_mode :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO Int get_call_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_call_mode" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_call_mode {-# NOINLINE bindVisualScriptFunctionCall_get_function #-} bindVisualScriptFunctionCall_get_function :: MethodBind bindVisualScriptFunctionCall_get_function = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_function :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO GodotString get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_function" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_function {-# NOINLINE bindVisualScriptFunctionCall_get_rpc_call_mode #-} bindVisualScriptFunctionCall_get_rpc_call_mode :: MethodBind bindVisualScriptFunctionCall_get_rpc_call_mode = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_rpc_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_rpc_call_mode :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO Int get_rpc_call_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_rpc_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_rpc_call_mode" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_rpc_call_mode {-# NOINLINE bindVisualScriptFunctionCall_get_singleton #-} bindVisualScriptFunctionCall_get_singleton :: MethodBind bindVisualScriptFunctionCall_get_singleton = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_singleton :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO GodotString get_singleton cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_singleton" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_singleton {-# NOINLINE bindVisualScriptFunctionCall_get_use_default_args #-} bindVisualScriptFunctionCall_get_use_default_args :: MethodBind bindVisualScriptFunctionCall_get_use_default_args = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_use_default_args" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_use_default_args :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO Int get_use_default_args cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_use_default_args (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_use_default_args" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_use_default_args {-# NOINLINE bindVisualScriptFunctionCall_get_validate #-} bindVisualScriptFunctionCall_get_validate :: MethodBind bindVisualScriptFunctionCall_get_validate = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "get_validate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_validate :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> IO Bool get_validate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_get_validate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "get_validate" '[] (IO Bool) where nodeMethod = Godot.Core.VisualScriptFunctionCall.get_validate {-# NOINLINE bindVisualScriptFunctionCall_set_base_path #-} bindVisualScriptFunctionCall_set_base_path :: MethodBind bindVisualScriptFunctionCall_set_base_path = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_path :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> NodePath -> IO () set_base_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_base_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_base_path {-# NOINLINE bindVisualScriptFunctionCall_set_base_script #-} bindVisualScriptFunctionCall_set_base_script :: MethodBind bindVisualScriptFunctionCall_set_base_script = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_script :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_script cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_base_script" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_base_script {-# NOINLINE bindVisualScriptFunctionCall_set_base_type #-} bindVisualScriptFunctionCall_set_base_type :: MethodBind bindVisualScriptFunctionCall_set_base_type = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_type :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_base_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_base_type {-# NOINLINE bindVisualScriptFunctionCall_set_basic_type #-} bindVisualScriptFunctionCall_set_basic_type :: MethodBind bindVisualScriptFunctionCall_set_basic_type = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_basic_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_basic_type :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> Int -> IO () set_basic_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_basic_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_basic_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_basic_type {-# NOINLINE bindVisualScriptFunctionCall_set_call_mode #-} bindVisualScriptFunctionCall_set_call_mode :: MethodBind bindVisualScriptFunctionCall_set_call_mode = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_call_mode :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> Int -> IO () set_call_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_call_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_call_mode {-# NOINLINE bindVisualScriptFunctionCall_set_function #-} bindVisualScriptFunctionCall_set_function :: MethodBind bindVisualScriptFunctionCall_set_function = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_function :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> GodotString -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_function" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_function {-# NOINLINE bindVisualScriptFunctionCall_set_rpc_call_mode #-} bindVisualScriptFunctionCall_set_rpc_call_mode :: MethodBind bindVisualScriptFunctionCall_set_rpc_call_mode = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_rpc_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_rpc_call_mode :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> Int -> IO () set_rpc_call_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_rpc_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_rpc_call_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_rpc_call_mode {-# NOINLINE bindVisualScriptFunctionCall_set_singleton #-} bindVisualScriptFunctionCall_set_singleton :: MethodBind bindVisualScriptFunctionCall_set_singleton = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_singleton :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> GodotString -> IO () set_singleton cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_singleton" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_singleton {-# NOINLINE bindVisualScriptFunctionCall_set_use_default_args #-} bindVisualScriptFunctionCall_set_use_default_args :: MethodBind bindVisualScriptFunctionCall_set_use_default_args = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_use_default_args" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_use_default_args :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> Int -> IO () set_use_default_args cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_use_default_args (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_use_default_args" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_use_default_args {-# NOINLINE bindVisualScriptFunctionCall_set_validate #-} bindVisualScriptFunctionCall_set_validate :: MethodBind bindVisualScriptFunctionCall_set_validate = unsafePerformIO $ withCString "VisualScriptFunctionCall" $ \ clsNamePtr -> withCString "set_validate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_validate :: (VisualScriptFunctionCall :< cls, Object :< cls) => cls -> Bool -> IO () set_validate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionCall_set_validate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionCall "set_validate" '[Bool] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionCall.set_validate ================================================ FILE: src/Godot/Core/VisualScriptFunctionState.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptFunctionState (Godot.Core.VisualScriptFunctionState._signal_callback, Godot.Core.VisualScriptFunctionState.connect_to_signal, Godot.Core.VisualScriptFunctionState.is_valid, Godot.Core.VisualScriptFunctionState.resume) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindVisualScriptFunctionState__signal_callback #-} bindVisualScriptFunctionState__signal_callback :: MethodBind bindVisualScriptFunctionState__signal_callback = unsafePerformIO $ withCString "VisualScriptFunctionState" $ \ clsNamePtr -> withCString "_signal_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _signal_callback :: (VisualScriptFunctionState :< cls, Object :< cls) => cls -> [Variant 'GodotTy] -> IO GodotVariant _signal_callback cls varargs = withVariantArray ([] ++ varargs) (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionState__signal_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionState "_signal_callback" '[[Variant 'GodotTy]] (IO GodotVariant) where nodeMethod = Godot.Core.VisualScriptFunctionState._signal_callback {-# NOINLINE bindVisualScriptFunctionState_connect_to_signal #-} bindVisualScriptFunctionState_connect_to_signal :: MethodBind bindVisualScriptFunctionState_connect_to_signal = unsafePerformIO $ withCString "VisualScriptFunctionState" $ \ clsNamePtr -> withCString "connect_to_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr connect_to_signal :: (VisualScriptFunctionState :< cls, Object :< cls) => cls -> Object -> GodotString -> Array -> IO () connect_to_signal cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionState_connect_to_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionState "connect_to_signal" '[Object, GodotString, Array] (IO ()) where nodeMethod = Godot.Core.VisualScriptFunctionState.connect_to_signal {-# NOINLINE bindVisualScriptFunctionState_is_valid #-} bindVisualScriptFunctionState_is_valid :: MethodBind bindVisualScriptFunctionState_is_valid = unsafePerformIO $ withCString "VisualScriptFunctionState" $ \ clsNamePtr -> withCString "is_valid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_valid :: (VisualScriptFunctionState :< cls, Object :< cls) => cls -> IO Bool is_valid cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionState_is_valid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionState "is_valid" '[] (IO Bool) where nodeMethod = Godot.Core.VisualScriptFunctionState.is_valid {-# NOINLINE bindVisualScriptFunctionState_resume #-} bindVisualScriptFunctionState_resume :: MethodBind bindVisualScriptFunctionState_resume = unsafePerformIO $ withCString "VisualScriptFunctionState" $ \ clsNamePtr -> withCString "resume" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr resume :: (VisualScriptFunctionState :< cls, Object :< cls) => cls -> Maybe Array -> IO GodotVariant resume cls arg1 = withVariantArray [maybe VariantNil toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptFunctionState_resume (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptFunctionState "resume" '[Maybe Array] (IO GodotVariant) where nodeMethod = Godot.Core.VisualScriptFunctionState.resume ================================================ FILE: src/Godot/Core/VisualScriptGlobalConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptGlobalConstant (Godot.Core.VisualScriptGlobalConstant.get_global_constant, Godot.Core.VisualScriptGlobalConstant.set_global_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptGlobalConstant "constant" Int 'False where nodeProperty = (get_global_constant, wrapDroppingSetter set_global_constant, Nothing) {-# NOINLINE bindVisualScriptGlobalConstant_get_global_constant #-} bindVisualScriptGlobalConstant_get_global_constant :: MethodBind bindVisualScriptGlobalConstant_get_global_constant = unsafePerformIO $ withCString "VisualScriptGlobalConstant" $ \ clsNamePtr -> withCString "get_global_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_global_constant :: (VisualScriptGlobalConstant :< cls, Object :< cls) => cls -> IO Int get_global_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptGlobalConstant_get_global_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptGlobalConstant "get_global_constant" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptGlobalConstant.get_global_constant {-# NOINLINE bindVisualScriptGlobalConstant_set_global_constant #-} bindVisualScriptGlobalConstant_set_global_constant :: MethodBind bindVisualScriptGlobalConstant_set_global_constant = unsafePerformIO $ withCString "VisualScriptGlobalConstant" $ \ clsNamePtr -> withCString "set_global_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_global_constant :: (VisualScriptGlobalConstant :< cls, Object :< cls) => cls -> Int -> IO () set_global_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptGlobalConstant_set_global_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptGlobalConstant "set_global_constant" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptGlobalConstant.set_global_constant ================================================ FILE: src/Godot/Core/VisualScriptIndexGet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptIndexGet () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptIndexSet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptIndexSet () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptInputAction.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptInputAction (Godot.Core.VisualScriptInputAction._MODE_PRESSED, Godot.Core.VisualScriptInputAction._MODE_JUST_PRESSED, Godot.Core.VisualScriptInputAction._MODE_JUST_RELEASED, Godot.Core.VisualScriptInputAction._MODE_RELEASED, Godot.Core.VisualScriptInputAction.get_action_mode, Godot.Core.VisualScriptInputAction.get_action_name, Godot.Core.VisualScriptInputAction.set_action_mode, Godot.Core.VisualScriptInputAction.set_action_name) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _MODE_PRESSED :: Int _MODE_PRESSED = 0 _MODE_JUST_PRESSED :: Int _MODE_JUST_PRESSED = 2 _MODE_JUST_RELEASED :: Int _MODE_JUST_RELEASED = 3 _MODE_RELEASED :: Int _MODE_RELEASED = 1 instance NodeProperty VisualScriptInputAction "action" GodotString 'False where nodeProperty = (get_action_name, wrapDroppingSetter set_action_name, Nothing) instance NodeProperty VisualScriptInputAction "mode" Int 'False where nodeProperty = (get_action_mode, wrapDroppingSetter set_action_mode, Nothing) {-# NOINLINE bindVisualScriptInputAction_get_action_mode #-} bindVisualScriptInputAction_get_action_mode :: MethodBind bindVisualScriptInputAction_get_action_mode = unsafePerformIO $ withCString "VisualScriptInputAction" $ \ clsNamePtr -> withCString "get_action_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_action_mode :: (VisualScriptInputAction :< cls, Object :< cls) => cls -> IO Int get_action_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptInputAction_get_action_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptInputAction "get_action_mode" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptInputAction.get_action_mode {-# NOINLINE bindVisualScriptInputAction_get_action_name #-} bindVisualScriptInputAction_get_action_name :: MethodBind bindVisualScriptInputAction_get_action_name = unsafePerformIO $ withCString "VisualScriptInputAction" $ \ clsNamePtr -> withCString "get_action_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_action_name :: (VisualScriptInputAction :< cls, Object :< cls) => cls -> IO GodotString get_action_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptInputAction_get_action_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptInputAction "get_action_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptInputAction.get_action_name {-# NOINLINE bindVisualScriptInputAction_set_action_mode #-} bindVisualScriptInputAction_set_action_mode :: MethodBind bindVisualScriptInputAction_set_action_mode = unsafePerformIO $ withCString "VisualScriptInputAction" $ \ clsNamePtr -> withCString "set_action_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_action_mode :: (VisualScriptInputAction :< cls, Object :< cls) => cls -> Int -> IO () set_action_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptInputAction_set_action_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptInputAction "set_action_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptInputAction.set_action_mode {-# NOINLINE bindVisualScriptInputAction_set_action_name #-} bindVisualScriptInputAction_set_action_name :: MethodBind bindVisualScriptInputAction_set_action_name = unsafePerformIO $ withCString "VisualScriptInputAction" $ \ clsNamePtr -> withCString "set_action_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_action_name :: (VisualScriptInputAction :< cls, Object :< cls) => cls -> GodotString -> IO () set_action_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptInputAction_set_action_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptInputAction "set_action_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptInputAction.set_action_name ================================================ FILE: src/Godot/Core/VisualScriptIterator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptIterator () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptLists.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptLists (Godot.Core.VisualScriptLists.add_input_data_port, Godot.Core.VisualScriptLists.add_output_data_port, Godot.Core.VisualScriptLists.remove_input_data_port, Godot.Core.VisualScriptLists.remove_output_data_port, Godot.Core.VisualScriptLists.set_input_data_port_name, Godot.Core.VisualScriptLists.set_input_data_port_type, Godot.Core.VisualScriptLists.set_output_data_port_name, Godot.Core.VisualScriptLists.set_output_data_port_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() {-# NOINLINE bindVisualScriptLists_add_input_data_port #-} bindVisualScriptLists_add_input_data_port :: MethodBind bindVisualScriptLists_add_input_data_port = unsafePerformIO $ withCString "VisualScriptLists" $ \ clsNamePtr -> withCString "add_input_data_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_input_data_port :: (VisualScriptLists :< cls, Object :< cls) => cls -> Int -> GodotString -> Int -> IO () add_input_data_port cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLists_add_input_data_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLists "add_input_data_port" '[Int, GodotString, Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptLists.add_input_data_port {-# NOINLINE bindVisualScriptLists_add_output_data_port #-} bindVisualScriptLists_add_output_data_port :: MethodBind bindVisualScriptLists_add_output_data_port = unsafePerformIO $ withCString "VisualScriptLists" $ \ clsNamePtr -> withCString "add_output_data_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_output_data_port :: (VisualScriptLists :< cls, Object :< cls) => cls -> Int -> GodotString -> Int -> IO () add_output_data_port cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLists_add_output_data_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLists "add_output_data_port" '[Int, GodotString, Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptLists.add_output_data_port {-# NOINLINE bindVisualScriptLists_remove_input_data_port #-} bindVisualScriptLists_remove_input_data_port :: MethodBind bindVisualScriptLists_remove_input_data_port = unsafePerformIO $ withCString "VisualScriptLists" $ \ clsNamePtr -> withCString "remove_input_data_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_input_data_port :: (VisualScriptLists :< cls, Object :< cls) => cls -> Int -> IO () remove_input_data_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLists_remove_input_data_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLists "remove_input_data_port" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptLists.remove_input_data_port {-# NOINLINE bindVisualScriptLists_remove_output_data_port #-} bindVisualScriptLists_remove_output_data_port :: MethodBind bindVisualScriptLists_remove_output_data_port = unsafePerformIO $ withCString "VisualScriptLists" $ \ clsNamePtr -> withCString "remove_output_data_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_output_data_port :: (VisualScriptLists :< cls, Object :< cls) => cls -> Int -> IO () remove_output_data_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLists_remove_output_data_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLists "remove_output_data_port" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptLists.remove_output_data_port {-# NOINLINE bindVisualScriptLists_set_input_data_port_name #-} bindVisualScriptLists_set_input_data_port_name :: MethodBind bindVisualScriptLists_set_input_data_port_name = unsafePerformIO $ withCString "VisualScriptLists" $ \ clsNamePtr -> withCString "set_input_data_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_input_data_port_name :: (VisualScriptLists :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_input_data_port_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLists_set_input_data_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLists "set_input_data_port_name" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptLists.set_input_data_port_name {-# NOINLINE bindVisualScriptLists_set_input_data_port_type #-} bindVisualScriptLists_set_input_data_port_type :: MethodBind bindVisualScriptLists_set_input_data_port_type = unsafePerformIO $ withCString "VisualScriptLists" $ \ clsNamePtr -> withCString "set_input_data_port_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_input_data_port_type :: (VisualScriptLists :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_input_data_port_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLists_set_input_data_port_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLists "set_input_data_port_type" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptLists.set_input_data_port_type {-# NOINLINE bindVisualScriptLists_set_output_data_port_name #-} bindVisualScriptLists_set_output_data_port_name :: MethodBind bindVisualScriptLists_set_output_data_port_name = unsafePerformIO $ withCString "VisualScriptLists" $ \ clsNamePtr -> withCString "set_output_data_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_output_data_port_name :: (VisualScriptLists :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_output_data_port_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLists_set_output_data_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLists "set_output_data_port_name" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptLists.set_output_data_port_name {-# NOINLINE bindVisualScriptLists_set_output_data_port_type #-} bindVisualScriptLists_set_output_data_port_type :: MethodBind bindVisualScriptLists_set_output_data_port_type = unsafePerformIO $ withCString "VisualScriptLists" $ \ clsNamePtr -> withCString "set_output_data_port_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_output_data_port_type :: (VisualScriptLists :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_output_data_port_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLists_set_output_data_port_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLists "set_output_data_port_type" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptLists.set_output_data_port_type ================================================ FILE: src/Godot/Core/VisualScriptLocalVar.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptLocalVar (Godot.Core.VisualScriptLocalVar.get_var_name, Godot.Core.VisualScriptLocalVar.get_var_type, Godot.Core.VisualScriptLocalVar.set_var_name, Godot.Core.VisualScriptLocalVar.set_var_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptLocalVar "type" Int 'False where nodeProperty = (get_var_type, wrapDroppingSetter set_var_type, Nothing) instance NodeProperty VisualScriptLocalVar "var_name" GodotString 'False where nodeProperty = (get_var_name, wrapDroppingSetter set_var_name, Nothing) {-# NOINLINE bindVisualScriptLocalVar_get_var_name #-} bindVisualScriptLocalVar_get_var_name :: MethodBind bindVisualScriptLocalVar_get_var_name = unsafePerformIO $ withCString "VisualScriptLocalVar" $ \ clsNamePtr -> withCString "get_var_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_var_name :: (VisualScriptLocalVar :< cls, Object :< cls) => cls -> IO GodotString get_var_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLocalVar_get_var_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLocalVar "get_var_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptLocalVar.get_var_name {-# NOINLINE bindVisualScriptLocalVar_get_var_type #-} bindVisualScriptLocalVar_get_var_type :: MethodBind bindVisualScriptLocalVar_get_var_type = unsafePerformIO $ withCString "VisualScriptLocalVar" $ \ clsNamePtr -> withCString "get_var_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_var_type :: (VisualScriptLocalVar :< cls, Object :< cls) => cls -> IO Int get_var_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLocalVar_get_var_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLocalVar "get_var_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptLocalVar.get_var_type {-# NOINLINE bindVisualScriptLocalVar_set_var_name #-} bindVisualScriptLocalVar_set_var_name :: MethodBind bindVisualScriptLocalVar_set_var_name = unsafePerformIO $ withCString "VisualScriptLocalVar" $ \ clsNamePtr -> withCString "set_var_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_var_name :: (VisualScriptLocalVar :< cls, Object :< cls) => cls -> GodotString -> IO () set_var_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLocalVar_set_var_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLocalVar "set_var_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptLocalVar.set_var_name {-# NOINLINE bindVisualScriptLocalVar_set_var_type #-} bindVisualScriptLocalVar_set_var_type :: MethodBind bindVisualScriptLocalVar_set_var_type = unsafePerformIO $ withCString "VisualScriptLocalVar" $ \ clsNamePtr -> withCString "set_var_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_var_type :: (VisualScriptLocalVar :< cls, Object :< cls) => cls -> Int -> IO () set_var_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLocalVar_set_var_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLocalVar "set_var_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptLocalVar.set_var_type ================================================ FILE: src/Godot/Core/VisualScriptLocalVarSet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptLocalVarSet (Godot.Core.VisualScriptLocalVarSet.get_var_name, Godot.Core.VisualScriptLocalVarSet.get_var_type, Godot.Core.VisualScriptLocalVarSet.set_var_name, Godot.Core.VisualScriptLocalVarSet.set_var_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptLocalVarSet "type" Int 'False where nodeProperty = (get_var_type, wrapDroppingSetter set_var_type, Nothing) instance NodeProperty VisualScriptLocalVarSet "var_name" GodotString 'False where nodeProperty = (get_var_name, wrapDroppingSetter set_var_name, Nothing) {-# NOINLINE bindVisualScriptLocalVarSet_get_var_name #-} bindVisualScriptLocalVarSet_get_var_name :: MethodBind bindVisualScriptLocalVarSet_get_var_name = unsafePerformIO $ withCString "VisualScriptLocalVarSet" $ \ clsNamePtr -> withCString "get_var_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_var_name :: (VisualScriptLocalVarSet :< cls, Object :< cls) => cls -> IO GodotString get_var_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLocalVarSet_get_var_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLocalVarSet "get_var_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptLocalVarSet.get_var_name {-# NOINLINE bindVisualScriptLocalVarSet_get_var_type #-} bindVisualScriptLocalVarSet_get_var_type :: MethodBind bindVisualScriptLocalVarSet_get_var_type = unsafePerformIO $ withCString "VisualScriptLocalVarSet" $ \ clsNamePtr -> withCString "get_var_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_var_type :: (VisualScriptLocalVarSet :< cls, Object :< cls) => cls -> IO Int get_var_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLocalVarSet_get_var_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLocalVarSet "get_var_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptLocalVarSet.get_var_type {-# NOINLINE bindVisualScriptLocalVarSet_set_var_name #-} bindVisualScriptLocalVarSet_set_var_name :: MethodBind bindVisualScriptLocalVarSet_set_var_name = unsafePerformIO $ withCString "VisualScriptLocalVarSet" $ \ clsNamePtr -> withCString "set_var_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_var_name :: (VisualScriptLocalVarSet :< cls, Object :< cls) => cls -> GodotString -> IO () set_var_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLocalVarSet_set_var_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLocalVarSet "set_var_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptLocalVarSet.set_var_name {-# NOINLINE bindVisualScriptLocalVarSet_set_var_type #-} bindVisualScriptLocalVarSet_set_var_type :: MethodBind bindVisualScriptLocalVarSet_set_var_type = unsafePerformIO $ withCString "VisualScriptLocalVarSet" $ \ clsNamePtr -> withCString "set_var_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_var_type :: (VisualScriptLocalVarSet :< cls, Object :< cls) => cls -> Int -> IO () set_var_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptLocalVarSet_set_var_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptLocalVarSet "set_var_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptLocalVarSet.set_var_type ================================================ FILE: src/Godot/Core/VisualScriptMathConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptMathConstant (Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_INF, Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_MAX, Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_HALF_PI, Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_TAU, Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_NAN, Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_PI, Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_ONE, Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_SQRT2, Godot.Core.VisualScriptMathConstant._MATH_CONSTANT_E, Godot.Core.VisualScriptMathConstant.get_math_constant, Godot.Core.VisualScriptMathConstant.set_math_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _MATH_CONSTANT_INF :: Int _MATH_CONSTANT_INF = 6 _MATH_CONSTANT_MAX :: Int _MATH_CONSTANT_MAX = 8 _MATH_CONSTANT_HALF_PI :: Int _MATH_CONSTANT_HALF_PI = 2 _MATH_CONSTANT_TAU :: Int _MATH_CONSTANT_TAU = 3 _MATH_CONSTANT_NAN :: Int _MATH_CONSTANT_NAN = 7 _MATH_CONSTANT_PI :: Int _MATH_CONSTANT_PI = 1 _MATH_CONSTANT_ONE :: Int _MATH_CONSTANT_ONE = 0 _MATH_CONSTANT_SQRT2 :: Int _MATH_CONSTANT_SQRT2 = 5 _MATH_CONSTANT_E :: Int _MATH_CONSTANT_E = 4 instance NodeProperty VisualScriptMathConstant "constant" Int 'False where nodeProperty = (get_math_constant, wrapDroppingSetter set_math_constant, Nothing) {-# NOINLINE bindVisualScriptMathConstant_get_math_constant #-} bindVisualScriptMathConstant_get_math_constant :: MethodBind bindVisualScriptMathConstant_get_math_constant = unsafePerformIO $ withCString "VisualScriptMathConstant" $ \ clsNamePtr -> withCString "get_math_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_math_constant :: (VisualScriptMathConstant :< cls, Object :< cls) => cls -> IO Int get_math_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptMathConstant_get_math_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptMathConstant "get_math_constant" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptMathConstant.get_math_constant {-# NOINLINE bindVisualScriptMathConstant_set_math_constant #-} bindVisualScriptMathConstant_set_math_constant :: MethodBind bindVisualScriptMathConstant_set_math_constant = unsafePerformIO $ withCString "VisualScriptMathConstant" $ \ clsNamePtr -> withCString "set_math_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_math_constant :: (VisualScriptMathConstant :< cls, Object :< cls) => cls -> Int -> IO () set_math_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptMathConstant_set_math_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptMathConstant "set_math_constant" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptMathConstant.set_math_constant ================================================ FILE: src/Godot/Core/VisualScriptNode.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptNode (Godot.Core.VisualScriptNode.sig_ports_changed, Godot.Core.VisualScriptNode._get_default_input_values, Godot.Core.VisualScriptNode._set_default_input_values, Godot.Core.VisualScriptNode.get_default_input_value, Godot.Core.VisualScriptNode.get_visual_script, Godot.Core.VisualScriptNode.ports_changed_notify, Godot.Core.VisualScriptNode.set_default_input_value) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() sig_ports_changed :: Godot.Internal.Dispatch.Signal VisualScriptNode sig_ports_changed = Godot.Internal.Dispatch.Signal "ports_changed" instance NodeSignal VisualScriptNode "ports_changed" '[] instance NodeProperty VisualScriptNode "_default_input_values" Array 'False where nodeProperty = (_get_default_input_values, wrapDroppingSetter _set_default_input_values, Nothing) {-# NOINLINE bindVisualScriptNode__get_default_input_values #-} bindVisualScriptNode__get_default_input_values :: MethodBind bindVisualScriptNode__get_default_input_values = unsafePerformIO $ withCString "VisualScriptNode" $ \ clsNamePtr -> withCString "_get_default_input_values" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_default_input_values :: (VisualScriptNode :< cls, Object :< cls) => cls -> IO Array _get_default_input_values cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptNode__get_default_input_values (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptNode "_get_default_input_values" '[] (IO Array) where nodeMethod = Godot.Core.VisualScriptNode._get_default_input_values {-# NOINLINE bindVisualScriptNode__set_default_input_values #-} bindVisualScriptNode__set_default_input_values :: MethodBind bindVisualScriptNode__set_default_input_values = unsafePerformIO $ withCString "VisualScriptNode" $ \ clsNamePtr -> withCString "_set_default_input_values" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_default_input_values :: (VisualScriptNode :< cls, Object :< cls) => cls -> Array -> IO () _set_default_input_values cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptNode__set_default_input_values (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptNode "_set_default_input_values" '[Array] (IO ()) where nodeMethod = Godot.Core.VisualScriptNode._set_default_input_values {-# NOINLINE bindVisualScriptNode_get_default_input_value #-} bindVisualScriptNode_get_default_input_value :: MethodBind bindVisualScriptNode_get_default_input_value = unsafePerformIO $ withCString "VisualScriptNode" $ \ clsNamePtr -> withCString "get_default_input_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_default_input_value :: (VisualScriptNode :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_default_input_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptNode_get_default_input_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptNode "get_default_input_value" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.VisualScriptNode.get_default_input_value {-# NOINLINE bindVisualScriptNode_get_visual_script #-} bindVisualScriptNode_get_visual_script :: MethodBind bindVisualScriptNode_get_visual_script = unsafePerformIO $ withCString "VisualScriptNode" $ \ clsNamePtr -> withCString "get_visual_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_visual_script :: (VisualScriptNode :< cls, Object :< cls) => cls -> IO VisualScript get_visual_script cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptNode_get_visual_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptNode "get_visual_script" '[] (IO VisualScript) where nodeMethod = Godot.Core.VisualScriptNode.get_visual_script {-# NOINLINE bindVisualScriptNode_ports_changed_notify #-} bindVisualScriptNode_ports_changed_notify :: MethodBind bindVisualScriptNode_ports_changed_notify = unsafePerformIO $ withCString "VisualScriptNode" $ \ clsNamePtr -> withCString "ports_changed_notify" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr ports_changed_notify :: (VisualScriptNode :< cls, Object :< cls) => cls -> IO () ports_changed_notify cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptNode_ports_changed_notify (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptNode "ports_changed_notify" '[] (IO ()) where nodeMethod = Godot.Core.VisualScriptNode.ports_changed_notify {-# NOINLINE bindVisualScriptNode_set_default_input_value #-} bindVisualScriptNode_set_default_input_value :: MethodBind bindVisualScriptNode_set_default_input_value = unsafePerformIO $ withCString "VisualScriptNode" $ \ clsNamePtr -> withCString "set_default_input_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_default_input_value :: (VisualScriptNode :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_default_input_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptNode_set_default_input_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptNode "set_default_input_value" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.VisualScriptNode.set_default_input_value ================================================ FILE: src/Godot/Core/VisualScriptOperator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptOperator (Godot.Core.VisualScriptOperator.get_operator, Godot.Core.VisualScriptOperator.get_typed, Godot.Core.VisualScriptOperator.set_operator, Godot.Core.VisualScriptOperator.set_typed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptOperator "operator" Int 'False where nodeProperty = (get_operator, wrapDroppingSetter set_operator, Nothing) instance NodeProperty VisualScriptOperator "type" Int 'False where nodeProperty = (get_typed, wrapDroppingSetter set_typed, Nothing) {-# NOINLINE bindVisualScriptOperator_get_operator #-} bindVisualScriptOperator_get_operator :: MethodBind bindVisualScriptOperator_get_operator = unsafePerformIO $ withCString "VisualScriptOperator" $ \ clsNamePtr -> withCString "get_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_operator :: (VisualScriptOperator :< cls, Object :< cls) => cls -> IO Int get_operator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptOperator_get_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptOperator "get_operator" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptOperator.get_operator {-# NOINLINE bindVisualScriptOperator_get_typed #-} bindVisualScriptOperator_get_typed :: MethodBind bindVisualScriptOperator_get_typed = unsafePerformIO $ withCString "VisualScriptOperator" $ \ clsNamePtr -> withCString "get_typed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_typed :: (VisualScriptOperator :< cls, Object :< cls) => cls -> IO Int get_typed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptOperator_get_typed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptOperator "get_typed" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptOperator.get_typed {-# NOINLINE bindVisualScriptOperator_set_operator #-} bindVisualScriptOperator_set_operator :: MethodBind bindVisualScriptOperator_set_operator = unsafePerformIO $ withCString "VisualScriptOperator" $ \ clsNamePtr -> withCString "set_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_operator :: (VisualScriptOperator :< cls, Object :< cls) => cls -> Int -> IO () set_operator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptOperator_set_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptOperator "set_operator" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptOperator.set_operator {-# NOINLINE bindVisualScriptOperator_set_typed #-} bindVisualScriptOperator_set_typed :: MethodBind bindVisualScriptOperator_set_typed = unsafePerformIO $ withCString "VisualScriptOperator" $ \ clsNamePtr -> withCString "set_typed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_typed :: (VisualScriptOperator :< cls, Object :< cls) => cls -> Int -> IO () set_typed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptOperator_set_typed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptOperator "set_typed" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptOperator.set_typed ================================================ FILE: src/Godot/Core/VisualScriptPreload.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptPreload (Godot.Core.VisualScriptPreload.get_preload, Godot.Core.VisualScriptPreload.set_preload) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptPreload "resource" Resource 'False where nodeProperty = (get_preload, wrapDroppingSetter set_preload, Nothing) {-# NOINLINE bindVisualScriptPreload_get_preload #-} bindVisualScriptPreload_get_preload :: MethodBind bindVisualScriptPreload_get_preload = unsafePerformIO $ withCString "VisualScriptPreload" $ \ clsNamePtr -> withCString "get_preload" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_preload :: (VisualScriptPreload :< cls, Object :< cls) => cls -> IO Resource get_preload cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPreload_get_preload (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPreload "get_preload" '[] (IO Resource) where nodeMethod = Godot.Core.VisualScriptPreload.get_preload {-# NOINLINE bindVisualScriptPreload_set_preload #-} bindVisualScriptPreload_set_preload :: MethodBind bindVisualScriptPreload_set_preload = unsafePerformIO $ withCString "VisualScriptPreload" $ \ clsNamePtr -> withCString "set_preload" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_preload :: (VisualScriptPreload :< cls, Object :< cls) => cls -> Resource -> IO () set_preload cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPreload_set_preload (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPreload "set_preload" '[Resource] (IO ()) where nodeMethod = Godot.Core.VisualScriptPreload.set_preload ================================================ FILE: src/Godot/Core/VisualScriptPropertyGet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptPropertyGet (Godot.Core.VisualScriptPropertyGet._CALL_MODE_NODE_PATH, Godot.Core.VisualScriptPropertyGet._CALL_MODE_SELF, Godot.Core.VisualScriptPropertyGet._CALL_MODE_INSTANCE, Godot.Core.VisualScriptPropertyGet._get_type_cache, Godot.Core.VisualScriptPropertyGet._set_type_cache, Godot.Core.VisualScriptPropertyGet.get_base_path, Godot.Core.VisualScriptPropertyGet.get_base_script, Godot.Core.VisualScriptPropertyGet.get_base_type, Godot.Core.VisualScriptPropertyGet.get_basic_type, Godot.Core.VisualScriptPropertyGet.get_call_mode, Godot.Core.VisualScriptPropertyGet.get_index, Godot.Core.VisualScriptPropertyGet.get_property, Godot.Core.VisualScriptPropertyGet.set_base_path, Godot.Core.VisualScriptPropertyGet.set_base_script, Godot.Core.VisualScriptPropertyGet.set_base_type, Godot.Core.VisualScriptPropertyGet.set_basic_type, Godot.Core.VisualScriptPropertyGet.set_call_mode, Godot.Core.VisualScriptPropertyGet.set_index, Godot.Core.VisualScriptPropertyGet.set_property) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _CALL_MODE_NODE_PATH :: Int _CALL_MODE_NODE_PATH = 1 _CALL_MODE_SELF :: Int _CALL_MODE_SELF = 0 _CALL_MODE_INSTANCE :: Int _CALL_MODE_INSTANCE = 2 instance NodeProperty VisualScriptPropertyGet "base_script" GodotString 'False where nodeProperty = (get_base_script, wrapDroppingSetter set_base_script, Nothing) instance NodeProperty VisualScriptPropertyGet "base_type" GodotString 'False where nodeProperty = (get_base_type, wrapDroppingSetter set_base_type, Nothing) instance NodeProperty VisualScriptPropertyGet "basic_type" Int 'False where nodeProperty = (get_basic_type, wrapDroppingSetter set_basic_type, Nothing) instance NodeProperty VisualScriptPropertyGet "index" GodotString 'False where nodeProperty = (get_index, wrapDroppingSetter set_index, Nothing) instance NodeProperty VisualScriptPropertyGet "node_path" NodePath 'False where nodeProperty = (get_base_path, wrapDroppingSetter set_base_path, Nothing) instance NodeProperty VisualScriptPropertyGet "property" GodotString 'False where nodeProperty = (get_property, wrapDroppingSetter set_property, Nothing) instance NodeProperty VisualScriptPropertyGet "set_mode" Int 'False where nodeProperty = (get_call_mode, wrapDroppingSetter set_call_mode, Nothing) instance NodeProperty VisualScriptPropertyGet "type_cache" Int 'False where nodeProperty = (_get_type_cache, wrapDroppingSetter _set_type_cache, Nothing) {-# NOINLINE bindVisualScriptPropertyGet__get_type_cache #-} bindVisualScriptPropertyGet__get_type_cache :: MethodBind bindVisualScriptPropertyGet__get_type_cache = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "_get_type_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_type_cache :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> IO Int _get_type_cache cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet__get_type_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "_get_type_cache" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptPropertyGet._get_type_cache {-# NOINLINE bindVisualScriptPropertyGet__set_type_cache #-} bindVisualScriptPropertyGet__set_type_cache :: MethodBind bindVisualScriptPropertyGet__set_type_cache = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "_set_type_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_type_cache :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> Int -> IO () _set_type_cache cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet__set_type_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "_set_type_cache" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertyGet._set_type_cache {-# NOINLINE bindVisualScriptPropertyGet_get_base_path #-} bindVisualScriptPropertyGet_get_base_path :: MethodBind bindVisualScriptPropertyGet_get_base_path = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "get_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_path :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> IO NodePath get_base_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_get_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "get_base_path" '[] (IO NodePath) where nodeMethod = Godot.Core.VisualScriptPropertyGet.get_base_path {-# NOINLINE bindVisualScriptPropertyGet_get_base_script #-} bindVisualScriptPropertyGet_get_base_script :: MethodBind bindVisualScriptPropertyGet_get_base_script = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "get_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_script :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> IO GodotString get_base_script cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_get_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "get_base_script" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptPropertyGet.get_base_script {-# NOINLINE bindVisualScriptPropertyGet_get_base_type #-} bindVisualScriptPropertyGet_get_base_type :: MethodBind bindVisualScriptPropertyGet_get_base_type = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "get_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_type :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> IO GodotString get_base_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_get_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "get_base_type" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptPropertyGet.get_base_type {-# NOINLINE bindVisualScriptPropertyGet_get_basic_type #-} bindVisualScriptPropertyGet_get_basic_type :: MethodBind bindVisualScriptPropertyGet_get_basic_type = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "get_basic_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_basic_type :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> IO Int get_basic_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_get_basic_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "get_basic_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptPropertyGet.get_basic_type {-# NOINLINE bindVisualScriptPropertyGet_get_call_mode #-} bindVisualScriptPropertyGet_get_call_mode :: MethodBind bindVisualScriptPropertyGet_get_call_mode = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "get_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_call_mode :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> IO Int get_call_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_get_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "get_call_mode" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptPropertyGet.get_call_mode {-# NOINLINE bindVisualScriptPropertyGet_get_index #-} bindVisualScriptPropertyGet_get_index :: MethodBind bindVisualScriptPropertyGet_get_index = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "get_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_index :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> IO GodotString get_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_get_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "get_index" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptPropertyGet.get_index {-# NOINLINE bindVisualScriptPropertyGet_get_property #-} bindVisualScriptPropertyGet_get_property :: MethodBind bindVisualScriptPropertyGet_get_property = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "get_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_property :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> IO GodotString get_property cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_get_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "get_property" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptPropertyGet.get_property {-# NOINLINE bindVisualScriptPropertyGet_set_base_path #-} bindVisualScriptPropertyGet_set_base_path :: MethodBind bindVisualScriptPropertyGet_set_base_path = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "set_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_path :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> NodePath -> IO () set_base_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_set_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "set_base_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertyGet.set_base_path {-# NOINLINE bindVisualScriptPropertyGet_set_base_script #-} bindVisualScriptPropertyGet_set_base_script :: MethodBind bindVisualScriptPropertyGet_set_base_script = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "set_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_script :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_script cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_set_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "set_base_script" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertyGet.set_base_script {-# NOINLINE bindVisualScriptPropertyGet_set_base_type #-} bindVisualScriptPropertyGet_set_base_type :: MethodBind bindVisualScriptPropertyGet_set_base_type = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "set_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_type :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_set_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "set_base_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertyGet.set_base_type {-# NOINLINE bindVisualScriptPropertyGet_set_basic_type #-} bindVisualScriptPropertyGet_set_basic_type :: MethodBind bindVisualScriptPropertyGet_set_basic_type = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "set_basic_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_basic_type :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> Int -> IO () set_basic_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_set_basic_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "set_basic_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertyGet.set_basic_type {-# NOINLINE bindVisualScriptPropertyGet_set_call_mode #-} bindVisualScriptPropertyGet_set_call_mode :: MethodBind bindVisualScriptPropertyGet_set_call_mode = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "set_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_call_mode :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> Int -> IO () set_call_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_set_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "set_call_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertyGet.set_call_mode {-# NOINLINE bindVisualScriptPropertyGet_set_index #-} bindVisualScriptPropertyGet_set_index :: MethodBind bindVisualScriptPropertyGet_set_index = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "set_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_index :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> GodotString -> IO () set_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_set_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "set_index" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertyGet.set_index {-# NOINLINE bindVisualScriptPropertyGet_set_property #-} bindVisualScriptPropertyGet_set_property :: MethodBind bindVisualScriptPropertyGet_set_property = unsafePerformIO $ withCString "VisualScriptPropertyGet" $ \ clsNamePtr -> withCString "set_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_property :: (VisualScriptPropertyGet :< cls, Object :< cls) => cls -> GodotString -> IO () set_property cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertyGet_set_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertyGet "set_property" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertyGet.set_property ================================================ FILE: src/Godot/Core/VisualScriptPropertySet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptPropertySet (Godot.Core.VisualScriptPropertySet._CALL_MODE_BASIC_TYPE, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_SHIFT_LEFT, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_DIV, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_MOD, Godot.Core.VisualScriptPropertySet._CALL_MODE_NODE_PATH, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_BIT_OR, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_SHIFT_RIGHT, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_NONE, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_ADD, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_MUL, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_SUB, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_BIT_AND, Godot.Core.VisualScriptPropertySet._CALL_MODE_SELF, Godot.Core.VisualScriptPropertySet._CALL_MODE_INSTANCE, Godot.Core.VisualScriptPropertySet._ASSIGN_OP_BIT_XOR, Godot.Core.VisualScriptPropertySet._get_type_cache, Godot.Core.VisualScriptPropertySet._set_type_cache, Godot.Core.VisualScriptPropertySet.get_assign_op, Godot.Core.VisualScriptPropertySet.get_base_path, Godot.Core.VisualScriptPropertySet.get_base_script, Godot.Core.VisualScriptPropertySet.get_base_type, Godot.Core.VisualScriptPropertySet.get_basic_type, Godot.Core.VisualScriptPropertySet.get_call_mode, Godot.Core.VisualScriptPropertySet.get_index, Godot.Core.VisualScriptPropertySet.get_property, Godot.Core.VisualScriptPropertySet.set_assign_op, Godot.Core.VisualScriptPropertySet.set_base_path, Godot.Core.VisualScriptPropertySet.set_base_script, Godot.Core.VisualScriptPropertySet.set_base_type, Godot.Core.VisualScriptPropertySet.set_basic_type, Godot.Core.VisualScriptPropertySet.set_call_mode, Godot.Core.VisualScriptPropertySet.set_index, Godot.Core.VisualScriptPropertySet.set_property) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _CALL_MODE_BASIC_TYPE :: Int _CALL_MODE_BASIC_TYPE = 3 _ASSIGN_OP_SHIFT_LEFT :: Int _ASSIGN_OP_SHIFT_LEFT = 6 _ASSIGN_OP_DIV :: Int _ASSIGN_OP_DIV = 4 _ASSIGN_OP_MOD :: Int _ASSIGN_OP_MOD = 5 _CALL_MODE_NODE_PATH :: Int _CALL_MODE_NODE_PATH = 1 _ASSIGN_OP_BIT_OR :: Int _ASSIGN_OP_BIT_OR = 9 _ASSIGN_OP_SHIFT_RIGHT :: Int _ASSIGN_OP_SHIFT_RIGHT = 7 _ASSIGN_OP_NONE :: Int _ASSIGN_OP_NONE = 0 _ASSIGN_OP_ADD :: Int _ASSIGN_OP_ADD = 1 _ASSIGN_OP_MUL :: Int _ASSIGN_OP_MUL = 3 _ASSIGN_OP_SUB :: Int _ASSIGN_OP_SUB = 2 _ASSIGN_OP_BIT_AND :: Int _ASSIGN_OP_BIT_AND = 8 _CALL_MODE_SELF :: Int _CALL_MODE_SELF = 0 _CALL_MODE_INSTANCE :: Int _CALL_MODE_INSTANCE = 2 _ASSIGN_OP_BIT_XOR :: Int _ASSIGN_OP_BIT_XOR = 10 instance NodeProperty VisualScriptPropertySet "assign_op" Int 'False where nodeProperty = (get_assign_op, wrapDroppingSetter set_assign_op, Nothing) instance NodeProperty VisualScriptPropertySet "base_script" GodotString 'False where nodeProperty = (get_base_script, wrapDroppingSetter set_base_script, Nothing) instance NodeProperty VisualScriptPropertySet "base_type" GodotString 'False where nodeProperty = (get_base_type, wrapDroppingSetter set_base_type, Nothing) instance NodeProperty VisualScriptPropertySet "basic_type" Int 'False where nodeProperty = (get_basic_type, wrapDroppingSetter set_basic_type, Nothing) instance NodeProperty VisualScriptPropertySet "index" GodotString 'False where nodeProperty = (get_index, wrapDroppingSetter set_index, Nothing) instance NodeProperty VisualScriptPropertySet "node_path" NodePath 'False where nodeProperty = (get_base_path, wrapDroppingSetter set_base_path, Nothing) instance NodeProperty VisualScriptPropertySet "property" GodotString 'False where nodeProperty = (get_property, wrapDroppingSetter set_property, Nothing) instance NodeProperty VisualScriptPropertySet "set_mode" Int 'False where nodeProperty = (get_call_mode, wrapDroppingSetter set_call_mode, Nothing) instance NodeProperty VisualScriptPropertySet "type_cache" Dictionary 'False where nodeProperty = (_get_type_cache, wrapDroppingSetter _set_type_cache, Nothing) {-# NOINLINE bindVisualScriptPropertySet__get_type_cache #-} bindVisualScriptPropertySet__get_type_cache :: MethodBind bindVisualScriptPropertySet__get_type_cache = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "_get_type_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_type_cache :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO Dictionary _get_type_cache cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet__get_type_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "_get_type_cache" '[] (IO Dictionary) where nodeMethod = Godot.Core.VisualScriptPropertySet._get_type_cache {-# NOINLINE bindVisualScriptPropertySet__set_type_cache #-} bindVisualScriptPropertySet__set_type_cache :: MethodBind bindVisualScriptPropertySet__set_type_cache = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "_set_type_cache" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_type_cache :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> Dictionary -> IO () _set_type_cache cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet__set_type_cache (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "_set_type_cache" '[Dictionary] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet._set_type_cache {-# NOINLINE bindVisualScriptPropertySet_get_assign_op #-} bindVisualScriptPropertySet_get_assign_op :: MethodBind bindVisualScriptPropertySet_get_assign_op = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "get_assign_op" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_assign_op :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO Int get_assign_op cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_get_assign_op (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "get_assign_op" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptPropertySet.get_assign_op {-# NOINLINE bindVisualScriptPropertySet_get_base_path #-} bindVisualScriptPropertySet_get_base_path :: MethodBind bindVisualScriptPropertySet_get_base_path = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "get_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_path :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO NodePath get_base_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_get_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "get_base_path" '[] (IO NodePath) where nodeMethod = Godot.Core.VisualScriptPropertySet.get_base_path {-# NOINLINE bindVisualScriptPropertySet_get_base_script #-} bindVisualScriptPropertySet_get_base_script :: MethodBind bindVisualScriptPropertySet_get_base_script = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "get_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_script :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO GodotString get_base_script cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_get_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "get_base_script" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptPropertySet.get_base_script {-# NOINLINE bindVisualScriptPropertySet_get_base_type #-} bindVisualScriptPropertySet_get_base_type :: MethodBind bindVisualScriptPropertySet_get_base_type = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "get_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_type :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO GodotString get_base_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_get_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "get_base_type" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptPropertySet.get_base_type {-# NOINLINE bindVisualScriptPropertySet_get_basic_type #-} bindVisualScriptPropertySet_get_basic_type :: MethodBind bindVisualScriptPropertySet_get_basic_type = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "get_basic_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_basic_type :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO Int get_basic_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_get_basic_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "get_basic_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptPropertySet.get_basic_type {-# NOINLINE bindVisualScriptPropertySet_get_call_mode #-} bindVisualScriptPropertySet_get_call_mode :: MethodBind bindVisualScriptPropertySet_get_call_mode = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "get_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_call_mode :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO Int get_call_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_get_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "get_call_mode" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptPropertySet.get_call_mode {-# NOINLINE bindVisualScriptPropertySet_get_index #-} bindVisualScriptPropertySet_get_index :: MethodBind bindVisualScriptPropertySet_get_index = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "get_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_index :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO GodotString get_index cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_get_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "get_index" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptPropertySet.get_index {-# NOINLINE bindVisualScriptPropertySet_get_property #-} bindVisualScriptPropertySet_get_property :: MethodBind bindVisualScriptPropertySet_get_property = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "get_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_property :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> IO GodotString get_property cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_get_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "get_property" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptPropertySet.get_property {-# NOINLINE bindVisualScriptPropertySet_set_assign_op #-} bindVisualScriptPropertySet_set_assign_op :: MethodBind bindVisualScriptPropertySet_set_assign_op = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "set_assign_op" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_assign_op :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> Int -> IO () set_assign_op cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_set_assign_op (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "set_assign_op" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet.set_assign_op {-# NOINLINE bindVisualScriptPropertySet_set_base_path #-} bindVisualScriptPropertySet_set_base_path :: MethodBind bindVisualScriptPropertySet_set_base_path = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "set_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_path :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> NodePath -> IO () set_base_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_set_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "set_base_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet.set_base_path {-# NOINLINE bindVisualScriptPropertySet_set_base_script #-} bindVisualScriptPropertySet_set_base_script :: MethodBind bindVisualScriptPropertySet_set_base_script = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "set_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_script :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_script cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_set_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "set_base_script" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet.set_base_script {-# NOINLINE bindVisualScriptPropertySet_set_base_type #-} bindVisualScriptPropertySet_set_base_type :: MethodBind bindVisualScriptPropertySet_set_base_type = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "set_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_type :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_set_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "set_base_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet.set_base_type {-# NOINLINE bindVisualScriptPropertySet_set_basic_type #-} bindVisualScriptPropertySet_set_basic_type :: MethodBind bindVisualScriptPropertySet_set_basic_type = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "set_basic_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_basic_type :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> Int -> IO () set_basic_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_set_basic_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "set_basic_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet.set_basic_type {-# NOINLINE bindVisualScriptPropertySet_set_call_mode #-} bindVisualScriptPropertySet_set_call_mode :: MethodBind bindVisualScriptPropertySet_set_call_mode = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "set_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_call_mode :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> Int -> IO () set_call_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_set_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "set_call_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet.set_call_mode {-# NOINLINE bindVisualScriptPropertySet_set_index #-} bindVisualScriptPropertySet_set_index :: MethodBind bindVisualScriptPropertySet_set_index = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "set_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_index :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> GodotString -> IO () set_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_set_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "set_index" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet.set_index {-# NOINLINE bindVisualScriptPropertySet_set_property #-} bindVisualScriptPropertySet_set_property :: MethodBind bindVisualScriptPropertySet_set_property = unsafePerformIO $ withCString "VisualScriptPropertySet" $ \ clsNamePtr -> withCString "set_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_property :: (VisualScriptPropertySet :< cls, Object :< cls) => cls -> GodotString -> IO () set_property cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptPropertySet_set_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptPropertySet "set_property" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptPropertySet.set_property ================================================ FILE: src/Godot/Core/VisualScriptResourcePath.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptResourcePath (Godot.Core.VisualScriptResourcePath.get_resource_path, Godot.Core.VisualScriptResourcePath.set_resource_path) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptResourcePath "path" GodotString 'False where nodeProperty = (get_resource_path, wrapDroppingSetter set_resource_path, Nothing) {-# NOINLINE bindVisualScriptResourcePath_get_resource_path #-} bindVisualScriptResourcePath_get_resource_path :: MethodBind bindVisualScriptResourcePath_get_resource_path = unsafePerformIO $ withCString "VisualScriptResourcePath" $ \ clsNamePtr -> withCString "get_resource_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_resource_path :: (VisualScriptResourcePath :< cls, Object :< cls) => cls -> IO GodotString get_resource_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptResourcePath_get_resource_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptResourcePath "get_resource_path" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptResourcePath.get_resource_path {-# NOINLINE bindVisualScriptResourcePath_set_resource_path #-} bindVisualScriptResourcePath_set_resource_path :: MethodBind bindVisualScriptResourcePath_set_resource_path = unsafePerformIO $ withCString "VisualScriptResourcePath" $ \ clsNamePtr -> withCString "set_resource_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_resource_path :: (VisualScriptResourcePath :< cls, Object :< cls) => cls -> GodotString -> IO () set_resource_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptResourcePath_set_resource_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptResourcePath "set_resource_path" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptResourcePath.set_resource_path ================================================ FILE: src/Godot/Core/VisualScriptReturn.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptReturn (Godot.Core.VisualScriptReturn.get_return_type, Godot.Core.VisualScriptReturn.is_return_value_enabled, Godot.Core.VisualScriptReturn.set_enable_return_value, Godot.Core.VisualScriptReturn.set_return_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptReturn "return_enabled" Bool 'False where nodeProperty = (is_return_value_enabled, wrapDroppingSetter set_enable_return_value, Nothing) instance NodeProperty VisualScriptReturn "return_type" Int 'False where nodeProperty = (get_return_type, wrapDroppingSetter set_return_type, Nothing) {-# NOINLINE bindVisualScriptReturn_get_return_type #-} bindVisualScriptReturn_get_return_type :: MethodBind bindVisualScriptReturn_get_return_type = unsafePerformIO $ withCString "VisualScriptReturn" $ \ clsNamePtr -> withCString "get_return_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_return_type :: (VisualScriptReturn :< cls, Object :< cls) => cls -> IO Int get_return_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptReturn_get_return_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptReturn "get_return_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptReturn.get_return_type {-# NOINLINE bindVisualScriptReturn_is_return_value_enabled #-} bindVisualScriptReturn_is_return_value_enabled :: MethodBind bindVisualScriptReturn_is_return_value_enabled = unsafePerformIO $ withCString "VisualScriptReturn" $ \ clsNamePtr -> withCString "is_return_value_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_return_value_enabled :: (VisualScriptReturn :< cls, Object :< cls) => cls -> IO Bool is_return_value_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptReturn_is_return_value_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptReturn "is_return_value_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.VisualScriptReturn.is_return_value_enabled {-# NOINLINE bindVisualScriptReturn_set_enable_return_value #-} bindVisualScriptReturn_set_enable_return_value :: MethodBind bindVisualScriptReturn_set_enable_return_value = unsafePerformIO $ withCString "VisualScriptReturn" $ \ clsNamePtr -> withCString "set_enable_return_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_enable_return_value :: (VisualScriptReturn :< cls, Object :< cls) => cls -> Bool -> IO () set_enable_return_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptReturn_set_enable_return_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptReturn "set_enable_return_value" '[Bool] (IO ()) where nodeMethod = Godot.Core.VisualScriptReturn.set_enable_return_value {-# NOINLINE bindVisualScriptReturn_set_return_type #-} bindVisualScriptReturn_set_return_type :: MethodBind bindVisualScriptReturn_set_return_type = unsafePerformIO $ withCString "VisualScriptReturn" $ \ clsNamePtr -> withCString "set_return_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_return_type :: (VisualScriptReturn :< cls, Object :< cls) => cls -> Int -> IO () set_return_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptReturn_set_return_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptReturn "set_return_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptReturn.set_return_type ================================================ FILE: src/Godot/Core/VisualScriptSceneNode.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptSceneNode (Godot.Core.VisualScriptSceneNode.get_node_path, Godot.Core.VisualScriptSceneNode.set_node_path) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptSceneNode "node_path" NodePath 'False where nodeProperty = (get_node_path, wrapDroppingSetter set_node_path, Nothing) {-# NOINLINE bindVisualScriptSceneNode_get_node_path #-} bindVisualScriptSceneNode_get_node_path :: MethodBind bindVisualScriptSceneNode_get_node_path = unsafePerformIO $ withCString "VisualScriptSceneNode" $ \ clsNamePtr -> withCString "get_node_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_node_path :: (VisualScriptSceneNode :< cls, Object :< cls) => cls -> IO NodePath get_node_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptSceneNode_get_node_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptSceneNode "get_node_path" '[] (IO NodePath) where nodeMethod = Godot.Core.VisualScriptSceneNode.get_node_path {-# NOINLINE bindVisualScriptSceneNode_set_node_path #-} bindVisualScriptSceneNode_set_node_path :: MethodBind bindVisualScriptSceneNode_set_node_path = unsafePerformIO $ withCString "VisualScriptSceneNode" $ \ clsNamePtr -> withCString "set_node_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_node_path :: (VisualScriptSceneNode :< cls, Object :< cls) => cls -> NodePath -> IO () set_node_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptSceneNode_set_node_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptSceneNode "set_node_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.VisualScriptSceneNode.set_node_path ================================================ FILE: src/Godot/Core/VisualScriptSceneTree.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptSceneTree () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptSelect.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptSelect (Godot.Core.VisualScriptSelect.get_typed, Godot.Core.VisualScriptSelect.set_typed) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptSelect "type" Int 'False where nodeProperty = (get_typed, wrapDroppingSetter set_typed, Nothing) {-# NOINLINE bindVisualScriptSelect_get_typed #-} bindVisualScriptSelect_get_typed :: MethodBind bindVisualScriptSelect_get_typed = unsafePerformIO $ withCString "VisualScriptSelect" $ \ clsNamePtr -> withCString "get_typed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_typed :: (VisualScriptSelect :< cls, Object :< cls) => cls -> IO Int get_typed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptSelect_get_typed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptSelect "get_typed" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptSelect.get_typed {-# NOINLINE bindVisualScriptSelect_set_typed #-} bindVisualScriptSelect_set_typed :: MethodBind bindVisualScriptSelect_set_typed = unsafePerformIO $ withCString "VisualScriptSelect" $ \ clsNamePtr -> withCString "set_typed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_typed :: (VisualScriptSelect :< cls, Object :< cls) => cls -> Int -> IO () set_typed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptSelect_set_typed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptSelect "set_typed" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptSelect.set_typed ================================================ FILE: src/Godot/Core/VisualScriptSelf.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptSelf () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptSequence.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptSequence (Godot.Core.VisualScriptSequence.get_steps, Godot.Core.VisualScriptSequence.set_steps) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptSequence "steps" Int 'False where nodeProperty = (get_steps, wrapDroppingSetter set_steps, Nothing) {-# NOINLINE bindVisualScriptSequence_get_steps #-} bindVisualScriptSequence_get_steps :: MethodBind bindVisualScriptSequence_get_steps = unsafePerformIO $ withCString "VisualScriptSequence" $ \ clsNamePtr -> withCString "get_steps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_steps :: (VisualScriptSequence :< cls, Object :< cls) => cls -> IO Int get_steps cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptSequence_get_steps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptSequence "get_steps" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptSequence.get_steps {-# NOINLINE bindVisualScriptSequence_set_steps #-} bindVisualScriptSequence_set_steps :: MethodBind bindVisualScriptSequence_set_steps = unsafePerformIO $ withCString "VisualScriptSequence" $ \ clsNamePtr -> withCString "set_steps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_steps :: (VisualScriptSequence :< cls, Object :< cls) => cls -> Int -> IO () set_steps cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptSequence_set_steps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptSequence "set_steps" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptSequence.set_steps ================================================ FILE: src/Godot/Core/VisualScriptSubCall.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptSubCall (Godot.Core.VisualScriptSubCall._subcall) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() {-# NOINLINE bindVisualScriptSubCall__subcall #-} bindVisualScriptSubCall__subcall :: MethodBind bindVisualScriptSubCall__subcall = unsafePerformIO $ withCString "VisualScriptSubCall" $ \ clsNamePtr -> withCString "_subcall" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _subcall :: (VisualScriptSubCall :< cls, Object :< cls) => cls -> GodotVariant -> IO GodotVariant _subcall cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptSubCall__subcall (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptSubCall "_subcall" '[GodotVariant] (IO GodotVariant) where nodeMethod = Godot.Core.VisualScriptSubCall._subcall ================================================ FILE: src/Godot/Core/VisualScriptSwitch.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptSwitch () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptTypeCast.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptTypeCast (Godot.Core.VisualScriptTypeCast.get_base_script, Godot.Core.VisualScriptTypeCast.get_base_type, Godot.Core.VisualScriptTypeCast.set_base_script, Godot.Core.VisualScriptTypeCast.set_base_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptTypeCast "base_script" GodotString 'False where nodeProperty = (get_base_script, wrapDroppingSetter set_base_script, Nothing) instance NodeProperty VisualScriptTypeCast "base_type" GodotString 'False where nodeProperty = (get_base_type, wrapDroppingSetter set_base_type, Nothing) {-# NOINLINE bindVisualScriptTypeCast_get_base_script #-} bindVisualScriptTypeCast_get_base_script :: MethodBind bindVisualScriptTypeCast_get_base_script = unsafePerformIO $ withCString "VisualScriptTypeCast" $ \ clsNamePtr -> withCString "get_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_script :: (VisualScriptTypeCast :< cls, Object :< cls) => cls -> IO GodotString get_base_script cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptTypeCast_get_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptTypeCast "get_base_script" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptTypeCast.get_base_script {-# NOINLINE bindVisualScriptTypeCast_get_base_type #-} bindVisualScriptTypeCast_get_base_type :: MethodBind bindVisualScriptTypeCast_get_base_type = unsafePerformIO $ withCString "VisualScriptTypeCast" $ \ clsNamePtr -> withCString "get_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_type :: (VisualScriptTypeCast :< cls, Object :< cls) => cls -> IO GodotString get_base_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptTypeCast_get_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptTypeCast "get_base_type" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptTypeCast.get_base_type {-# NOINLINE bindVisualScriptTypeCast_set_base_script #-} bindVisualScriptTypeCast_set_base_script :: MethodBind bindVisualScriptTypeCast_set_base_script = unsafePerformIO $ withCString "VisualScriptTypeCast" $ \ clsNamePtr -> withCString "set_base_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_script :: (VisualScriptTypeCast :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_script cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptTypeCast_set_base_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptTypeCast "set_base_script" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptTypeCast.set_base_script {-# NOINLINE bindVisualScriptTypeCast_set_base_type #-} bindVisualScriptTypeCast_set_base_type :: MethodBind bindVisualScriptTypeCast_set_base_type = unsafePerformIO $ withCString "VisualScriptTypeCast" $ \ clsNamePtr -> withCString "set_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_type :: (VisualScriptTypeCast :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptTypeCast_set_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptTypeCast "set_base_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptTypeCast.set_base_type ================================================ FILE: src/Godot/Core/VisualScriptVariableGet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptVariableGet (Godot.Core.VisualScriptVariableGet.get_variable, Godot.Core.VisualScriptVariableGet.set_variable) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptVariableGet "var_name" GodotString 'False where nodeProperty = (get_variable, wrapDroppingSetter set_variable, Nothing) {-# NOINLINE bindVisualScriptVariableGet_get_variable #-} bindVisualScriptVariableGet_get_variable :: MethodBind bindVisualScriptVariableGet_get_variable = unsafePerformIO $ withCString "VisualScriptVariableGet" $ \ clsNamePtr -> withCString "get_variable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_variable :: (VisualScriptVariableGet :< cls, Object :< cls) => cls -> IO GodotString get_variable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptVariableGet_get_variable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptVariableGet "get_variable" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptVariableGet.get_variable {-# NOINLINE bindVisualScriptVariableGet_set_variable #-} bindVisualScriptVariableGet_set_variable :: MethodBind bindVisualScriptVariableGet_set_variable = unsafePerformIO $ withCString "VisualScriptVariableGet" $ \ clsNamePtr -> withCString "set_variable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_variable :: (VisualScriptVariableGet :< cls, Object :< cls) => cls -> GodotString -> IO () set_variable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptVariableGet_set_variable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptVariableGet "set_variable" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptVariableGet.set_variable ================================================ FILE: src/Godot/Core/VisualScriptVariableSet.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptVariableSet (Godot.Core.VisualScriptVariableSet.get_variable, Godot.Core.VisualScriptVariableSet.set_variable) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() instance NodeProperty VisualScriptVariableSet "var_name" GodotString 'False where nodeProperty = (get_variable, wrapDroppingSetter set_variable, Nothing) {-# NOINLINE bindVisualScriptVariableSet_get_variable #-} bindVisualScriptVariableSet_get_variable :: MethodBind bindVisualScriptVariableSet_get_variable = unsafePerformIO $ withCString "VisualScriptVariableSet" $ \ clsNamePtr -> withCString "get_variable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_variable :: (VisualScriptVariableSet :< cls, Object :< cls) => cls -> IO GodotString get_variable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptVariableSet_get_variable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptVariableSet "get_variable" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptVariableSet.get_variable {-# NOINLINE bindVisualScriptVariableSet_set_variable #-} bindVisualScriptVariableSet_set_variable :: MethodBind bindVisualScriptVariableSet_set_variable = unsafePerformIO $ withCString "VisualScriptVariableSet" $ \ clsNamePtr -> withCString "set_variable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_variable :: (VisualScriptVariableSet :< cls, Object :< cls) => cls -> GodotString -> IO () set_variable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptVariableSet_set_variable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptVariableSet "set_variable" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptVariableSet.set_variable ================================================ FILE: src/Godot/Core/VisualScriptWhile.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptWhile () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() ================================================ FILE: src/Godot/Core/VisualScriptYield.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptYield (Godot.Core.VisualScriptYield._YIELD_FRAME, Godot.Core.VisualScriptYield._YIELD_PHYSICS_FRAME, Godot.Core.VisualScriptYield._YIELD_WAIT, Godot.Core.VisualScriptYield.get_wait_time, Godot.Core.VisualScriptYield.get_yield_mode, Godot.Core.VisualScriptYield.set_wait_time, Godot.Core.VisualScriptYield.set_yield_mode) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _YIELD_FRAME :: Int _YIELD_FRAME = 1 _YIELD_PHYSICS_FRAME :: Int _YIELD_PHYSICS_FRAME = 2 _YIELD_WAIT :: Int _YIELD_WAIT = 3 instance NodeProperty VisualScriptYield "mode" Int 'False where nodeProperty = (get_yield_mode, wrapDroppingSetter set_yield_mode, Nothing) instance NodeProperty VisualScriptYield "wait_time" Float 'False where nodeProperty = (get_wait_time, wrapDroppingSetter set_wait_time, Nothing) {-# NOINLINE bindVisualScriptYield_get_wait_time #-} bindVisualScriptYield_get_wait_time :: MethodBind bindVisualScriptYield_get_wait_time = unsafePerformIO $ withCString "VisualScriptYield" $ \ clsNamePtr -> withCString "get_wait_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_wait_time :: (VisualScriptYield :< cls, Object :< cls) => cls -> IO Float get_wait_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYield_get_wait_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYield "get_wait_time" '[] (IO Float) where nodeMethod = Godot.Core.VisualScriptYield.get_wait_time {-# NOINLINE bindVisualScriptYield_get_yield_mode #-} bindVisualScriptYield_get_yield_mode :: MethodBind bindVisualScriptYield_get_yield_mode = unsafePerformIO $ withCString "VisualScriptYield" $ \ clsNamePtr -> withCString "get_yield_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_yield_mode :: (VisualScriptYield :< cls, Object :< cls) => cls -> IO Int get_yield_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYield_get_yield_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYield "get_yield_mode" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptYield.get_yield_mode {-# NOINLINE bindVisualScriptYield_set_wait_time #-} bindVisualScriptYield_set_wait_time :: MethodBind bindVisualScriptYield_set_wait_time = unsafePerformIO $ withCString "VisualScriptYield" $ \ clsNamePtr -> withCString "set_wait_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_wait_time :: (VisualScriptYield :< cls, Object :< cls) => cls -> Float -> IO () set_wait_time cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYield_set_wait_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYield "set_wait_time" '[Float] (IO ()) where nodeMethod = Godot.Core.VisualScriptYield.set_wait_time {-# NOINLINE bindVisualScriptYield_set_yield_mode #-} bindVisualScriptYield_set_yield_mode :: MethodBind bindVisualScriptYield_set_yield_mode = unsafePerformIO $ withCString "VisualScriptYield" $ \ clsNamePtr -> withCString "set_yield_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_yield_mode :: (VisualScriptYield :< cls, Object :< cls) => cls -> Int -> IO () set_yield_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYield_set_yield_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYield "set_yield_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptYield.set_yield_mode ================================================ FILE: src/Godot/Core/VisualScriptYieldSignal.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualScriptYieldSignal (Godot.Core.VisualScriptYieldSignal._CALL_MODE_NODE_PATH, Godot.Core.VisualScriptYieldSignal._CALL_MODE_SELF, Godot.Core.VisualScriptYieldSignal._CALL_MODE_INSTANCE, Godot.Core.VisualScriptYieldSignal.get_base_path, Godot.Core.VisualScriptYieldSignal.get_base_type, Godot.Core.VisualScriptYieldSignal.get_call_mode, Godot.Core.VisualScriptYieldSignal.get_signal, Godot.Core.VisualScriptYieldSignal.set_base_path, Godot.Core.VisualScriptYieldSignal.set_base_type, Godot.Core.VisualScriptYieldSignal.set_call_mode, Godot.Core.VisualScriptYieldSignal.set_signal) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualScriptNode() _CALL_MODE_NODE_PATH :: Int _CALL_MODE_NODE_PATH = 1 _CALL_MODE_SELF :: Int _CALL_MODE_SELF = 0 _CALL_MODE_INSTANCE :: Int _CALL_MODE_INSTANCE = 2 instance NodeProperty VisualScriptYieldSignal "base_type" GodotString 'False where nodeProperty = (get_base_type, wrapDroppingSetter set_base_type, Nothing) instance NodeProperty VisualScriptYieldSignal "call_mode" Int 'False where nodeProperty = (get_call_mode, wrapDroppingSetter set_call_mode, Nothing) instance NodeProperty VisualScriptYieldSignal "node_path" NodePath 'False where nodeProperty = (get_base_path, wrapDroppingSetter set_base_path, Nothing) instance NodeProperty VisualScriptYieldSignal "signal" GodotString 'False where nodeProperty = (get_signal, wrapDroppingSetter set_signal, Nothing) {-# NOINLINE bindVisualScriptYieldSignal_get_base_path #-} bindVisualScriptYieldSignal_get_base_path :: MethodBind bindVisualScriptYieldSignal_get_base_path = unsafePerformIO $ withCString "VisualScriptYieldSignal" $ \ clsNamePtr -> withCString "get_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_path :: (VisualScriptYieldSignal :< cls, Object :< cls) => cls -> IO NodePath get_base_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYieldSignal_get_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYieldSignal "get_base_path" '[] (IO NodePath) where nodeMethod = Godot.Core.VisualScriptYieldSignal.get_base_path {-# NOINLINE bindVisualScriptYieldSignal_get_base_type #-} bindVisualScriptYieldSignal_get_base_type :: MethodBind bindVisualScriptYieldSignal_get_base_type = unsafePerformIO $ withCString "VisualScriptYieldSignal" $ \ clsNamePtr -> withCString "get_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_base_type :: (VisualScriptYieldSignal :< cls, Object :< cls) => cls -> IO GodotString get_base_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYieldSignal_get_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYieldSignal "get_base_type" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptYieldSignal.get_base_type {-# NOINLINE bindVisualScriptYieldSignal_get_call_mode #-} bindVisualScriptYieldSignal_get_call_mode :: MethodBind bindVisualScriptYieldSignal_get_call_mode = unsafePerformIO $ withCString "VisualScriptYieldSignal" $ \ clsNamePtr -> withCString "get_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_call_mode :: (VisualScriptYieldSignal :< cls, Object :< cls) => cls -> IO Int get_call_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYieldSignal_get_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYieldSignal "get_call_mode" '[] (IO Int) where nodeMethod = Godot.Core.VisualScriptYieldSignal.get_call_mode {-# NOINLINE bindVisualScriptYieldSignal_get_signal #-} bindVisualScriptYieldSignal_get_signal :: MethodBind bindVisualScriptYieldSignal_get_signal = unsafePerformIO $ withCString "VisualScriptYieldSignal" $ \ clsNamePtr -> withCString "get_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_signal :: (VisualScriptYieldSignal :< cls, Object :< cls) => cls -> IO GodotString get_signal cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYieldSignal_get_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYieldSignal "get_signal" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualScriptYieldSignal.get_signal {-# NOINLINE bindVisualScriptYieldSignal_set_base_path #-} bindVisualScriptYieldSignal_set_base_path :: MethodBind bindVisualScriptYieldSignal_set_base_path = unsafePerformIO $ withCString "VisualScriptYieldSignal" $ \ clsNamePtr -> withCString "set_base_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_path :: (VisualScriptYieldSignal :< cls, Object :< cls) => cls -> NodePath -> IO () set_base_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYieldSignal_set_base_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYieldSignal "set_base_path" '[NodePath] (IO ()) where nodeMethod = Godot.Core.VisualScriptYieldSignal.set_base_path {-# NOINLINE bindVisualScriptYieldSignal_set_base_type #-} bindVisualScriptYieldSignal_set_base_type :: MethodBind bindVisualScriptYieldSignal_set_base_type = unsafePerformIO $ withCString "VisualScriptYieldSignal" $ \ clsNamePtr -> withCString "set_base_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_base_type :: (VisualScriptYieldSignal :< cls, Object :< cls) => cls -> GodotString -> IO () set_base_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYieldSignal_set_base_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYieldSignal "set_base_type" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptYieldSignal.set_base_type {-# NOINLINE bindVisualScriptYieldSignal_set_call_mode #-} bindVisualScriptYieldSignal_set_call_mode :: MethodBind bindVisualScriptYieldSignal_set_call_mode = unsafePerformIO $ withCString "VisualScriptYieldSignal" $ \ clsNamePtr -> withCString "set_call_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_call_mode :: (VisualScriptYieldSignal :< cls, Object :< cls) => cls -> Int -> IO () set_call_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYieldSignal_set_call_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYieldSignal "set_call_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualScriptYieldSignal.set_call_mode {-# NOINLINE bindVisualScriptYieldSignal_set_signal #-} bindVisualScriptYieldSignal_set_signal :: MethodBind bindVisualScriptYieldSignal_set_signal = unsafePerformIO $ withCString "VisualScriptYieldSignal" $ \ clsNamePtr -> withCString "set_signal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_signal :: (VisualScriptYieldSignal :< cls, Object :< cls) => cls -> GodotString -> IO () set_signal cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptYieldSignal_set_signal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptYieldSignal "set_signal" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualScriptYieldSignal.set_signal ================================================ FILE: src/Godot/Core/VisualServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualServer (Godot.Core.VisualServer._ARRAY_COMPRESS_WEIGHTS, Godot.Core.VisualServer._ARRAY_FLAG_USE_16_BIT_BONES, Godot.Core.VisualServer._VIEWPORT_UPDATE_ALWAYS, Godot.Core.VisualServer._ARRAY_FORMAT_INDEX, Godot.Core.VisualServer._INFO_SURFACE_CHANGES_IN_FRAME, Godot.Core.VisualServer._VIEWPORT_DEBUG_DRAW_OVERDRAW, Godot.Core.VisualServer._VIEWPORT_RENDER_INFO_MATERIAL_CHANGES_IN_FRAME, Godot.Core.VisualServer._ARRAY_COMPRESS_TANGENT, Godot.Core.VisualServer._INSTANCE_MULTIMESH, Godot.Core.VisualServer._VIEWPORT_CLEAR_ALWAYS, Godot.Core.VisualServer._SHADER_SPATIAL, Godot.Core.VisualServer._SHADOW_CASTING_SETTING_SHADOWS_ONLY, Godot.Core.VisualServer._ARRAY_COMPRESS_NORMAL, Godot.Core.VisualServer._ARRAY_FORMAT_COLOR, Godot.Core.VisualServer._VIEWPORT_CLEAR_NEVER, Godot.Core.VisualServer._TEXTURE_TYPE_2D_ARRAY, Godot.Core.VisualServer._INSTANCE_GEOMETRY_MASK, Godot.Core.VisualServer._VIEWPORT_USAGE_2D, Godot.Core.VisualServer._INSTANCE_LIGHTMAP_CAPTURE, Godot.Core.VisualServer._MULTIMESH_COLOR_FLOAT, Godot.Core.VisualServer._LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS, Godot.Core.VisualServer._INSTANCE_IMMEDIATE, Godot.Core.VisualServer._CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE, Godot.Core.VisualServer._ARRAY_FORMAT_TEX_UV, Godot.Core.VisualServer._CANVAS_OCCLUDER_POLYGON_CULL_DISABLED, Godot.Core.VisualServer._ARRAY_COMPRESS_VERTEX, Godot.Core.VisualServer._SCENARIO_DEBUG_DISABLED, Godot.Core.VisualServer._ENV_DOF_BLUR_QUALITY_HIGH, Godot.Core.VisualServer._LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL, Godot.Core.VisualServer._ARRAY_FORMAT_VERTEX, Godot.Core.VisualServer._SHADER_MAX, Godot.Core.VisualServer._VIEWPORT_DEBUG_DRAW_DISABLED, Godot.Core.VisualServer._CANVAS_ITEM_Z_MIN, Godot.Core.VisualServer._VIEWPORT_MSAA_8X, Godot.Core.VisualServer._INFO_MATERIAL_CHANGES_IN_FRAME, Godot.Core.VisualServer._MAX_GLOW_LEVELS, Godot.Core.VisualServer._LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL, Godot.Core.VisualServer._TEXTURE_TYPE_CUBEMAP, Godot.Core.VisualServer._VIEWPORT_RENDER_INFO_SURFACE_CHANGES_IN_FRAME, Godot.Core.VisualServer._ARRAY_COMPRESS_TEX_UV, Godot.Core.VisualServer._ARRAY_COMPRESS_BONES, Godot.Core.VisualServer._REFLECTION_PROBE_UPDATE_ALWAYS, Godot.Core.VisualServer._VIEWPORT_MSAA_DISABLED, Godot.Core.VisualServer._CUBEMAP_RIGHT, Godot.Core.VisualServer._ARRAY_MAX, Godot.Core.VisualServer._LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET, Godot.Core.VisualServer._ENV_TONE_MAPPER_FILMIC, Godot.Core.VisualServer._PARTICLES_DRAW_ORDER_LIFETIME, Godot.Core.VisualServer._NINE_PATCH_STRETCH, Godot.Core.VisualServer._INFO_USAGE_VIDEO_MEM_TOTAL, Godot.Core.VisualServer._ARRAY_NORMAL, Godot.Core.VisualServer._MULTIMESH_COLOR_NONE, Godot.Core.VisualServer._ARRAY_FORMAT_TEX_UV2, Godot.Core.VisualServer._ENV_SSAO_QUALITY_LOW, Godot.Core.VisualServer._INSTANCE_MESH, Godot.Core.VisualServer._MATERIAL_RENDER_PRIORITY_MAX, Godot.Core.VisualServer._LIGHT_PARAM_SHADOW_MAX_DISTANCE, Godot.Core.VisualServer._VIEWPORT_MSAA_2X, Godot.Core.VisualServer._PARTICLES_DRAW_ORDER_INDEX, Godot.Core.VisualServer._ENV_DOF_BLUR_QUALITY_LOW, Godot.Core.VisualServer._INFO_SHADER_CHANGES_IN_FRAME, Godot.Core.VisualServer._GLOW_BLEND_MODE_ADDITIVE, Godot.Core.VisualServer._ENV_BG_CANVAS, Godot.Core.VisualServer._LIGHT_OMNI_SHADOW_DUAL_PARABOLOID, Godot.Core.VisualServer._ARRAY_INDEX, Godot.Core.VisualServer._LIGHT_PARAM_ENERGY, Godot.Core.VisualServer._ARRAY_COLOR, Godot.Core.VisualServer._LIGHT_OMNI_SHADOW_CUBE, Godot.Core.VisualServer._PRIMITIVE_TRIANGLE_STRIP, Godot.Core.VisualServer._VIEWPORT_RENDER_INFO_MAX, Godot.Core.VisualServer._PRIMITIVE_TRIANGLES, Godot.Core.VisualServer._TEXTURE_FLAGS_DEFAULT, Godot.Core.VisualServer._VIEWPORT_USAGE_3D_NO_EFFECTS, Godot.Core.VisualServer._ARRAY_TEX_UV, Godot.Core.VisualServer._VIEWPORT_CLEAR_ONLY_NEXT_FRAME, Godot.Core.VisualServer._CANVAS_LIGHT_FILTER_PCF7, Godot.Core.VisualServer._BLEND_SHAPE_MODE_NORMALIZED, Godot.Core.VisualServer._ENV_BG_COLOR_SKY, Godot.Core.VisualServer._PRIMITIVE_LINE_LOOP, Godot.Core.VisualServer._LIGHT_PARAM_SPECULAR, Godot.Core.VisualServer._VIEWPORT_MSAA_EXT_2X, Godot.Core.VisualServer._CANVAS_LIGHT_MODE_SUB, Godot.Core.VisualServer._VIEWPORT_USAGE_3D, Godot.Core.VisualServer._GLOW_BLEND_MODE_SOFTLIGHT, Godot.Core.VisualServer._PRIMITIVE_TRIANGLE_FAN, Godot.Core.VisualServer._VIEWPORT_DEBUG_DRAW_UNSHADED, Godot.Core.VisualServer._MATERIAL_RENDER_PRIORITY_MIN, Godot.Core.VisualServer._LIGHT_OMNI_SHADOW_DETAIL_VERTICAL, Godot.Core.VisualServer._INSTANCE_FLAG_MAX, Godot.Core.VisualServer._MULTIMESH_TRANSFORM_3D, Godot.Core.VisualServer._SCENARIO_DEBUG_OVERDRAW, Godot.Core.VisualServer._ARRAY_FORMAT_NORMAL, Godot.Core.VisualServer._MULTIMESH_CUSTOM_DATA_8BIT, Godot.Core.VisualServer._ARRAY_TEX_UV2, Godot.Core.VisualServer._ENV_DOF_BLUR_QUALITY_MEDIUM, Godot.Core.VisualServer._TEXTURE_TYPE_2D, Godot.Core.VisualServer._ENV_BG_SKY, Godot.Core.VisualServer._FEATURE_SHADERS, Godot.Core.VisualServer._CUBEMAP_TOP, Godot.Core.VisualServer._PARTICLES_DRAW_ORDER_VIEW_DEPTH, Godot.Core.VisualServer._CUBEMAP_BACK, Godot.Core.VisualServer._LIGHT_SPOT, Godot.Core.VisualServer._LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS, Godot.Core.VisualServer._INSTANCE_PARTICLES, Godot.Core.VisualServer._TEXTURE_FLAG_REPEAT, Godot.Core.VisualServer._LIGHT_PARAM_SPOT_ATTENUATION, Godot.Core.VisualServer._REFLECTION_PROBE_UPDATE_ONCE, Godot.Core.VisualServer._ARRAY_COMPRESS_DEFAULT, Godot.Core.VisualServer._CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE, Godot.Core.VisualServer._CANVAS_ITEM_Z_MAX, Godot.Core.VisualServer._ENV_TONE_MAPPER_LINEAR, Godot.Core.VisualServer._LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET, Godot.Core.VisualServer._VIEWPORT_RENDER_INFO_VERTICES_IN_FRAME, Godot.Core.VisualServer._MULTIMESH_CUSTOM_DATA_NONE, Godot.Core.VisualServer._LIGHT_OMNI, Godot.Core.VisualServer._ENV_BG_MAX, Godot.Core.VisualServer._INSTANCE_REFLECTION_PROBE, Godot.Core.VisualServer._INFO_TEXTURE_MEM_USED, Godot.Core.VisualServer._INSTANCE_NONE, Godot.Core.VisualServer._SHADER_CANVAS_ITEM, Godot.Core.VisualServer._ENV_SSAO_QUALITY_MEDIUM, Godot.Core.VisualServer._CANVAS_LIGHT_FILTER_PCF3, Godot.Core.VisualServer._ARRAY_FORMAT_BONES, Godot.Core.VisualServer._LIGHT_PARAM_SPOT_ANGLE, Godot.Core.VisualServer._ARRAY_WEIGHTS_SIZE, Godot.Core.VisualServer._SHADOW_CASTING_SETTING_DOUBLE_SIDED, Godot.Core.VisualServer._ENV_SSAO_QUALITY_HIGH, Godot.Core.VisualServer._INFO_VERTICES_IN_FRAME, Godot.Core.VisualServer._INFO_VIDEO_MEM_USED, Godot.Core.VisualServer._GLOW_BLEND_MODE_REPLACE, Godot.Core.VisualServer._NINE_PATCH_TILE_FIT, Godot.Core.VisualServer._VIEWPORT_UPDATE_ONCE, Godot.Core.VisualServer._ARRAY_COMPRESS_COLOR, Godot.Core.VisualServer._GLOW_BLEND_MODE_SCREEN, Godot.Core.VisualServer._MAX_CURSORS, Godot.Core.VisualServer._TEXTURE_FLAG_CONVERT_TO_LINEAR, Godot.Core.VisualServer._PRIMITIVE_MAX, Godot.Core.VisualServer._LIGHT_PARAM_CONTACT_SHADOW_SIZE, Godot.Core.VisualServer._INSTANCE_MAX, Godot.Core.VisualServer._ENV_SSAO_BLUR_3x3, Godot.Core.VisualServer._ARRAY_WEIGHTS, Godot.Core.VisualServer._LIGHT_PARAM_MAX, Godot.Core.VisualServer._CUBEMAP_BOTTOM, Godot.Core.VisualServer._ARRAY_TANGENT, Godot.Core.VisualServer._SCENARIO_DEBUG_SHADELESS, Godot.Core.VisualServer._INFO_OBJECTS_IN_FRAME, Godot.Core.VisualServer._INSTANCE_GI_PROBE, Godot.Core.VisualServer._LIGHT_PARAM_SHADOW_NORMAL_BIAS, Godot.Core.VisualServer._VIEWPORT_USAGE_2D_NO_SAMPLING, Godot.Core.VisualServer._ENV_SSAO_BLUR_2x2, Godot.Core.VisualServer._VIEWPORT_UPDATE_DISABLED, Godot.Core.VisualServer._SHADOW_CASTING_SETTING_OFF, Godot.Core.VisualServer._VIEWPORT_MSAA_16X, Godot.Core.VisualServer._CANVAS_LIGHT_FILTER_PCF9, Godot.Core.VisualServer._ENV_SSAO_BLUR_DISABLED, Godot.Core.VisualServer._TEXTURE_FLAG_ANISOTROPIC_FILTER, Godot.Core.VisualServer._FEATURE_MULTITHREADED, Godot.Core.VisualServer._ENV_SSAO_BLUR_1x1, Godot.Core.VisualServer._INFO_DRAW_CALLS_IN_FRAME, Godot.Core.VisualServer._ENV_BG_COLOR, Godot.Core.VisualServer._ENV_TONE_MAPPER_ACES, Godot.Core.VisualServer._LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE, Godot.Core.VisualServer._LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_OPTIMIZED, Godot.Core.VisualServer._ARRAY_COMPRESS_TEX_UV2, Godot.Core.VisualServer._MULTIMESH_COLOR_8BIT, Godot.Core.VisualServer._MULTIMESH_TRANSFORM_2D, Godot.Core.VisualServer._VIEWPORT_UPDATE_WHEN_VISIBLE, Godot.Core.VisualServer._VIEWPORT_MSAA_EXT_4X, Godot.Core.VisualServer._INSTANCE_LIGHT, Godot.Core.VisualServer._TEXTURE_TYPE_3D, Godot.Core.VisualServer._TEXTURE_FLAG_MIPMAPS, Godot.Core.VisualServer._PRIMITIVE_LINE_STRIP, Godot.Core.VisualServer._TEXTURE_FLAG_FILTER, Godot.Core.VisualServer._ENV_BG_KEEP, Godot.Core.VisualServer._CANVAS_LIGHT_FILTER_NONE, Godot.Core.VisualServer._CUBEMAP_FRONT, Godot.Core.VisualServer._TEXTURE_FLAG_USED_FOR_STREAMING, Godot.Core.VisualServer._INFO_VERTEX_MEM_USED, Godot.Core.VisualServer._TEXTURE_FLAG_MIRRORED_REPEAT, Godot.Core.VisualServer._PRIMITIVE_LINES, Godot.Core.VisualServer._VIEWPORT_RENDER_INFO_OBJECTS_IN_FRAME, Godot.Core.VisualServer._ENV_BG_CLEAR_COLOR, Godot.Core.VisualServer._SHADOW_CASTING_SETTING_ON, Godot.Core.VisualServer._SCENARIO_DEBUG_WIREFRAME, Godot.Core.VisualServer._CANVAS_LIGHT_MODE_ADD, Godot.Core.VisualServer._LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE, Godot.Core.VisualServer._VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME, Godot.Core.VisualServer._ARRAY_BONES, Godot.Core.VisualServer._LIGHT_PARAM_ATTENUATION, Godot.Core.VisualServer._VIEWPORT_DEBUG_DRAW_WIREFRAME, Godot.Core.VisualServer._CANVAS_LIGHT_MODE_MIX, Godot.Core.VisualServer._NINE_PATCH_TILE, Godot.Core.VisualServer._VIEWPORT_RENDER_INFO_SHADER_CHANGES_IN_FRAME, Godot.Core.VisualServer._INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE, Godot.Core.VisualServer._CANVAS_LIGHT_MODE_MASK, Godot.Core.VisualServer._LIGHT_PARAM_RANGE, Godot.Core.VisualServer._BLEND_SHAPE_MODE_RELATIVE, Godot.Core.VisualServer._VIEWPORT_MSAA_4X, Godot.Core.VisualServer._LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET, Godot.Core.VisualServer._ENV_TONE_MAPPER_REINHARD, Godot.Core.VisualServer._CANVAS_LIGHT_FILTER_PCF13, Godot.Core.VisualServer._MULTIMESH_CUSTOM_DATA_FLOAT, Godot.Core.VisualServer._NO_INDEX_ARRAY, Godot.Core.VisualServer._ARRAY_VERTEX, Godot.Core.VisualServer._ARRAY_FLAG_USE_2D_VERTICES, Godot.Core.VisualServer._CANVAS_LIGHT_FILTER_PCF5, Godot.Core.VisualServer._LIGHT_DIRECTIONAL, Godot.Core.VisualServer._ARRAY_COMPRESS_INDEX, Godot.Core.VisualServer._INSTANCE_FLAG_USE_BAKED_LIGHT, Godot.Core.VisualServer._CUBEMAP_LEFT, Godot.Core.VisualServer._LIGHT_PARAM_SHADOW_BIAS, Godot.Core.VisualServer._ARRAY_FORMAT_WEIGHTS, Godot.Core.VisualServer._SHADER_PARTICLES, Godot.Core.VisualServer._ARRAY_FORMAT_TANGENT, Godot.Core.VisualServer._PRIMITIVE_POINTS, Godot.Core.VisualServer.sig_frame_post_draw, Godot.Core.VisualServer.sig_frame_pre_draw, Godot.Core.VisualServer.black_bars_set_images, Godot.Core.VisualServer.black_bars_set_margins, Godot.Core.VisualServer.camera_create, Godot.Core.VisualServer.camera_set_cull_mask, Godot.Core.VisualServer.camera_set_environment, Godot.Core.VisualServer.camera_set_frustum, Godot.Core.VisualServer.camera_set_orthogonal, Godot.Core.VisualServer.camera_set_perspective, Godot.Core.VisualServer.camera_set_transform, Godot.Core.VisualServer.camera_set_use_vertical_aspect, Godot.Core.VisualServer.canvas_create, Godot.Core.VisualServer.canvas_item_add_circle, Godot.Core.VisualServer.canvas_item_add_clip_ignore, Godot.Core.VisualServer.canvas_item_add_line, Godot.Core.VisualServer.canvas_item_add_mesh, Godot.Core.VisualServer.canvas_item_add_multimesh, Godot.Core.VisualServer.canvas_item_add_nine_patch, Godot.Core.VisualServer.canvas_item_add_particles, Godot.Core.VisualServer.canvas_item_add_polygon, Godot.Core.VisualServer.canvas_item_add_polyline, Godot.Core.VisualServer.canvas_item_add_primitive, Godot.Core.VisualServer.canvas_item_add_rect, Godot.Core.VisualServer.canvas_item_add_set_transform, Godot.Core.VisualServer.canvas_item_add_texture_rect, Godot.Core.VisualServer.canvas_item_add_texture_rect_region, Godot.Core.VisualServer.canvas_item_add_triangle_array, Godot.Core.VisualServer.canvas_item_clear, Godot.Core.VisualServer.canvas_item_create, Godot.Core.VisualServer.canvas_item_set_clip, Godot.Core.VisualServer.canvas_item_set_copy_to_backbuffer, Godot.Core.VisualServer.canvas_item_set_custom_rect, Godot.Core.VisualServer.canvas_item_set_distance_field_mode, Godot.Core.VisualServer.canvas_item_set_draw_behind_parent, Godot.Core.VisualServer.canvas_item_set_draw_index, Godot.Core.VisualServer.canvas_item_set_light_mask, Godot.Core.VisualServer.canvas_item_set_material, Godot.Core.VisualServer.canvas_item_set_modulate, Godot.Core.VisualServer.canvas_item_set_parent, Godot.Core.VisualServer.canvas_item_set_self_modulate, Godot.Core.VisualServer.canvas_item_set_sort_children_by_y, Godot.Core.VisualServer.canvas_item_set_transform, Godot.Core.VisualServer.canvas_item_set_use_parent_material, Godot.Core.VisualServer.canvas_item_set_visible, Godot.Core.VisualServer.canvas_item_set_z_as_relative_to_parent, Godot.Core.VisualServer.canvas_item_set_z_index, Godot.Core.VisualServer.canvas_light_attach_to_canvas, Godot.Core.VisualServer.canvas_light_create, Godot.Core.VisualServer.canvas_light_occluder_attach_to_canvas, Godot.Core.VisualServer.canvas_light_occluder_create, Godot.Core.VisualServer.canvas_light_occluder_set_enabled, Godot.Core.VisualServer.canvas_light_occluder_set_light_mask, Godot.Core.VisualServer.canvas_light_occluder_set_polygon, Godot.Core.VisualServer.canvas_light_occluder_set_transform, Godot.Core.VisualServer.canvas_light_set_color, Godot.Core.VisualServer.canvas_light_set_enabled, Godot.Core.VisualServer.canvas_light_set_energy, Godot.Core.VisualServer.canvas_light_set_height, Godot.Core.VisualServer.canvas_light_set_item_cull_mask, Godot.Core.VisualServer.canvas_light_set_item_shadow_cull_mask, Godot.Core.VisualServer.canvas_light_set_layer_range, Godot.Core.VisualServer.canvas_light_set_mode, Godot.Core.VisualServer.canvas_light_set_scale, Godot.Core.VisualServer.canvas_light_set_shadow_buffer_size, Godot.Core.VisualServer.canvas_light_set_shadow_color, Godot.Core.VisualServer.canvas_light_set_shadow_enabled, Godot.Core.VisualServer.canvas_light_set_shadow_filter, Godot.Core.VisualServer.canvas_light_set_shadow_gradient_length, Godot.Core.VisualServer.canvas_light_set_shadow_smooth, Godot.Core.VisualServer.canvas_light_set_texture, Godot.Core.VisualServer.canvas_light_set_texture_offset, Godot.Core.VisualServer.canvas_light_set_transform, Godot.Core.VisualServer.canvas_light_set_z_range, Godot.Core.VisualServer.canvas_occluder_polygon_create, Godot.Core.VisualServer.canvas_occluder_polygon_set_cull_mode, Godot.Core.VisualServer.canvas_occluder_polygon_set_shape, Godot.Core.VisualServer.canvas_occluder_polygon_set_shape_as_lines, Godot.Core.VisualServer.canvas_set_item_mirroring, Godot.Core.VisualServer.canvas_set_modulate, Godot.Core.VisualServer.directional_light_create, Godot.Core.VisualServer.draw, Godot.Core.VisualServer.environment_create, Godot.Core.VisualServer.environment_set_adjustment, Godot.Core.VisualServer.environment_set_ambient_light, Godot.Core.VisualServer.environment_set_background, Godot.Core.VisualServer.environment_set_bg_color, Godot.Core.VisualServer.environment_set_bg_energy, Godot.Core.VisualServer.environment_set_canvas_max_layer, Godot.Core.VisualServer.environment_set_dof_blur_far, Godot.Core.VisualServer.environment_set_dof_blur_near, Godot.Core.VisualServer.environment_set_fog, Godot.Core.VisualServer.environment_set_fog_depth, Godot.Core.VisualServer.environment_set_fog_height, Godot.Core.VisualServer.environment_set_glow, Godot.Core.VisualServer.environment_set_sky, Godot.Core.VisualServer.environment_set_sky_custom_fov, Godot.Core.VisualServer.environment_set_sky_orientation, Godot.Core.VisualServer.environment_set_ssao, Godot.Core.VisualServer.environment_set_ssr, Godot.Core.VisualServer.environment_set_tonemap, Godot.Core.VisualServer.finish, Godot.Core.VisualServer.force_draw, Godot.Core.VisualServer.force_sync, Godot.Core.VisualServer.free_rid, Godot.Core.VisualServer.get_render_info, Godot.Core.VisualServer.get_test_cube, Godot.Core.VisualServer.get_test_texture, Godot.Core.VisualServer.get_video_adapter_name, Godot.Core.VisualServer.get_video_adapter_vendor, Godot.Core.VisualServer.get_white_texture, Godot.Core.VisualServer.gi_probe_create, Godot.Core.VisualServer.gi_probe_get_bias, Godot.Core.VisualServer.gi_probe_get_bounds, Godot.Core.VisualServer.gi_probe_get_cell_size, Godot.Core.VisualServer.gi_probe_get_dynamic_data, Godot.Core.VisualServer.gi_probe_get_dynamic_range, Godot.Core.VisualServer.gi_probe_get_energy, Godot.Core.VisualServer.gi_probe_get_normal_bias, Godot.Core.VisualServer.gi_probe_get_propagation, Godot.Core.VisualServer.gi_probe_get_to_cell_xform, Godot.Core.VisualServer.gi_probe_is_compressed, Godot.Core.VisualServer.gi_probe_is_interior, Godot.Core.VisualServer.gi_probe_set_bias, Godot.Core.VisualServer.gi_probe_set_bounds, Godot.Core.VisualServer.gi_probe_set_cell_size, Godot.Core.VisualServer.gi_probe_set_compress, Godot.Core.VisualServer.gi_probe_set_dynamic_data, Godot.Core.VisualServer.gi_probe_set_dynamic_range, Godot.Core.VisualServer.gi_probe_set_energy, Godot.Core.VisualServer.gi_probe_set_interior, Godot.Core.VisualServer.gi_probe_set_normal_bias, Godot.Core.VisualServer.gi_probe_set_propagation, Godot.Core.VisualServer.gi_probe_set_to_cell_xform, Godot.Core.VisualServer.has_changed, Godot.Core.VisualServer.has_feature, Godot.Core.VisualServer.has_os_feature, Godot.Core.VisualServer.immediate_begin, Godot.Core.VisualServer.immediate_clear, Godot.Core.VisualServer.immediate_color, Godot.Core.VisualServer.immediate_create, Godot.Core.VisualServer.immediate_end, Godot.Core.VisualServer.immediate_get_material, Godot.Core.VisualServer.immediate_normal, Godot.Core.VisualServer.immediate_set_material, Godot.Core.VisualServer.immediate_tangent, Godot.Core.VisualServer.immediate_uv, Godot.Core.VisualServer.immediate_uv2, Godot.Core.VisualServer.immediate_vertex, Godot.Core.VisualServer.immediate_vertex_2d, Godot.Core.VisualServer.init, Godot.Core.VisualServer.instance_attach_object_instance_id, Godot.Core.VisualServer.instance_attach_skeleton, Godot.Core.VisualServer.instance_create, Godot.Core.VisualServer.instance_create2, Godot.Core.VisualServer.instance_geometry_set_as_instance_lod, Godot.Core.VisualServer.instance_geometry_set_cast_shadows_setting, Godot.Core.VisualServer.instance_geometry_set_draw_range, Godot.Core.VisualServer.instance_geometry_set_flag, Godot.Core.VisualServer.instance_geometry_set_material_override, Godot.Core.VisualServer.instance_set_base, Godot.Core.VisualServer.instance_set_blend_shape_weight, Godot.Core.VisualServer.instance_set_custom_aabb, Godot.Core.VisualServer.instance_set_exterior, Godot.Core.VisualServer.instance_set_extra_visibility_margin, Godot.Core.VisualServer.instance_set_layer_mask, Godot.Core.VisualServer.instance_set_scenario, Godot.Core.VisualServer.instance_set_surface_material, Godot.Core.VisualServer.instance_set_transform, Godot.Core.VisualServer.instance_set_use_lightmap, Godot.Core.VisualServer.instance_set_visible, Godot.Core.VisualServer.instances_cull_aabb, Godot.Core.VisualServer.instances_cull_convex, Godot.Core.VisualServer.instances_cull_ray, Godot.Core.VisualServer.light_directional_set_blend_splits, Godot.Core.VisualServer.light_directional_set_shadow_depth_range_mode, Godot.Core.VisualServer.light_directional_set_shadow_mode, Godot.Core.VisualServer.light_omni_set_shadow_detail, Godot.Core.VisualServer.light_omni_set_shadow_mode, Godot.Core.VisualServer.light_set_color, Godot.Core.VisualServer.light_set_cull_mask, Godot.Core.VisualServer.light_set_negative, Godot.Core.VisualServer.light_set_param, Godot.Core.VisualServer.light_set_projector, Godot.Core.VisualServer.light_set_reverse_cull_face_mode, Godot.Core.VisualServer.light_set_shadow, Godot.Core.VisualServer.light_set_shadow_color, Godot.Core.VisualServer.light_set_use_gi, Godot.Core.VisualServer.lightmap_capture_create, Godot.Core.VisualServer.lightmap_capture_get_bounds, Godot.Core.VisualServer.lightmap_capture_get_energy, Godot.Core.VisualServer.lightmap_capture_get_octree, Godot.Core.VisualServer.lightmap_capture_get_octree_cell_subdiv, Godot.Core.VisualServer.lightmap_capture_get_octree_cell_transform, Godot.Core.VisualServer.lightmap_capture_set_bounds, Godot.Core.VisualServer.lightmap_capture_set_energy, Godot.Core.VisualServer.lightmap_capture_set_octree, Godot.Core.VisualServer.lightmap_capture_set_octree_cell_subdiv, Godot.Core.VisualServer.lightmap_capture_set_octree_cell_transform, Godot.Core.VisualServer.make_sphere_mesh, Godot.Core.VisualServer.material_create, Godot.Core.VisualServer.material_get_param, Godot.Core.VisualServer.material_get_param_default, Godot.Core.VisualServer.material_get_shader, Godot.Core.VisualServer.material_set_line_width, Godot.Core.VisualServer.material_set_next_pass, Godot.Core.VisualServer.material_set_param, Godot.Core.VisualServer.material_set_render_priority, Godot.Core.VisualServer.material_set_shader, Godot.Core.VisualServer.mesh_add_surface_from_arrays, Godot.Core.VisualServer.mesh_clear, Godot.Core.VisualServer.mesh_create, Godot.Core.VisualServer.mesh_get_blend_shape_count, Godot.Core.VisualServer.mesh_get_blend_shape_mode, Godot.Core.VisualServer.mesh_get_custom_aabb, Godot.Core.VisualServer.mesh_get_surface_count, Godot.Core.VisualServer.mesh_remove_surface, Godot.Core.VisualServer.mesh_set_blend_shape_count, Godot.Core.VisualServer.mesh_set_blend_shape_mode, Godot.Core.VisualServer.mesh_set_custom_aabb, Godot.Core.VisualServer.mesh_surface_get_aabb, Godot.Core.VisualServer.mesh_surface_get_array, Godot.Core.VisualServer.mesh_surface_get_array_index_len, Godot.Core.VisualServer.mesh_surface_get_array_len, Godot.Core.VisualServer.mesh_surface_get_arrays, Godot.Core.VisualServer.mesh_surface_get_blend_shape_arrays, Godot.Core.VisualServer.mesh_surface_get_format, Godot.Core.VisualServer.mesh_surface_get_format_offset, Godot.Core.VisualServer.mesh_surface_get_format_stride, Godot.Core.VisualServer.mesh_surface_get_index_array, Godot.Core.VisualServer.mesh_surface_get_material, Godot.Core.VisualServer.mesh_surface_get_primitive_type, Godot.Core.VisualServer.mesh_surface_get_skeleton_aabb, Godot.Core.VisualServer.mesh_surface_set_material, Godot.Core.VisualServer.mesh_surface_update_region, Godot.Core.VisualServer.multimesh_allocate, Godot.Core.VisualServer.multimesh_create, Godot.Core.VisualServer.multimesh_get_aabb, Godot.Core.VisualServer.multimesh_get_instance_count, Godot.Core.VisualServer.multimesh_get_mesh, Godot.Core.VisualServer.multimesh_get_visible_instances, Godot.Core.VisualServer.multimesh_instance_get_color, Godot.Core.VisualServer.multimesh_instance_get_custom_data, Godot.Core.VisualServer.multimesh_instance_get_transform, Godot.Core.VisualServer.multimesh_instance_get_transform_2d, Godot.Core.VisualServer.multimesh_instance_set_color, Godot.Core.VisualServer.multimesh_instance_set_custom_data, Godot.Core.VisualServer.multimesh_instance_set_transform, Godot.Core.VisualServer.multimesh_instance_set_transform_2d, Godot.Core.VisualServer.multimesh_set_as_bulk_array, Godot.Core.VisualServer.multimesh_set_mesh, Godot.Core.VisualServer.multimesh_set_visible_instances, Godot.Core.VisualServer.omni_light_create, Godot.Core.VisualServer.particles_create, Godot.Core.VisualServer.particles_get_current_aabb, Godot.Core.VisualServer.particles_get_emitting, Godot.Core.VisualServer.particles_is_inactive, Godot.Core.VisualServer.particles_request_process, Godot.Core.VisualServer.particles_restart, Godot.Core.VisualServer.particles_set_amount, Godot.Core.VisualServer.particles_set_custom_aabb, Godot.Core.VisualServer.particles_set_draw_order, Godot.Core.VisualServer.particles_set_draw_pass_mesh, Godot.Core.VisualServer.particles_set_draw_passes, Godot.Core.VisualServer.particles_set_emission_transform, Godot.Core.VisualServer.particles_set_emitting, Godot.Core.VisualServer.particles_set_explosiveness_ratio, Godot.Core.VisualServer.particles_set_fixed_fps, Godot.Core.VisualServer.particles_set_fractional_delta, Godot.Core.VisualServer.particles_set_lifetime, Godot.Core.VisualServer.particles_set_one_shot, Godot.Core.VisualServer.particles_set_pre_process_time, Godot.Core.VisualServer.particles_set_process_material, Godot.Core.VisualServer.particles_set_randomness_ratio, Godot.Core.VisualServer.particles_set_speed_scale, Godot.Core.VisualServer.particles_set_use_local_coordinates, Godot.Core.VisualServer.reflection_probe_create, Godot.Core.VisualServer.reflection_probe_set_as_interior, Godot.Core.VisualServer.reflection_probe_set_cull_mask, Godot.Core.VisualServer.reflection_probe_set_enable_box_projection, Godot.Core.VisualServer.reflection_probe_set_enable_shadows, Godot.Core.VisualServer.reflection_probe_set_extents, Godot.Core.VisualServer.reflection_probe_set_intensity, Godot.Core.VisualServer.reflection_probe_set_interior_ambient, Godot.Core.VisualServer.reflection_probe_set_interior_ambient_energy, Godot.Core.VisualServer.reflection_probe_set_interior_ambient_probe_contribution, Godot.Core.VisualServer.reflection_probe_set_max_distance, Godot.Core.VisualServer.reflection_probe_set_origin_offset, Godot.Core.VisualServer.reflection_probe_set_update_mode, Godot.Core.VisualServer.request_frame_drawn_callback, Godot.Core.VisualServer.scenario_create, Godot.Core.VisualServer.scenario_set_debug, Godot.Core.VisualServer.scenario_set_environment, Godot.Core.VisualServer.scenario_set_fallback_environment, Godot.Core.VisualServer.scenario_set_reflection_atlas_size, Godot.Core.VisualServer.set_boot_image, Godot.Core.VisualServer.set_debug_generate_wireframes, Godot.Core.VisualServer.set_default_clear_color, Godot.Core.VisualServer.shader_create, Godot.Core.VisualServer.shader_get_code, Godot.Core.VisualServer.shader_get_default_texture_param, Godot.Core.VisualServer.shader_get_param_list, Godot.Core.VisualServer.shader_set_code, Godot.Core.VisualServer.shader_set_default_texture_param, Godot.Core.VisualServer.skeleton_allocate, Godot.Core.VisualServer.skeleton_bone_get_transform, Godot.Core.VisualServer.skeleton_bone_get_transform_2d, Godot.Core.VisualServer.skeleton_bone_set_transform, Godot.Core.VisualServer.skeleton_bone_set_transform_2d, Godot.Core.VisualServer.skeleton_create, Godot.Core.VisualServer.skeleton_get_bone_count, Godot.Core.VisualServer.sky_create, Godot.Core.VisualServer.sky_set_texture, Godot.Core.VisualServer.spot_light_create, Godot.Core.VisualServer.sync, Godot.Core.VisualServer.texture_allocate, Godot.Core.VisualServer.texture_bind, Godot.Core.VisualServer.texture_create, Godot.Core.VisualServer.texture_create_from_image, Godot.Core.VisualServer.texture_debug_usage, Godot.Core.VisualServer.texture_get_data, Godot.Core.VisualServer.texture_get_depth, Godot.Core.VisualServer.texture_get_flags, Godot.Core.VisualServer.texture_get_format, Godot.Core.VisualServer.texture_get_height, Godot.Core.VisualServer.texture_get_path, Godot.Core.VisualServer.texture_get_texid, Godot.Core.VisualServer.texture_get_type, Godot.Core.VisualServer.texture_get_width, Godot.Core.VisualServer.texture_set_data, Godot.Core.VisualServer.texture_set_data_partial, Godot.Core.VisualServer.texture_set_flags, Godot.Core.VisualServer.texture_set_path, Godot.Core.VisualServer.texture_set_shrink_all_x2_on_set_data, Godot.Core.VisualServer.texture_set_size_override, Godot.Core.VisualServer.textures_keep_original, Godot.Core.VisualServer.viewport_attach_camera, Godot.Core.VisualServer.viewport_attach_canvas, Godot.Core.VisualServer.viewport_attach_to_screen, Godot.Core.VisualServer.viewport_create, Godot.Core.VisualServer.viewport_detach, Godot.Core.VisualServer.viewport_get_render_info, Godot.Core.VisualServer.viewport_get_texture, Godot.Core.VisualServer.viewport_remove_canvas, Godot.Core.VisualServer.viewport_set_active, Godot.Core.VisualServer.viewport_set_canvas_stacking, Godot.Core.VisualServer.viewport_set_canvas_transform, Godot.Core.VisualServer.viewport_set_clear_mode, Godot.Core.VisualServer.viewport_set_debug_draw, Godot.Core.VisualServer.viewport_set_disable_3d, Godot.Core.VisualServer.viewport_set_disable_environment, Godot.Core.VisualServer.viewport_set_global_canvas_transform, Godot.Core.VisualServer.viewport_set_hdr, Godot.Core.VisualServer.viewport_set_hide_canvas, Godot.Core.VisualServer.viewport_set_hide_scenario, Godot.Core.VisualServer.viewport_set_msaa, Godot.Core.VisualServer.viewport_set_parent_viewport, Godot.Core.VisualServer.viewport_set_render_direct_to_screen, Godot.Core.VisualServer.viewport_set_scenario, Godot.Core.VisualServer.viewport_set_shadow_atlas_quadrant_subdivision, Godot.Core.VisualServer.viewport_set_shadow_atlas_size, Godot.Core.VisualServer.viewport_set_size, Godot.Core.VisualServer.viewport_set_transparent_background, Godot.Core.VisualServer.viewport_set_update_mode, Godot.Core.VisualServer.viewport_set_usage, Godot.Core.VisualServer.viewport_set_use_arvr, Godot.Core.VisualServer.viewport_set_vflip) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() _ARRAY_COMPRESS_WEIGHTS :: Int _ARRAY_COMPRESS_WEIGHTS = 65536 _ARRAY_FLAG_USE_16_BIT_BONES :: Int _ARRAY_FLAG_USE_16_BIT_BONES = 524288 _VIEWPORT_UPDATE_ALWAYS :: Int _VIEWPORT_UPDATE_ALWAYS = 3 _ARRAY_FORMAT_INDEX :: Int _ARRAY_FORMAT_INDEX = 256 _INFO_SURFACE_CHANGES_IN_FRAME :: Int _INFO_SURFACE_CHANGES_IN_FRAME = 4 _VIEWPORT_DEBUG_DRAW_OVERDRAW :: Int _VIEWPORT_DEBUG_DRAW_OVERDRAW = 2 _VIEWPORT_RENDER_INFO_MATERIAL_CHANGES_IN_FRAME :: Int _VIEWPORT_RENDER_INFO_MATERIAL_CHANGES_IN_FRAME = 2 _ARRAY_COMPRESS_TANGENT :: Int _ARRAY_COMPRESS_TANGENT = 2048 _INSTANCE_MULTIMESH :: Int _INSTANCE_MULTIMESH = 2 _VIEWPORT_CLEAR_ALWAYS :: Int _VIEWPORT_CLEAR_ALWAYS = 0 _SHADER_SPATIAL :: Int _SHADER_SPATIAL = 0 _SHADOW_CASTING_SETTING_SHADOWS_ONLY :: Int _SHADOW_CASTING_SETTING_SHADOWS_ONLY = 3 _ARRAY_COMPRESS_NORMAL :: Int _ARRAY_COMPRESS_NORMAL = 1024 _ARRAY_FORMAT_COLOR :: Int _ARRAY_FORMAT_COLOR = 8 _VIEWPORT_CLEAR_NEVER :: Int _VIEWPORT_CLEAR_NEVER = 1 _TEXTURE_TYPE_2D_ARRAY :: Int _TEXTURE_TYPE_2D_ARRAY = 2 _INSTANCE_GEOMETRY_MASK :: Int _INSTANCE_GEOMETRY_MASK = 30 _VIEWPORT_USAGE_2D :: Int _VIEWPORT_USAGE_2D = 0 _INSTANCE_LIGHTMAP_CAPTURE :: Int _INSTANCE_LIGHTMAP_CAPTURE = 8 _MULTIMESH_COLOR_FLOAT :: Int _MULTIMESH_COLOR_FLOAT = 2 _LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS :: Int _LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS = 1 _INSTANCE_IMMEDIATE :: Int _INSTANCE_IMMEDIATE = 3 _CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE :: Int _CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE = 1 _ARRAY_FORMAT_TEX_UV :: Int _ARRAY_FORMAT_TEX_UV = 16 _CANVAS_OCCLUDER_POLYGON_CULL_DISABLED :: Int _CANVAS_OCCLUDER_POLYGON_CULL_DISABLED = 0 _ARRAY_COMPRESS_VERTEX :: Int _ARRAY_COMPRESS_VERTEX = 512 _SCENARIO_DEBUG_DISABLED :: Int _SCENARIO_DEBUG_DISABLED = 0 _ENV_DOF_BLUR_QUALITY_HIGH :: Int _ENV_DOF_BLUR_QUALITY_HIGH = 2 _LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL :: Int _LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL = 0 _ARRAY_FORMAT_VERTEX :: Int _ARRAY_FORMAT_VERTEX = 1 _SHADER_MAX :: Int _SHADER_MAX = 3 _VIEWPORT_DEBUG_DRAW_DISABLED :: Int _VIEWPORT_DEBUG_DRAW_DISABLED = 0 _CANVAS_ITEM_Z_MIN :: Int _CANVAS_ITEM_Z_MIN = -4096 _VIEWPORT_MSAA_8X :: Int _VIEWPORT_MSAA_8X = 3 _INFO_MATERIAL_CHANGES_IN_FRAME :: Int _INFO_MATERIAL_CHANGES_IN_FRAME = 2 _MAX_GLOW_LEVELS :: Int _MAX_GLOW_LEVELS = 7 _LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL :: Int _LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL = 1 _TEXTURE_TYPE_CUBEMAP :: Int _TEXTURE_TYPE_CUBEMAP = 1 _VIEWPORT_RENDER_INFO_SURFACE_CHANGES_IN_FRAME :: Int _VIEWPORT_RENDER_INFO_SURFACE_CHANGES_IN_FRAME = 4 _ARRAY_COMPRESS_TEX_UV :: Int _ARRAY_COMPRESS_TEX_UV = 8192 _ARRAY_COMPRESS_BONES :: Int _ARRAY_COMPRESS_BONES = 32768 _REFLECTION_PROBE_UPDATE_ALWAYS :: Int _REFLECTION_PROBE_UPDATE_ALWAYS = 1 _VIEWPORT_MSAA_DISABLED :: Int _VIEWPORT_MSAA_DISABLED = 0 _CUBEMAP_RIGHT :: Int _CUBEMAP_RIGHT = 1 _ARRAY_MAX :: Int _ARRAY_MAX = 9 _LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET :: Int _LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET = 10 _ENV_TONE_MAPPER_FILMIC :: Int _ENV_TONE_MAPPER_FILMIC = 2 _PARTICLES_DRAW_ORDER_LIFETIME :: Int _PARTICLES_DRAW_ORDER_LIFETIME = 1 _NINE_PATCH_STRETCH :: Int _NINE_PATCH_STRETCH = 0 _INFO_USAGE_VIDEO_MEM_TOTAL :: Int _INFO_USAGE_VIDEO_MEM_TOTAL = 6 _ARRAY_NORMAL :: Int _ARRAY_NORMAL = 1 _MULTIMESH_COLOR_NONE :: Int _MULTIMESH_COLOR_NONE = 0 _ARRAY_FORMAT_TEX_UV2 :: Int _ARRAY_FORMAT_TEX_UV2 = 32 _ENV_SSAO_QUALITY_LOW :: Int _ENV_SSAO_QUALITY_LOW = 0 _INSTANCE_MESH :: Int _INSTANCE_MESH = 1 _MATERIAL_RENDER_PRIORITY_MAX :: Int _MATERIAL_RENDER_PRIORITY_MAX = 127 _LIGHT_PARAM_SHADOW_MAX_DISTANCE :: Int _LIGHT_PARAM_SHADOW_MAX_DISTANCE = 8 _VIEWPORT_MSAA_2X :: Int _VIEWPORT_MSAA_2X = 1 _PARTICLES_DRAW_ORDER_INDEX :: Int _PARTICLES_DRAW_ORDER_INDEX = 0 _ENV_DOF_BLUR_QUALITY_LOW :: Int _ENV_DOF_BLUR_QUALITY_LOW = 0 _INFO_SHADER_CHANGES_IN_FRAME :: Int _INFO_SHADER_CHANGES_IN_FRAME = 3 _GLOW_BLEND_MODE_ADDITIVE :: Int _GLOW_BLEND_MODE_ADDITIVE = 0 _ENV_BG_CANVAS :: Int _ENV_BG_CANVAS = 4 _LIGHT_OMNI_SHADOW_DUAL_PARABOLOID :: Int _LIGHT_OMNI_SHADOW_DUAL_PARABOLOID = 0 _ARRAY_INDEX :: Int _ARRAY_INDEX = 8 _LIGHT_PARAM_ENERGY :: Int _LIGHT_PARAM_ENERGY = 0 _ARRAY_COLOR :: Int _ARRAY_COLOR = 3 _LIGHT_OMNI_SHADOW_CUBE :: Int _LIGHT_OMNI_SHADOW_CUBE = 1 _PRIMITIVE_TRIANGLE_STRIP :: Int _PRIMITIVE_TRIANGLE_STRIP = 5 _VIEWPORT_RENDER_INFO_MAX :: Int _VIEWPORT_RENDER_INFO_MAX = 6 _PRIMITIVE_TRIANGLES :: Int _PRIMITIVE_TRIANGLES = 4 _TEXTURE_FLAGS_DEFAULT :: Int _TEXTURE_FLAGS_DEFAULT = 7 _VIEWPORT_USAGE_3D_NO_EFFECTS :: Int _VIEWPORT_USAGE_3D_NO_EFFECTS = 3 _ARRAY_TEX_UV :: Int _ARRAY_TEX_UV = 4 _VIEWPORT_CLEAR_ONLY_NEXT_FRAME :: Int _VIEWPORT_CLEAR_ONLY_NEXT_FRAME = 2 _CANVAS_LIGHT_FILTER_PCF7 :: Int _CANVAS_LIGHT_FILTER_PCF7 = 3 _BLEND_SHAPE_MODE_NORMALIZED :: Int _BLEND_SHAPE_MODE_NORMALIZED = 0 _ENV_BG_COLOR_SKY :: Int _ENV_BG_COLOR_SKY = 3 _PRIMITIVE_LINE_LOOP :: Int _PRIMITIVE_LINE_LOOP = 3 _LIGHT_PARAM_SPECULAR :: Int _LIGHT_PARAM_SPECULAR = 2 _VIEWPORT_MSAA_EXT_2X :: Int _VIEWPORT_MSAA_EXT_2X = 5 _CANVAS_LIGHT_MODE_SUB :: Int _CANVAS_LIGHT_MODE_SUB = 1 _VIEWPORT_USAGE_3D :: Int _VIEWPORT_USAGE_3D = 2 _GLOW_BLEND_MODE_SOFTLIGHT :: Int _GLOW_BLEND_MODE_SOFTLIGHT = 2 _PRIMITIVE_TRIANGLE_FAN :: Int _PRIMITIVE_TRIANGLE_FAN = 6 _VIEWPORT_DEBUG_DRAW_UNSHADED :: Int _VIEWPORT_DEBUG_DRAW_UNSHADED = 1 _MATERIAL_RENDER_PRIORITY_MIN :: Int _MATERIAL_RENDER_PRIORITY_MIN = -128 _LIGHT_OMNI_SHADOW_DETAIL_VERTICAL :: Int _LIGHT_OMNI_SHADOW_DETAIL_VERTICAL = 0 _INSTANCE_FLAG_MAX :: Int _INSTANCE_FLAG_MAX = 2 _MULTIMESH_TRANSFORM_3D :: Int _MULTIMESH_TRANSFORM_3D = 1 _SCENARIO_DEBUG_OVERDRAW :: Int _SCENARIO_DEBUG_OVERDRAW = 2 _ARRAY_FORMAT_NORMAL :: Int _ARRAY_FORMAT_NORMAL = 2 _MULTIMESH_CUSTOM_DATA_8BIT :: Int _MULTIMESH_CUSTOM_DATA_8BIT = 1 _ARRAY_TEX_UV2 :: Int _ARRAY_TEX_UV2 = 5 _ENV_DOF_BLUR_QUALITY_MEDIUM :: Int _ENV_DOF_BLUR_QUALITY_MEDIUM = 1 _TEXTURE_TYPE_2D :: Int _TEXTURE_TYPE_2D = 0 _ENV_BG_SKY :: Int _ENV_BG_SKY = 2 _FEATURE_SHADERS :: Int _FEATURE_SHADERS = 0 _CUBEMAP_TOP :: Int _CUBEMAP_TOP = 3 _PARTICLES_DRAW_ORDER_VIEW_DEPTH :: Int _PARTICLES_DRAW_ORDER_VIEW_DEPTH = 2 _CUBEMAP_BACK :: Int _CUBEMAP_BACK = 5 _LIGHT_SPOT :: Int _LIGHT_SPOT = 2 _LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS :: Int _LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS = 2 _INSTANCE_PARTICLES :: Int _INSTANCE_PARTICLES = 4 _TEXTURE_FLAG_REPEAT :: Int _TEXTURE_FLAG_REPEAT = 2 _LIGHT_PARAM_SPOT_ATTENUATION :: Int _LIGHT_PARAM_SPOT_ATTENUATION = 6 _REFLECTION_PROBE_UPDATE_ONCE :: Int _REFLECTION_PROBE_UPDATE_ONCE = 0 _ARRAY_COMPRESS_DEFAULT :: Int _ARRAY_COMPRESS_DEFAULT = 97280 _CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE :: Int _CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE = 2 _CANVAS_ITEM_Z_MAX :: Int _CANVAS_ITEM_Z_MAX = 4096 _ENV_TONE_MAPPER_LINEAR :: Int _ENV_TONE_MAPPER_LINEAR = 0 _LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET :: Int _LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET = 11 _VIEWPORT_RENDER_INFO_VERTICES_IN_FRAME :: Int _VIEWPORT_RENDER_INFO_VERTICES_IN_FRAME = 1 _MULTIMESH_CUSTOM_DATA_NONE :: Int _MULTIMESH_CUSTOM_DATA_NONE = 0 _LIGHT_OMNI :: Int _LIGHT_OMNI = 1 _ENV_BG_MAX :: Int _ENV_BG_MAX = 7 _INSTANCE_REFLECTION_PROBE :: Int _INSTANCE_REFLECTION_PROBE = 6 _INFO_TEXTURE_MEM_USED :: Int _INFO_TEXTURE_MEM_USED = 8 _INSTANCE_NONE :: Int _INSTANCE_NONE = 0 _SHADER_CANVAS_ITEM :: Int _SHADER_CANVAS_ITEM = 1 _ENV_SSAO_QUALITY_MEDIUM :: Int _ENV_SSAO_QUALITY_MEDIUM = 1 _CANVAS_LIGHT_FILTER_PCF3 :: Int _CANVAS_LIGHT_FILTER_PCF3 = 1 _ARRAY_FORMAT_BONES :: Int _ARRAY_FORMAT_BONES = 64 _LIGHT_PARAM_SPOT_ANGLE :: Int _LIGHT_PARAM_SPOT_ANGLE = 5 _ARRAY_WEIGHTS_SIZE :: Int _ARRAY_WEIGHTS_SIZE = 4 _SHADOW_CASTING_SETTING_DOUBLE_SIDED :: Int _SHADOW_CASTING_SETTING_DOUBLE_SIDED = 2 _ENV_SSAO_QUALITY_HIGH :: Int _ENV_SSAO_QUALITY_HIGH = 2 _INFO_VERTICES_IN_FRAME :: Int _INFO_VERTICES_IN_FRAME = 1 _INFO_VIDEO_MEM_USED :: Int _INFO_VIDEO_MEM_USED = 7 _GLOW_BLEND_MODE_REPLACE :: Int _GLOW_BLEND_MODE_REPLACE = 3 _NINE_PATCH_TILE_FIT :: Int _NINE_PATCH_TILE_FIT = 2 _VIEWPORT_UPDATE_ONCE :: Int _VIEWPORT_UPDATE_ONCE = 1 _ARRAY_COMPRESS_COLOR :: Int _ARRAY_COMPRESS_COLOR = 4096 _GLOW_BLEND_MODE_SCREEN :: Int _GLOW_BLEND_MODE_SCREEN = 1 _MAX_CURSORS :: Int _MAX_CURSORS = 8 _TEXTURE_FLAG_CONVERT_TO_LINEAR :: Int _TEXTURE_FLAG_CONVERT_TO_LINEAR = 16 _PRIMITIVE_MAX :: Int _PRIMITIVE_MAX = 7 _LIGHT_PARAM_CONTACT_SHADOW_SIZE :: Int _LIGHT_PARAM_CONTACT_SHADOW_SIZE = 7 _INSTANCE_MAX :: Int _INSTANCE_MAX = 9 _ENV_SSAO_BLUR_3x3 :: Int _ENV_SSAO_BLUR_3x3 = 3 _ARRAY_WEIGHTS :: Int _ARRAY_WEIGHTS = 7 _LIGHT_PARAM_MAX :: Int _LIGHT_PARAM_MAX = 15 _CUBEMAP_BOTTOM :: Int _CUBEMAP_BOTTOM = 2 _ARRAY_TANGENT :: Int _ARRAY_TANGENT = 2 _SCENARIO_DEBUG_SHADELESS :: Int _SCENARIO_DEBUG_SHADELESS = 3 _INFO_OBJECTS_IN_FRAME :: Int _INFO_OBJECTS_IN_FRAME = 0 _INSTANCE_GI_PROBE :: Int _INSTANCE_GI_PROBE = 7 _LIGHT_PARAM_SHADOW_NORMAL_BIAS :: Int _LIGHT_PARAM_SHADOW_NORMAL_BIAS = 12 _VIEWPORT_USAGE_2D_NO_SAMPLING :: Int _VIEWPORT_USAGE_2D_NO_SAMPLING = 1 _ENV_SSAO_BLUR_2x2 :: Int _ENV_SSAO_BLUR_2x2 = 2 _VIEWPORT_UPDATE_DISABLED :: Int _VIEWPORT_UPDATE_DISABLED = 0 _SHADOW_CASTING_SETTING_OFF :: Int _SHADOW_CASTING_SETTING_OFF = 0 _VIEWPORT_MSAA_16X :: Int _VIEWPORT_MSAA_16X = 4 _CANVAS_LIGHT_FILTER_PCF9 :: Int _CANVAS_LIGHT_FILTER_PCF9 = 4 _ENV_SSAO_BLUR_DISABLED :: Int _ENV_SSAO_BLUR_DISABLED = 0 _TEXTURE_FLAG_ANISOTROPIC_FILTER :: Int _TEXTURE_FLAG_ANISOTROPIC_FILTER = 8 _FEATURE_MULTITHREADED :: Int _FEATURE_MULTITHREADED = 1 _ENV_SSAO_BLUR_1x1 :: Int _ENV_SSAO_BLUR_1x1 = 1 _INFO_DRAW_CALLS_IN_FRAME :: Int _INFO_DRAW_CALLS_IN_FRAME = 5 _ENV_BG_COLOR :: Int _ENV_BG_COLOR = 1 _ENV_TONE_MAPPER_ACES :: Int _ENV_TONE_MAPPER_ACES = 3 _LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE :: Int _LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE = 0 _LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_OPTIMIZED :: Int _LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_OPTIMIZED = 1 _ARRAY_COMPRESS_TEX_UV2 :: Int _ARRAY_COMPRESS_TEX_UV2 = 16384 _MULTIMESH_COLOR_8BIT :: Int _MULTIMESH_COLOR_8BIT = 1 _MULTIMESH_TRANSFORM_2D :: Int _MULTIMESH_TRANSFORM_2D = 0 _VIEWPORT_UPDATE_WHEN_VISIBLE :: Int _VIEWPORT_UPDATE_WHEN_VISIBLE = 2 _VIEWPORT_MSAA_EXT_4X :: Int _VIEWPORT_MSAA_EXT_4X = 6 _INSTANCE_LIGHT :: Int _INSTANCE_LIGHT = 5 _TEXTURE_TYPE_3D :: Int _TEXTURE_TYPE_3D = 3 _TEXTURE_FLAG_MIPMAPS :: Int _TEXTURE_FLAG_MIPMAPS = 1 _PRIMITIVE_LINE_STRIP :: Int _PRIMITIVE_LINE_STRIP = 2 _TEXTURE_FLAG_FILTER :: Int _TEXTURE_FLAG_FILTER = 4 _ENV_BG_KEEP :: Int _ENV_BG_KEEP = 5 _CANVAS_LIGHT_FILTER_NONE :: Int _CANVAS_LIGHT_FILTER_NONE = 0 _CUBEMAP_FRONT :: Int _CUBEMAP_FRONT = 4 _TEXTURE_FLAG_USED_FOR_STREAMING :: Int _TEXTURE_FLAG_USED_FOR_STREAMING = 2048 _INFO_VERTEX_MEM_USED :: Int _INFO_VERTEX_MEM_USED = 9 _TEXTURE_FLAG_MIRRORED_REPEAT :: Int _TEXTURE_FLAG_MIRRORED_REPEAT = 32 _PRIMITIVE_LINES :: Int _PRIMITIVE_LINES = 1 _VIEWPORT_RENDER_INFO_OBJECTS_IN_FRAME :: Int _VIEWPORT_RENDER_INFO_OBJECTS_IN_FRAME = 0 _ENV_BG_CLEAR_COLOR :: Int _ENV_BG_CLEAR_COLOR = 0 _SHADOW_CASTING_SETTING_ON :: Int _SHADOW_CASTING_SETTING_ON = 1 _SCENARIO_DEBUG_WIREFRAME :: Int _SCENARIO_DEBUG_WIREFRAME = 1 _CANVAS_LIGHT_MODE_ADD :: Int _CANVAS_LIGHT_MODE_ADD = 0 _LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE :: Int _LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE = 14 _VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME :: Int _VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME = 5 _ARRAY_BONES :: Int _ARRAY_BONES = 6 _LIGHT_PARAM_ATTENUATION :: Int _LIGHT_PARAM_ATTENUATION = 4 _VIEWPORT_DEBUG_DRAW_WIREFRAME :: Int _VIEWPORT_DEBUG_DRAW_WIREFRAME = 3 _CANVAS_LIGHT_MODE_MIX :: Int _CANVAS_LIGHT_MODE_MIX = 2 _NINE_PATCH_TILE :: Int _NINE_PATCH_TILE = 1 _VIEWPORT_RENDER_INFO_SHADER_CHANGES_IN_FRAME :: Int _VIEWPORT_RENDER_INFO_SHADER_CHANGES_IN_FRAME = 3 _INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE :: Int _INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE = 1 _CANVAS_LIGHT_MODE_MASK :: Int _CANVAS_LIGHT_MODE_MASK = 3 _LIGHT_PARAM_RANGE :: Int _LIGHT_PARAM_RANGE = 3 _BLEND_SHAPE_MODE_RELATIVE :: Int _BLEND_SHAPE_MODE_RELATIVE = 1 _VIEWPORT_MSAA_4X :: Int _VIEWPORT_MSAA_4X = 2 _LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET :: Int _LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET = 9 _ENV_TONE_MAPPER_REINHARD :: Int _ENV_TONE_MAPPER_REINHARD = 1 _CANVAS_LIGHT_FILTER_PCF13 :: Int _CANVAS_LIGHT_FILTER_PCF13 = 5 _MULTIMESH_CUSTOM_DATA_FLOAT :: Int _MULTIMESH_CUSTOM_DATA_FLOAT = 2 _NO_INDEX_ARRAY :: Int _NO_INDEX_ARRAY = -1 _ARRAY_VERTEX :: Int _ARRAY_VERTEX = 0 _ARRAY_FLAG_USE_2D_VERTICES :: Int _ARRAY_FLAG_USE_2D_VERTICES = 262144 _CANVAS_LIGHT_FILTER_PCF5 :: Int _CANVAS_LIGHT_FILTER_PCF5 = 2 _LIGHT_DIRECTIONAL :: Int _LIGHT_DIRECTIONAL = 0 _ARRAY_COMPRESS_INDEX :: Int _ARRAY_COMPRESS_INDEX = 131072 _INSTANCE_FLAG_USE_BAKED_LIGHT :: Int _INSTANCE_FLAG_USE_BAKED_LIGHT = 0 _CUBEMAP_LEFT :: Int _CUBEMAP_LEFT = 0 _LIGHT_PARAM_SHADOW_BIAS :: Int _LIGHT_PARAM_SHADOW_BIAS = 13 _ARRAY_FORMAT_WEIGHTS :: Int _ARRAY_FORMAT_WEIGHTS = 128 _SHADER_PARTICLES :: Int _SHADER_PARTICLES = 2 _ARRAY_FORMAT_TANGENT :: Int _ARRAY_FORMAT_TANGENT = 4 _PRIMITIVE_POINTS :: Int _PRIMITIVE_POINTS = 0 -- | Emitted at the end of the frame, after the VisualServer has finished updating all the Viewports. sig_frame_post_draw :: Godot.Internal.Dispatch.Signal VisualServer sig_frame_post_draw = Godot.Internal.Dispatch.Signal "frame_post_draw" instance NodeSignal VisualServer "frame_post_draw" '[] -- | Emitted at the beginning of the frame, before the VisualServer updates all the Viewports. sig_frame_pre_draw :: Godot.Internal.Dispatch.Signal VisualServer sig_frame_pre_draw = Godot.Internal.Dispatch.Signal "frame_pre_draw" instance NodeSignal VisualServer "frame_pre_draw" '[] {-# NOINLINE bindVisualServer_black_bars_set_images #-} -- | Sets images to be rendered in the window margin. bindVisualServer_black_bars_set_images :: MethodBind bindVisualServer_black_bars_set_images = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "black_bars_set_images" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets images to be rendered in the window margin. black_bars_set_images :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Rid -> Rid -> IO () black_bars_set_images cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_black_bars_set_images (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "black_bars_set_images" '[Rid, Rid, Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.black_bars_set_images {-# NOINLINE bindVisualServer_black_bars_set_margins #-} -- | Sets margin size, where black bars (or images, if @method black_bars_set_images@ was used) are rendered. bindVisualServer_black_bars_set_margins :: MethodBind bindVisualServer_black_bars_set_margins = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "black_bars_set_margins" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets margin size, where black bars (or images, if @method black_bars_set_images@ was used) are rendered. black_bars_set_margins :: (VisualServer :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> IO () black_bars_set_margins cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_black_bars_set_margins (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "black_bars_set_margins" '[Int, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.black_bars_set_margins {-# NOINLINE bindVisualServer_camera_create #-} -- | Creates a camera and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @camera_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_camera_create :: MethodBind bindVisualServer_camera_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "camera_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a camera and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @camera_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. camera_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid camera_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_camera_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "camera_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.camera_create {-# NOINLINE bindVisualServer_camera_set_cull_mask #-} -- | Sets the cull mask associated with this camera. The cull mask describes which 3D layers are rendered by this camera. Equivalent to @Camera.cull_mask@. bindVisualServer_camera_set_cull_mask :: MethodBind bindVisualServer_camera_set_cull_mask = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "camera_set_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the cull mask associated with this camera. The cull mask describes which 3D layers are rendered by this camera. Equivalent to @Camera.cull_mask@. camera_set_cull_mask :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () camera_set_cull_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_camera_set_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "camera_set_cull_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.camera_set_cull_mask {-# NOINLINE bindVisualServer_camera_set_environment #-} -- | Sets the environment used by this camera. Equivalent to @Camera.environment@. bindVisualServer_camera_set_environment :: MethodBind bindVisualServer_camera_set_environment = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "camera_set_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the environment used by this camera. Equivalent to @Camera.environment@. camera_set_environment :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () camera_set_environment cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_camera_set_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "camera_set_environment" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.camera_set_environment {-# NOINLINE bindVisualServer_camera_set_frustum #-} -- | Sets camera to use frustum projection. This mode allows adjusting the @offset@ argument to create "tilted frustum" effects. bindVisualServer_camera_set_frustum :: MethodBind bindVisualServer_camera_set_frustum = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "camera_set_frustum" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets camera to use frustum projection. This mode allows adjusting the @offset@ argument to create "tilted frustum" effects. camera_set_frustum :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> Vector2 -> Float -> Float -> IO () camera_set_frustum cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_camera_set_frustum (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "camera_set_frustum" '[Rid, Float, Vector2, Float, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.camera_set_frustum {-# NOINLINE bindVisualServer_camera_set_orthogonal #-} -- | Sets camera to use orthogonal projection, also known as orthographic projection. Objects remain the same size on the screen no matter how far away they are. bindVisualServer_camera_set_orthogonal :: MethodBind bindVisualServer_camera_set_orthogonal = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "camera_set_orthogonal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets camera to use orthogonal projection, also known as orthographic projection. Objects remain the same size on the screen no matter how far away they are. camera_set_orthogonal :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> Float -> Float -> IO () camera_set_orthogonal cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_camera_set_orthogonal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "camera_set_orthogonal" '[Rid, Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.camera_set_orthogonal {-# NOINLINE bindVisualServer_camera_set_perspective #-} -- | Sets camera to use perspective projection. Objects on the screen becomes smaller when they are far away. bindVisualServer_camera_set_perspective :: MethodBind bindVisualServer_camera_set_perspective = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "camera_set_perspective" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets camera to use perspective projection. Objects on the screen becomes smaller when they are far away. camera_set_perspective :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> Float -> Float -> IO () camera_set_perspective cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_camera_set_perspective (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "camera_set_perspective" '[Rid, Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.camera_set_perspective {-# NOINLINE bindVisualServer_camera_set_transform #-} -- | Sets @Transform@ of camera. bindVisualServer_camera_set_transform :: MethodBind bindVisualServer_camera_set_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "camera_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets @Transform@ of camera. camera_set_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform -> IO () camera_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_camera_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "camera_set_transform" '[Rid, Transform] (IO ()) where nodeMethod = Godot.Core.VisualServer.camera_set_transform {-# NOINLINE bindVisualServer_camera_set_use_vertical_aspect #-} -- | If @true@, preserves the horizontal aspect ratio which is equivalent to @Camera.KEEP_WIDTH@. If @false@, preserves the vertical aspect ratio which is equivalent to @Camera.KEEP_HEIGHT@. bindVisualServer_camera_set_use_vertical_aspect :: MethodBind bindVisualServer_camera_set_use_vertical_aspect = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "camera_set_use_vertical_aspect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, preserves the horizontal aspect ratio which is equivalent to @Camera.KEEP_WIDTH@. If @false@, preserves the vertical aspect ratio which is equivalent to @Camera.KEEP_HEIGHT@. camera_set_use_vertical_aspect :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () camera_set_use_vertical_aspect cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_camera_set_use_vertical_aspect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "camera_set_use_vertical_aspect" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.camera_set_use_vertical_aspect {-# NOINLINE bindVisualServer_canvas_create #-} -- | Creates a canvas and returns the assigned @RID@. It can be accessed with the RID that is returned. This RID will be used in all @canvas_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_canvas_create :: MethodBind bindVisualServer_canvas_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a canvas and returns the assigned @RID@. It can be accessed with the RID that is returned. This RID will be used in all @canvas_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. canvas_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid canvas_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.canvas_create {-# NOINLINE bindVisualServer_canvas_item_add_circle #-} -- | Adds a circle command to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_circle :: MethodBind bindVisualServer_canvas_item_add_circle = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_circle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a circle command to the @CanvasItem@'s draw commands. canvas_item_add_circle :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> Float -> Color -> IO () canvas_item_add_circle cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_circle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_circle" '[Rid, Vector2, Float, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_circle {-# NOINLINE bindVisualServer_canvas_item_add_clip_ignore #-} -- | If ignore is @true@, the VisualServer does not perform clipping. bindVisualServer_canvas_item_add_clip_ignore :: MethodBind bindVisualServer_canvas_item_add_clip_ignore = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_clip_ignore" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If ignore is @true@, the VisualServer does not perform clipping. canvas_item_add_clip_ignore :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_item_add_clip_ignore cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_clip_ignore (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_clip_ignore" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_clip_ignore {-# NOINLINE bindVisualServer_canvas_item_add_line #-} -- | Adds a line command to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_line :: MethodBind bindVisualServer_canvas_item_add_line = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a line command to the @CanvasItem@'s draw commands. canvas_item_add_line :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> Vector2 -> Color -> Maybe Float -> Maybe Bool -> IO () canvas_item_add_line cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantReal (1)) toVariant arg5, maybe (VariantBool False) toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_line" '[Rid, Vector2, Vector2, Color, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_line {-# NOINLINE bindVisualServer_canvas_item_add_mesh #-} -- | Adds a mesh command to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_mesh :: MethodBind bindVisualServer_canvas_item_add_mesh = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a mesh command to the @CanvasItem@'s draw commands. canvas_item_add_mesh :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Maybe Transform2d -> Maybe Color -> Maybe Rid -> Maybe Rid -> IO () canvas_item_add_mesh cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantTransform2d (TF2d (V2 1 0) (V2 0 1) (V2 0 0)) arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4, maybe VariantNil toVariant arg5, maybe VariantNil toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_mesh" '[Rid, Rid, Maybe Transform2d, Maybe Color, Maybe Rid, Maybe Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_mesh {-# NOINLINE bindVisualServer_canvas_item_add_multimesh #-} -- | Adds a @MultiMesh@ to the @CanvasItem@'s draw commands. Only affects its aabb at the moment. bindVisualServer_canvas_item_add_multimesh :: MethodBind bindVisualServer_canvas_item_add_multimesh = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_multimesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @MultiMesh@ to the @CanvasItem@'s draw commands. Only affects its aabb at the moment. canvas_item_add_multimesh :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Rid -> Maybe Rid -> IO () canvas_item_add_multimesh cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_multimesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_multimesh" '[Rid, Rid, Rid, Maybe Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_multimesh {-# NOINLINE bindVisualServer_canvas_item_add_nine_patch #-} -- | Adds a nine patch image to the @CanvasItem@'s draw commands. -- See @NinePatchRect@ for more explanation. bindVisualServer_canvas_item_add_nine_patch :: MethodBind bindVisualServer_canvas_item_add_nine_patch = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_nine_patch" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a nine patch image to the @CanvasItem@'s draw commands. -- See @NinePatchRect@ for more explanation. canvas_item_add_nine_patch :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rect2 -> Rect2 -> Rid -> Vector2 -> Vector2 -> Maybe Int -> Maybe Int -> Maybe Bool -> Maybe Color -> Maybe Rid -> IO () canvas_item_add_nine_patch cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, maybe (VariantInt (0)) toVariant arg7, maybe (VariantInt (0)) toVariant arg8, maybe (VariantBool True) toVariant arg9, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg10, maybe VariantNil toVariant arg11] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_nine_patch (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_nine_patch" '[Rid, Rect2, Rect2, Rid, Vector2, Vector2, Maybe Int, Maybe Int, Maybe Bool, Maybe Color, Maybe Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_nine_patch {-# NOINLINE bindVisualServer_canvas_item_add_particles #-} -- | Adds a particle system to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_particles :: MethodBind bindVisualServer_canvas_item_add_particles = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_particles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a particle system to the @CanvasItem@'s draw commands. canvas_item_add_particles :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Rid -> Rid -> IO () canvas_item_add_particles cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_particles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_particles" '[Rid, Rid, Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_particles {-# NOINLINE bindVisualServer_canvas_item_add_polygon #-} -- | Adds a polygon to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_polygon :: MethodBind bindVisualServer_canvas_item_add_polygon = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a polygon to the @CanvasItem@'s draw commands. canvas_item_add_polygon :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolVector2Array -> PoolColorArray -> Maybe PoolVector2Array -> Maybe Rid -> Maybe Rid -> Maybe Bool -> IO () canvas_item_add_polygon cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantPoolVector2Array V.empty arg4, maybe VariantNil toVariant arg5, maybe VariantNil toVariant arg6, maybe (VariantBool False) toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_polygon" '[Rid, PoolVector2Array, PoolColorArray, Maybe PoolVector2Array, Maybe Rid, Maybe Rid, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_polygon {-# NOINLINE bindVisualServer_canvas_item_add_polyline #-} -- | Adds a polyline, which is a line from multiple points with a width, to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_polyline :: MethodBind bindVisualServer_canvas_item_add_polyline = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_polyline" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a polyline, which is a line from multiple points with a width, to the @CanvasItem@'s draw commands. canvas_item_add_polyline :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolVector2Array -> PoolColorArray -> Maybe Float -> Maybe Bool -> IO () canvas_item_add_polyline cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantReal (1)) toVariant arg4, maybe (VariantBool False) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_polyline (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_polyline" '[Rid, PoolVector2Array, PoolColorArray, Maybe Float, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_polyline {-# NOINLINE bindVisualServer_canvas_item_add_primitive #-} -- | Adds a primitive to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_primitive :: MethodBind bindVisualServer_canvas_item_add_primitive = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_primitive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a primitive to the @CanvasItem@'s draw commands. canvas_item_add_primitive :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolVector2Array -> PoolColorArray -> PoolVector2Array -> Rid -> Maybe Float -> Maybe Rid -> IO () canvas_item_add_primitive cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, maybe (VariantReal (1)) toVariant arg6, maybe VariantNil toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_primitive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_primitive" '[Rid, PoolVector2Array, PoolColorArray, PoolVector2Array, Rid, Maybe Float, Maybe Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_primitive {-# NOINLINE bindVisualServer_canvas_item_add_rect #-} -- | Adds a rectangle to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_rect :: MethodBind bindVisualServer_canvas_item_add_rect = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a rectangle to the @CanvasItem@'s draw commands. canvas_item_add_rect :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rect2 -> Color -> IO () canvas_item_add_rect cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_rect" '[Rid, Rect2, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_rect {-# NOINLINE bindVisualServer_canvas_item_add_set_transform #-} -- | Adds a @Transform2D@ command to the @CanvasItem@'s draw commands. -- This sets the extra_matrix uniform when executed. This affects the later commands of the canvas item. bindVisualServer_canvas_item_add_set_transform :: MethodBind bindVisualServer_canvas_item_add_set_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a @Transform2D@ command to the @CanvasItem@'s draw commands. -- This sets the extra_matrix uniform when executed. This affects the later commands of the canvas item. canvas_item_add_set_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform2d -> IO () canvas_item_add_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_set_transform" '[Rid, Transform2d] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_set_transform {-# NOINLINE bindVisualServer_canvas_item_add_texture_rect #-} -- | Adds a textured rect to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_texture_rect :: MethodBind bindVisualServer_canvas_item_add_texture_rect = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_texture_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a textured rect to the @CanvasItem@'s draw commands. canvas_item_add_texture_rect :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rect2 -> Rid -> Maybe Bool -> Maybe Color -> Maybe Bool -> Maybe Rid -> IO () canvas_item_add_texture_rect cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantBool False) toVariant arg4, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg5, maybe (VariantBool False) toVariant arg6, maybe VariantNil toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_texture_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_texture_rect" '[Rid, Rect2, Rid, Maybe Bool, Maybe Color, Maybe Bool, Maybe Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_texture_rect {-# NOINLINE bindVisualServer_canvas_item_add_texture_rect_region #-} -- | Adds a texture rect with region setting to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_texture_rect_region :: MethodBind bindVisualServer_canvas_item_add_texture_rect_region = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_texture_rect_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a texture rect with region setting to the @CanvasItem@'s draw commands. canvas_item_add_texture_rect_region :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rect2 -> Rid -> Rect2 -> Maybe Color -> Maybe Bool -> Maybe Rid -> Maybe Bool -> IO () canvas_item_add_texture_rect_region cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg5, maybe (VariantBool False) toVariant arg6, maybe VariantNil toVariant arg7, maybe (VariantBool True) toVariant arg8] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_texture_rect_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_texture_rect_region" '[Rid, Rect2, Rid, Rect2, Maybe Color, Maybe Bool, Maybe Rid, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_texture_rect_region {-# NOINLINE bindVisualServer_canvas_item_add_triangle_array #-} -- | Adds a triangle array to the @CanvasItem@'s draw commands. bindVisualServer_canvas_item_add_triangle_array :: MethodBind bindVisualServer_canvas_item_add_triangle_array = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_add_triangle_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a triangle array to the @CanvasItem@'s draw commands. canvas_item_add_triangle_array :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolIntArray -> PoolVector2Array -> PoolColorArray -> Maybe PoolVector2Array -> Maybe PoolIntArray -> Maybe PoolRealArray -> Maybe Rid -> Maybe Int -> Maybe Rid -> Maybe Bool -> Maybe Bool -> IO () canvas_item_add_triangle_array cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 arg12 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, defaultedVariant VariantPoolVector2Array V.empty arg5, defaultedVariant VariantPoolIntArray V.empty arg6, defaultedVariant VariantPoolRealArray V.empty arg7, maybe VariantNil toVariant arg8, maybe (VariantInt (-1)) toVariant arg9, maybe VariantNil toVariant arg10, maybe (VariantBool False) toVariant arg11, maybe (VariantBool False) toVariant arg12] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_add_triangle_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_add_triangle_array" '[Rid, PoolIntArray, PoolVector2Array, PoolColorArray, Maybe PoolVector2Array, Maybe PoolIntArray, Maybe PoolRealArray, Maybe Rid, Maybe Int, Maybe Rid, Maybe Bool, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_add_triangle_array {-# NOINLINE bindVisualServer_canvas_item_clear #-} -- | Clears the @CanvasItem@ and removes all commands in it. bindVisualServer_canvas_item_clear :: MethodBind bindVisualServer_canvas_item_clear = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears the @CanvasItem@ and removes all commands in it. canvas_item_clear :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO () canvas_item_clear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_clear" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_clear {-# NOINLINE bindVisualServer_canvas_item_create #-} -- | Creates a new @CanvasItem@ and returns its @RID@. It can be accessed with the RID that is returned. This RID will be used in all @canvas_item_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_canvas_item_create :: MethodBind bindVisualServer_canvas_item_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new @CanvasItem@ and returns its @RID@. It can be accessed with the RID that is returned. This RID will be used in all @canvas_item_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. canvas_item_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid canvas_item_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.canvas_item_create {-# NOINLINE bindVisualServer_canvas_item_set_clip #-} -- | Sets clipping for the @CanvasItem@. bindVisualServer_canvas_item_set_clip :: MethodBind bindVisualServer_canvas_item_set_clip = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_clip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets clipping for the @CanvasItem@. canvas_item_set_clip :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_item_set_clip cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_clip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_clip" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_clip {-# NOINLINE bindVisualServer_canvas_item_set_copy_to_backbuffer #-} -- | Sets the @CanvasItem@ to copy a rect to the backbuffer. bindVisualServer_canvas_item_set_copy_to_backbuffer :: MethodBind bindVisualServer_canvas_item_set_copy_to_backbuffer = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_copy_to_backbuffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @CanvasItem@ to copy a rect to the backbuffer. canvas_item_set_copy_to_backbuffer :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Rect2 -> IO () canvas_item_set_copy_to_backbuffer cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_copy_to_backbuffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_copy_to_backbuffer" '[Rid, Bool, Rect2] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_copy_to_backbuffer {-# NOINLINE bindVisualServer_canvas_item_set_custom_rect #-} -- | Defines a custom drawing rectangle for the @CanvasItem@. bindVisualServer_canvas_item_set_custom_rect :: MethodBind bindVisualServer_canvas_item_set_custom_rect = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_custom_rect" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines a custom drawing rectangle for the @CanvasItem@. canvas_item_set_custom_rect :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Maybe Rect2 -> IO () canvas_item_set_custom_rect cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantRect2 (V2 (V2 0 0) (V2 0 0)) arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_custom_rect (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_custom_rect" '[Rid, Bool, Maybe Rect2] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_custom_rect {-# NOINLINE bindVisualServer_canvas_item_set_distance_field_mode #-} -- | Enables the use of distance fields for GUI elements that are rendering distance field based fonts. bindVisualServer_canvas_item_set_distance_field_mode :: MethodBind bindVisualServer_canvas_item_set_distance_field_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_distance_field_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables the use of distance fields for GUI elements that are rendering distance field based fonts. canvas_item_set_distance_field_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_item_set_distance_field_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_distance_field_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_distance_field_mode" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_distance_field_mode {-# NOINLINE bindVisualServer_canvas_item_set_draw_behind_parent #-} -- | Sets @CanvasItem@ to be drawn behind its parent. bindVisualServer_canvas_item_set_draw_behind_parent :: MethodBind bindVisualServer_canvas_item_set_draw_behind_parent = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_draw_behind_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets @CanvasItem@ to be drawn behind its parent. canvas_item_set_draw_behind_parent :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_item_set_draw_behind_parent cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_draw_behind_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_draw_behind_parent" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_draw_behind_parent {-# NOINLINE bindVisualServer_canvas_item_set_draw_index #-} -- | Sets the index for the @CanvasItem@. bindVisualServer_canvas_item_set_draw_index :: MethodBind bindVisualServer_canvas_item_set_draw_index = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_draw_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the index for the @CanvasItem@. canvas_item_set_draw_index :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_item_set_draw_index cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_draw_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_draw_index" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_draw_index {-# NOINLINE bindVisualServer_canvas_item_set_light_mask #-} -- | The light mask. See @LightOccluder2D@ for more information on light masks. bindVisualServer_canvas_item_set_light_mask :: MethodBind bindVisualServer_canvas_item_set_light_mask = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_light_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light mask. See @LightOccluder2D@ for more information on light masks. canvas_item_set_light_mask :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_item_set_light_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_light_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_light_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_light_mask {-# NOINLINE bindVisualServer_canvas_item_set_material #-} -- | Sets a new material to the @CanvasItem@. bindVisualServer_canvas_item_set_material :: MethodBind bindVisualServer_canvas_item_set_material = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a new material to the @CanvasItem@. canvas_item_set_material :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () canvas_item_set_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_material" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_material {-# NOINLINE bindVisualServer_canvas_item_set_modulate #-} -- | Sets the color that modulates the @CanvasItem@ and its children. bindVisualServer_canvas_item_set_modulate :: MethodBind bindVisualServer_canvas_item_set_modulate = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color that modulates the @CanvasItem@ and its children. canvas_item_set_modulate :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () canvas_item_set_modulate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_modulate" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_modulate {-# NOINLINE bindVisualServer_canvas_item_set_parent #-} -- | Sets the parent for the @CanvasItem@. The parent can be another canvas item, or it can be the root canvas that is attached to the viewport. bindVisualServer_canvas_item_set_parent :: MethodBind bindVisualServer_canvas_item_set_parent = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the parent for the @CanvasItem@. The parent can be another canvas item, or it can be the root canvas that is attached to the viewport. canvas_item_set_parent :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () canvas_item_set_parent cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_parent" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_parent {-# NOINLINE bindVisualServer_canvas_item_set_self_modulate #-} -- | Sets the color that modulates the @CanvasItem@ without children. bindVisualServer_canvas_item_set_self_modulate :: MethodBind bindVisualServer_canvas_item_set_self_modulate = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_self_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color that modulates the @CanvasItem@ without children. canvas_item_set_self_modulate :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () canvas_item_set_self_modulate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_self_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_self_modulate" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_self_modulate {-# NOINLINE bindVisualServer_canvas_item_set_sort_children_by_y #-} -- | Sets if @CanvasItem@'s children should be sorted by y-position. bindVisualServer_canvas_item_set_sort_children_by_y :: MethodBind bindVisualServer_canvas_item_set_sort_children_by_y = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_sort_children_by_y" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets if @CanvasItem@'s children should be sorted by y-position. canvas_item_set_sort_children_by_y :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_item_set_sort_children_by_y cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_sort_children_by_y (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_sort_children_by_y" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_sort_children_by_y {-# NOINLINE bindVisualServer_canvas_item_set_transform #-} -- | Sets the @CanvasItem@'s @Transform2D@. bindVisualServer_canvas_item_set_transform :: MethodBind bindVisualServer_canvas_item_set_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @CanvasItem@'s @Transform2D@. canvas_item_set_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform2d -> IO () canvas_item_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_transform" '[Rid, Transform2d] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_transform {-# NOINLINE bindVisualServer_canvas_item_set_use_parent_material #-} -- | Sets if the @CanvasItem@ uses its parent's material. bindVisualServer_canvas_item_set_use_parent_material :: MethodBind bindVisualServer_canvas_item_set_use_parent_material = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_use_parent_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets if the @CanvasItem@ uses its parent's material. canvas_item_set_use_parent_material :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_item_set_use_parent_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_use_parent_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_use_parent_material" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_use_parent_material {-# NOINLINE bindVisualServer_canvas_item_set_visible #-} -- | Sets if the canvas item (including its children) is visible. bindVisualServer_canvas_item_set_visible :: MethodBind bindVisualServer_canvas_item_set_visible = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets if the canvas item (including its children) is visible. canvas_item_set_visible :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_item_set_visible cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_visible" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_visible {-# NOINLINE bindVisualServer_canvas_item_set_z_as_relative_to_parent #-} -- | If this is enabled, the Z index of the parent will be added to the children's Z index. bindVisualServer_canvas_item_set_z_as_relative_to_parent :: MethodBind bindVisualServer_canvas_item_set_z_as_relative_to_parent = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_z_as_relative_to_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If this is enabled, the Z index of the parent will be added to the children's Z index. canvas_item_set_z_as_relative_to_parent :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_item_set_z_as_relative_to_parent cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_z_as_relative_to_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_z_as_relative_to_parent" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_z_as_relative_to_parent {-# NOINLINE bindVisualServer_canvas_item_set_z_index #-} -- | Sets the @CanvasItem@'s Z index, i.e. its draw order (lower indexes are drawn first). bindVisualServer_canvas_item_set_z_index :: MethodBind bindVisualServer_canvas_item_set_z_index = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_item_set_z_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @CanvasItem@'s Z index, i.e. its draw order (lower indexes are drawn first). canvas_item_set_z_index :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_item_set_z_index cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_item_set_z_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_item_set_z_index" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_item_set_z_index {-# NOINLINE bindVisualServer_canvas_light_attach_to_canvas #-} -- | Attaches the canvas light to the canvas. Removes it from its previous canvas. bindVisualServer_canvas_light_attach_to_canvas :: MethodBind bindVisualServer_canvas_light_attach_to_canvas = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_attach_to_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Attaches the canvas light to the canvas. Removes it from its previous canvas. canvas_light_attach_to_canvas :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () canvas_light_attach_to_canvas cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_attach_to_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_attach_to_canvas" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_attach_to_canvas {-# NOINLINE bindVisualServer_canvas_light_create #-} -- | Creates a canvas light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @canvas_light_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_canvas_light_create :: MethodBind bindVisualServer_canvas_light_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a canvas light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @canvas_light_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. canvas_light_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid canvas_light_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.canvas_light_create {-# NOINLINE bindVisualServer_canvas_light_occluder_attach_to_canvas #-} -- | Attaches a light occluder to the canvas. Removes it from its previous canvas. bindVisualServer_canvas_light_occluder_attach_to_canvas :: MethodBind bindVisualServer_canvas_light_occluder_attach_to_canvas = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_occluder_attach_to_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Attaches a light occluder to the canvas. Removes it from its previous canvas. canvas_light_occluder_attach_to_canvas :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () canvas_light_occluder_attach_to_canvas cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_occluder_attach_to_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_occluder_attach_to_canvas" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_occluder_attach_to_canvas {-# NOINLINE bindVisualServer_canvas_light_occluder_create #-} -- | Creates a light occluder and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @canvas_light_ocluder_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_canvas_light_occluder_create :: MethodBind bindVisualServer_canvas_light_occluder_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_occluder_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a light occluder and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @canvas_light_ocluder_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. canvas_light_occluder_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid canvas_light_occluder_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_occluder_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_occluder_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.canvas_light_occluder_create {-# NOINLINE bindVisualServer_canvas_light_occluder_set_enabled #-} -- | Enables or disables light occluder. bindVisualServer_canvas_light_occluder_set_enabled :: MethodBind bindVisualServer_canvas_light_occluder_set_enabled = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_occluder_set_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables light occluder. canvas_light_occluder_set_enabled :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_light_occluder_set_enabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_occluder_set_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_occluder_set_enabled" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_occluder_set_enabled {-# NOINLINE bindVisualServer_canvas_light_occluder_set_light_mask #-} -- | The light mask. See @LightOccluder2D@ for more information on light masks. bindVisualServer_canvas_light_occluder_set_light_mask :: MethodBind bindVisualServer_canvas_light_occluder_set_light_mask = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_occluder_set_light_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light mask. See @LightOccluder2D@ for more information on light masks. canvas_light_occluder_set_light_mask :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_light_occluder_set_light_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_occluder_set_light_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_occluder_set_light_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_occluder_set_light_mask {-# NOINLINE bindVisualServer_canvas_light_occluder_set_polygon #-} -- | Sets a light occluder's polygon. bindVisualServer_canvas_light_occluder_set_polygon :: MethodBind bindVisualServer_canvas_light_occluder_set_polygon = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_occluder_set_polygon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a light occluder's polygon. canvas_light_occluder_set_polygon :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () canvas_light_occluder_set_polygon cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_occluder_set_polygon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_occluder_set_polygon" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_occluder_set_polygon {-# NOINLINE bindVisualServer_canvas_light_occluder_set_transform #-} -- | Sets a light occluder's @Transform2D@. bindVisualServer_canvas_light_occluder_set_transform :: MethodBind bindVisualServer_canvas_light_occluder_set_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_occluder_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a light occluder's @Transform2D@. canvas_light_occluder_set_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform2d -> IO () canvas_light_occluder_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_occluder_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_occluder_set_transform" '[Rid, Transform2d] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_occluder_set_transform {-# NOINLINE bindVisualServer_canvas_light_set_color #-} -- | Sets the color for a light. bindVisualServer_canvas_light_set_color :: MethodBind bindVisualServer_canvas_light_set_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color for a light. canvas_light_set_color :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () canvas_light_set_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_color" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_color {-# NOINLINE bindVisualServer_canvas_light_set_enabled #-} -- | Enables or disables a canvas light. bindVisualServer_canvas_light_set_enabled :: MethodBind bindVisualServer_canvas_light_set_enabled = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables a canvas light. canvas_light_set_enabled :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_light_set_enabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_enabled" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_enabled {-# NOINLINE bindVisualServer_canvas_light_set_energy #-} -- | Sets a canvas light's energy. bindVisualServer_canvas_light_set_energy :: MethodBind bindVisualServer_canvas_light_set_energy = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a canvas light's energy. canvas_light_set_energy :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () canvas_light_set_energy cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_energy" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_energy {-# NOINLINE bindVisualServer_canvas_light_set_height #-} -- | Sets a canvas light's height. bindVisualServer_canvas_light_set_height :: MethodBind bindVisualServer_canvas_light_set_height = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a canvas light's height. canvas_light_set_height :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () canvas_light_set_height cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_height" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_height {-# NOINLINE bindVisualServer_canvas_light_set_item_cull_mask #-} -- | The light mask. See @LightOccluder2D@ for more information on light masks. bindVisualServer_canvas_light_set_item_cull_mask :: MethodBind bindVisualServer_canvas_light_set_item_cull_mask = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_item_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The light mask. See @LightOccluder2D@ for more information on light masks. canvas_light_set_item_cull_mask :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_light_set_item_cull_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_item_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_item_cull_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_item_cull_mask {-# NOINLINE bindVisualServer_canvas_light_set_item_shadow_cull_mask #-} -- | The binary mask used to determine which layers this canvas light's shadows affects. See @LightOccluder2D@ for more information on light masks. bindVisualServer_canvas_light_set_item_shadow_cull_mask :: MethodBind bindVisualServer_canvas_light_set_item_shadow_cull_mask = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_item_shadow_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The binary mask used to determine which layers this canvas light's shadows affects. See @LightOccluder2D@ for more information on light masks. canvas_light_set_item_shadow_cull_mask :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_light_set_item_shadow_cull_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_item_shadow_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_item_shadow_cull_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_item_shadow_cull_mask {-# NOINLINE bindVisualServer_canvas_light_set_layer_range #-} -- | The layer range that gets rendered with this light. bindVisualServer_canvas_light_set_layer_range :: MethodBind bindVisualServer_canvas_light_set_layer_range = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_layer_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The layer range that gets rendered with this light. canvas_light_set_layer_range :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> IO () canvas_light_set_layer_range cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_layer_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_layer_range" '[Rid, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_layer_range {-# NOINLINE bindVisualServer_canvas_light_set_mode #-} -- | The mode of the light, see @enum CanvasLightMode@ constants. bindVisualServer_canvas_light_set_mode :: MethodBind bindVisualServer_canvas_light_set_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The mode of the light, see @enum CanvasLightMode@ constants. canvas_light_set_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_light_set_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_mode {-# NOINLINE bindVisualServer_canvas_light_set_scale #-} -- | Sets the texture's scale factor of the light. Equivalent to @Light2D.texture_scale@. bindVisualServer_canvas_light_set_scale :: MethodBind bindVisualServer_canvas_light_set_scale = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the texture's scale factor of the light. Equivalent to @Light2D.texture_scale@. canvas_light_set_scale :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () canvas_light_set_scale cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_scale" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_scale {-# NOINLINE bindVisualServer_canvas_light_set_shadow_buffer_size #-} -- | Sets the width of the shadow buffer, size gets scaled to the next power of two for this. bindVisualServer_canvas_light_set_shadow_buffer_size :: MethodBind bindVisualServer_canvas_light_set_shadow_buffer_size = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_shadow_buffer_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the width of the shadow buffer, size gets scaled to the next power of two for this. canvas_light_set_shadow_buffer_size :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_light_set_shadow_buffer_size cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_shadow_buffer_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_shadow_buffer_size" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_shadow_buffer_size {-# NOINLINE bindVisualServer_canvas_light_set_shadow_color #-} -- | Sets the color of the canvas light's shadow. bindVisualServer_canvas_light_set_shadow_color :: MethodBind bindVisualServer_canvas_light_set_shadow_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_shadow_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color of the canvas light's shadow. canvas_light_set_shadow_color :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () canvas_light_set_shadow_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_shadow_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_shadow_color" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_shadow_color {-# NOINLINE bindVisualServer_canvas_light_set_shadow_enabled #-} -- | Enables or disables the canvas light's shadow. bindVisualServer_canvas_light_set_shadow_enabled :: MethodBind bindVisualServer_canvas_light_set_shadow_enabled = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_shadow_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Enables or disables the canvas light's shadow. canvas_light_set_shadow_enabled :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () canvas_light_set_shadow_enabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_shadow_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_shadow_enabled" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_shadow_enabled {-# NOINLINE bindVisualServer_canvas_light_set_shadow_filter #-} -- | Sets the canvas light's shadow's filter, see @enum CanvasLightShadowFilter@ constants. bindVisualServer_canvas_light_set_shadow_filter :: MethodBind bindVisualServer_canvas_light_set_shadow_filter = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_shadow_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the canvas light's shadow's filter, see @enum CanvasLightShadowFilter@ constants. canvas_light_set_shadow_filter :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_light_set_shadow_filter cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_shadow_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_shadow_filter" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_shadow_filter {-# NOINLINE bindVisualServer_canvas_light_set_shadow_gradient_length #-} -- | Sets the length of the shadow's gradient. bindVisualServer_canvas_light_set_shadow_gradient_length :: MethodBind bindVisualServer_canvas_light_set_shadow_gradient_length = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_shadow_gradient_length" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the length of the shadow's gradient. canvas_light_set_shadow_gradient_length :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () canvas_light_set_shadow_gradient_length cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_shadow_gradient_length (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_shadow_gradient_length" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_shadow_gradient_length {-# NOINLINE bindVisualServer_canvas_light_set_shadow_smooth #-} -- | Smoothens the shadow. The lower, the smoother. bindVisualServer_canvas_light_set_shadow_smooth :: MethodBind bindVisualServer_canvas_light_set_shadow_smooth = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_shadow_smooth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Smoothens the shadow. The lower, the smoother. canvas_light_set_shadow_smooth :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () canvas_light_set_shadow_smooth cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_shadow_smooth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_shadow_smooth" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_shadow_smooth {-# NOINLINE bindVisualServer_canvas_light_set_texture #-} -- | Sets texture to be used by light. Equivalent to @Light2D.texture@. bindVisualServer_canvas_light_set_texture :: MethodBind bindVisualServer_canvas_light_set_texture = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets texture to be used by light. Equivalent to @Light2D.texture@. canvas_light_set_texture :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () canvas_light_set_texture cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_texture" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_texture {-# NOINLINE bindVisualServer_canvas_light_set_texture_offset #-} -- | Sets the offset of the light's texture. Equivalent to @Light2D.offset@. bindVisualServer_canvas_light_set_texture_offset :: MethodBind bindVisualServer_canvas_light_set_texture_offset = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_texture_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the offset of the light's texture. Equivalent to @Light2D.offset@. canvas_light_set_texture_offset :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> IO () canvas_light_set_texture_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_texture_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_texture_offset" '[Rid, Vector2] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_texture_offset {-# NOINLINE bindVisualServer_canvas_light_set_transform #-} -- | Sets the canvas light's @Transform2D@. bindVisualServer_canvas_light_set_transform :: MethodBind bindVisualServer_canvas_light_set_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the canvas light's @Transform2D@. canvas_light_set_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform2d -> IO () canvas_light_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_transform" '[Rid, Transform2d] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_transform {-# NOINLINE bindVisualServer_canvas_light_set_z_range #-} -- | Sets the Z range of objects that will be affected by this light. Equivalent to @Light2D.range_z_min@ and @Light2D.range_z_max@. bindVisualServer_canvas_light_set_z_range :: MethodBind bindVisualServer_canvas_light_set_z_range = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_light_set_z_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the Z range of objects that will be affected by this light. Equivalent to @Light2D.range_z_min@ and @Light2D.range_z_max@. canvas_light_set_z_range :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> IO () canvas_light_set_z_range cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_light_set_z_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_light_set_z_range" '[Rid, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_light_set_z_range {-# NOINLINE bindVisualServer_canvas_occluder_polygon_create #-} -- | Creates a new light occluder polygon and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @canvas_occluder_polygon_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_canvas_occluder_polygon_create :: MethodBind bindVisualServer_canvas_occluder_polygon_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_occluder_polygon_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new light occluder polygon and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @canvas_occluder_polygon_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. canvas_occluder_polygon_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid canvas_occluder_polygon_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_occluder_polygon_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_occluder_polygon_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.canvas_occluder_polygon_create {-# NOINLINE bindVisualServer_canvas_occluder_polygon_set_cull_mode #-} -- | Sets an occluder polygons cull mode. See @enum CanvasOccluderPolygonCullMode@ constants. bindVisualServer_canvas_occluder_polygon_set_cull_mode :: MethodBind bindVisualServer_canvas_occluder_polygon_set_cull_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_occluder_polygon_set_cull_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an occluder polygons cull mode. See @enum CanvasOccluderPolygonCullMode@ constants. canvas_occluder_polygon_set_cull_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () canvas_occluder_polygon_set_cull_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_occluder_polygon_set_cull_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_occluder_polygon_set_cull_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_occluder_polygon_set_cull_mode {-# NOINLINE bindVisualServer_canvas_occluder_polygon_set_shape #-} -- | Sets the shape of the occluder polygon. bindVisualServer_canvas_occluder_polygon_set_shape :: MethodBind bindVisualServer_canvas_occluder_polygon_set_shape = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_occluder_polygon_set_shape" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the shape of the occluder polygon. canvas_occluder_polygon_set_shape :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolVector2Array -> Bool -> IO () canvas_occluder_polygon_set_shape cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_occluder_polygon_set_shape (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_occluder_polygon_set_shape" '[Rid, PoolVector2Array, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_occluder_polygon_set_shape {-# NOINLINE bindVisualServer_canvas_occluder_polygon_set_shape_as_lines #-} -- | Sets the shape of the occluder polygon as lines. bindVisualServer_canvas_occluder_polygon_set_shape_as_lines :: MethodBind bindVisualServer_canvas_occluder_polygon_set_shape_as_lines = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_occluder_polygon_set_shape_as_lines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the shape of the occluder polygon as lines. canvas_occluder_polygon_set_shape_as_lines :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolVector2Array -> IO () canvas_occluder_polygon_set_shape_as_lines cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_occluder_polygon_set_shape_as_lines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_occluder_polygon_set_shape_as_lines" '[Rid, PoolVector2Array] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_occluder_polygon_set_shape_as_lines {-# NOINLINE bindVisualServer_canvas_set_item_mirroring #-} -- | A copy of the canvas item will be drawn with a local offset of the mirroring @Vector2@. bindVisualServer_canvas_set_item_mirroring :: MethodBind bindVisualServer_canvas_set_item_mirroring = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_set_item_mirroring" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A copy of the canvas item will be drawn with a local offset of the mirroring @Vector2@. canvas_set_item_mirroring :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Vector2 -> IO () canvas_set_item_mirroring cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_set_item_mirroring (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_set_item_mirroring" '[Rid, Rid, Vector2] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_set_item_mirroring {-# NOINLINE bindVisualServer_canvas_set_modulate #-} -- | Modulates all colors in the given canvas. bindVisualServer_canvas_set_modulate :: MethodBind bindVisualServer_canvas_set_modulate = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "canvas_set_modulate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Modulates all colors in the given canvas. canvas_set_modulate :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () canvas_set_modulate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_canvas_set_modulate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "canvas_set_modulate" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.canvas_set_modulate {-# NOINLINE bindVisualServer_directional_light_create #-} -- | Creates a directional light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most @light_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this directional light to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_directional_light_create :: MethodBind bindVisualServer_directional_light_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "directional_light_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a directional light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most @light_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this directional light to an instance using @method instance_set_base@ using the returned RID. directional_light_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid directional_light_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_directional_light_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "directional_light_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.directional_light_create {-# NOINLINE bindVisualServer_draw #-} -- | Draws a frame. @i@This method is deprecated@/i@, please use @method force_draw@ instead. bindVisualServer_draw :: MethodBind bindVisualServer_draw = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Draws a frame. @i@This method is deprecated@/i@, please use @method force_draw@ instead. draw :: (VisualServer :< cls, Object :< cls) => cls -> Maybe Bool -> Maybe Float -> IO () draw cls arg1 arg2 = withVariantArray [maybe (VariantBool True) toVariant arg1, maybe (VariantReal (0)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "draw" '[Maybe Bool, Maybe Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.draw {-# NOINLINE bindVisualServer_environment_create #-} -- | Creates an environment and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @environment_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_environment_create :: MethodBind bindVisualServer_environment_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an environment and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @environment_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. environment_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid environment_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.environment_create {-# NOINLINE bindVisualServer_environment_set_adjustment #-} -- | Sets the values to be used with the "Adjustment" post-process effect. See @Environment@ for more details. bindVisualServer_environment_set_adjustment :: MethodBind bindVisualServer_environment_set_adjustment = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_adjustment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the values to be used with the "Adjustment" post-process effect. See @Environment@ for more details. environment_set_adjustment :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Float -> Float -> Float -> Rid -> IO () environment_set_adjustment cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_adjustment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_adjustment" '[Rid, Bool, Float, Float, Float, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_adjustment {-# NOINLINE bindVisualServer_environment_set_ambient_light #-} -- | Sets the ambient light parameters. See @Environment@ for more details. bindVisualServer_environment_set_ambient_light :: MethodBind bindVisualServer_environment_set_ambient_light = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_ambient_light" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the ambient light parameters. See @Environment@ for more details. environment_set_ambient_light :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> Maybe Float -> Maybe Float -> IO () environment_set_ambient_light cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantReal (1)) toVariant arg3, maybe (VariantReal (0)) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_ambient_light (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_ambient_light" '[Rid, Color, Maybe Float, Maybe Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_ambient_light {-# NOINLINE bindVisualServer_environment_set_background #-} -- | Sets the @i@BGMode@/i@ of the environment. Equivalent to @Environment.background_mode@. bindVisualServer_environment_set_background :: MethodBind bindVisualServer_environment_set_background = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_background" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @i@BGMode@/i@ of the environment. Equivalent to @Environment.background_mode@. environment_set_background :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () environment_set_background cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_background (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_background" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_background {-# NOINLINE bindVisualServer_environment_set_bg_color #-} -- | Color displayed for clear areas of the scene (if using Custom color or Color+Sky background modes). bindVisualServer_environment_set_bg_color :: MethodBind bindVisualServer_environment_set_bg_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_bg_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Color displayed for clear areas of the scene (if using Custom color or Color+Sky background modes). environment_set_bg_color :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () environment_set_bg_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_bg_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_bg_color" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_bg_color {-# NOINLINE bindVisualServer_environment_set_bg_energy #-} -- | Sets the intensity of the background color. bindVisualServer_environment_set_bg_energy :: MethodBind bindVisualServer_environment_set_bg_energy = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_bg_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the intensity of the background color. environment_set_bg_energy :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () environment_set_bg_energy cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_bg_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_bg_energy" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_bg_energy {-# NOINLINE bindVisualServer_environment_set_canvas_max_layer #-} -- | Sets the maximum layer to use if using Canvas background mode. bindVisualServer_environment_set_canvas_max_layer :: MethodBind bindVisualServer_environment_set_canvas_max_layer = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_canvas_max_layer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the maximum layer to use if using Canvas background mode. environment_set_canvas_max_layer :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () environment_set_canvas_max_layer cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_canvas_max_layer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_canvas_max_layer" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_canvas_max_layer {-# NOINLINE bindVisualServer_environment_set_dof_blur_far #-} -- | Sets the values to be used with the "DoF Far Blur" post-process effect. See @Environment@ for more details. bindVisualServer_environment_set_dof_blur_far :: MethodBind bindVisualServer_environment_set_dof_blur_far = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_dof_blur_far" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the values to be used with the "DoF Far Blur" post-process effect. See @Environment@ for more details. environment_set_dof_blur_far :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Float -> Float -> Float -> Int -> IO () environment_set_dof_blur_far cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_dof_blur_far (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_dof_blur_far" '[Rid, Bool, Float, Float, Float, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_dof_blur_far {-# NOINLINE bindVisualServer_environment_set_dof_blur_near #-} -- | Sets the values to be used with the "DoF Near Blur" post-process effect. See @Environment@ for more details. bindVisualServer_environment_set_dof_blur_near :: MethodBind bindVisualServer_environment_set_dof_blur_near = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_dof_blur_near" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the values to be used with the "DoF Near Blur" post-process effect. See @Environment@ for more details. environment_set_dof_blur_near :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Float -> Float -> Float -> Int -> IO () environment_set_dof_blur_near cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_dof_blur_near (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_dof_blur_near" '[Rid, Bool, Float, Float, Float, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_dof_blur_near {-# NOINLINE bindVisualServer_environment_set_fog #-} -- | Sets the variables to be used with the scene fog. See @Environment@ for more details. bindVisualServer_environment_set_fog :: MethodBind bindVisualServer_environment_set_fog = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_fog" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the variables to be used with the scene fog. See @Environment@ for more details. environment_set_fog :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Color -> Color -> Float -> IO () environment_set_fog cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_fog (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_fog" '[Rid, Bool, Color, Color, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_fog {-# NOINLINE bindVisualServer_environment_set_fog_depth #-} -- | Sets the variables to be used with the fog depth effect. See @Environment@ for more details. bindVisualServer_environment_set_fog_depth :: MethodBind bindVisualServer_environment_set_fog_depth = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_fog_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the variables to be used with the fog depth effect. See @Environment@ for more details. environment_set_fog_depth :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Float -> Float -> Float -> Bool -> Float -> IO () environment_set_fog_depth cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_fog_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_fog_depth" '[Rid, Bool, Float, Float, Float, Bool, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_fog_depth {-# NOINLINE bindVisualServer_environment_set_fog_height #-} -- | Sets the variables to be used with the fog height effect. See @Environment@ for more details. bindVisualServer_environment_set_fog_height :: MethodBind bindVisualServer_environment_set_fog_height = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_fog_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the variables to be used with the fog height effect. See @Environment@ for more details. environment_set_fog_height :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Float -> Float -> Float -> IO () environment_set_fog_height cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_fog_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_fog_height" '[Rid, Bool, Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_fog_height {-# NOINLINE bindVisualServer_environment_set_glow #-} -- | Sets the variables to be used with the "glow" post-process effect. See @Environment@ for more details. bindVisualServer_environment_set_glow :: MethodBind bindVisualServer_environment_set_glow = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_glow" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the variables to be used with the "glow" post-process effect. See @Environment@ for more details. environment_set_glow :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Int -> Float -> Float -> Float -> Int -> Float -> Float -> Float -> Bool -> IO () environment_set_glow cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, toVariant arg7, toVariant arg8, toVariant arg9, toVariant arg10, toVariant arg11] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_glow (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_glow" '[Rid, Bool, Int, Float, Float, Float, Int, Float, Float, Float, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_glow {-# NOINLINE bindVisualServer_environment_set_sky #-} -- | Sets the @Sky@ to be used as the environment's background when using @i@BGMode@/i@ sky. Equivalent to @Environment.background_sky@. bindVisualServer_environment_set_sky :: MethodBind bindVisualServer_environment_set_sky = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_sky" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Sky@ to be used as the environment's background when using @i@BGMode@/i@ sky. Equivalent to @Environment.background_sky@. environment_set_sky :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () environment_set_sky cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_sky (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_sky" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_sky {-# NOINLINE bindVisualServer_environment_set_sky_custom_fov #-} -- | Sets a custom field of view for the background @Sky@. Equivalent to @Environment.background_sky_custom_fov@. bindVisualServer_environment_set_sky_custom_fov :: MethodBind bindVisualServer_environment_set_sky_custom_fov = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_sky_custom_fov" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a custom field of view for the background @Sky@. Equivalent to @Environment.background_sky_custom_fov@. environment_set_sky_custom_fov :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () environment_set_sky_custom_fov cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_sky_custom_fov (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_sky_custom_fov" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_sky_custom_fov {-# NOINLINE bindVisualServer_environment_set_sky_orientation #-} -- | Sets the rotation of the background @Sky@ expressed as a @Basis@. Equivalent to @Environment.background_sky_orientation@. bindVisualServer_environment_set_sky_orientation :: MethodBind bindVisualServer_environment_set_sky_orientation = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_sky_orientation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the rotation of the background @Sky@ expressed as a @Basis@. Equivalent to @Environment.background_sky_orientation@. environment_set_sky_orientation :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Basis -> IO () environment_set_sky_orientation cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_sky_orientation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_sky_orientation" '[Rid, Basis] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_sky_orientation {-# NOINLINE bindVisualServer_environment_set_ssao #-} -- | Sets the variables to be used with the "Screen Space Ambient Occlusion (SSAO)" post-process effect. See @Environment@ for more details. bindVisualServer_environment_set_ssao :: MethodBind bindVisualServer_environment_set_ssao = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_ssao" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the variables to be used with the "Screen Space Ambient Occlusion (SSAO)" post-process effect. See @Environment@ for more details. environment_set_ssao :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Float -> Float -> Float -> Float -> Float -> Float -> Float -> Color -> Int -> Int -> Float -> IO () environment_set_ssao cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 arg12 arg13 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, toVariant arg7, toVariant arg8, toVariant arg9, toVariant arg10, toVariant arg11, toVariant arg12, toVariant arg13] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_ssao (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_ssao" '[Rid, Bool, Float, Float, Float, Float, Float, Float, Float, Color, Int, Int, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_ssao {-# NOINLINE bindVisualServer_environment_set_ssr #-} -- | Sets the variables to be used with the "screen space reflections" post-process effect. See @Environment@ for more details. bindVisualServer_environment_set_ssr :: MethodBind bindVisualServer_environment_set_ssr = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_ssr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the variables to be used with the "screen space reflections" post-process effect. See @Environment@ for more details. environment_set_ssr :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> Int -> Float -> Float -> Float -> Bool -> IO () environment_set_ssr cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_ssr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_ssr" '[Rid, Bool, Int, Float, Float, Float, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_ssr {-# NOINLINE bindVisualServer_environment_set_tonemap #-} -- | Sets the variables to be used with the "tonemap" post-process effect. See @Environment@ for more details. bindVisualServer_environment_set_tonemap :: MethodBind bindVisualServer_environment_set_tonemap = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "environment_set_tonemap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the variables to be used with the "tonemap" post-process effect. See @Environment@ for more details. environment_set_tonemap :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> Float -> Bool -> Float -> Float -> Float -> Float -> IO () environment_set_tonemap cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, toVariant arg7, toVariant arg8, toVariant arg9] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_environment_set_tonemap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "environment_set_tonemap" '[Rid, Int, Float, Float, Bool, Float, Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.environment_set_tonemap {-# NOINLINE bindVisualServer_finish #-} -- | Removes buffers and clears testcubes. bindVisualServer_finish :: MethodBind bindVisualServer_finish = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "finish" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes buffers and clears testcubes. finish :: (VisualServer :< cls, Object :< cls) => cls -> IO () finish cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_finish (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "finish" '[] (IO ()) where nodeMethod = Godot.Core.VisualServer.finish {-# NOINLINE bindVisualServer_force_draw #-} -- | Forces a frame to be drawn when the function is called. Drawing a frame updates all @Viewport@s that are set to update. Use with extreme caution. bindVisualServer_force_draw :: MethodBind bindVisualServer_force_draw = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "force_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Forces a frame to be drawn when the function is called. Drawing a frame updates all @Viewport@s that are set to update. Use with extreme caution. force_draw :: (VisualServer :< cls, Object :< cls) => cls -> Maybe Bool -> Maybe Float -> IO () force_draw cls arg1 arg2 = withVariantArray [maybe (VariantBool True) toVariant arg1, maybe (VariantReal (0)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_force_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "force_draw" '[Maybe Bool, Maybe Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.force_draw {-# NOINLINE bindVisualServer_force_sync #-} -- | Synchronizes threads. bindVisualServer_force_sync :: MethodBind bindVisualServer_force_sync = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "force_sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Synchronizes threads. force_sync :: (VisualServer :< cls, Object :< cls) => cls -> IO () force_sync cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_force_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "force_sync" '[] (IO ()) where nodeMethod = Godot.Core.VisualServer.force_sync {-# NOINLINE bindVisualServer_free_rid #-} -- | Tries to free an object in the VisualServer. bindVisualServer_free_rid :: MethodBind bindVisualServer_free_rid = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "free_rid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Tries to free an object in the VisualServer. free_rid :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO () free_rid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_free_rid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "free_rid" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.free_rid {-# NOINLINE bindVisualServer_get_render_info #-} -- | Returns a certain information, see @enum RenderInfo@ for options. bindVisualServer_get_render_info :: MethodBind bindVisualServer_get_render_info = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "get_render_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a certain information, see @enum RenderInfo@ for options. get_render_info :: (VisualServer :< cls, Object :< cls) => cls -> Int -> IO Int get_render_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_get_render_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "get_render_info" '[Int] (IO Int) where nodeMethod = Godot.Core.VisualServer.get_render_info {-# NOINLINE bindVisualServer_get_test_cube #-} -- | Returns the id of the test cube. Creates one if none exists. bindVisualServer_get_test_cube :: MethodBind bindVisualServer_get_test_cube = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "get_test_cube" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the id of the test cube. Creates one if none exists. get_test_cube :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid get_test_cube cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_get_test_cube (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "get_test_cube" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.get_test_cube {-# NOINLINE bindVisualServer_get_test_texture #-} -- | Returns the id of the test texture. Creates one if none exists. bindVisualServer_get_test_texture :: MethodBind bindVisualServer_get_test_texture = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "get_test_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the id of the test texture. Creates one if none exists. get_test_texture :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid get_test_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_get_test_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "get_test_texture" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.get_test_texture {-# NOINLINE bindVisualServer_get_video_adapter_name #-} -- | Returns the name of the video adapter (e.g. "GeForce GTX 1080/PCIe/SSE2"). -- __Note:__ When running a headless or server binary, this function returns an empty string. bindVisualServer_get_video_adapter_name :: MethodBind bindVisualServer_get_video_adapter_name = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "get_video_adapter_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the video adapter (e.g. "GeForce GTX 1080/PCIe/SSE2"). -- __Note:__ When running a headless or server binary, this function returns an empty string. get_video_adapter_name :: (VisualServer :< cls, Object :< cls) => cls -> IO GodotString get_video_adapter_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_get_video_adapter_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "get_video_adapter_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualServer.get_video_adapter_name {-# NOINLINE bindVisualServer_get_video_adapter_vendor #-} -- | Returns the vendor of the video adapter (e.g. "NVIDIA Corporation"). -- __Note:__ When running a headless or server binary, this function returns an empty string. bindVisualServer_get_video_adapter_vendor :: MethodBind bindVisualServer_get_video_adapter_vendor = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "get_video_adapter_vendor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the vendor of the video adapter (e.g. "NVIDIA Corporation"). -- __Note:__ When running a headless or server binary, this function returns an empty string. get_video_adapter_vendor :: (VisualServer :< cls, Object :< cls) => cls -> IO GodotString get_video_adapter_vendor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_get_video_adapter_vendor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "get_video_adapter_vendor" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualServer.get_video_adapter_vendor {-# NOINLINE bindVisualServer_get_white_texture #-} -- | Returns the id of a white texture. Creates one if none exists. bindVisualServer_get_white_texture :: MethodBind bindVisualServer_get_white_texture = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "get_white_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the id of a white texture. Creates one if none exists. get_white_texture :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid get_white_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_get_white_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "get_white_texture" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.get_white_texture {-# NOINLINE bindVisualServer_gi_probe_create #-} -- | Creates a GI probe and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @gi_probe_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this GI probe to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_gi_probe_create :: MethodBind bindVisualServer_gi_probe_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a GI probe and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @gi_probe_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this GI probe to an instance using @method instance_set_base@ using the returned RID. gi_probe_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid gi_probe_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.gi_probe_create {-# NOINLINE bindVisualServer_gi_probe_get_bias #-} -- | Returns the bias value for the GI probe. Bias is used to avoid self occlusion. Equivalent to @GIProbeData.bias@. bindVisualServer_gi_probe_get_bias :: MethodBind bindVisualServer_gi_probe_get_bias = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the bias value for the GI probe. Bias is used to avoid self occlusion. Equivalent to @GIProbeData.bias@. gi_probe_get_bias :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Float gi_probe_get_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_bias" '[Rid] (IO Float) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_bias {-# NOINLINE bindVisualServer_gi_probe_get_bounds #-} -- | Returns the axis-aligned bounding box that covers the full extent of the GI probe. bindVisualServer_gi_probe_get_bounds :: MethodBind bindVisualServer_gi_probe_get_bounds = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the axis-aligned bounding box that covers the full extent of the GI probe. gi_probe_get_bounds :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Aabb gi_probe_get_bounds cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_bounds" '[Rid] (IO Aabb) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_bounds {-# NOINLINE bindVisualServer_gi_probe_get_cell_size #-} -- | Returns the cell size set by @method gi_probe_set_cell_size@. bindVisualServer_gi_probe_get_cell_size :: MethodBind bindVisualServer_gi_probe_get_cell_size = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cell size set by @method gi_probe_set_cell_size@. gi_probe_get_cell_size :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Float gi_probe_get_cell_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_cell_size" '[Rid] (IO Float) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_cell_size {-# NOINLINE bindVisualServer_gi_probe_get_dynamic_data #-} -- | Returns the data used by the GI probe. bindVisualServer_gi_probe_get_dynamic_data :: MethodBind bindVisualServer_gi_probe_get_dynamic_data = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_dynamic_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the data used by the GI probe. gi_probe_get_dynamic_data :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO PoolIntArray gi_probe_get_dynamic_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_dynamic_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_dynamic_data" '[Rid] (IO PoolIntArray) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_dynamic_data {-# NOINLINE bindVisualServer_gi_probe_get_dynamic_range #-} -- | Returns the dynamic range set for this GI probe. Equivalent to @GIProbe.dynamic_range@. bindVisualServer_gi_probe_get_dynamic_range :: MethodBind bindVisualServer_gi_probe_get_dynamic_range = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_dynamic_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the dynamic range set for this GI probe. Equivalent to @GIProbe.dynamic_range@. gi_probe_get_dynamic_range :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int gi_probe_get_dynamic_range cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_dynamic_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_dynamic_range" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_dynamic_range {-# NOINLINE bindVisualServer_gi_probe_get_energy #-} -- | Returns the energy multiplier for this GI probe. Equivalent to @GIProbe.energy@. bindVisualServer_gi_probe_get_energy :: MethodBind bindVisualServer_gi_probe_get_energy = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the energy multiplier for this GI probe. Equivalent to @GIProbe.energy@. gi_probe_get_energy :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Float gi_probe_get_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_energy" '[Rid] (IO Float) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_energy {-# NOINLINE bindVisualServer_gi_probe_get_normal_bias #-} -- | Returns the normal bias for this GI probe. Equivalent to @GIProbe.normal_bias@. bindVisualServer_gi_probe_get_normal_bias :: MethodBind bindVisualServer_gi_probe_get_normal_bias = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_normal_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the normal bias for this GI probe. Equivalent to @GIProbe.normal_bias@. gi_probe_get_normal_bias :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Float gi_probe_get_normal_bias cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_normal_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_normal_bias" '[Rid] (IO Float) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_normal_bias {-# NOINLINE bindVisualServer_gi_probe_get_propagation #-} -- | Returns the propagation value for this GI probe. Equivalent to @GIProbe.propagation@. bindVisualServer_gi_probe_get_propagation :: MethodBind bindVisualServer_gi_probe_get_propagation = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_propagation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the propagation value for this GI probe. Equivalent to @GIProbe.propagation@. gi_probe_get_propagation :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Float gi_probe_get_propagation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_propagation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_propagation" '[Rid] (IO Float) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_propagation {-# NOINLINE bindVisualServer_gi_probe_get_to_cell_xform #-} -- | Returns the Transform set by @method gi_probe_set_to_cell_xform@. bindVisualServer_gi_probe_get_to_cell_xform :: MethodBind bindVisualServer_gi_probe_get_to_cell_xform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_get_to_cell_xform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the Transform set by @method gi_probe_set_to_cell_xform@. gi_probe_get_to_cell_xform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Transform gi_probe_get_to_cell_xform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_get_to_cell_xform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_get_to_cell_xform" '[Rid] (IO Transform) where nodeMethod = Godot.Core.VisualServer.gi_probe_get_to_cell_xform {-# NOINLINE bindVisualServer_gi_probe_is_compressed #-} -- | Returns @true@ if the GI probe data associated with this GI probe is compressed. Equivalent to @GIProbe.compress@. bindVisualServer_gi_probe_is_compressed :: MethodBind bindVisualServer_gi_probe_is_compressed = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_is_compressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the GI probe data associated with this GI probe is compressed. Equivalent to @GIProbe.compress@. gi_probe_is_compressed :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Bool gi_probe_is_compressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_is_compressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_is_compressed" '[Rid] (IO Bool) where nodeMethod = Godot.Core.VisualServer.gi_probe_is_compressed {-# NOINLINE bindVisualServer_gi_probe_is_interior #-} -- | Returns @true@ if the GI probe is set to interior, meaning it does not account for sky light. Equivalent to @GIProbe.interior@. bindVisualServer_gi_probe_is_interior :: MethodBind bindVisualServer_gi_probe_is_interior = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_is_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the GI probe is set to interior, meaning it does not account for sky light. Equivalent to @GIProbe.interior@. gi_probe_is_interior :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Bool gi_probe_is_interior cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_is_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_is_interior" '[Rid] (IO Bool) where nodeMethod = Godot.Core.VisualServer.gi_probe_is_interior {-# NOINLINE bindVisualServer_gi_probe_set_bias #-} -- | Sets the bias value to avoid self-occlusion. Equivalent to @GIProbe.bias@. bindVisualServer_gi_probe_set_bias :: MethodBind bindVisualServer_gi_probe_set_bias = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the bias value to avoid self-occlusion. Equivalent to @GIProbe.bias@. gi_probe_set_bias :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () gi_probe_set_bias cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_bias" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_bias {-# NOINLINE bindVisualServer_gi_probe_set_bounds #-} -- | Sets the axis-aligned bounding box that covers the extent of the GI probe. bindVisualServer_gi_probe_set_bounds :: MethodBind bindVisualServer_gi_probe_set_bounds = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the axis-aligned bounding box that covers the extent of the GI probe. gi_probe_set_bounds :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Aabb -> IO () gi_probe_set_bounds cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_bounds" '[Rid, Aabb] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_bounds {-# NOINLINE bindVisualServer_gi_probe_set_cell_size #-} -- | Sets the size of individual cells within the GI probe. bindVisualServer_gi_probe_set_cell_size :: MethodBind bindVisualServer_gi_probe_set_cell_size = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_cell_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of individual cells within the GI probe. gi_probe_set_cell_size :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () gi_probe_set_cell_size cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_cell_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_cell_size" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_cell_size {-# NOINLINE bindVisualServer_gi_probe_set_compress #-} -- | Sets the compression setting for the GI probe data. Compressed data will take up less space but may look worse. Equivalent to @GIProbe.compress@. bindVisualServer_gi_probe_set_compress :: MethodBind bindVisualServer_gi_probe_set_compress = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_compress" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the compression setting for the GI probe data. Compressed data will take up less space but may look worse. Equivalent to @GIProbe.compress@. gi_probe_set_compress :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () gi_probe_set_compress cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_compress (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_compress" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_compress {-# NOINLINE bindVisualServer_gi_probe_set_dynamic_data #-} -- | Sets the data to be used in the GI probe for lighting calculations. Normally this is created and called internally within the @GIProbe@ node. You should not try to set this yourself. bindVisualServer_gi_probe_set_dynamic_data :: MethodBind bindVisualServer_gi_probe_set_dynamic_data = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_dynamic_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the data to be used in the GI probe for lighting calculations. Normally this is created and called internally within the @GIProbe@ node. You should not try to set this yourself. gi_probe_set_dynamic_data :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolIntArray -> IO () gi_probe_set_dynamic_data cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_dynamic_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_dynamic_data" '[Rid, PoolIntArray] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_dynamic_data {-# NOINLINE bindVisualServer_gi_probe_set_dynamic_range #-} -- | Sets the dynamic range of the GI probe. Dynamic range sets the limit for how bright lights can be. A smaller range captures greater detail but limits how bright lights can be. Equivalent to @GIProbe.dynamic_range@. bindVisualServer_gi_probe_set_dynamic_range :: MethodBind bindVisualServer_gi_probe_set_dynamic_range = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_dynamic_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the dynamic range of the GI probe. Dynamic range sets the limit for how bright lights can be. A smaller range captures greater detail but limits how bright lights can be. Equivalent to @GIProbe.dynamic_range@. gi_probe_set_dynamic_range :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () gi_probe_set_dynamic_range cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_dynamic_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_dynamic_range" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_dynamic_range {-# NOINLINE bindVisualServer_gi_probe_set_energy #-} -- | Sets the energy multiplier for this GI probe. A higher energy makes the indirect light from the GI probe brighter. Equivalent to @GIProbe.energy@. bindVisualServer_gi_probe_set_energy :: MethodBind bindVisualServer_gi_probe_set_energy = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the energy multiplier for this GI probe. A higher energy makes the indirect light from the GI probe brighter. Equivalent to @GIProbe.energy@. gi_probe_set_energy :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () gi_probe_set_energy cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_energy" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_energy {-# NOINLINE bindVisualServer_gi_probe_set_interior #-} -- | Sets the interior value of this GI probe. A GI probe set to interior does not include the sky when calculating lighting. Equivalent to @GIProbe.interior@. bindVisualServer_gi_probe_set_interior :: MethodBind bindVisualServer_gi_probe_set_interior = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the interior value of this GI probe. A GI probe set to interior does not include the sky when calculating lighting. Equivalent to @GIProbe.interior@. gi_probe_set_interior :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () gi_probe_set_interior cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_interior" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_interior {-# NOINLINE bindVisualServer_gi_probe_set_normal_bias #-} -- | Sets the normal bias for this GI probe. Normal bias behaves similar to the other form of bias and may help reduce self-occlusion. Equivalent to @GIProbe.normal_bias@. bindVisualServer_gi_probe_set_normal_bias :: MethodBind bindVisualServer_gi_probe_set_normal_bias = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_normal_bias" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the normal bias for this GI probe. Normal bias behaves similar to the other form of bias and may help reduce self-occlusion. Equivalent to @GIProbe.normal_bias@. gi_probe_set_normal_bias :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () gi_probe_set_normal_bias cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_normal_bias (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_normal_bias" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_normal_bias {-# NOINLINE bindVisualServer_gi_probe_set_propagation #-} -- | Sets the propagation of light within this GI probe. Equivalent to @GIProbe.propagation@. bindVisualServer_gi_probe_set_propagation :: MethodBind bindVisualServer_gi_probe_set_propagation = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_propagation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the propagation of light within this GI probe. Equivalent to @GIProbe.propagation@. gi_probe_set_propagation :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () gi_probe_set_propagation cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_propagation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_propagation" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_propagation {-# NOINLINE bindVisualServer_gi_probe_set_to_cell_xform #-} -- | Sets the to cell @Transform@ for this GI probe. bindVisualServer_gi_probe_set_to_cell_xform :: MethodBind bindVisualServer_gi_probe_set_to_cell_xform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "gi_probe_set_to_cell_xform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the to cell @Transform@ for this GI probe. gi_probe_set_to_cell_xform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform -> IO () gi_probe_set_to_cell_xform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_gi_probe_set_to_cell_xform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "gi_probe_set_to_cell_xform" '[Rid, Transform] (IO ()) where nodeMethod = Godot.Core.VisualServer.gi_probe_set_to_cell_xform {-# NOINLINE bindVisualServer_has_changed #-} -- | Returns @true@ if changes have been made to the VisualServer's data. @method draw@ is usually called if this happens. bindVisualServer_has_changed :: MethodBind bindVisualServer_has_changed = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "has_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if changes have been made to the VisualServer's data. @method draw@ is usually called if this happens. has_changed :: (VisualServer :< cls, Object :< cls) => cls -> IO Bool has_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_has_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "has_changed" '[] (IO Bool) where nodeMethod = Godot.Core.VisualServer.has_changed {-# NOINLINE bindVisualServer_has_feature #-} -- | Not yet implemented. Always returns @false@. bindVisualServer_has_feature :: MethodBind bindVisualServer_has_feature = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "has_feature" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Not yet implemented. Always returns @false@. has_feature :: (VisualServer :< cls, Object :< cls) => cls -> Int -> IO Bool has_feature cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_has_feature (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "has_feature" '[Int] (IO Bool) where nodeMethod = Godot.Core.VisualServer.has_feature {-# NOINLINE bindVisualServer_has_os_feature #-} -- | Returns @true@ if the OS supports a certain feature. Features might be @s3tc@, @etc@, @etc2@ and @pvrtc@. bindVisualServer_has_os_feature :: MethodBind bindVisualServer_has_os_feature = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "has_os_feature" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the OS supports a certain feature. Features might be @s3tc@, @etc@, @etc2@ and @pvrtc@. has_os_feature :: (VisualServer :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_os_feature cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_has_os_feature (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "has_os_feature" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.VisualServer.has_os_feature {-# NOINLINE bindVisualServer_immediate_begin #-} -- | Sets up @ImmediateGeometry@ internals to prepare for drawing. Equivalent to @method ImmediateGeometry.begin@. bindVisualServer_immediate_begin :: MethodBind bindVisualServer_immediate_begin = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets up @ImmediateGeometry@ internals to prepare for drawing. Equivalent to @method ImmediateGeometry.begin@. immediate_begin :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Maybe Rid -> IO () immediate_begin cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_begin" '[Rid, Int, Maybe Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_begin {-# NOINLINE bindVisualServer_immediate_clear #-} -- | Clears everything that was set up between @method immediate_begin@ and @method immediate_end@. Equivalent to @method ImmediateGeometry.clear@. bindVisualServer_immediate_clear :: MethodBind bindVisualServer_immediate_clear = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clears everything that was set up between @method immediate_begin@ and @method immediate_end@. Equivalent to @method ImmediateGeometry.clear@. immediate_clear :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO () immediate_clear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_clear" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_clear {-# NOINLINE bindVisualServer_immediate_color #-} -- | Sets the color to be used with next vertex. Equivalent to @method ImmediateGeometry.set_color@. bindVisualServer_immediate_color :: MethodBind bindVisualServer_immediate_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color to be used with next vertex. Equivalent to @method ImmediateGeometry.set_color@. immediate_color :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () immediate_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_color" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_color {-# NOINLINE bindVisualServer_immediate_create #-} -- | Creates an immediate geometry and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @immediate_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this immediate geometry to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_immediate_create :: MethodBind bindVisualServer_immediate_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an immediate geometry and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @immediate_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this immediate geometry to an instance using @method instance_set_base@ using the returned RID. immediate_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid immediate_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.immediate_create {-# NOINLINE bindVisualServer_immediate_end #-} -- | Ends drawing the @ImmediateGeometry@ and displays it. Equivalent to @method ImmediateGeometry.end@. bindVisualServer_immediate_end :: MethodBind bindVisualServer_immediate_end = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Ends drawing the @ImmediateGeometry@ and displays it. Equivalent to @method ImmediateGeometry.end@. immediate_end :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO () immediate_end cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_end" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_end {-# NOINLINE bindVisualServer_immediate_get_material #-} -- | Returns the material assigned to the @ImmediateGeometry@. bindVisualServer_immediate_get_material :: MethodBind bindVisualServer_immediate_get_material = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the material assigned to the @ImmediateGeometry@. immediate_get_material :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Rid immediate_get_material cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_get_material" '[Rid] (IO Rid) where nodeMethod = Godot.Core.VisualServer.immediate_get_material {-# NOINLINE bindVisualServer_immediate_normal #-} -- | Sets the normal to be used with next vertex. Equivalent to @method ImmediateGeometry.set_normal@. bindVisualServer_immediate_normal :: MethodBind bindVisualServer_immediate_normal = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_normal" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the normal to be used with next vertex. Equivalent to @method ImmediateGeometry.set_normal@. immediate_normal :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () immediate_normal cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_normal (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_normal" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_normal {-# NOINLINE bindVisualServer_immediate_set_material #-} -- | Sets the material to be used to draw the @ImmediateGeometry@. bindVisualServer_immediate_set_material :: MethodBind bindVisualServer_immediate_set_material = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the material to be used to draw the @ImmediateGeometry@. immediate_set_material :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () immediate_set_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_set_material" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_set_material {-# NOINLINE bindVisualServer_immediate_tangent #-} -- | Sets the tangent to be used with next vertex. Equivalent to @method ImmediateGeometry.set_tangent@. bindVisualServer_immediate_tangent :: MethodBind bindVisualServer_immediate_tangent = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_tangent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the tangent to be used with next vertex. Equivalent to @method ImmediateGeometry.set_tangent@. immediate_tangent :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Plane -> IO () immediate_tangent cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_tangent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_tangent" '[Rid, Plane] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_tangent {-# NOINLINE bindVisualServer_immediate_uv #-} -- | Sets the UV to be used with next vertex. Equivalent to @method ImmediateGeometry.set_uv@. bindVisualServer_immediate_uv :: MethodBind bindVisualServer_immediate_uv = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_uv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the UV to be used with next vertex. Equivalent to @method ImmediateGeometry.set_uv@. immediate_uv :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> IO () immediate_uv cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_uv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_uv" '[Rid, Vector2] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_uv {-# NOINLINE bindVisualServer_immediate_uv2 #-} -- | Sets the UV2 to be used with next vertex. Equivalent to @method ImmediateGeometry.set_uv2@. bindVisualServer_immediate_uv2 :: MethodBind bindVisualServer_immediate_uv2 = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_uv2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the UV2 to be used with next vertex. Equivalent to @method ImmediateGeometry.set_uv2@. immediate_uv2 :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> IO () immediate_uv2 cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_uv2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_uv2" '[Rid, Vector2] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_uv2 {-# NOINLINE bindVisualServer_immediate_vertex #-} -- | Adds the next vertex using the information provided in advance. Equivalent to @method ImmediateGeometry.add_vertex@. bindVisualServer_immediate_vertex :: MethodBind bindVisualServer_immediate_vertex = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_vertex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the next vertex using the information provided in advance. Equivalent to @method ImmediateGeometry.add_vertex@. immediate_vertex :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () immediate_vertex cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_vertex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_vertex" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_vertex {-# NOINLINE bindVisualServer_immediate_vertex_2d #-} -- | Adds the next vertex using the information provided in advance. This is a helper class that calls @method immediate_vertex@ under the hood. Equivalent to @method ImmediateGeometry.add_vertex@. bindVisualServer_immediate_vertex_2d :: MethodBind bindVisualServer_immediate_vertex_2d = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "immediate_vertex_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the next vertex using the information provided in advance. This is a helper class that calls @method immediate_vertex@ under the hood. Equivalent to @method ImmediateGeometry.add_vertex@. immediate_vertex_2d :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector2 -> IO () immediate_vertex_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_immediate_vertex_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "immediate_vertex_2d" '[Rid, Vector2] (IO ()) where nodeMethod = Godot.Core.VisualServer.immediate_vertex_2d {-# NOINLINE bindVisualServer_init #-} -- | Initializes the visual server. This function is called internally by platform-dependent code during engine initialization. If called from a running game, it will not do anything. bindVisualServer_init :: MethodBind bindVisualServer_init = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "init" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Initializes the visual server. This function is called internally by platform-dependent code during engine initialization. If called from a running game, it will not do anything. init :: (VisualServer :< cls, Object :< cls) => cls -> IO () init cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_init (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "init" '[] (IO ()) where nodeMethod = Godot.Core.VisualServer.init {-# NOINLINE bindVisualServer_instance_attach_object_instance_id #-} -- | Attaches a unique Object ID to instance. Object ID must be attached to instance for proper culling with @method instances_cull_aabb@, @method instances_cull_convex@, and @method instances_cull_ray@. bindVisualServer_instance_attach_object_instance_id :: MethodBind bindVisualServer_instance_attach_object_instance_id = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_attach_object_instance_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Attaches a unique Object ID to instance. Object ID must be attached to instance for proper culling with @method instances_cull_aabb@, @method instances_cull_convex@, and @method instances_cull_ray@. instance_attach_object_instance_id :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () instance_attach_object_instance_id cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_attach_object_instance_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_attach_object_instance_id" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_attach_object_instance_id {-# NOINLINE bindVisualServer_instance_attach_skeleton #-} -- | Attaches a skeleton to an instance. Removes the previous skeleton from the instance. bindVisualServer_instance_attach_skeleton :: MethodBind bindVisualServer_instance_attach_skeleton = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_attach_skeleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Attaches a skeleton to an instance. Removes the previous skeleton from the instance. instance_attach_skeleton :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () instance_attach_skeleton cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_attach_skeleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_attach_skeleton" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_attach_skeleton {-# NOINLINE bindVisualServer_instance_create #-} -- | Creates a visual instance and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @instance_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- An instance is a way of placing a 3D object in the scenario. Objects like particles, meshes, and reflection probes need to be associated with an instance to be visible in the scenario using @method instance_set_base@. bindVisualServer_instance_create :: MethodBind bindVisualServer_instance_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a visual instance and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @instance_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- An instance is a way of placing a 3D object in the scenario. Objects like particles, meshes, and reflection probes need to be associated with an instance to be visible in the scenario using @method instance_set_base@. instance_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid instance_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.instance_create {-# NOINLINE bindVisualServer_instance_create2 #-} -- | Creates a visual instance, adds it to the VisualServer, and sets both base and scenario. It can be accessed with the RID that is returned. This RID will be used in all @instance_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_instance_create2 :: MethodBind bindVisualServer_instance_create2 = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_create2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a visual instance, adds it to the VisualServer, and sets both base and scenario. It can be accessed with the RID that is returned. This RID will be used in all @instance_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. instance_create2 :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO Rid instance_create2 cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_create2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_create2" '[Rid, Rid] (IO Rid) where nodeMethod = Godot.Core.VisualServer.instance_create2 {-# NOINLINE bindVisualServer_instance_geometry_set_as_instance_lod #-} -- | Not implemented in Godot 3.x. bindVisualServer_instance_geometry_set_as_instance_lod :: MethodBind bindVisualServer_instance_geometry_set_as_instance_lod = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_geometry_set_as_instance_lod" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Not implemented in Godot 3.x. instance_geometry_set_as_instance_lod :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () instance_geometry_set_as_instance_lod cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_geometry_set_as_instance_lod (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_geometry_set_as_instance_lod" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_geometry_set_as_instance_lod {-# NOINLINE bindVisualServer_instance_geometry_set_cast_shadows_setting #-} -- | Sets the shadow casting setting to one of @enum ShadowCastingSetting@. Equivalent to @GeometryInstance.cast_shadow@. bindVisualServer_instance_geometry_set_cast_shadows_setting :: MethodBind bindVisualServer_instance_geometry_set_cast_shadows_setting = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_geometry_set_cast_shadows_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the shadow casting setting to one of @enum ShadowCastingSetting@. Equivalent to @GeometryInstance.cast_shadow@. instance_geometry_set_cast_shadows_setting :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () instance_geometry_set_cast_shadows_setting cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_geometry_set_cast_shadows_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_geometry_set_cast_shadows_setting" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_geometry_set_cast_shadows_setting {-# NOINLINE bindVisualServer_instance_geometry_set_draw_range #-} -- | Not implemented in Godot 3.x. bindVisualServer_instance_geometry_set_draw_range :: MethodBind bindVisualServer_instance_geometry_set_draw_range = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_geometry_set_draw_range" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Not implemented in Godot 3.x. instance_geometry_set_draw_range :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> Float -> Float -> Float -> IO () instance_geometry_set_draw_range cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_geometry_set_draw_range (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_geometry_set_draw_range" '[Rid, Float, Float, Float, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_geometry_set_draw_range {-# NOINLINE bindVisualServer_instance_geometry_set_flag #-} -- | Sets the flag for a given @enum InstanceFlags@. See @enum InstanceFlags@ for more details. bindVisualServer_instance_geometry_set_flag :: MethodBind bindVisualServer_instance_geometry_set_flag = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_geometry_set_flag" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the flag for a given @enum InstanceFlags@. See @enum InstanceFlags@ for more details. instance_geometry_set_flag :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Bool -> IO () instance_geometry_set_flag cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_geometry_set_flag (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_geometry_set_flag" '[Rid, Int, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_geometry_set_flag {-# NOINLINE bindVisualServer_instance_geometry_set_material_override #-} -- | Sets a material that will override the material for all surfaces on the mesh associated with this instance. Equivalent to @GeometryInstance.material_override@. bindVisualServer_instance_geometry_set_material_override :: MethodBind bindVisualServer_instance_geometry_set_material_override = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_geometry_set_material_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a material that will override the material for all surfaces on the mesh associated with this instance. Equivalent to @GeometryInstance.material_override@. instance_geometry_set_material_override :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () instance_geometry_set_material_override cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_geometry_set_material_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_geometry_set_material_override" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_geometry_set_material_override {-# NOINLINE bindVisualServer_instance_set_base #-} -- | Sets the base of the instance. A base can be any of the 3D objects that are created in the VisualServer that can be displayed. For example, any of the light types, mesh, multimesh, immediate geometry, particle system, reflection probe, lightmap capture, and the GI probe are all types that can be set as the base of an instance in order to be displayed in the scenario. bindVisualServer_instance_set_base :: MethodBind bindVisualServer_instance_set_base = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_base" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the base of the instance. A base can be any of the 3D objects that are created in the VisualServer that can be displayed. For example, any of the light types, mesh, multimesh, immediate geometry, particle system, reflection probe, lightmap capture, and the GI probe are all types that can be set as the base of an instance in order to be displayed in the scenario. instance_set_base :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () instance_set_base cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_base (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_base" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_base {-# NOINLINE bindVisualServer_instance_set_blend_shape_weight #-} -- | Sets the weight for a given blend shape associated with this instance. bindVisualServer_instance_set_blend_shape_weight :: MethodBind bindVisualServer_instance_set_blend_shape_weight = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_blend_shape_weight" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the weight for a given blend shape associated with this instance. instance_set_blend_shape_weight :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () instance_set_blend_shape_weight cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_blend_shape_weight (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_blend_shape_weight" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_blend_shape_weight {-# NOINLINE bindVisualServer_instance_set_custom_aabb #-} -- | Sets a custom AABB to use when culling objects from the view frustum. Equivalent to @method GeometryInstance.set_custom_aabb@. bindVisualServer_instance_set_custom_aabb :: MethodBind bindVisualServer_instance_set_custom_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a custom AABB to use when culling objects from the view frustum. Equivalent to @method GeometryInstance.set_custom_aabb@. instance_set_custom_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Aabb -> IO () instance_set_custom_aabb cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_custom_aabb" '[Rid, Aabb] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_custom_aabb {-# NOINLINE bindVisualServer_instance_set_exterior #-} -- | Function not implemented in Godot 3.x. bindVisualServer_instance_set_exterior :: MethodBind bindVisualServer_instance_set_exterior = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_exterior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Function not implemented in Godot 3.x. instance_set_exterior :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () instance_set_exterior cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_exterior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_exterior" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_exterior {-# NOINLINE bindVisualServer_instance_set_extra_visibility_margin #-} -- | Sets a margin to increase the size of the AABB when culling objects from the view frustum. This allows you avoid culling objects that fall outside the view frustum. Equivalent to @GeometryInstance.extra_cull_margin@. bindVisualServer_instance_set_extra_visibility_margin :: MethodBind bindVisualServer_instance_set_extra_visibility_margin = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_extra_visibility_margin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a margin to increase the size of the AABB when culling objects from the view frustum. This allows you avoid culling objects that fall outside the view frustum. Equivalent to @GeometryInstance.extra_cull_margin@. instance_set_extra_visibility_margin :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () instance_set_extra_visibility_margin cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_extra_visibility_margin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_extra_visibility_margin" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_extra_visibility_margin {-# NOINLINE bindVisualServer_instance_set_layer_mask #-} -- | Sets the render layers that this instance will be drawn to. Equivalent to @VisualInstance.layers@. bindVisualServer_instance_set_layer_mask :: MethodBind bindVisualServer_instance_set_layer_mask = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_layer_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the render layers that this instance will be drawn to. Equivalent to @VisualInstance.layers@. instance_set_layer_mask :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () instance_set_layer_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_layer_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_layer_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_layer_mask {-# NOINLINE bindVisualServer_instance_set_scenario #-} -- | Sets the scenario that the instance is in. The scenario is the 3D world that the objects will be displayed in. bindVisualServer_instance_set_scenario :: MethodBind bindVisualServer_instance_set_scenario = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_scenario" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the scenario that the instance is in. The scenario is the 3D world that the objects will be displayed in. instance_set_scenario :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () instance_set_scenario cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_scenario (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_scenario" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_scenario {-# NOINLINE bindVisualServer_instance_set_surface_material #-} -- | Sets the material of a specific surface. Equivalent to @method MeshInstance.set_surface_material@. bindVisualServer_instance_set_surface_material :: MethodBind bindVisualServer_instance_set_surface_material = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_surface_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the material of a specific surface. Equivalent to @method MeshInstance.set_surface_material@. instance_set_surface_material :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Rid -> IO () instance_set_surface_material cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_surface_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_surface_material" '[Rid, Int, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_surface_material {-# NOINLINE bindVisualServer_instance_set_transform #-} -- | Sets the world space transform of the instance. Equivalent to @Spatial.transform@. bindVisualServer_instance_set_transform :: MethodBind bindVisualServer_instance_set_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the world space transform of the instance. Equivalent to @Spatial.transform@. instance_set_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform -> IO () instance_set_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_transform" '[Rid, Transform] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_transform {-# NOINLINE bindVisualServer_instance_set_use_lightmap #-} -- | Sets the lightmap to use with this instance. bindVisualServer_instance_set_use_lightmap :: MethodBind bindVisualServer_instance_set_use_lightmap = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_use_lightmap" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the lightmap to use with this instance. instance_set_use_lightmap :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Rid -> IO () instance_set_use_lightmap cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_use_lightmap (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_use_lightmap" '[Rid, Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_use_lightmap {-# NOINLINE bindVisualServer_instance_set_visible #-} -- | Sets whether an instance is drawn or not. Equivalent to @Spatial.visible@. bindVisualServer_instance_set_visible :: MethodBind bindVisualServer_instance_set_visible = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instance_set_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether an instance is drawn or not. Equivalent to @Spatial.visible@. instance_set_visible :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () instance_set_visible cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instance_set_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instance_set_visible" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.instance_set_visible {-# NOINLINE bindVisualServer_instances_cull_aabb #-} -- | Returns an array of object IDs intersecting with the provided AABB. Only visual 3D nodes are considered, such as @MeshInstance@ or @DirectionalLight@. Use @method @GDScript.instance_from_id@ to obtain the actual nodes. A scenario RID must be provided, which is available in the @World@ you want to query. This forces an update for all resources queued to update. -- __Warning:__ This function is primarily intended for editor usage. For in-game use cases, prefer physics collision. bindVisualServer_instances_cull_aabb :: MethodBind bindVisualServer_instances_cull_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instances_cull_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of object IDs intersecting with the provided AABB. Only visual 3D nodes are considered, such as @MeshInstance@ or @DirectionalLight@. Use @method @GDScript.instance_from_id@ to obtain the actual nodes. A scenario RID must be provided, which is available in the @World@ you want to query. This forces an update for all resources queued to update. -- __Warning:__ This function is primarily intended for editor usage. For in-game use cases, prefer physics collision. instances_cull_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Aabb -> Maybe Rid -> IO Array instances_cull_aabb cls arg1 arg2 = withVariantArray [toVariant arg1, maybe VariantNil toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instances_cull_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instances_cull_aabb" '[Aabb, Maybe Rid] (IO Array) where nodeMethod = Godot.Core.VisualServer.instances_cull_aabb {-# NOINLINE bindVisualServer_instances_cull_convex #-} -- | Returns an array of object IDs intersecting with the provided convex shape. Only visual 3D nodes are considered, such as @MeshInstance@ or @DirectionalLight@. Use @method @GDScript.instance_from_id@ to obtain the actual nodes. A scenario RID must be provided, which is available in the @World@ you want to query. This forces an update for all resources queued to update. -- __Warning:__ This function is primarily intended for editor usage. For in-game use cases, prefer physics collision. bindVisualServer_instances_cull_convex :: MethodBind bindVisualServer_instances_cull_convex = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instances_cull_convex" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of object IDs intersecting with the provided convex shape. Only visual 3D nodes are considered, such as @MeshInstance@ or @DirectionalLight@. Use @method @GDScript.instance_from_id@ to obtain the actual nodes. A scenario RID must be provided, which is available in the @World@ you want to query. This forces an update for all resources queued to update. -- __Warning:__ This function is primarily intended for editor usage. For in-game use cases, prefer physics collision. instances_cull_convex :: (VisualServer :< cls, Object :< cls) => cls -> Array -> Maybe Rid -> IO Array instances_cull_convex cls arg1 arg2 = withVariantArray [toVariant arg1, maybe VariantNil toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instances_cull_convex (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instances_cull_convex" '[Array, Maybe Rid] (IO Array) where nodeMethod = Godot.Core.VisualServer.instances_cull_convex {-# NOINLINE bindVisualServer_instances_cull_ray #-} -- | Returns an array of object IDs intersecting with the provided 3D ray. Only visual 3D nodes are considered, such as @MeshInstance@ or @DirectionalLight@. Use @method @GDScript.instance_from_id@ to obtain the actual nodes. A scenario RID must be provided, which is available in the @World@ you want to query. This forces an update for all resources queued to update. -- __Warning:__ This function is primarily intended for editor usage. For in-game use cases, prefer physics collision. bindVisualServer_instances_cull_ray :: MethodBind bindVisualServer_instances_cull_ray = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "instances_cull_ray" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array of object IDs intersecting with the provided 3D ray. Only visual 3D nodes are considered, such as @MeshInstance@ or @DirectionalLight@. Use @method @GDScript.instance_from_id@ to obtain the actual nodes. A scenario RID must be provided, which is available in the @World@ you want to query. This forces an update for all resources queued to update. -- __Warning:__ This function is primarily intended for editor usage. For in-game use cases, prefer physics collision. instances_cull_ray :: (VisualServer :< cls, Object :< cls) => cls -> Vector3 -> Vector3 -> Maybe Rid -> IO Array instances_cull_ray cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_instances_cull_ray (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "instances_cull_ray" '[Vector3, Vector3, Maybe Rid] (IO Array) where nodeMethod = Godot.Core.VisualServer.instances_cull_ray {-# NOINLINE bindVisualServer_light_directional_set_blend_splits #-} -- | If @true@, this directional light will blend between shadow map splits resulting in a smoother transition between them. Equivalent to @DirectionalLight.directional_shadow_blend_splits@. bindVisualServer_light_directional_set_blend_splits :: MethodBind bindVisualServer_light_directional_set_blend_splits = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_directional_set_blend_splits" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, this directional light will blend between shadow map splits resulting in a smoother transition between them. Equivalent to @DirectionalLight.directional_shadow_blend_splits@. light_directional_set_blend_splits :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () light_directional_set_blend_splits cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_directional_set_blend_splits (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_directional_set_blend_splits" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_directional_set_blend_splits {-# NOINLINE bindVisualServer_light_directional_set_shadow_depth_range_mode #-} -- | Sets the shadow depth range mode for this directional light. Equivalent to @DirectionalLight.directional_shadow_depth_range@. See @enum LightDirectionalShadowDepthRangeMode@ for options. bindVisualServer_light_directional_set_shadow_depth_range_mode :: MethodBind bindVisualServer_light_directional_set_shadow_depth_range_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_directional_set_shadow_depth_range_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the shadow depth range mode for this directional light. Equivalent to @DirectionalLight.directional_shadow_depth_range@. See @enum LightDirectionalShadowDepthRangeMode@ for options. light_directional_set_shadow_depth_range_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () light_directional_set_shadow_depth_range_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_directional_set_shadow_depth_range_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_directional_set_shadow_depth_range_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_directional_set_shadow_depth_range_mode {-# NOINLINE bindVisualServer_light_directional_set_shadow_mode #-} -- | Sets the shadow mode for this directional light. Equivalent to @DirectionalLight.directional_shadow_mode@. See @enum LightDirectionalShadowMode@ for options. bindVisualServer_light_directional_set_shadow_mode :: MethodBind bindVisualServer_light_directional_set_shadow_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_directional_set_shadow_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the shadow mode for this directional light. Equivalent to @DirectionalLight.directional_shadow_mode@. See @enum LightDirectionalShadowMode@ for options. light_directional_set_shadow_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () light_directional_set_shadow_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_directional_set_shadow_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_directional_set_shadow_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_directional_set_shadow_mode {-# NOINLINE bindVisualServer_light_omni_set_shadow_detail #-} -- | Sets whether to use vertical or horizontal detail for this omni light. This can be used to alleviate artifacts in the shadow map. Equivalent to @OmniLight.omni_shadow_detail@. bindVisualServer_light_omni_set_shadow_detail :: MethodBind bindVisualServer_light_omni_set_shadow_detail = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_omni_set_shadow_detail" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether to use vertical or horizontal detail for this omni light. This can be used to alleviate artifacts in the shadow map. Equivalent to @OmniLight.omni_shadow_detail@. light_omni_set_shadow_detail :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () light_omni_set_shadow_detail cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_omni_set_shadow_detail (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_omni_set_shadow_detail" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_omni_set_shadow_detail {-# NOINLINE bindVisualServer_light_omni_set_shadow_mode #-} -- | Sets whether to use a dual paraboloid or a cubemap for the shadow map. Dual paraboloid is faster but may suffer from artifacts. Equivalent to @OmniLight.omni_shadow_mode@. bindVisualServer_light_omni_set_shadow_mode :: MethodBind bindVisualServer_light_omni_set_shadow_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_omni_set_shadow_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether to use a dual paraboloid or a cubemap for the shadow map. Dual paraboloid is faster but may suffer from artifacts. Equivalent to @OmniLight.omni_shadow_mode@. light_omni_set_shadow_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () light_omni_set_shadow_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_omni_set_shadow_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_omni_set_shadow_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_omni_set_shadow_mode {-# NOINLINE bindVisualServer_light_set_color #-} -- | Sets the color of the light. Equivalent to @Light.light_color@. bindVisualServer_light_set_color :: MethodBind bindVisualServer_light_set_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color of the light. Equivalent to @Light.light_color@. light_set_color :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () light_set_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_color" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_color {-# NOINLINE bindVisualServer_light_set_cull_mask #-} -- | Sets the cull mask for this Light. Lights only affect objects in the selected layers. Equivalent to @Light.light_cull_mask@. bindVisualServer_light_set_cull_mask :: MethodBind bindVisualServer_light_set_cull_mask = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the cull mask for this Light. Lights only affect objects in the selected layers. Equivalent to @Light.light_cull_mask@. light_set_cull_mask :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () light_set_cull_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_cull_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_cull_mask {-# NOINLINE bindVisualServer_light_set_negative #-} -- | If @true@, light will subtract light instead of adding light. Equivalent to @Light.light_negative@. bindVisualServer_light_set_negative :: MethodBind bindVisualServer_light_set_negative = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_negative" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, light will subtract light instead of adding light. Equivalent to @Light.light_negative@. light_set_negative :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () light_set_negative cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_negative (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_negative" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_negative {-# NOINLINE bindVisualServer_light_set_param #-} -- | Sets the specified light parameter. See @enum LightParam@ for options. Equivalent to @method Light.set_param@. bindVisualServer_light_set_param :: MethodBind bindVisualServer_light_set_param = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified light parameter. See @enum LightParam@ for options. Equivalent to @method Light.set_param@. light_set_param :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Float -> IO () light_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_param" '[Rid, Int, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_param {-# NOINLINE bindVisualServer_light_set_projector #-} -- | Not implemented in Godot 3.x. bindVisualServer_light_set_projector :: MethodBind bindVisualServer_light_set_projector = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_projector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Not implemented in Godot 3.x. light_set_projector :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () light_set_projector cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_projector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_projector" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_projector {-# NOINLINE bindVisualServer_light_set_reverse_cull_face_mode #-} -- | If @true@, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double sided shadows with @method instance_geometry_set_cast_shadows_setting@. Equivalent to @Light.shadow_reverse_cull_face@. bindVisualServer_light_set_reverse_cull_face_mode :: MethodBind bindVisualServer_light_set_reverse_cull_face_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_reverse_cull_face_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double sided shadows with @method instance_geometry_set_cast_shadows_setting@. Equivalent to @Light.shadow_reverse_cull_face@. light_set_reverse_cull_face_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () light_set_reverse_cull_face_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_reverse_cull_face_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_reverse_cull_face_mode" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_reverse_cull_face_mode {-# NOINLINE bindVisualServer_light_set_shadow #-} -- | If @true@, light will cast shadows. Equivalent to @Light.shadow_enabled@. bindVisualServer_light_set_shadow :: MethodBind bindVisualServer_light_set_shadow = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_shadow" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, light will cast shadows. Equivalent to @Light.shadow_enabled@. light_set_shadow :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () light_set_shadow cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_shadow (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_shadow" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_shadow {-# NOINLINE bindVisualServer_light_set_shadow_color #-} -- | Sets the color of the shadow cast by the light. Equivalent to @Light.shadow_color@. bindVisualServer_light_set_shadow_color :: MethodBind bindVisualServer_light_set_shadow_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_shadow_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color of the shadow cast by the light. Equivalent to @Light.shadow_color@. light_set_shadow_color :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () light_set_shadow_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_shadow_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_shadow_color" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_shadow_color {-# NOINLINE bindVisualServer_light_set_use_gi #-} -- | Sets whether GI probes capture light information from this light. bindVisualServer_light_set_use_gi :: MethodBind bindVisualServer_light_set_use_gi = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "light_set_use_gi" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets whether GI probes capture light information from this light. light_set_use_gi :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () light_set_use_gi cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_light_set_use_gi (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "light_set_use_gi" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.light_set_use_gi {-# NOINLINE bindVisualServer_lightmap_capture_create #-} -- | Creates a lightmap capture and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @lightmap_capture_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this lightmap capture to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_lightmap_capture_create :: MethodBind bindVisualServer_lightmap_capture_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a lightmap capture and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @lightmap_capture_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this lightmap capture to an instance using @method instance_set_base@ using the returned RID. lightmap_capture_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid lightmap_capture_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_create {-# NOINLINE bindVisualServer_lightmap_capture_get_bounds #-} -- | Returns the size of the lightmap capture area. bindVisualServer_lightmap_capture_get_bounds :: MethodBind bindVisualServer_lightmap_capture_get_bounds = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_get_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the size of the lightmap capture area. lightmap_capture_get_bounds :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Aabb lightmap_capture_get_bounds cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_get_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_get_bounds" '[Rid] (IO Aabb) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_get_bounds {-# NOINLINE bindVisualServer_lightmap_capture_get_energy #-} -- | Returns the energy multiplier used by the lightmap capture. bindVisualServer_lightmap_capture_get_energy :: MethodBind bindVisualServer_lightmap_capture_get_energy = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_get_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the energy multiplier used by the lightmap capture. lightmap_capture_get_energy :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Float lightmap_capture_get_energy cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_get_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_get_energy" '[Rid] (IO Float) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_get_energy {-# NOINLINE bindVisualServer_lightmap_capture_get_octree #-} -- | Returns the octree used by the lightmap capture. bindVisualServer_lightmap_capture_get_octree :: MethodBind bindVisualServer_lightmap_capture_get_octree = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_get_octree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the octree used by the lightmap capture. lightmap_capture_get_octree :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO PoolByteArray lightmap_capture_get_octree cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_get_octree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_get_octree" '[Rid] (IO PoolByteArray) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_get_octree {-# NOINLINE bindVisualServer_lightmap_capture_get_octree_cell_subdiv #-} -- | Returns the cell subdivision amount used by this lightmap capture's octree. bindVisualServer_lightmap_capture_get_octree_cell_subdiv :: MethodBind bindVisualServer_lightmap_capture_get_octree_cell_subdiv = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_get_octree_cell_subdiv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cell subdivision amount used by this lightmap capture's octree. lightmap_capture_get_octree_cell_subdiv :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int lightmap_capture_get_octree_cell_subdiv cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_get_octree_cell_subdiv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_get_octree_cell_subdiv" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_get_octree_cell_subdiv {-# NOINLINE bindVisualServer_lightmap_capture_get_octree_cell_transform #-} -- | Returns the cell transform for this lightmap capture's octree. bindVisualServer_lightmap_capture_get_octree_cell_transform :: MethodBind bindVisualServer_lightmap_capture_get_octree_cell_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_get_octree_cell_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the cell transform for this lightmap capture's octree. lightmap_capture_get_octree_cell_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Transform lightmap_capture_get_octree_cell_transform cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_get_octree_cell_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_get_octree_cell_transform" '[Rid] (IO Transform) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_get_octree_cell_transform {-# NOINLINE bindVisualServer_lightmap_capture_set_bounds #-} -- | Sets the size of the area covered by the lightmap capture. Equivalent to @BakedLightmapData.bounds@. bindVisualServer_lightmap_capture_set_bounds :: MethodBind bindVisualServer_lightmap_capture_set_bounds = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_set_bounds" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the area covered by the lightmap capture. Equivalent to @BakedLightmapData.bounds@. lightmap_capture_set_bounds :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Aabb -> IO () lightmap_capture_set_bounds cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_set_bounds (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_set_bounds" '[Rid, Aabb] (IO ()) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_set_bounds {-# NOINLINE bindVisualServer_lightmap_capture_set_energy #-} -- | Sets the energy multiplier for this lightmap capture. Equivalent to @BakedLightmapData.energy@. bindVisualServer_lightmap_capture_set_energy :: MethodBind bindVisualServer_lightmap_capture_set_energy = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_set_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the energy multiplier for this lightmap capture. Equivalent to @BakedLightmapData.energy@. lightmap_capture_set_energy :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () lightmap_capture_set_energy cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_set_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_set_energy" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_set_energy {-# NOINLINE bindVisualServer_lightmap_capture_set_octree #-} -- | Sets the octree to be used by this lightmap capture. This function is normally used by the @BakedLightmap@ node. Equivalent to @BakedLightmapData.octree@. bindVisualServer_lightmap_capture_set_octree :: MethodBind bindVisualServer_lightmap_capture_set_octree = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_set_octree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the octree to be used by this lightmap capture. This function is normally used by the @BakedLightmap@ node. Equivalent to @BakedLightmapData.octree@. lightmap_capture_set_octree :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolByteArray -> IO () lightmap_capture_set_octree cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_set_octree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_set_octree" '[Rid, PoolByteArray] (IO ()) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_set_octree {-# NOINLINE bindVisualServer_lightmap_capture_set_octree_cell_subdiv #-} -- | Sets the subdivision level of this lightmap capture's octree. Equivalent to @BakedLightmapData.cell_subdiv@. bindVisualServer_lightmap_capture_set_octree_cell_subdiv :: MethodBind bindVisualServer_lightmap_capture_set_octree_cell_subdiv = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_set_octree_cell_subdiv" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the subdivision level of this lightmap capture's octree. Equivalent to @BakedLightmapData.cell_subdiv@. lightmap_capture_set_octree_cell_subdiv :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () lightmap_capture_set_octree_cell_subdiv cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_set_octree_cell_subdiv (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_set_octree_cell_subdiv" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_set_octree_cell_subdiv {-# NOINLINE bindVisualServer_lightmap_capture_set_octree_cell_transform #-} -- | Sets the octree cell transform for this lightmap capture's octree. Equivalent to @BakedLightmapData.cell_space_transform@. bindVisualServer_lightmap_capture_set_octree_cell_transform :: MethodBind bindVisualServer_lightmap_capture_set_octree_cell_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "lightmap_capture_set_octree_cell_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the octree cell transform for this lightmap capture's octree. Equivalent to @BakedLightmapData.cell_space_transform@. lightmap_capture_set_octree_cell_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform -> IO () lightmap_capture_set_octree_cell_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_lightmap_capture_set_octree_cell_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "lightmap_capture_set_octree_cell_transform" '[Rid, Transform] (IO ()) where nodeMethod = Godot.Core.VisualServer.lightmap_capture_set_octree_cell_transform {-# NOINLINE bindVisualServer_make_sphere_mesh #-} -- | Returns a mesh of a sphere with the given amount of horizontal and vertical subdivisions. bindVisualServer_make_sphere_mesh :: MethodBind bindVisualServer_make_sphere_mesh = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "make_sphere_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh of a sphere with the given amount of horizontal and vertical subdivisions. make_sphere_mesh :: (VisualServer :< cls, Object :< cls) => cls -> Int -> Int -> Float -> IO Rid make_sphere_mesh cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_make_sphere_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "make_sphere_mesh" '[Int, Int, Float] (IO Rid) where nodeMethod = Godot.Core.VisualServer.make_sphere_mesh {-# NOINLINE bindVisualServer_material_create #-} -- | Creates an empty material and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @material_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_material_create :: MethodBind bindVisualServer_material_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an empty material and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @material_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. material_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid material_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.material_create {-# NOINLINE bindVisualServer_material_get_param #-} -- | Returns the value of a certain material's parameter. bindVisualServer_material_get_param :: MethodBind bindVisualServer_material_get_param = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_get_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of a certain material's parameter. material_get_param :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> GodotString -> IO GodotVariant material_get_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_get_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_get_param" '[Rid, GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.VisualServer.material_get_param {-# NOINLINE bindVisualServer_material_get_param_default #-} -- | Returns the default value for the param if available. Otherwise returns an empty @Variant@. bindVisualServer_material_get_param_default :: MethodBind bindVisualServer_material_get_param_default = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_get_param_default" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the default value for the param if available. Otherwise returns an empty @Variant@. material_get_param_default :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> GodotString -> IO GodotVariant material_get_param_default cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_get_param_default (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_get_param_default" '[Rid, GodotString] (IO GodotVariant) where nodeMethod = Godot.Core.VisualServer.material_get_param_default {-# NOINLINE bindVisualServer_material_get_shader #-} -- | Returns the shader of a certain material's shader. Returns an empty RID if the material doesn't have a shader. bindVisualServer_material_get_shader :: MethodBind bindVisualServer_material_get_shader = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_get_shader" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shader of a certain material's shader. Returns an empty RID if the material doesn't have a shader. material_get_shader :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Rid material_get_shader cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_get_shader (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_get_shader" '[Rid] (IO Rid) where nodeMethod = Godot.Core.VisualServer.material_get_shader {-# NOINLINE bindVisualServer_material_set_line_width #-} -- | Sets a material's line width. bindVisualServer_material_set_line_width :: MethodBind bindVisualServer_material_set_line_width = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_set_line_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a material's line width. material_set_line_width :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () material_set_line_width cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_set_line_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_set_line_width" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.material_set_line_width {-# NOINLINE bindVisualServer_material_set_next_pass #-} -- | Sets an object's next material. bindVisualServer_material_set_next_pass :: MethodBind bindVisualServer_material_set_next_pass = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_set_next_pass" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets an object's next material. material_set_next_pass :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () material_set_next_pass cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_set_next_pass (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_set_next_pass" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.material_set_next_pass {-# NOINLINE bindVisualServer_material_set_param #-} -- | Sets a material's parameter. bindVisualServer_material_set_param :: MethodBind bindVisualServer_material_set_param = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_set_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a material's parameter. material_set_param :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> GodotString -> GodotVariant -> IO () material_set_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_set_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_set_param" '[Rid, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.VisualServer.material_set_param {-# NOINLINE bindVisualServer_material_set_render_priority #-} -- | Sets a material's render priority. bindVisualServer_material_set_render_priority :: MethodBind bindVisualServer_material_set_render_priority = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_set_render_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a material's render priority. material_set_render_priority :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () material_set_render_priority cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_set_render_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_set_render_priority" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.material_set_render_priority {-# NOINLINE bindVisualServer_material_set_shader #-} -- | Sets a shader material's shader. bindVisualServer_material_set_shader :: MethodBind bindVisualServer_material_set_shader = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "material_set_shader" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a shader material's shader. material_set_shader :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () material_set_shader cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_material_set_shader (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "material_set_shader" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.material_set_shader {-# NOINLINE bindVisualServer_mesh_add_surface_from_arrays #-} -- | Adds a surface generated from the Arrays to a mesh. See @enum PrimitiveType@ constants for types. bindVisualServer_mesh_add_surface_from_arrays :: MethodBind bindVisualServer_mesh_add_surface_from_arrays = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_add_surface_from_arrays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a surface generated from the Arrays to a mesh. See @enum PrimitiveType@ constants for types. mesh_add_surface_from_arrays :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Array -> Maybe Array -> Maybe Int -> IO () mesh_add_surface_from_arrays cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, defaultedVariant VariantArray V.empty arg4, maybe (VariantInt (97280)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_add_surface_from_arrays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_add_surface_from_arrays" '[Rid, Int, Array, Maybe Array, Maybe Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.mesh_add_surface_from_arrays {-# NOINLINE bindVisualServer_mesh_clear #-} -- | Removes all surfaces from a mesh. bindVisualServer_mesh_clear :: MethodBind bindVisualServer_mesh_clear = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all surfaces from a mesh. mesh_clear :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO () mesh_clear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_clear" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.mesh_clear {-# NOINLINE bindVisualServer_mesh_create #-} -- | Creates a new mesh and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @mesh_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this mesh to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_mesh_create :: MethodBind bindVisualServer_mesh_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new mesh and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @mesh_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this mesh to an instance using @method instance_set_base@ using the returned RID. mesh_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid mesh_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.mesh_create {-# NOINLINE bindVisualServer_mesh_get_blend_shape_count #-} -- | Returns a mesh's blend shape count. bindVisualServer_mesh_get_blend_shape_count :: MethodBind bindVisualServer_mesh_get_blend_shape_count = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_get_blend_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's blend shape count. mesh_get_blend_shape_count :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int mesh_get_blend_shape_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_get_blend_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_get_blend_shape_count" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_get_blend_shape_count {-# NOINLINE bindVisualServer_mesh_get_blend_shape_mode #-} -- | Returns a mesh's blend shape mode. bindVisualServer_mesh_get_blend_shape_mode :: MethodBind bindVisualServer_mesh_get_blend_shape_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_get_blend_shape_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's blend shape mode. mesh_get_blend_shape_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int mesh_get_blend_shape_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_get_blend_shape_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_get_blend_shape_mode" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_get_blend_shape_mode {-# NOINLINE bindVisualServer_mesh_get_custom_aabb #-} -- | Returns a mesh's custom aabb. bindVisualServer_mesh_get_custom_aabb :: MethodBind bindVisualServer_mesh_get_custom_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_get_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's custom aabb. mesh_get_custom_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Aabb mesh_get_custom_aabb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_get_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_get_custom_aabb" '[Rid] (IO Aabb) where nodeMethod = Godot.Core.VisualServer.mesh_get_custom_aabb {-# NOINLINE bindVisualServer_mesh_get_surface_count #-} -- | Returns a mesh's number of surfaces. bindVisualServer_mesh_get_surface_count :: MethodBind bindVisualServer_mesh_get_surface_count = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_get_surface_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's number of surfaces. mesh_get_surface_count :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int mesh_get_surface_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_get_surface_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_get_surface_count" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_get_surface_count {-# NOINLINE bindVisualServer_mesh_remove_surface #-} -- | Removes a mesh's surface. bindVisualServer_mesh_remove_surface :: MethodBind bindVisualServer_mesh_remove_surface = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_remove_surface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a mesh's surface. mesh_remove_surface :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () mesh_remove_surface cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_remove_surface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_remove_surface" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.mesh_remove_surface {-# NOINLINE bindVisualServer_mesh_set_blend_shape_count #-} -- | Sets a mesh's blend shape count. bindVisualServer_mesh_set_blend_shape_count :: MethodBind bindVisualServer_mesh_set_blend_shape_count = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_set_blend_shape_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a mesh's blend shape count. mesh_set_blend_shape_count :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () mesh_set_blend_shape_count cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_set_blend_shape_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_set_blend_shape_count" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.mesh_set_blend_shape_count {-# NOINLINE bindVisualServer_mesh_set_blend_shape_mode #-} -- | Sets a mesh's blend shape mode. bindVisualServer_mesh_set_blend_shape_mode :: MethodBind bindVisualServer_mesh_set_blend_shape_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_set_blend_shape_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a mesh's blend shape mode. mesh_set_blend_shape_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () mesh_set_blend_shape_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_set_blend_shape_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_set_blend_shape_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.mesh_set_blend_shape_mode {-# NOINLINE bindVisualServer_mesh_set_custom_aabb #-} -- | Sets a mesh's custom aabb. bindVisualServer_mesh_set_custom_aabb :: MethodBind bindVisualServer_mesh_set_custom_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_set_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a mesh's custom aabb. mesh_set_custom_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Aabb -> IO () mesh_set_custom_aabb cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_set_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_set_custom_aabb" '[Rid, Aabb] (IO ()) where nodeMethod = Godot.Core.VisualServer.mesh_set_custom_aabb {-# NOINLINE bindVisualServer_mesh_surface_get_aabb #-} -- | Returns a mesh's surface's aabb. bindVisualServer_mesh_surface_get_aabb :: MethodBind bindVisualServer_mesh_surface_get_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's surface's aabb. mesh_surface_get_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Aabb mesh_surface_get_aabb cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_aabb" '[Rid, Int] (IO Aabb) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_aabb {-# NOINLINE bindVisualServer_mesh_surface_get_array #-} -- | Returns a mesh's surface's vertex buffer. bindVisualServer_mesh_surface_get_array :: MethodBind bindVisualServer_mesh_surface_get_array = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's surface's vertex buffer. mesh_surface_get_array :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO PoolByteArray mesh_surface_get_array cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_array" '[Rid, Int] (IO PoolByteArray) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_array {-# NOINLINE bindVisualServer_mesh_surface_get_array_index_len #-} -- | Returns a mesh's surface's amount of indices. bindVisualServer_mesh_surface_get_array_index_len :: MethodBind bindVisualServer_mesh_surface_get_array_index_len = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_array_index_len" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's surface's amount of indices. mesh_surface_get_array_index_len :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Int mesh_surface_get_array_index_len cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_array_index_len (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_array_index_len" '[Rid, Int] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_array_index_len {-# NOINLINE bindVisualServer_mesh_surface_get_array_len #-} -- | Returns a mesh's surface's amount of vertices. bindVisualServer_mesh_surface_get_array_len :: MethodBind bindVisualServer_mesh_surface_get_array_len = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_array_len" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's surface's amount of vertices. mesh_surface_get_array_len :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Int mesh_surface_get_array_len cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_array_len (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_array_len" '[Rid, Int] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_array_len {-# NOINLINE bindVisualServer_mesh_surface_get_arrays #-} -- | Returns a mesh's surface's buffer arrays. bindVisualServer_mesh_surface_get_arrays :: MethodBind bindVisualServer_mesh_surface_get_arrays = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_arrays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's surface's buffer arrays. mesh_surface_get_arrays :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Array mesh_surface_get_arrays cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_arrays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_arrays" '[Rid, Int] (IO Array) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_arrays {-# NOINLINE bindVisualServer_mesh_surface_get_blend_shape_arrays #-} -- | Returns a mesh's surface's arrays for blend shapes. bindVisualServer_mesh_surface_get_blend_shape_arrays :: MethodBind bindVisualServer_mesh_surface_get_blend_shape_arrays = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_blend_shape_arrays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's surface's arrays for blend shapes. mesh_surface_get_blend_shape_arrays :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Array mesh_surface_get_blend_shape_arrays cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_blend_shape_arrays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_blend_shape_arrays" '[Rid, Int] (IO Array) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_blend_shape_arrays {-# NOINLINE bindVisualServer_mesh_surface_get_format #-} -- | Returns the format of a mesh's surface. bindVisualServer_mesh_surface_get_format :: MethodBind bindVisualServer_mesh_surface_get_format = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the format of a mesh's surface. mesh_surface_get_format :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Int mesh_surface_get_format cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_format" '[Rid, Int] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_format {-# NOINLINE bindVisualServer_mesh_surface_get_format_offset #-} -- | Function is unused in Godot 3.x. bindVisualServer_mesh_surface_get_format_offset :: MethodBind bindVisualServer_mesh_surface_get_format_offset = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_format_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Function is unused in Godot 3.x. mesh_surface_get_format_offset :: (VisualServer :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> IO Int mesh_surface_get_format_offset cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_format_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_format_offset" '[Int, Int, Int, Int] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_format_offset {-# NOINLINE bindVisualServer_mesh_surface_get_format_stride #-} -- | Function is unused in Godot 3.x. bindVisualServer_mesh_surface_get_format_stride :: MethodBind bindVisualServer_mesh_surface_get_format_stride = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_format_stride" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Function is unused in Godot 3.x. mesh_surface_get_format_stride :: (VisualServer :< cls, Object :< cls) => cls -> Int -> Int -> Int -> IO Int mesh_surface_get_format_stride cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_format_stride (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_format_stride" '[Int, Int, Int] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_format_stride {-# NOINLINE bindVisualServer_mesh_surface_get_index_array #-} -- | Returns a mesh's surface's index buffer. bindVisualServer_mesh_surface_get_index_array :: MethodBind bindVisualServer_mesh_surface_get_index_array = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_index_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's surface's index buffer. mesh_surface_get_index_array :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO PoolByteArray mesh_surface_get_index_array cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_index_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_index_array" '[Rid, Int] (IO PoolByteArray) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_index_array {-# NOINLINE bindVisualServer_mesh_surface_get_material #-} -- | Returns a mesh's surface's material. bindVisualServer_mesh_surface_get_material :: MethodBind bindVisualServer_mesh_surface_get_material = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a mesh's surface's material. mesh_surface_get_material :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Rid mesh_surface_get_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_material" '[Rid, Int] (IO Rid) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_material {-# NOINLINE bindVisualServer_mesh_surface_get_primitive_type #-} -- | Returns the primitive type of a mesh's surface. bindVisualServer_mesh_surface_get_primitive_type :: MethodBind bindVisualServer_mesh_surface_get_primitive_type = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_primitive_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the primitive type of a mesh's surface. mesh_surface_get_primitive_type :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Int mesh_surface_get_primitive_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_primitive_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_primitive_type" '[Rid, Int] (IO Int) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_primitive_type {-# NOINLINE bindVisualServer_mesh_surface_get_skeleton_aabb #-} -- | Returns the aabb of a mesh's surface's skeleton. bindVisualServer_mesh_surface_get_skeleton_aabb :: MethodBind bindVisualServer_mesh_surface_get_skeleton_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_get_skeleton_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the aabb of a mesh's surface's skeleton. mesh_surface_get_skeleton_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Array mesh_surface_get_skeleton_aabb cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_get_skeleton_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_get_skeleton_aabb" '[Rid, Int] (IO Array) where nodeMethod = Godot.Core.VisualServer.mesh_surface_get_skeleton_aabb {-# NOINLINE bindVisualServer_mesh_surface_set_material #-} -- | Sets a mesh's surface's material. bindVisualServer_mesh_surface_set_material :: MethodBind bindVisualServer_mesh_surface_set_material = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_set_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a mesh's surface's material. mesh_surface_set_material :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Rid -> IO () mesh_surface_set_material cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_set_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_set_material" '[Rid, Int, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.mesh_surface_set_material {-# NOINLINE bindVisualServer_mesh_surface_update_region #-} -- | Updates a specific region of a vertex buffer for the specified surface. Warning: this function alters the vertex buffer directly with no safety mechanisms, you can easily corrupt your mesh. bindVisualServer_mesh_surface_update_region :: MethodBind bindVisualServer_mesh_surface_update_region = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "mesh_surface_update_region" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates a specific region of a vertex buffer for the specified surface. Warning: this function alters the vertex buffer directly with no safety mechanisms, you can easily corrupt your mesh. mesh_surface_update_region :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> PoolByteArray -> IO () mesh_surface_update_region cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_mesh_surface_update_region (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "mesh_surface_update_region" '[Rid, Int, Int, PoolByteArray] (IO ()) where nodeMethod = Godot.Core.VisualServer.mesh_surface_update_region {-# NOINLINE bindVisualServer_multimesh_allocate #-} -- | Allocates space for the multimesh data. Format parameters determine how the data will be stored by OpenGL. See @enum MultimeshTransformFormat@, @enum MultimeshColorFormat@, and @enum MultimeshCustomDataFormat@ for usage. Equivalent to @MultiMesh.instance_count@. bindVisualServer_multimesh_allocate :: MethodBind bindVisualServer_multimesh_allocate = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_allocate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allocates space for the multimesh data. Format parameters determine how the data will be stored by OpenGL. See @enum MultimeshTransformFormat@, @enum MultimeshColorFormat@, and @enum MultimeshCustomDataFormat@ for usage. Equivalent to @MultiMesh.instance_count@. multimesh_allocate :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> Int -> Maybe Int -> IO () multimesh_allocate cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, maybe (VariantInt (0)) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_allocate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_allocate" '[Rid, Int, Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.multimesh_allocate {-# NOINLINE bindVisualServer_multimesh_create #-} -- | Creates a new multimesh on the VisualServer and returns an @RID@ handle. This RID will be used in all @multimesh_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this multimesh to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_multimesh_create :: MethodBind bindVisualServer_multimesh_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new multimesh on the VisualServer and returns an @RID@ handle. This RID will be used in all @multimesh_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this multimesh to an instance using @method instance_set_base@ using the returned RID. multimesh_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid multimesh_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.multimesh_create {-# NOINLINE bindVisualServer_multimesh_get_aabb #-} -- | Calculates and returns the axis-aligned bounding box that encloses all instances within the multimesh. bindVisualServer_multimesh_get_aabb :: MethodBind bindVisualServer_multimesh_get_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_get_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calculates and returns the axis-aligned bounding box that encloses all instances within the multimesh. multimesh_get_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Aabb multimesh_get_aabb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_get_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_get_aabb" '[Rid] (IO Aabb) where nodeMethod = Godot.Core.VisualServer.multimesh_get_aabb {-# NOINLINE bindVisualServer_multimesh_get_instance_count #-} -- | Returns the number of instances allocated for this multimesh. bindVisualServer_multimesh_get_instance_count :: MethodBind bindVisualServer_multimesh_get_instance_count = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_get_instance_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of instances allocated for this multimesh. multimesh_get_instance_count :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int multimesh_get_instance_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_get_instance_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_get_instance_count" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.multimesh_get_instance_count {-# NOINLINE bindVisualServer_multimesh_get_mesh #-} -- | Returns the RID of the mesh that will be used in drawing this multimesh. bindVisualServer_multimesh_get_mesh :: MethodBind bindVisualServer_multimesh_get_mesh = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_get_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the RID of the mesh that will be used in drawing this multimesh. multimesh_get_mesh :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Rid multimesh_get_mesh cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_get_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_get_mesh" '[Rid] (IO Rid) where nodeMethod = Godot.Core.VisualServer.multimesh_get_mesh {-# NOINLINE bindVisualServer_multimesh_get_visible_instances #-} -- | Returns the number of visible instances for this multimesh. bindVisualServer_multimesh_get_visible_instances :: MethodBind bindVisualServer_multimesh_get_visible_instances = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_get_visible_instances" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of visible instances for this multimesh. multimesh_get_visible_instances :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int multimesh_get_visible_instances cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_get_visible_instances (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_get_visible_instances" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.multimesh_get_visible_instances {-# NOINLINE bindVisualServer_multimesh_instance_get_color #-} -- | Returns the color by which the specified instance will be modulated. bindVisualServer_multimesh_instance_get_color :: MethodBind bindVisualServer_multimesh_instance_get_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_instance_get_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the color by which the specified instance will be modulated. multimesh_instance_get_color :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Color multimesh_instance_get_color cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_instance_get_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_instance_get_color" '[Rid, Int] (IO Color) where nodeMethod = Godot.Core.VisualServer.multimesh_instance_get_color {-# NOINLINE bindVisualServer_multimesh_instance_get_custom_data #-} -- | Returns the custom data associated with the specified instance. bindVisualServer_multimesh_instance_get_custom_data :: MethodBind bindVisualServer_multimesh_instance_get_custom_data = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_instance_get_custom_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the custom data associated with the specified instance. multimesh_instance_get_custom_data :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Color multimesh_instance_get_custom_data cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_instance_get_custom_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_instance_get_custom_data" '[Rid, Int] (IO Color) where nodeMethod = Godot.Core.VisualServer.multimesh_instance_get_custom_data {-# NOINLINE bindVisualServer_multimesh_instance_get_transform #-} -- | Returns the @Transform@ of the specified instance. bindVisualServer_multimesh_instance_get_transform :: MethodBind bindVisualServer_multimesh_instance_get_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_instance_get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Transform@ of the specified instance. multimesh_instance_get_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Transform multimesh_instance_get_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_instance_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_instance_get_transform" '[Rid, Int] (IO Transform) where nodeMethod = Godot.Core.VisualServer.multimesh_instance_get_transform {-# NOINLINE bindVisualServer_multimesh_instance_get_transform_2d #-} -- | Returns the @Transform2D@ of the specified instance. For use when the multimesh is set to use 2D transforms. bindVisualServer_multimesh_instance_get_transform_2d :: MethodBind bindVisualServer_multimesh_instance_get_transform_2d = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_instance_get_transform_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Transform2D@ of the specified instance. For use when the multimesh is set to use 2D transforms. multimesh_instance_get_transform_2d :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Transform2d multimesh_instance_get_transform_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_instance_get_transform_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_instance_get_transform_2d" '[Rid, Int] (IO Transform2d) where nodeMethod = Godot.Core.VisualServer.multimesh_instance_get_transform_2d {-# NOINLINE bindVisualServer_multimesh_instance_set_color #-} -- | Sets the color by which this instance will be modulated. Equivalent to @method MultiMesh.set_instance_color@. bindVisualServer_multimesh_instance_set_color :: MethodBind bindVisualServer_multimesh_instance_set_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_instance_set_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the color by which this instance will be modulated. Equivalent to @method MultiMesh.set_instance_color@. multimesh_instance_set_color :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Color -> IO () multimesh_instance_set_color cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_instance_set_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_instance_set_color" '[Rid, Int, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.multimesh_instance_set_color {-# NOINLINE bindVisualServer_multimesh_instance_set_custom_data #-} -- | Sets the custom data for this instance. Custom data is passed as a @Color@, but is interpreted as a @vec4@ in the shader. Equivalent to @method MultiMesh.set_instance_custom_data@. bindVisualServer_multimesh_instance_set_custom_data :: MethodBind bindVisualServer_multimesh_instance_set_custom_data = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_instance_set_custom_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the custom data for this instance. Custom data is passed as a @Color@, but is interpreted as a @vec4@ in the shader. Equivalent to @method MultiMesh.set_instance_custom_data@. multimesh_instance_set_custom_data :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Color -> IO () multimesh_instance_set_custom_data cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_instance_set_custom_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_instance_set_custom_data" '[Rid, Int, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.multimesh_instance_set_custom_data {-# NOINLINE bindVisualServer_multimesh_instance_set_transform #-} -- | Sets the @Transform@ for this instance. Equivalent to @method MultiMesh.set_instance_transform@. bindVisualServer_multimesh_instance_set_transform :: MethodBind bindVisualServer_multimesh_instance_set_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_instance_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform@ for this instance. Equivalent to @method MultiMesh.set_instance_transform@. multimesh_instance_set_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Transform -> IO () multimesh_instance_set_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_instance_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_instance_set_transform" '[Rid, Int, Transform] (IO ()) where nodeMethod = Godot.Core.VisualServer.multimesh_instance_set_transform {-# NOINLINE bindVisualServer_multimesh_instance_set_transform_2d #-} -- | Sets the @Transform2D@ for this instance. For use when multimesh is used in 2D. Equivalent to @method MultiMesh.set_instance_transform_2d@. bindVisualServer_multimesh_instance_set_transform_2d :: MethodBind bindVisualServer_multimesh_instance_set_transform_2d = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_instance_set_transform_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform2D@ for this instance. For use when multimesh is used in 2D. Equivalent to @method MultiMesh.set_instance_transform_2d@. multimesh_instance_set_transform_2d :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Transform2d -> IO () multimesh_instance_set_transform_2d cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_instance_set_transform_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_instance_set_transform_2d" '[Rid, Int, Transform2d] (IO ()) where nodeMethod = Godot.Core.VisualServer.multimesh_instance_set_transform_2d {-# NOINLINE bindVisualServer_multimesh_set_as_bulk_array #-} -- | Sets all data related to the instances in one go. This is especially useful when loading the data from disk or preparing the data from GDNative. -- -- All data is packed in one large float array. An array may look like this: Transform for instance 1, color data for instance 1, custom data for instance 1, transform for instance 2, color data for instance 2, etc. -- -- @Transform@ is stored as 12 floats, @Transform2D@ is stored as 8 floats, @COLOR_8BIT@ / @CUSTOM_DATA_8BIT@ is stored as 1 float (4 bytes as is) and @COLOR_FLOAT@ / @CUSTOM_DATA_FLOAT@ is stored as 4 floats. bindVisualServer_multimesh_set_as_bulk_array :: MethodBind bindVisualServer_multimesh_set_as_bulk_array = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_set_as_bulk_array" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets all data related to the instances in one go. This is especially useful when loading the data from disk or preparing the data from GDNative. -- -- All data is packed in one large float array. An array may look like this: Transform for instance 1, color data for instance 1, custom data for instance 1, transform for instance 2, color data for instance 2, etc. -- -- @Transform@ is stored as 12 floats, @Transform2D@ is stored as 8 floats, @COLOR_8BIT@ / @CUSTOM_DATA_8BIT@ is stored as 1 float (4 bytes as is) and @COLOR_FLOAT@ / @CUSTOM_DATA_FLOAT@ is stored as 4 floats. multimesh_set_as_bulk_array :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> PoolRealArray -> IO () multimesh_set_as_bulk_array cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_set_as_bulk_array (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_set_as_bulk_array" '[Rid, PoolRealArray] (IO ()) where nodeMethod = Godot.Core.VisualServer.multimesh_set_as_bulk_array {-# NOINLINE bindVisualServer_multimesh_set_mesh #-} -- | Sets the mesh to be drawn by the multimesh. Equivalent to @MultiMesh.mesh@. bindVisualServer_multimesh_set_mesh :: MethodBind bindVisualServer_multimesh_set_mesh = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_set_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the mesh to be drawn by the multimesh. Equivalent to @MultiMesh.mesh@. multimesh_set_mesh :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () multimesh_set_mesh cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_set_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_set_mesh" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.multimesh_set_mesh {-# NOINLINE bindVisualServer_multimesh_set_visible_instances #-} -- | Sets the number of instances visible at a given time. If -1, all instances that have been allocated are drawn. Equivalent to @MultiMesh.visible_instance_count@. bindVisualServer_multimesh_set_visible_instances :: MethodBind bindVisualServer_multimesh_set_visible_instances = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "multimesh_set_visible_instances" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the number of instances visible at a given time. If -1, all instances that have been allocated are drawn. Equivalent to @MultiMesh.visible_instance_count@. multimesh_set_visible_instances :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () multimesh_set_visible_instances cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_multimesh_set_visible_instances (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "multimesh_set_visible_instances" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.multimesh_set_visible_instances {-# NOINLINE bindVisualServer_omni_light_create #-} -- | Creates a new omni light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most @light_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this omni light to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_omni_light_create :: MethodBind bindVisualServer_omni_light_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "omni_light_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a new omni light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most @light_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this omni light to an instance using @method instance_set_base@ using the returned RID. omni_light_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid omni_light_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_omni_light_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "omni_light_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.omni_light_create {-# NOINLINE bindVisualServer_particles_create #-} -- | Creates a particle system and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @particles_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach these particles to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_particles_create :: MethodBind bindVisualServer_particles_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a particle system and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @particles_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach these particles to an instance using @method instance_set_base@ using the returned RID. particles_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid particles_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.particles_create {-# NOINLINE bindVisualServer_particles_get_current_aabb #-} -- | Calculates and returns the axis-aligned bounding box that contains all the particles. Equivalent to @method Particles.capture_aabb@. bindVisualServer_particles_get_current_aabb :: MethodBind bindVisualServer_particles_get_current_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_get_current_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Calculates and returns the axis-aligned bounding box that contains all the particles. Equivalent to @method Particles.capture_aabb@. particles_get_current_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Aabb particles_get_current_aabb cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_get_current_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_get_current_aabb" '[Rid] (IO Aabb) where nodeMethod = Godot.Core.VisualServer.particles_get_current_aabb {-# NOINLINE bindVisualServer_particles_get_emitting #-} -- | Returns @true@ if particles are currently set to emitting. bindVisualServer_particles_get_emitting :: MethodBind bindVisualServer_particles_get_emitting = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_get_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if particles are currently set to emitting. particles_get_emitting :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Bool particles_get_emitting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_get_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_get_emitting" '[Rid] (IO Bool) where nodeMethod = Godot.Core.VisualServer.particles_get_emitting {-# NOINLINE bindVisualServer_particles_is_inactive #-} -- | Returns @true@ if particles are not emitting and particles are set to inactive. bindVisualServer_particles_is_inactive :: MethodBind bindVisualServer_particles_is_inactive = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_is_inactive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if particles are not emitting and particles are set to inactive. particles_is_inactive :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Bool particles_is_inactive cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_is_inactive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_is_inactive" '[Rid] (IO Bool) where nodeMethod = Godot.Core.VisualServer.particles_is_inactive {-# NOINLINE bindVisualServer_particles_request_process #-} -- | Add particle system to list of particle systems that need to be updated. Update will take place on the next frame, or on the next call to @method instances_cull_aabb@, @method instances_cull_convex@, or @method instances_cull_ray@. bindVisualServer_particles_request_process :: MethodBind bindVisualServer_particles_request_process = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_request_process" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Add particle system to list of particle systems that need to be updated. Update will take place on the next frame, or on the next call to @method instances_cull_aabb@, @method instances_cull_convex@, or @method instances_cull_ray@. particles_request_process :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO () particles_request_process cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_request_process (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_request_process" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_request_process {-# NOINLINE bindVisualServer_particles_restart #-} -- | Reset the particles on the next update. Equivalent to @method Particles.restart@. bindVisualServer_particles_restart :: MethodBind bindVisualServer_particles_restart = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_restart" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reset the particles on the next update. Equivalent to @method Particles.restart@. particles_restart :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO () particles_restart cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_restart (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_restart" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_restart {-# NOINLINE bindVisualServer_particles_set_amount #-} -- | Sets the number of particles to be drawn and allocates the memory for them. Equivalent to @Particles.amount@. bindVisualServer_particles_set_amount :: MethodBind bindVisualServer_particles_set_amount = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_amount" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the number of particles to be drawn and allocates the memory for them. Equivalent to @Particles.amount@. particles_set_amount :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () particles_set_amount cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_amount (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_amount" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_amount {-# NOINLINE bindVisualServer_particles_set_custom_aabb #-} -- | Sets a custom axis-aligned bounding box for the particle system. Equivalent to @Particles.visibility_aabb@. bindVisualServer_particles_set_custom_aabb :: MethodBind bindVisualServer_particles_set_custom_aabb = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_custom_aabb" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a custom axis-aligned bounding box for the particle system. Equivalent to @Particles.visibility_aabb@. particles_set_custom_aabb :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Aabb -> IO () particles_set_custom_aabb cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_custom_aabb (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_custom_aabb" '[Rid, Aabb] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_custom_aabb {-# NOINLINE bindVisualServer_particles_set_draw_order #-} -- | Sets the draw order of the particles to one of the named enums from @enum ParticlesDrawOrder@. See @enum ParticlesDrawOrder@ for options. Equivalent to @Particles.draw_order@. bindVisualServer_particles_set_draw_order :: MethodBind bindVisualServer_particles_set_draw_order = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_draw_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the draw order of the particles to one of the named enums from @enum ParticlesDrawOrder@. See @enum ParticlesDrawOrder@ for options. Equivalent to @Particles.draw_order@. particles_set_draw_order :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () particles_set_draw_order cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_draw_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_draw_order" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_draw_order {-# NOINLINE bindVisualServer_particles_set_draw_pass_mesh #-} -- | Sets the mesh to be used for the specified draw pass. Equivalent to @Particles.draw_pass_1@, @Particles.draw_pass_2@, @Particles.draw_pass_3@, and @Particles.draw_pass_4@. bindVisualServer_particles_set_draw_pass_mesh :: MethodBind bindVisualServer_particles_set_draw_pass_mesh = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_draw_pass_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the mesh to be used for the specified draw pass. Equivalent to @Particles.draw_pass_1@, @Particles.draw_pass_2@, @Particles.draw_pass_3@, and @Particles.draw_pass_4@. particles_set_draw_pass_mesh :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Rid -> IO () particles_set_draw_pass_mesh cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_draw_pass_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_draw_pass_mesh" '[Rid, Int, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_draw_pass_mesh {-# NOINLINE bindVisualServer_particles_set_draw_passes #-} -- | Sets the number of draw passes to use. Equivalent to @Particles.draw_passes@. bindVisualServer_particles_set_draw_passes :: MethodBind bindVisualServer_particles_set_draw_passes = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_draw_passes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the number of draw passes to use. Equivalent to @Particles.draw_passes@. particles_set_draw_passes :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () particles_set_draw_passes cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_draw_passes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_draw_passes" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_draw_passes {-# NOINLINE bindVisualServer_particles_set_emission_transform #-} -- | Sets the @Transform@ that will be used by the particles when they first emit. bindVisualServer_particles_set_emission_transform :: MethodBind bindVisualServer_particles_set_emission_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_emission_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform@ that will be used by the particles when they first emit. particles_set_emission_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform -> IO () particles_set_emission_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_emission_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_emission_transform" '[Rid, Transform] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_emission_transform {-# NOINLINE bindVisualServer_particles_set_emitting #-} -- | If @true@, particles will emit over time. Setting to false does not reset the particles, but only stops their emission. Equivalent to @Particles.emitting@. bindVisualServer_particles_set_emitting :: MethodBind bindVisualServer_particles_set_emitting = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_emitting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles will emit over time. Setting to false does not reset the particles, but only stops their emission. Equivalent to @Particles.emitting@. particles_set_emitting :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () particles_set_emitting cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_emitting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_emitting" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_emitting {-# NOINLINE bindVisualServer_particles_set_explosiveness_ratio #-} -- | Sets the explosiveness ratio. Equivalent to @Particles.explosiveness@. bindVisualServer_particles_set_explosiveness_ratio :: MethodBind bindVisualServer_particles_set_explosiveness_ratio = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_explosiveness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the explosiveness ratio. Equivalent to @Particles.explosiveness@. particles_set_explosiveness_ratio :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () particles_set_explosiveness_ratio cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_explosiveness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_explosiveness_ratio" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_explosiveness_ratio {-# NOINLINE bindVisualServer_particles_set_fixed_fps #-} -- | Sets the frame rate that the particle system rendering will be fixed to. Equivalent to @Particles.fixed_fps@. bindVisualServer_particles_set_fixed_fps :: MethodBind bindVisualServer_particles_set_fixed_fps = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_fixed_fps" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the frame rate that the particle system rendering will be fixed to. Equivalent to @Particles.fixed_fps@. particles_set_fixed_fps :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () particles_set_fixed_fps cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_fixed_fps (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_fixed_fps" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_fixed_fps {-# NOINLINE bindVisualServer_particles_set_fractional_delta #-} -- | If @true@, uses fractional delta which smooths the movement of the particles. Equivalent to @Particles.fract_delta@. bindVisualServer_particles_set_fractional_delta :: MethodBind bindVisualServer_particles_set_fractional_delta = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_fractional_delta" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, uses fractional delta which smooths the movement of the particles. Equivalent to @Particles.fract_delta@. particles_set_fractional_delta :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () particles_set_fractional_delta cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_fractional_delta (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_fractional_delta" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_fractional_delta {-# NOINLINE bindVisualServer_particles_set_lifetime #-} -- | Sets the lifetime of each particle in the system. Equivalent to @Particles.lifetime@. bindVisualServer_particles_set_lifetime :: MethodBind bindVisualServer_particles_set_lifetime = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_lifetime" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the lifetime of each particle in the system. Equivalent to @Particles.lifetime@. particles_set_lifetime :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () particles_set_lifetime cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_lifetime (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_lifetime" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_lifetime {-# NOINLINE bindVisualServer_particles_set_one_shot #-} -- | If @true@, particles will emit once and then stop. Equivalent to @Particles.one_shot@. bindVisualServer_particles_set_one_shot :: MethodBind bindVisualServer_particles_set_one_shot = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_one_shot" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles will emit once and then stop. Equivalent to @Particles.one_shot@. particles_set_one_shot :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () particles_set_one_shot cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_one_shot (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_one_shot" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_one_shot {-# NOINLINE bindVisualServer_particles_set_pre_process_time #-} -- | Sets the preprocess time for the particles animation. This lets you delay starting an animation until after the particles have begun emitting. Equivalent to @Particles.preprocess@. bindVisualServer_particles_set_pre_process_time :: MethodBind bindVisualServer_particles_set_pre_process_time = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_pre_process_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the preprocess time for the particles animation. This lets you delay starting an animation until after the particles have begun emitting. Equivalent to @Particles.preprocess@. particles_set_pre_process_time :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () particles_set_pre_process_time cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_pre_process_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_pre_process_time" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_pre_process_time {-# NOINLINE bindVisualServer_particles_set_process_material #-} -- | Sets the material for processing the particles. Note: this is not the material used to draw the materials. Equivalent to @Particles.process_material@. bindVisualServer_particles_set_process_material :: MethodBind bindVisualServer_particles_set_process_material = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_process_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the material for processing the particles. Note: this is not the material used to draw the materials. Equivalent to @Particles.process_material@. particles_set_process_material :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () particles_set_process_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_process_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_process_material" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_process_material {-# NOINLINE bindVisualServer_particles_set_randomness_ratio #-} -- | Sets the emission randomness ratio. This randomizes the emission of particles within their phase. Equivalent to @Particles.randomness@. bindVisualServer_particles_set_randomness_ratio :: MethodBind bindVisualServer_particles_set_randomness_ratio = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_randomness_ratio" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the emission randomness ratio. This randomizes the emission of particles within their phase. Equivalent to @Particles.randomness@. particles_set_randomness_ratio :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () particles_set_randomness_ratio cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_randomness_ratio (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_randomness_ratio" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_randomness_ratio {-# NOINLINE bindVisualServer_particles_set_speed_scale #-} -- | Sets the speed scale of the particle system. Equivalent to @Particles.speed_scale@. bindVisualServer_particles_set_speed_scale :: MethodBind bindVisualServer_particles_set_speed_scale = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_speed_scale" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the speed scale of the particle system. Equivalent to @Particles.speed_scale@. particles_set_speed_scale :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () particles_set_speed_scale cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_speed_scale (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_speed_scale" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_speed_scale {-# NOINLINE bindVisualServer_particles_set_use_local_coordinates #-} -- | If @true@, particles use local coordinates. If @false@ they use global coordinates. Equivalent to @Particles.local_coords@. bindVisualServer_particles_set_use_local_coordinates :: MethodBind bindVisualServer_particles_set_use_local_coordinates = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "particles_set_use_local_coordinates" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, particles use local coordinates. If @false@ they use global coordinates. Equivalent to @Particles.local_coords@. particles_set_use_local_coordinates :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () particles_set_use_local_coordinates cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_particles_set_use_local_coordinates (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "particles_set_use_local_coordinates" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.particles_set_use_local_coordinates {-# NOINLINE bindVisualServer_reflection_probe_create #-} -- | Creates a reflection probe and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @reflection_probe_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this reflection probe to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_reflection_probe_create :: MethodBind bindVisualServer_reflection_probe_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a reflection probe and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @reflection_probe_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this reflection probe to an instance using @method instance_set_base@ using the returned RID. reflection_probe_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid reflection_probe_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.reflection_probe_create {-# NOINLINE bindVisualServer_reflection_probe_set_as_interior #-} -- | If @true@, reflections will ignore sky contribution. Equivalent to @ReflectionProbe.interior_enable@. bindVisualServer_reflection_probe_set_as_interior :: MethodBind bindVisualServer_reflection_probe_set_as_interior = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_as_interior" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, reflections will ignore sky contribution. Equivalent to @ReflectionProbe.interior_enable@. reflection_probe_set_as_interior :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () reflection_probe_set_as_interior cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_as_interior (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_as_interior" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_as_interior {-# NOINLINE bindVisualServer_reflection_probe_set_cull_mask #-} -- | Sets the render cull mask for this reflection probe. Only instances with a matching cull mask will be rendered by this probe. Equivalent to @ReflectionProbe.cull_mask@. bindVisualServer_reflection_probe_set_cull_mask :: MethodBind bindVisualServer_reflection_probe_set_cull_mask = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_cull_mask" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the render cull mask for this reflection probe. Only instances with a matching cull mask will be rendered by this probe. Equivalent to @ReflectionProbe.cull_mask@. reflection_probe_set_cull_mask :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () reflection_probe_set_cull_mask cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_cull_mask (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_cull_mask" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_cull_mask {-# NOINLINE bindVisualServer_reflection_probe_set_enable_box_projection #-} -- | If @true@, uses box projection. This can make reflections look more correct in certain situations. Equivalent to @ReflectionProbe.box_projection@. bindVisualServer_reflection_probe_set_enable_box_projection :: MethodBind bindVisualServer_reflection_probe_set_enable_box_projection = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_enable_box_projection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, uses box projection. This can make reflections look more correct in certain situations. Equivalent to @ReflectionProbe.box_projection@. reflection_probe_set_enable_box_projection :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () reflection_probe_set_enable_box_projection cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_enable_box_projection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_enable_box_projection" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_enable_box_projection {-# NOINLINE bindVisualServer_reflection_probe_set_enable_shadows #-} -- | If @true@, computes shadows in the reflection probe. This makes the reflection much slower to compute. Equivalent to @ReflectionProbe.enable_shadows@. bindVisualServer_reflection_probe_set_enable_shadows :: MethodBind bindVisualServer_reflection_probe_set_enable_shadows = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_enable_shadows" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, computes shadows in the reflection probe. This makes the reflection much slower to compute. Equivalent to @ReflectionProbe.enable_shadows@. reflection_probe_set_enable_shadows :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () reflection_probe_set_enable_shadows cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_enable_shadows (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_enable_shadows" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_enable_shadows {-# NOINLINE bindVisualServer_reflection_probe_set_extents #-} -- | Sets the size of the area that the reflection probe will capture. Equivalent to @ReflectionProbe.extents@. bindVisualServer_reflection_probe_set_extents :: MethodBind bindVisualServer_reflection_probe_set_extents = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_extents" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the area that the reflection probe will capture. Equivalent to @ReflectionProbe.extents@. reflection_probe_set_extents :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () reflection_probe_set_extents cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_extents (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_extents" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_extents {-# NOINLINE bindVisualServer_reflection_probe_set_intensity #-} -- | Sets the intensity of the reflection probe. Intensity modulates the strength of the reflection. Equivalent to @ReflectionProbe.intensity@. bindVisualServer_reflection_probe_set_intensity :: MethodBind bindVisualServer_reflection_probe_set_intensity = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_intensity" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the intensity of the reflection probe. Intensity modulates the strength of the reflection. Equivalent to @ReflectionProbe.intensity@. reflection_probe_set_intensity :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () reflection_probe_set_intensity cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_intensity (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_intensity" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_intensity {-# NOINLINE bindVisualServer_reflection_probe_set_interior_ambient #-} -- | Sets the ambient light color for this reflection probe when set to interior mode. Equivalent to @ReflectionProbe.interior_ambient_color@. bindVisualServer_reflection_probe_set_interior_ambient :: MethodBind bindVisualServer_reflection_probe_set_interior_ambient = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_interior_ambient" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the ambient light color for this reflection probe when set to interior mode. Equivalent to @ReflectionProbe.interior_ambient_color@. reflection_probe_set_interior_ambient :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Color -> IO () reflection_probe_set_interior_ambient cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_interior_ambient (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_interior_ambient" '[Rid, Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_interior_ambient {-# NOINLINE bindVisualServer_reflection_probe_set_interior_ambient_energy #-} -- | Sets the energy multiplier for this reflection probes ambient light contribution when set to interior mode. Equivalent to @ReflectionProbe.interior_ambient_energy@. bindVisualServer_reflection_probe_set_interior_ambient_energy :: MethodBind bindVisualServer_reflection_probe_set_interior_ambient_energy = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_interior_ambient_energy" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the energy multiplier for this reflection probes ambient light contribution when set to interior mode. Equivalent to @ReflectionProbe.interior_ambient_energy@. reflection_probe_set_interior_ambient_energy :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () reflection_probe_set_interior_ambient_energy cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_interior_ambient_energy (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_interior_ambient_energy" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_interior_ambient_energy {-# NOINLINE bindVisualServer_reflection_probe_set_interior_ambient_probe_contribution #-} -- | Sets the contribution value for how much the reflection affects the ambient light for this reflection probe when set to interior mode. Useful so that ambient light matches the color of the room. Equivalent to @ReflectionProbe.interior_ambient_contrib@. bindVisualServer_reflection_probe_set_interior_ambient_probe_contribution :: MethodBind bindVisualServer_reflection_probe_set_interior_ambient_probe_contribution = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_interior_ambient_probe_contribution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the contribution value for how much the reflection affects the ambient light for this reflection probe when set to interior mode. Useful so that ambient light matches the color of the room. Equivalent to @ReflectionProbe.interior_ambient_contrib@. reflection_probe_set_interior_ambient_probe_contribution :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () reflection_probe_set_interior_ambient_probe_contribution cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_interior_ambient_probe_contribution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_interior_ambient_probe_contribution" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_interior_ambient_probe_contribution {-# NOINLINE bindVisualServer_reflection_probe_set_max_distance #-} -- | Sets the max distance away from the probe an object can be before it is culled. Equivalent to @ReflectionProbe.max_distance@. bindVisualServer_reflection_probe_set_max_distance :: MethodBind bindVisualServer_reflection_probe_set_max_distance = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_max_distance" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the max distance away from the probe an object can be before it is culled. Equivalent to @ReflectionProbe.max_distance@. reflection_probe_set_max_distance :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Float -> IO () reflection_probe_set_max_distance cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_max_distance (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_max_distance" '[Rid, Float] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_max_distance {-# NOINLINE bindVisualServer_reflection_probe_set_origin_offset #-} -- | Sets the origin offset to be used when this reflection probe is in box project mode. Equivalent to @ReflectionProbe.origin_offset@. bindVisualServer_reflection_probe_set_origin_offset :: MethodBind bindVisualServer_reflection_probe_set_origin_offset = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_origin_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the origin offset to be used when this reflection probe is in box project mode. Equivalent to @ReflectionProbe.origin_offset@. reflection_probe_set_origin_offset :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Vector3 -> IO () reflection_probe_set_origin_offset cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_origin_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_origin_offset" '[Rid, Vector3] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_origin_offset {-# NOINLINE bindVisualServer_reflection_probe_set_update_mode #-} -- | Sets how often the reflection probe updates. Can either be once or every frame. See @enum ReflectionProbeUpdateMode@ for options. bindVisualServer_reflection_probe_set_update_mode :: MethodBind bindVisualServer_reflection_probe_set_update_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "reflection_probe_set_update_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets how often the reflection probe updates. Can either be once or every frame. See @enum ReflectionProbeUpdateMode@ for options. reflection_probe_set_update_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () reflection_probe_set_update_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_reflection_probe_set_update_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "reflection_probe_set_update_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.reflection_probe_set_update_mode {-# NOINLINE bindVisualServer_request_frame_drawn_callback #-} -- | Schedules a callback to the corresponding named @method@ on @where@ after a frame has been drawn. -- The callback method must use only 1 argument which will be called with @userdata@. bindVisualServer_request_frame_drawn_callback :: MethodBind bindVisualServer_request_frame_drawn_callback = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "request_frame_drawn_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Schedules a callback to the corresponding named @method@ on @where@ after a frame has been drawn. -- The callback method must use only 1 argument which will be called with @userdata@. request_frame_drawn_callback :: (VisualServer :< cls, Object :< cls) => cls -> Object -> GodotString -> GodotVariant -> IO () request_frame_drawn_callback cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_request_frame_drawn_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "request_frame_drawn_callback" '[Object, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Core.VisualServer.request_frame_drawn_callback {-# NOINLINE bindVisualServer_scenario_create #-} -- | Creates a scenario and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @scenario_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- The scenario is the 3D world that all the visual instances exist in. bindVisualServer_scenario_create :: MethodBind bindVisualServer_scenario_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "scenario_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a scenario and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @scenario_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- The scenario is the 3D world that all the visual instances exist in. scenario_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid scenario_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_scenario_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "scenario_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.scenario_create {-# NOINLINE bindVisualServer_scenario_set_debug #-} -- | Sets the @enum ScenarioDebugMode@ for this scenario. See @enum ScenarioDebugMode@ for options. bindVisualServer_scenario_set_debug :: MethodBind bindVisualServer_scenario_set_debug = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "scenario_set_debug" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @enum ScenarioDebugMode@ for this scenario. See @enum ScenarioDebugMode@ for options. scenario_set_debug :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () scenario_set_debug cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_scenario_set_debug (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "scenario_set_debug" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.scenario_set_debug {-# NOINLINE bindVisualServer_scenario_set_environment #-} -- | Sets the environment that will be used with this scenario. bindVisualServer_scenario_set_environment :: MethodBind bindVisualServer_scenario_set_environment = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "scenario_set_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the environment that will be used with this scenario. scenario_set_environment :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () scenario_set_environment cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_scenario_set_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "scenario_set_environment" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.scenario_set_environment {-# NOINLINE bindVisualServer_scenario_set_fallback_environment #-} -- | Sets the fallback environment to be used by this scenario. The fallback environment is used if no environment is set. Internally, this is used by the editor to provide a default environment. bindVisualServer_scenario_set_fallback_environment :: MethodBind bindVisualServer_scenario_set_fallback_environment = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "scenario_set_fallback_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the fallback environment to be used by this scenario. The fallback environment is used if no environment is set. Internally, this is used by the editor to provide a default environment. scenario_set_fallback_environment :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () scenario_set_fallback_environment cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_scenario_set_fallback_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "scenario_set_fallback_environment" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.scenario_set_fallback_environment {-# NOINLINE bindVisualServer_scenario_set_reflection_atlas_size #-} -- | Sets the size of the reflection atlas shared by all reflection probes in this scenario. bindVisualServer_scenario_set_reflection_atlas_size :: MethodBind bindVisualServer_scenario_set_reflection_atlas_size = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "scenario_set_reflection_atlas_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the reflection atlas shared by all reflection probes in this scenario. scenario_set_reflection_atlas_size :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> IO () scenario_set_reflection_atlas_size cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_scenario_set_reflection_atlas_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "scenario_set_reflection_atlas_size" '[Rid, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.scenario_set_reflection_atlas_size {-# NOINLINE bindVisualServer_set_boot_image #-} -- | Sets a boot image. The color defines the background color. If @scale@ is @true@, the image will be scaled to fit the screen size. If @use_filter@ is @true@, the image will be scaled with linear interpolation. If @use_filter@ is @false@, the image will be scaled with nearest-neighbor interpolation. bindVisualServer_set_boot_image :: MethodBind bindVisualServer_set_boot_image = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "set_boot_image" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a boot image. The color defines the background color. If @scale@ is @true@, the image will be scaled to fit the screen size. If @use_filter@ is @true@, the image will be scaled with linear interpolation. If @use_filter@ is @false@, the image will be scaled with nearest-neighbor interpolation. set_boot_image :: (VisualServer :< cls, Object :< cls) => cls -> Image -> Color -> Bool -> Maybe Bool -> IO () set_boot_image cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe (VariantBool True) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_set_boot_image (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "set_boot_image" '[Image, Color, Bool, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.set_boot_image {-# NOINLINE bindVisualServer_set_debug_generate_wireframes #-} -- | If @true@, the engine will generate wireframes for use with the wireframe debug mode. bindVisualServer_set_debug_generate_wireframes :: MethodBind bindVisualServer_set_debug_generate_wireframes = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "set_debug_generate_wireframes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the engine will generate wireframes for use with the wireframe debug mode. set_debug_generate_wireframes :: (VisualServer :< cls, Object :< cls) => cls -> Bool -> IO () set_debug_generate_wireframes cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_set_debug_generate_wireframes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "set_debug_generate_wireframes" '[Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.set_debug_generate_wireframes {-# NOINLINE bindVisualServer_set_default_clear_color #-} -- | Sets the default clear color which is used when a specific clear color has not been selected. bindVisualServer_set_default_clear_color :: MethodBind bindVisualServer_set_default_clear_color = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "set_default_clear_color" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the default clear color which is used when a specific clear color has not been selected. set_default_clear_color :: (VisualServer :< cls, Object :< cls) => cls -> Color -> IO () set_default_clear_color cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_set_default_clear_color (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "set_default_clear_color" '[Color] (IO ()) where nodeMethod = Godot.Core.VisualServer.set_default_clear_color {-# NOINLINE bindVisualServer_shader_create #-} -- | Creates an empty shader and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @shader_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_shader_create :: MethodBind bindVisualServer_shader_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "shader_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an empty shader and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @shader_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. shader_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid shader_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_shader_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "shader_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.shader_create {-# NOINLINE bindVisualServer_shader_get_code #-} -- | Returns a shader's code. bindVisualServer_shader_get_code :: MethodBind bindVisualServer_shader_get_code = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "shader_get_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a shader's code. shader_get_code :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO GodotString shader_get_code cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_shader_get_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "shader_get_code" '[Rid] (IO GodotString) where nodeMethod = Godot.Core.VisualServer.shader_get_code {-# NOINLINE bindVisualServer_shader_get_default_texture_param #-} -- | Returns a default texture from a shader searched by name. bindVisualServer_shader_get_default_texture_param :: MethodBind bindVisualServer_shader_get_default_texture_param = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "shader_get_default_texture_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a default texture from a shader searched by name. shader_get_default_texture_param :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> GodotString -> IO Rid shader_get_default_texture_param cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_shader_get_default_texture_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "shader_get_default_texture_param" '[Rid, GodotString] (IO Rid) where nodeMethod = Godot.Core.VisualServer.shader_get_default_texture_param {-# NOINLINE bindVisualServer_shader_get_param_list #-} -- | Returns the parameters of a shader. bindVisualServer_shader_get_param_list :: MethodBind bindVisualServer_shader_get_param_list = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "shader_get_param_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parameters of a shader. shader_get_param_list :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Array shader_get_param_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_shader_get_param_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "shader_get_param_list" '[Rid] (IO Array) where nodeMethod = Godot.Core.VisualServer.shader_get_param_list {-# NOINLINE bindVisualServer_shader_set_code #-} -- | Sets a shader's code. bindVisualServer_shader_set_code :: MethodBind bindVisualServer_shader_set_code = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "shader_set_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a shader's code. shader_set_code :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> GodotString -> IO () shader_set_code cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_shader_set_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "shader_set_code" '[Rid, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualServer.shader_set_code {-# NOINLINE bindVisualServer_shader_set_default_texture_param #-} -- | Sets a shader's default texture. Overwrites the texture given by name. bindVisualServer_shader_set_default_texture_param :: MethodBind bindVisualServer_shader_set_default_texture_param = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "shader_set_default_texture_param" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a shader's default texture. Overwrites the texture given by name. shader_set_default_texture_param :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> GodotString -> Rid -> IO () shader_set_default_texture_param cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_shader_set_default_texture_param (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "shader_set_default_texture_param" '[Rid, GodotString, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.shader_set_default_texture_param {-# NOINLINE bindVisualServer_skeleton_allocate #-} -- | Allocates the GPU buffers for this skeleton. bindVisualServer_skeleton_allocate :: MethodBind bindVisualServer_skeleton_allocate = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "skeleton_allocate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allocates the GPU buffers for this skeleton. skeleton_allocate :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Maybe Bool -> IO () skeleton_allocate cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_skeleton_allocate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "skeleton_allocate" '[Rid, Int, Maybe Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.skeleton_allocate {-# NOINLINE bindVisualServer_skeleton_bone_get_transform #-} -- | Returns the @Transform@ set for a specific bone of this skeleton. bindVisualServer_skeleton_bone_get_transform :: MethodBind bindVisualServer_skeleton_bone_get_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "skeleton_bone_get_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Transform@ set for a specific bone of this skeleton. skeleton_bone_get_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Transform skeleton_bone_get_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_skeleton_bone_get_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "skeleton_bone_get_transform" '[Rid, Int] (IO Transform) where nodeMethod = Godot.Core.VisualServer.skeleton_bone_get_transform {-# NOINLINE bindVisualServer_skeleton_bone_get_transform_2d #-} -- | Returns the @Transform2D@ set for a specific bone of this skeleton. bindVisualServer_skeleton_bone_get_transform_2d :: MethodBind bindVisualServer_skeleton_bone_get_transform_2d = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "skeleton_bone_get_transform_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Transform2D@ set for a specific bone of this skeleton. skeleton_bone_get_transform_2d :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Transform2d skeleton_bone_get_transform_2d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_skeleton_bone_get_transform_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "skeleton_bone_get_transform_2d" '[Rid, Int] (IO Transform2d) where nodeMethod = Godot.Core.VisualServer.skeleton_bone_get_transform_2d {-# NOINLINE bindVisualServer_skeleton_bone_set_transform #-} -- | Sets the @Transform@ for a specific bone of this skeleton. bindVisualServer_skeleton_bone_set_transform :: MethodBind bindVisualServer_skeleton_bone_set_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "skeleton_bone_set_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform@ for a specific bone of this skeleton. skeleton_bone_set_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Transform -> IO () skeleton_bone_set_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_skeleton_bone_set_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "skeleton_bone_set_transform" '[Rid, Int, Transform] (IO ()) where nodeMethod = Godot.Core.VisualServer.skeleton_bone_set_transform {-# NOINLINE bindVisualServer_skeleton_bone_set_transform_2d #-} -- | Sets the @Transform2D@ for a specific bone of this skeleton. bindVisualServer_skeleton_bone_set_transform_2d :: MethodBind bindVisualServer_skeleton_bone_set_transform_2d = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "skeleton_bone_set_transform_2d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @Transform2D@ for a specific bone of this skeleton. skeleton_bone_set_transform_2d :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Transform2d -> IO () skeleton_bone_set_transform_2d cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_skeleton_bone_set_transform_2d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "skeleton_bone_set_transform_2d" '[Rid, Int, Transform2d] (IO ()) where nodeMethod = Godot.Core.VisualServer.skeleton_bone_set_transform_2d {-# NOINLINE bindVisualServer_skeleton_create #-} -- | Creates a skeleton and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @skeleton_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_skeleton_create :: MethodBind bindVisualServer_skeleton_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "skeleton_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a skeleton and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @skeleton_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. skeleton_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid skeleton_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_skeleton_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "skeleton_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.skeleton_create {-# NOINLINE bindVisualServer_skeleton_get_bone_count #-} -- | Returns the number of bones allocated for this skeleton. bindVisualServer_skeleton_get_bone_count :: MethodBind bindVisualServer_skeleton_get_bone_count = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "skeleton_get_bone_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of bones allocated for this skeleton. skeleton_get_bone_count :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int skeleton_get_bone_count cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_skeleton_get_bone_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "skeleton_get_bone_count" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.skeleton_get_bone_count {-# NOINLINE bindVisualServer_sky_create #-} -- | Creates an empty sky and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @sky_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_sky_create :: MethodBind bindVisualServer_sky_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "sky_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an empty sky and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @sky_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. sky_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid sky_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_sky_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "sky_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.sky_create {-# NOINLINE bindVisualServer_sky_set_texture #-} -- | Sets a sky's texture. bindVisualServer_sky_set_texture :: MethodBind bindVisualServer_sky_set_texture = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "sky_set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a sky's texture. sky_set_texture :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Int -> IO () sky_set_texture cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_sky_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "sky_set_texture" '[Rid, Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.sky_set_texture {-# NOINLINE bindVisualServer_spot_light_create #-} -- | Creates a spot light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most @light_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this spot light to an instance using @method instance_set_base@ using the returned RID. bindVisualServer_spot_light_create :: MethodBind bindVisualServer_spot_light_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "spot_light_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a spot light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most @light_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. -- To place in a scene, attach this spot light to an instance using @method instance_set_base@ using the returned RID. spot_light_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid spot_light_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_spot_light_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "spot_light_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.spot_light_create {-# NOINLINE bindVisualServer_sync #-} -- | Not implemented in Godot 3.x. bindVisualServer_sync :: MethodBind bindVisualServer_sync = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "sync" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Not implemented in Godot 3.x. sync :: (VisualServer :< cls, Object :< cls) => cls -> IO () sync cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_sync (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "sync" '[] (IO ()) where nodeMethod = Godot.Core.VisualServer.sync {-# NOINLINE bindVisualServer_texture_allocate #-} -- | Allocates the GPU memory for the texture. bindVisualServer_texture_allocate :: MethodBind bindVisualServer_texture_allocate = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_allocate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Allocates the GPU memory for the texture. texture_allocate :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> Int -> Int -> Int -> Maybe Int -> IO () texture_allocate cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, maybe (VariantInt (7)) toVariant arg7] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_allocate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_allocate" '[Rid, Int, Int, Int, Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.texture_allocate {-# NOINLINE bindVisualServer_texture_bind #-} -- | Binds the texture to a texture slot. bindVisualServer_texture_bind :: MethodBind bindVisualServer_texture_bind = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_bind" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Binds the texture to a texture slot. texture_bind :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () texture_bind cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_bind (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_bind" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.texture_bind {-# NOINLINE bindVisualServer_texture_create #-} -- | Creates an empty texture and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @texture_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_texture_create :: MethodBind bindVisualServer_texture_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an empty texture and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @texture_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. texture_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid texture_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.texture_create {-# NOINLINE bindVisualServer_texture_create_from_image #-} -- | Creates a texture, allocates the space for an image, and fills in the image. bindVisualServer_texture_create_from_image :: MethodBind bindVisualServer_texture_create_from_image = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_create_from_image" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a texture, allocates the space for an image, and fills in the image. texture_create_from_image :: (VisualServer :< cls, Object :< cls) => cls -> Image -> Maybe Int -> IO Rid texture_create_from_image cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (7)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_create_from_image (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_create_from_image" '[Image, Maybe Int] (IO Rid) where nodeMethod = Godot.Core.VisualServer.texture_create_from_image {-# NOINLINE bindVisualServer_texture_debug_usage #-} -- | Returns a list of all the textures and their information. bindVisualServer_texture_debug_usage :: MethodBind bindVisualServer_texture_debug_usage = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_debug_usage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a list of all the textures and their information. texture_debug_usage :: (VisualServer :< cls, Object :< cls) => cls -> IO Array texture_debug_usage cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_debug_usage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_debug_usage" '[] (IO Array) where nodeMethod = Godot.Core.VisualServer.texture_debug_usage {-# NOINLINE bindVisualServer_texture_get_data #-} -- | Returns a copy of a texture's image unless it's a CubeMap, in which case it returns the @RID@ of the image at one of the cubes sides. bindVisualServer_texture_get_data :: MethodBind bindVisualServer_texture_get_data = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a copy of a texture's image unless it's a CubeMap, in which case it returns the @RID@ of the image at one of the cubes sides. texture_get_data :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Maybe Int -> IO Image texture_get_data cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantInt (0)) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_data" '[Rid, Maybe Int] (IO Image) where nodeMethod = Godot.Core.VisualServer.texture_get_data {-# NOINLINE bindVisualServer_texture_get_depth #-} -- | Returns the depth of the texture. bindVisualServer_texture_get_depth :: MethodBind bindVisualServer_texture_get_depth = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_depth" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the depth of the texture. texture_get_depth :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int texture_get_depth cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_depth (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_depth" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.texture_get_depth {-# NOINLINE bindVisualServer_texture_get_flags #-} -- | Returns the flags of a texture. bindVisualServer_texture_get_flags :: MethodBind bindVisualServer_texture_get_flags = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the flags of a texture. texture_get_flags :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int texture_get_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_flags" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.texture_get_flags {-# NOINLINE bindVisualServer_texture_get_format #-} -- | Returns the format of the texture's image. bindVisualServer_texture_get_format :: MethodBind bindVisualServer_texture_get_format = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_format" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the format of the texture's image. texture_get_format :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int texture_get_format cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_format (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_format" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.texture_get_format {-# NOINLINE bindVisualServer_texture_get_height #-} -- | Returns the texture's height. bindVisualServer_texture_get_height :: MethodBind bindVisualServer_texture_get_height = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_height" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the texture's height. texture_get_height :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int texture_get_height cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_height (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_height" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.texture_get_height {-# NOINLINE bindVisualServer_texture_get_path #-} -- | Returns the texture's path. bindVisualServer_texture_get_path :: MethodBind bindVisualServer_texture_get_path = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the texture's path. texture_get_path :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO GodotString texture_get_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_path" '[Rid] (IO GodotString) where nodeMethod = Godot.Core.VisualServer.texture_get_path {-# NOINLINE bindVisualServer_texture_get_texid #-} -- | Returns the opengl id of the texture's image. bindVisualServer_texture_get_texid :: MethodBind bindVisualServer_texture_get_texid = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_texid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the opengl id of the texture's image. texture_get_texid :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int texture_get_texid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_texid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_texid" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.texture_get_texid {-# NOINLINE bindVisualServer_texture_get_type #-} -- | Returns the type of the texture, can be any of the @enum TextureType@. bindVisualServer_texture_get_type :: MethodBind bindVisualServer_texture_get_type = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the type of the texture, can be any of the @enum TextureType@. texture_get_type :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int texture_get_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_type" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.texture_get_type {-# NOINLINE bindVisualServer_texture_get_width #-} -- | Returns the texture's width. bindVisualServer_texture_get_width :: MethodBind bindVisualServer_texture_get_width = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_get_width" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the texture's width. texture_get_width :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Int texture_get_width cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_get_width (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_get_width" '[Rid] (IO Int) where nodeMethod = Godot.Core.VisualServer.texture_get_width {-# NOINLINE bindVisualServer_texture_set_data #-} -- | Sets the texture's image data. If it's a CubeMap, it sets the image data at a cube side. bindVisualServer_texture_set_data :: MethodBind bindVisualServer_texture_set_data = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the texture's image data. If it's a CubeMap, it sets the image data at a cube side. texture_set_data :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Image -> Maybe Int -> IO () texture_set_data cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_set_data" '[Rid, Image, Maybe Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.texture_set_data {-# NOINLINE bindVisualServer_texture_set_data_partial #-} -- | Sets a part of the data for a texture. Warning: this function calls the underlying graphics API directly and may corrupt your texture if used improperly. bindVisualServer_texture_set_data_partial :: MethodBind bindVisualServer_texture_set_data_partial = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_set_data_partial" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a part of the data for a texture. Warning: this function calls the underlying graphics API directly and may corrupt your texture if used improperly. texture_set_data_partial :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Image -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Maybe Int -> IO () texture_set_data_partial cls arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6, toVariant arg7, toVariant arg8, toVariant arg9, maybe (VariantInt (0)) toVariant arg10] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_set_data_partial (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_set_data_partial" '[Rid, Image, Int, Int, Int, Int, Int, Int, Int, Maybe Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.texture_set_data_partial {-# NOINLINE bindVisualServer_texture_set_flags #-} -- | Sets the texture's flags. See @enum TextureFlags@ for options. bindVisualServer_texture_set_flags :: MethodBind bindVisualServer_texture_set_flags = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_set_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the texture's flags. See @enum TextureFlags@ for options. texture_set_flags :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () texture_set_flags cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_set_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_set_flags" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.texture_set_flags {-# NOINLINE bindVisualServer_texture_set_path #-} -- | Sets the texture's path. bindVisualServer_texture_set_path :: MethodBind bindVisualServer_texture_set_path = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_set_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the texture's path. texture_set_path :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> GodotString -> IO () texture_set_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_set_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_set_path" '[Rid, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualServer.texture_set_path {-# NOINLINE bindVisualServer_texture_set_shrink_all_x2_on_set_data #-} -- | If @true@, sets internal processes to shrink all image data to half the size. bindVisualServer_texture_set_shrink_all_x2_on_set_data :: MethodBind bindVisualServer_texture_set_shrink_all_x2_on_set_data = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_set_shrink_all_x2_on_set_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets internal processes to shrink all image data to half the size. texture_set_shrink_all_x2_on_set_data :: (VisualServer :< cls, Object :< cls) => cls -> Bool -> IO () texture_set_shrink_all_x2_on_set_data cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_set_shrink_all_x2_on_set_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_set_shrink_all_x2_on_set_data" '[Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.texture_set_shrink_all_x2_on_set_data {-# NOINLINE bindVisualServer_texture_set_size_override #-} -- | Resizes the texture to the specified dimensions. bindVisualServer_texture_set_size_override :: MethodBind bindVisualServer_texture_set_size_override = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "texture_set_size_override" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Resizes the texture to the specified dimensions. texture_set_size_override :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> Int -> IO () texture_set_size_override cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_texture_set_size_override (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "texture_set_size_override" '[Rid, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.texture_set_size_override {-# NOINLINE bindVisualServer_textures_keep_original #-} -- | If @true@, the image will be stored in the texture's images array if overwritten. bindVisualServer_textures_keep_original :: MethodBind bindVisualServer_textures_keep_original = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "textures_keep_original" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the image will be stored in the texture's images array if overwritten. textures_keep_original :: (VisualServer :< cls, Object :< cls) => cls -> Bool -> IO () textures_keep_original cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_textures_keep_original (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "textures_keep_original" '[Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.textures_keep_original {-# NOINLINE bindVisualServer_viewport_attach_camera #-} -- | Sets a viewport's camera. bindVisualServer_viewport_attach_camera :: MethodBind bindVisualServer_viewport_attach_camera = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_attach_camera" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a viewport's camera. viewport_attach_camera :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () viewport_attach_camera cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_attach_camera (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_attach_camera" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_attach_camera {-# NOINLINE bindVisualServer_viewport_attach_canvas #-} -- | Sets a viewport's canvas. bindVisualServer_viewport_attach_canvas :: MethodBind bindVisualServer_viewport_attach_canvas = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_attach_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a viewport's canvas. viewport_attach_canvas :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () viewport_attach_canvas cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_attach_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_attach_canvas" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_attach_canvas {-# NOINLINE bindVisualServer_viewport_attach_to_screen #-} -- | Copies viewport to a region of the screen specified by @rect@. If @Viewport.render_direct_to_screen@ is @true@, then viewport does not use a framebuffer and the contents of the viewport are rendered directly to screen. However, note that the root viewport is drawn last, therefore it will draw over the screen. Accordingly, you must set the root viewport to an area that does not cover the area that you have attached this viewport to. -- For example, you can set the root viewport to not render at all with the following code: -- -- @ -- -- func _ready(): -- get_viewport().set_attach_to_screen_rect(Rect2()) -- $Viewport.set_attach_to_screen_rect(Rect2(0, 0, 600, 600)) -- -- @ -- -- Using this can result in significant optimization, especially on lower-end devices. However, it comes at the cost of having to manage your viewports manually. For a further optimization see, @method viewport_set_render_direct_to_screen@. bindVisualServer_viewport_attach_to_screen :: MethodBind bindVisualServer_viewport_attach_to_screen = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_attach_to_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Copies viewport to a region of the screen specified by @rect@. If @Viewport.render_direct_to_screen@ is @true@, then viewport does not use a framebuffer and the contents of the viewport are rendered directly to screen. However, note that the root viewport is drawn last, therefore it will draw over the screen. Accordingly, you must set the root viewport to an area that does not cover the area that you have attached this viewport to. -- For example, you can set the root viewport to not render at all with the following code: -- -- @ -- -- func _ready(): -- get_viewport().set_attach_to_screen_rect(Rect2()) -- $Viewport.set_attach_to_screen_rect(Rect2(0, 0, 600, 600)) -- -- @ -- -- Using this can result in significant optimization, especially on lower-end devices. However, it comes at the cost of having to manage your viewports manually. For a further optimization see, @method viewport_set_render_direct_to_screen@. viewport_attach_to_screen :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Maybe Rect2 -> Maybe Int -> IO () viewport_attach_to_screen cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, defaultedVariant VariantRect2 (V2 (V2 0 0) (V2 0 0)) arg2, maybe (VariantInt (0)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_attach_to_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_attach_to_screen" '[Rid, Maybe Rect2, Maybe Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_attach_to_screen {-# NOINLINE bindVisualServer_viewport_create #-} -- | Creates an empty viewport and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @viewport_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. bindVisualServer_viewport_create :: MethodBind bindVisualServer_viewport_create = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an empty viewport and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all @viewport_*@ VisualServer functions. -- Once finished with your RID, you will want to free the RID using the VisualServer's @method free_rid@ static method. viewport_create :: (VisualServer :< cls, Object :< cls) => cls -> IO Rid viewport_create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_create" '[] (IO Rid) where nodeMethod = Godot.Core.VisualServer.viewport_create {-# NOINLINE bindVisualServer_viewport_detach #-} -- | Detaches the viewport from the screen. bindVisualServer_viewport_detach :: MethodBind bindVisualServer_viewport_detach = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_detach" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Detaches the viewport from the screen. viewport_detach :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO () viewport_detach cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_detach (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_detach" '[Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_detach {-# NOINLINE bindVisualServer_viewport_get_render_info #-} -- | Returns a viewport's render information. For options, see the @enum ViewportRenderInfo@ constants. bindVisualServer_viewport_get_render_info :: MethodBind bindVisualServer_viewport_get_render_info = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_get_render_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a viewport's render information. For options, see the @enum ViewportRenderInfo@ constants. viewport_get_render_info :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO Int viewport_get_render_info cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_get_render_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_get_render_info" '[Rid, Int] (IO Int) where nodeMethod = Godot.Core.VisualServer.viewport_get_render_info {-# NOINLINE bindVisualServer_viewport_get_texture #-} -- | Returns the viewport's last rendered frame. bindVisualServer_viewport_get_texture :: MethodBind bindVisualServer_viewport_get_texture = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the viewport's last rendered frame. viewport_get_texture :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> IO Rid viewport_get_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_get_texture" '[Rid] (IO Rid) where nodeMethod = Godot.Core.VisualServer.viewport_get_texture {-# NOINLINE bindVisualServer_viewport_remove_canvas #-} -- | Detaches a viewport from a canvas and vice versa. bindVisualServer_viewport_remove_canvas :: MethodBind bindVisualServer_viewport_remove_canvas = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_remove_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Detaches a viewport from a canvas and vice versa. viewport_remove_canvas :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () viewport_remove_canvas cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_remove_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_remove_canvas" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_remove_canvas {-# NOINLINE bindVisualServer_viewport_set_active #-} -- | If @true@, sets the viewport active, else sets it inactive. bindVisualServer_viewport_set_active :: MethodBind bindVisualServer_viewport_set_active = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_active" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, sets the viewport active, else sets it inactive. viewport_set_active :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_active cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_active (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_active" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_active {-# NOINLINE bindVisualServer_viewport_set_canvas_stacking #-} -- | Sets the stacking order for a viewport's canvas. -- @layer@ is the actual canvas layer, while @sublayer@ specifies the stacking order of the canvas among those in the same layer. bindVisualServer_viewport_set_canvas_stacking :: MethodBind bindVisualServer_viewport_set_canvas_stacking = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_canvas_stacking" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the stacking order for a viewport's canvas. -- @layer@ is the actual canvas layer, while @sublayer@ specifies the stacking order of the canvas among those in the same layer. viewport_set_canvas_stacking :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Int -> Int -> IO () viewport_set_canvas_stacking cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_canvas_stacking (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_canvas_stacking" '[Rid, Rid, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_canvas_stacking {-# NOINLINE bindVisualServer_viewport_set_canvas_transform #-} -- | Sets the transformation of a viewport's canvas. bindVisualServer_viewport_set_canvas_transform :: MethodBind bindVisualServer_viewport_set_canvas_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_canvas_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the transformation of a viewport's canvas. viewport_set_canvas_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> Transform2d -> IO () viewport_set_canvas_transform cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_canvas_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_canvas_transform" '[Rid, Rid, Transform2d] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_canvas_transform {-# NOINLINE bindVisualServer_viewport_set_clear_mode #-} -- | Sets the clear mode of a viewport. See @enum ViewportClearMode@ for options. bindVisualServer_viewport_set_clear_mode :: MethodBind bindVisualServer_viewport_set_clear_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_clear_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the clear mode of a viewport. See @enum ViewportClearMode@ for options. viewport_set_clear_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () viewport_set_clear_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_clear_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_clear_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_clear_mode {-# NOINLINE bindVisualServer_viewport_set_debug_draw #-} -- | Sets the debug draw mode of a viewport. See @enum ViewportDebugDraw@ for options. bindVisualServer_viewport_set_debug_draw :: MethodBind bindVisualServer_viewport_set_debug_draw = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_debug_draw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the debug draw mode of a viewport. See @enum ViewportDebugDraw@ for options. viewport_set_debug_draw :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () viewport_set_debug_draw cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_debug_draw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_debug_draw" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_debug_draw {-# NOINLINE bindVisualServer_viewport_set_disable_3d #-} -- | If @true@, a viewport's 3D rendering is disabled. bindVisualServer_viewport_set_disable_3d :: MethodBind bindVisualServer_viewport_set_disable_3d = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_disable_3d" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, a viewport's 3D rendering is disabled. viewport_set_disable_3d :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_disable_3d cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_disable_3d (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_disable_3d" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_disable_3d {-# NOINLINE bindVisualServer_viewport_set_disable_environment #-} -- | If @true@, rendering of a viewport's environment is disabled. bindVisualServer_viewport_set_disable_environment :: MethodBind bindVisualServer_viewport_set_disable_environment = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_disable_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, rendering of a viewport's environment is disabled. viewport_set_disable_environment :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_disable_environment cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_disable_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_disable_environment" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_disable_environment {-# NOINLINE bindVisualServer_viewport_set_global_canvas_transform #-} -- | Sets the viewport's global transformation matrix. bindVisualServer_viewport_set_global_canvas_transform :: MethodBind bindVisualServer_viewport_set_global_canvas_transform = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_global_canvas_transform" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the viewport's global transformation matrix. viewport_set_global_canvas_transform :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Transform2d -> IO () viewport_set_global_canvas_transform cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_global_canvas_transform (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_global_canvas_transform" '[Rid, Transform2d] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_global_canvas_transform {-# NOINLINE bindVisualServer_viewport_set_hdr #-} -- | If @true@, the viewport renders to hdr. bindVisualServer_viewport_set_hdr :: MethodBind bindVisualServer_viewport_set_hdr = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_hdr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport renders to hdr. viewport_set_hdr :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_hdr cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_hdr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_hdr" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_hdr {-# NOINLINE bindVisualServer_viewport_set_hide_canvas #-} -- | If @true@, the viewport's canvas is not rendered. bindVisualServer_viewport_set_hide_canvas :: MethodBind bindVisualServer_viewport_set_hide_canvas = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_hide_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport's canvas is not rendered. viewport_set_hide_canvas :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_hide_canvas cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_hide_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_hide_canvas" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_hide_canvas {-# NOINLINE bindVisualServer_viewport_set_hide_scenario #-} -- | Currently unimplemented in Godot 3.x. bindVisualServer_viewport_set_hide_scenario :: MethodBind bindVisualServer_viewport_set_hide_scenario = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_hide_scenario" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Currently unimplemented in Godot 3.x. viewport_set_hide_scenario :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_hide_scenario cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_hide_scenario (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_hide_scenario" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_hide_scenario {-# NOINLINE bindVisualServer_viewport_set_msaa #-} -- | Sets the anti-aliasing mode. See @enum ViewportMSAA@ for options. bindVisualServer_viewport_set_msaa :: MethodBind bindVisualServer_viewport_set_msaa = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_msaa" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the anti-aliasing mode. See @enum ViewportMSAA@ for options. viewport_set_msaa :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () viewport_set_msaa cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_msaa (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_msaa" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_msaa {-# NOINLINE bindVisualServer_viewport_set_parent_viewport #-} -- | Sets the viewport's parent to another viewport. bindVisualServer_viewport_set_parent_viewport :: MethodBind bindVisualServer_viewport_set_parent_viewport = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_parent_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the viewport's parent to another viewport. viewport_set_parent_viewport :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () viewport_set_parent_viewport cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_parent_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_parent_viewport" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_parent_viewport {-# NOINLINE bindVisualServer_viewport_set_render_direct_to_screen #-} -- | If @true@, render the contents of the viewport directly to screen. This allows a low-level optimization where you can skip drawing a viewport to the root viewport. While this optimization can result in a significant increase in speed (especially on older devices), it comes at a cost of usability. When this is enabled, you cannot read from the viewport or from the @SCREEN_TEXTURE@. You also lose the benefit of certain window settings, such as the various stretch modes. Another consequence to be aware of is that in 2D the rendering happens in window coordinates, so if you have a viewport that is double the size of the window, and you set this, then only the portion that fits within the window will be drawn, no automatic scaling is possible, even if your game scene is significantly larger than the window size. bindVisualServer_viewport_set_render_direct_to_screen :: MethodBind bindVisualServer_viewport_set_render_direct_to_screen = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_render_direct_to_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, render the contents of the viewport directly to screen. This allows a low-level optimization where you can skip drawing a viewport to the root viewport. While this optimization can result in a significant increase in speed (especially on older devices), it comes at a cost of usability. When this is enabled, you cannot read from the viewport or from the @SCREEN_TEXTURE@. You also lose the benefit of certain window settings, such as the various stretch modes. Another consequence to be aware of is that in 2D the rendering happens in window coordinates, so if you have a viewport that is double the size of the window, and you set this, then only the portion that fits within the window will be drawn, no automatic scaling is possible, even if your game scene is significantly larger than the window size. viewport_set_render_direct_to_screen :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_render_direct_to_screen cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_render_direct_to_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_render_direct_to_screen" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_render_direct_to_screen {-# NOINLINE bindVisualServer_viewport_set_scenario #-} -- | Sets a viewport's scenario. -- The scenario contains information about the @enum ScenarioDebugMode@, environment information, reflection atlas etc. bindVisualServer_viewport_set_scenario :: MethodBind bindVisualServer_viewport_set_scenario = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_scenario" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets a viewport's scenario. -- The scenario contains information about the @enum ScenarioDebugMode@, environment information, reflection atlas etc. viewport_set_scenario :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Rid -> IO () viewport_set_scenario cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_scenario (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_scenario" '[Rid, Rid] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_scenario {-# NOINLINE bindVisualServer_viewport_set_shadow_atlas_quadrant_subdivision #-} -- | Sets the shadow atlas quadrant's subdivision. bindVisualServer_viewport_set_shadow_atlas_quadrant_subdivision :: MethodBind bindVisualServer_viewport_set_shadow_atlas_quadrant_subdivision = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_shadow_atlas_quadrant_subdivision" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the shadow atlas quadrant's subdivision. viewport_set_shadow_atlas_quadrant_subdivision :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> IO () viewport_set_shadow_atlas_quadrant_subdivision cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_shadow_atlas_quadrant_subdivision (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_shadow_atlas_quadrant_subdivision" '[Rid, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_shadow_atlas_quadrant_subdivision {-# NOINLINE bindVisualServer_viewport_set_shadow_atlas_size #-} -- | Sets the size of the shadow atlas's images (used for omni and spot lights). The value will be rounded up to the nearest power of 2. bindVisualServer_viewport_set_shadow_atlas_size :: MethodBind bindVisualServer_viewport_set_shadow_atlas_size = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_shadow_atlas_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the size of the shadow atlas's images (used for omni and spot lights). The value will be rounded up to the nearest power of 2. viewport_set_shadow_atlas_size :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () viewport_set_shadow_atlas_size cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_shadow_atlas_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_shadow_atlas_size" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_shadow_atlas_size {-# NOINLINE bindVisualServer_viewport_set_size #-} -- | Sets the viewport's width and height. bindVisualServer_viewport_set_size :: MethodBind bindVisualServer_viewport_set_size = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the viewport's width and height. viewport_set_size :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> Int -> IO () viewport_set_size cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_size" '[Rid, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_size {-# NOINLINE bindVisualServer_viewport_set_transparent_background #-} -- | If @true@, the viewport renders its background as transparent. bindVisualServer_viewport_set_transparent_background :: MethodBind bindVisualServer_viewport_set_transparent_background = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_transparent_background" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport renders its background as transparent. viewport_set_transparent_background :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_transparent_background cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_transparent_background (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_transparent_background" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_transparent_background {-# NOINLINE bindVisualServer_viewport_set_update_mode #-} -- | Sets when the viewport should be updated. See @enum ViewportUpdateMode@ constants for options. bindVisualServer_viewport_set_update_mode :: MethodBind bindVisualServer_viewport_set_update_mode = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_update_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets when the viewport should be updated. See @enum ViewportUpdateMode@ constants for options. viewport_set_update_mode :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () viewport_set_update_mode cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_update_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_update_mode" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_update_mode {-# NOINLINE bindVisualServer_viewport_set_usage #-} -- | Sets the viewport's 2D/3D mode. See @enum ViewportUsage@ constants for options. bindVisualServer_viewport_set_usage :: MethodBind bindVisualServer_viewport_set_usage = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_usage" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the viewport's 2D/3D mode. See @enum ViewportUsage@ constants for options. viewport_set_usage :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Int -> IO () viewport_set_usage cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_usage (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_usage" '[Rid, Int] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_usage {-# NOINLINE bindVisualServer_viewport_set_use_arvr #-} -- | If @true@, the viewport uses augmented or virtual reality technologies. See @ARVRInterface@. bindVisualServer_viewport_set_use_arvr :: MethodBind bindVisualServer_viewport_set_use_arvr = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_use_arvr" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport uses augmented or virtual reality technologies. See @ARVRInterface@. viewport_set_use_arvr :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_use_arvr cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_use_arvr (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_use_arvr" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_use_arvr {-# NOINLINE bindVisualServer_viewport_set_vflip #-} -- | If @true@, the viewport's rendering is flipped vertically. bindVisualServer_viewport_set_vflip :: MethodBind bindVisualServer_viewport_set_vflip = unsafePerformIO $ withCString "VisualServer" $ \ clsNamePtr -> withCString "viewport_set_vflip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the viewport's rendering is flipped vertically. viewport_set_vflip :: (VisualServer :< cls, Object :< cls) => cls -> Rid -> Bool -> IO () viewport_set_vflip cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualServer_viewport_set_vflip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualServer "viewport_set_vflip" '[Rid, Bool] (IO ()) where nodeMethod = Godot.Core.VisualServer.viewport_set_vflip ================================================ FILE: src/Godot/Core/VisualShader.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShader (Godot.Core.VisualShader._NODE_ID_INVALID, Godot.Core.VisualShader._TYPE_VERTEX, Godot.Core.VisualShader._TYPE_FRAGMENT, Godot.Core.VisualShader._NODE_ID_OUTPUT, Godot.Core.VisualShader._TYPE_MAX, Godot.Core.VisualShader._TYPE_LIGHT, Godot.Core.VisualShader._input_type_changed, Godot.Core.VisualShader._queue_update, Godot.Core.VisualShader._update_shader, Godot.Core.VisualShader.add_node, Godot.Core.VisualShader.can_connect_nodes, Godot.Core.VisualShader.connect_nodes, Godot.Core.VisualShader.connect_nodes_forced, Godot.Core.VisualShader.disconnect_nodes, Godot.Core.VisualShader.get_graph_offset, Godot.Core.VisualShader.get_node, Godot.Core.VisualShader.get_node_connections, Godot.Core.VisualShader.get_node_list, Godot.Core.VisualShader.get_node_position, Godot.Core.VisualShader.get_valid_node_id, Godot.Core.VisualShader.is_node_connection, Godot.Core.VisualShader.remove_node, Godot.Core.VisualShader.set_graph_offset, Godot.Core.VisualShader.set_mode, Godot.Core.VisualShader.set_node_position) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Shader() _NODE_ID_INVALID :: Int _NODE_ID_INVALID = -1 _TYPE_VERTEX :: Int _TYPE_VERTEX = 0 _TYPE_FRAGMENT :: Int _TYPE_FRAGMENT = 1 _NODE_ID_OUTPUT :: Int _NODE_ID_OUTPUT = 0 _TYPE_MAX :: Int _TYPE_MAX = 3 _TYPE_LIGHT :: Int _TYPE_LIGHT = 2 instance NodeProperty VisualShader "graph_offset" Vector2 'False where nodeProperty = (get_graph_offset, wrapDroppingSetter set_graph_offset, Nothing) {-# NOINLINE bindVisualShader__input_type_changed #-} bindVisualShader__input_type_changed :: MethodBind bindVisualShader__input_type_changed = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "_input_type_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _input_type_changed :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> IO () _input_type_changed cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader__input_type_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "_input_type_changed" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualShader._input_type_changed {-# NOINLINE bindVisualShader__queue_update #-} bindVisualShader__queue_update :: MethodBind bindVisualShader__queue_update = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "_queue_update" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _queue_update :: (VisualShader :< cls, Object :< cls) => cls -> IO () _queue_update cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader__queue_update (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "_queue_update" '[] (IO ()) where nodeMethod = Godot.Core.VisualShader._queue_update {-# NOINLINE bindVisualShader__update_shader #-} bindVisualShader__update_shader :: MethodBind bindVisualShader__update_shader = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "_update_shader" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_shader :: (VisualShader :< cls, Object :< cls) => cls -> IO () _update_shader cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader__update_shader (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "_update_shader" '[] (IO ()) where nodeMethod = Godot.Core.VisualShader._update_shader {-# NOINLINE bindVisualShader_add_node #-} -- | Adds the specified node to the shader. bindVisualShader_add_node :: MethodBind bindVisualShader_add_node = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "add_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the specified node to the shader. add_node :: (VisualShader :< cls, Object :< cls) => cls -> Int -> VisualShaderNode -> Vector2 -> Int -> IO () add_node cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_add_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "add_node" '[Int, VisualShaderNode, Vector2, Int] (IO ()) where nodeMethod = Godot.Core.VisualShader.add_node {-# NOINLINE bindVisualShader_can_connect_nodes #-} -- | Returns @true@ if the specified nodes and ports can be connected together. bindVisualShader_can_connect_nodes :: MethodBind bindVisualShader_can_connect_nodes = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "can_connect_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified nodes and ports can be connected together. can_connect_nodes :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> Int -> IO Bool can_connect_nodes cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_can_connect_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "can_connect_nodes" '[Int, Int, Int, Int, Int] (IO Bool) where nodeMethod = Godot.Core.VisualShader.can_connect_nodes {-# NOINLINE bindVisualShader_connect_nodes #-} -- | Connects the specified nodes and ports. bindVisualShader_connect_nodes :: MethodBind bindVisualShader_connect_nodes = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "connect_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects the specified nodes and ports. connect_nodes :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> Int -> IO Int connect_nodes cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_connect_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "connect_nodes" '[Int, Int, Int, Int, Int] (IO Int) where nodeMethod = Godot.Core.VisualShader.connect_nodes {-# NOINLINE bindVisualShader_connect_nodes_forced #-} -- | Connects the specified nodes and ports, even if they can't be connected. Such connection is invalid and will not function properly. bindVisualShader_connect_nodes_forced :: MethodBind bindVisualShader_connect_nodes_forced = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "connect_nodes_forced" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects the specified nodes and ports, even if they can't be connected. Such connection is invalid and will not function properly. connect_nodes_forced :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> Int -> IO () connect_nodes_forced cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_connect_nodes_forced (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "connect_nodes_forced" '[Int, Int, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualShader.connect_nodes_forced {-# NOINLINE bindVisualShader_disconnect_nodes #-} -- | Connects the specified nodes and ports. bindVisualShader_disconnect_nodes :: MethodBind bindVisualShader_disconnect_nodes = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "disconnect_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Connects the specified nodes and ports. disconnect_nodes :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> Int -> IO () disconnect_nodes cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_disconnect_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "disconnect_nodes" '[Int, Int, Int, Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualShader.disconnect_nodes {-# NOINLINE bindVisualShader_get_graph_offset #-} -- | The offset vector of the whole graph. bindVisualShader_get_graph_offset :: MethodBind bindVisualShader_get_graph_offset = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "get_graph_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The offset vector of the whole graph. get_graph_offset :: (VisualShader :< cls, Object :< cls) => cls -> IO Vector2 get_graph_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_get_graph_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "get_graph_offset" '[] (IO Vector2) where nodeMethod = Godot.Core.VisualShader.get_graph_offset {-# NOINLINE bindVisualShader_get_node #-} -- | Returns the shader node instance with specified @type@ and @id@. bindVisualShader_get_node :: MethodBind bindVisualShader_get_node = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "get_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the shader node instance with specified @type@ and @id@. get_node :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> IO VisualShaderNode get_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_get_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "get_node" '[Int, Int] (IO VisualShaderNode) where nodeMethod = Godot.Core.VisualShader.get_node {-# NOINLINE bindVisualShader_get_node_connections #-} -- | Returns the list of connected nodes with the specified type. bindVisualShader_get_node_connections :: MethodBind bindVisualShader_get_node_connections = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "get_node_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of connected nodes with the specified type. get_node_connections :: (VisualShader :< cls, Object :< cls) => cls -> Int -> IO Array get_node_connections cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_get_node_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "get_node_connections" '[Int] (IO Array) where nodeMethod = Godot.Core.VisualShader.get_node_connections {-# NOINLINE bindVisualShader_get_node_list #-} -- | Returns the list of all nodes in the shader with the specified type. bindVisualShader_get_node_list :: MethodBind bindVisualShader_get_node_list = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "get_node_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of all nodes in the shader with the specified type. get_node_list :: (VisualShader :< cls, Object :< cls) => cls -> Int -> IO PoolIntArray get_node_list cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_get_node_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "get_node_list" '[Int] (IO PoolIntArray) where nodeMethod = Godot.Core.VisualShader.get_node_list {-# NOINLINE bindVisualShader_get_node_position #-} -- | Returns the position of the specified node within the shader graph. bindVisualShader_get_node_position :: MethodBind bindVisualShader_get_node_position = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "get_node_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the position of the specified node within the shader graph. get_node_position :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> IO Vector2 get_node_position cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_get_node_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "get_node_position" '[Int, Int] (IO Vector2) where nodeMethod = Godot.Core.VisualShader.get_node_position {-# NOINLINE bindVisualShader_get_valid_node_id #-} bindVisualShader_get_valid_node_id :: MethodBind bindVisualShader_get_valid_node_id = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "get_valid_node_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_valid_node_id :: (VisualShader :< cls, Object :< cls) => cls -> Int -> IO Int get_valid_node_id cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_get_valid_node_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "get_valid_node_id" '[Int] (IO Int) where nodeMethod = Godot.Core.VisualShader.get_valid_node_id {-# NOINLINE bindVisualShader_is_node_connection #-} -- | Returns @true@ if the specified node and port connection exist. bindVisualShader_is_node_connection :: MethodBind bindVisualShader_is_node_connection = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "is_node_connection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified node and port connection exist. is_node_connection :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> Int -> IO Bool is_node_connection cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_is_node_connection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "is_node_connection" '[Int, Int, Int, Int, Int] (IO Bool) where nodeMethod = Godot.Core.VisualShader.is_node_connection {-# NOINLINE bindVisualShader_remove_node #-} -- | Removes the specified node from the shader. bindVisualShader_remove_node :: MethodBind bindVisualShader_remove_node = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "remove_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the specified node from the shader. remove_node :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> IO () remove_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_remove_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "remove_node" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualShader.remove_node {-# NOINLINE bindVisualShader_set_graph_offset #-} -- | The offset vector of the whole graph. bindVisualShader_set_graph_offset :: MethodBind bindVisualShader_set_graph_offset = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "set_graph_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The offset vector of the whole graph. set_graph_offset :: (VisualShader :< cls, Object :< cls) => cls -> Vector2 -> IO () set_graph_offset cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_set_graph_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "set_graph_offset" '[Vector2] (IO ()) where nodeMethod = Godot.Core.VisualShader.set_graph_offset {-# NOINLINE bindVisualShader_set_mode #-} -- | Sets the mode of this shader. bindVisualShader_set_mode :: MethodBind bindVisualShader_set_mode = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the mode of this shader. set_mode :: (VisualShader :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShader.set_mode {-# NOINLINE bindVisualShader_set_node_position #-} -- | Sets the position of the specified node. bindVisualShader_set_node_position :: MethodBind bindVisualShader_set_node_position = unsafePerformIO $ withCString "VisualShader" $ \ clsNamePtr -> withCString "set_node_position" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the position of the specified node. set_node_position :: (VisualShader :< cls, Object :< cls) => cls -> Int -> Int -> Vector2 -> IO () set_node_position cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShader_set_node_position (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShader "set_node_position" '[Int, Int, Vector2] (IO ()) where nodeMethod = Godot.Core.VisualShader.set_node_position ================================================ FILE: src/Godot/Core/VisualShaderNode.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNode (Godot.Core.VisualShaderNode._PORT_TYPE_MAX, Godot.Core.VisualShaderNode._PORT_TYPE_TRANSFORM, Godot.Core.VisualShaderNode._PORT_TYPE_VECTOR, Godot.Core.VisualShaderNode._PORT_TYPE_SCALAR, Godot.Core.VisualShaderNode._PORT_TYPE_SAMPLER, Godot.Core.VisualShaderNode._PORT_TYPE_BOOLEAN, Godot.Core.VisualShaderNode.sig_editor_refresh_request, Godot.Core.VisualShaderNode.get_default_input_values, Godot.Core.VisualShaderNode.get_input_port_default_value, Godot.Core.VisualShaderNode.get_output_port_for_preview, Godot.Core.VisualShaderNode.set_default_input_values, Godot.Core.VisualShaderNode.set_input_port_default_value, Godot.Core.VisualShaderNode.set_output_port_for_preview) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _PORT_TYPE_MAX :: Int _PORT_TYPE_MAX = 5 _PORT_TYPE_TRANSFORM :: Int _PORT_TYPE_TRANSFORM = 3 _PORT_TYPE_VECTOR :: Int _PORT_TYPE_VECTOR = 1 _PORT_TYPE_SCALAR :: Int _PORT_TYPE_SCALAR = 0 _PORT_TYPE_SAMPLER :: Int _PORT_TYPE_SAMPLER = 4 _PORT_TYPE_BOOLEAN :: Int _PORT_TYPE_BOOLEAN = 2 -- | Emitted when the node requests an editor refresh. Currently called only in setter of @VisualShaderNodeTexture.source@, @VisualShaderNodeTexture@, and @VisualShaderNodeCubeMap@ (and their derivatives). sig_editor_refresh_request :: Godot.Internal.Dispatch.Signal VisualShaderNode sig_editor_refresh_request = Godot.Internal.Dispatch.Signal "editor_refresh_request" instance NodeSignal VisualShaderNode "editor_refresh_request" '[] instance NodeProperty VisualShaderNode "default_input_values" Array 'False where nodeProperty = (get_default_input_values, wrapDroppingSetter set_default_input_values, Nothing) instance NodeProperty VisualShaderNode "output_port_for_preview" Int 'False where nodeProperty = (get_output_port_for_preview, wrapDroppingSetter set_output_port_for_preview, Nothing) {-# NOINLINE bindVisualShaderNode_get_default_input_values #-} -- | Returns an @Array@ containing default values for all of the input ports of the node in the form @@index0, value0, index1, value1, ...@@. bindVisualShaderNode_get_default_input_values :: MethodBind bindVisualShaderNode_get_default_input_values = unsafePerformIO $ withCString "VisualShaderNode" $ \ clsNamePtr -> withCString "get_default_input_values" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ containing default values for all of the input ports of the node in the form @@index0, value0, index1, value1, ...@@. get_default_input_values :: (VisualShaderNode :< cls, Object :< cls) => cls -> IO Array get_default_input_values cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNode_get_default_input_values (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNode "get_default_input_values" '[] (IO Array) where nodeMethod = Godot.Core.VisualShaderNode.get_default_input_values {-# NOINLINE bindVisualShaderNode_get_input_port_default_value #-} -- | Returns the default value of the input @port@. bindVisualShaderNode_get_input_port_default_value :: MethodBind bindVisualShaderNode_get_input_port_default_value = unsafePerformIO $ withCString "VisualShaderNode" $ \ clsNamePtr -> withCString "get_input_port_default_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the default value of the input @port@. get_input_port_default_value :: (VisualShaderNode :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_input_port_default_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNode_get_input_port_default_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNode "get_input_port_default_value" '[Int] (IO GodotVariant) where nodeMethod = Godot.Core.VisualShaderNode.get_input_port_default_value {-# NOINLINE bindVisualShaderNode_get_output_port_for_preview #-} -- | Sets the output port index which will be showed for preview. If set to @-1@ no port will be open for preview. bindVisualShaderNode_get_output_port_for_preview :: MethodBind bindVisualShaderNode_get_output_port_for_preview = unsafePerformIO $ withCString "VisualShaderNode" $ \ clsNamePtr -> withCString "get_output_port_for_preview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the output port index which will be showed for preview. If set to @-1@ no port will be open for preview. get_output_port_for_preview :: (VisualShaderNode :< cls, Object :< cls) => cls -> IO Int get_output_port_for_preview cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNode_get_output_port_for_preview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNode "get_output_port_for_preview" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNode.get_output_port_for_preview {-# NOINLINE bindVisualShaderNode_set_default_input_values #-} -- | Sets the default input ports values using an @Array@ of the form @@index0, value0, index1, value1, ...@@. For example: @@0, Vector3(0, 0, 0), 1, Vector3(0, 0, 0)@@. bindVisualShaderNode_set_default_input_values :: MethodBind bindVisualShaderNode_set_default_input_values = unsafePerformIO $ withCString "VisualShaderNode" $ \ clsNamePtr -> withCString "set_default_input_values" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the default input ports values using an @Array@ of the form @@index0, value0, index1, value1, ...@@. For example: @@0, Vector3(0, 0, 0), 1, Vector3(0, 0, 0)@@. set_default_input_values :: (VisualShaderNode :< cls, Object :< cls) => cls -> Array -> IO () set_default_input_values cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNode_set_default_input_values (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNode "set_default_input_values" '[Array] (IO ()) where nodeMethod = Godot.Core.VisualShaderNode.set_default_input_values {-# NOINLINE bindVisualShaderNode_set_input_port_default_value #-} -- | Sets the default value for the selected input @port@. bindVisualShaderNode_set_input_port_default_value :: MethodBind bindVisualShaderNode_set_input_port_default_value = unsafePerformIO $ withCString "VisualShaderNode" $ \ clsNamePtr -> withCString "set_input_port_default_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the default value for the selected input @port@. set_input_port_default_value :: (VisualShaderNode :< cls, Object :< cls) => cls -> Int -> GodotVariant -> IO () set_input_port_default_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNode_set_input_port_default_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNode "set_input_port_default_value" '[Int, GodotVariant] (IO ()) where nodeMethod = Godot.Core.VisualShaderNode.set_input_port_default_value {-# NOINLINE bindVisualShaderNode_set_output_port_for_preview #-} -- | Sets the output port index which will be showed for preview. If set to @-1@ no port will be open for preview. bindVisualShaderNode_set_output_port_for_preview :: MethodBind bindVisualShaderNode_set_output_port_for_preview = unsafePerformIO $ withCString "VisualShaderNode" $ \ clsNamePtr -> withCString "set_output_port_for_preview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the output port index which will be showed for preview. If set to @-1@ no port will be open for preview. set_output_port_for_preview :: (VisualShaderNode :< cls, Object :< cls) => cls -> Int -> IO () set_output_port_for_preview cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNode_set_output_port_for_preview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNode "set_output_port_for_preview" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNode.set_output_port_for_preview ================================================ FILE: src/Godot/Core/VisualShaderNodeBooleanConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeBooleanConstant (Godot.Core.VisualShaderNodeBooleanConstant.get_constant, Godot.Core.VisualShaderNodeBooleanConstant.set_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() instance NodeProperty VisualShaderNodeBooleanConstant "constant" Bool 'False where nodeProperty = (get_constant, wrapDroppingSetter set_constant, Nothing) {-# NOINLINE bindVisualShaderNodeBooleanConstant_get_constant #-} -- | A boolean constant which represents a state of this node. bindVisualShaderNodeBooleanConstant_get_constant :: MethodBind bindVisualShaderNodeBooleanConstant_get_constant = unsafePerformIO $ withCString "VisualShaderNodeBooleanConstant" $ \ clsNamePtr -> withCString "get_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A boolean constant which represents a state of this node. get_constant :: (VisualShaderNodeBooleanConstant :< cls, Object :< cls) => cls -> IO Bool get_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeBooleanConstant_get_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeBooleanConstant "get_constant" '[] (IO Bool) where nodeMethod = Godot.Core.VisualShaderNodeBooleanConstant.get_constant {-# NOINLINE bindVisualShaderNodeBooleanConstant_set_constant #-} -- | A boolean constant which represents a state of this node. bindVisualShaderNodeBooleanConstant_set_constant :: MethodBind bindVisualShaderNodeBooleanConstant_set_constant = unsafePerformIO $ withCString "VisualShaderNodeBooleanConstant" $ \ clsNamePtr -> withCString "set_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A boolean constant which represents a state of this node. set_constant :: (VisualShaderNodeBooleanConstant :< cls, Object :< cls) => cls -> Bool -> IO () set_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeBooleanConstant_set_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeBooleanConstant "set_constant" '[Bool] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeBooleanConstant.set_constant ================================================ FILE: src/Godot/Core/VisualShaderNodeBooleanUniform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeBooleanUniform () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeUniform() ================================================ FILE: src/Godot/Core/VisualShaderNodeColorConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeColorConstant (Godot.Core.VisualShaderNodeColorConstant.get_constant, Godot.Core.VisualShaderNodeColorConstant.set_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() instance NodeProperty VisualShaderNodeColorConstant "constant" Color 'False where nodeProperty = (get_constant, wrapDroppingSetter set_constant, Nothing) {-# NOINLINE bindVisualShaderNodeColorConstant_get_constant #-} -- | A @Color@ constant which represents a state of this node. bindVisualShaderNodeColorConstant_get_constant :: MethodBind bindVisualShaderNodeColorConstant_get_constant = unsafePerformIO $ withCString "VisualShaderNodeColorConstant" $ \ clsNamePtr -> withCString "get_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Color@ constant which represents a state of this node. get_constant :: (VisualShaderNodeColorConstant :< cls, Object :< cls) => cls -> IO Color get_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeColorConstant_get_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeColorConstant "get_constant" '[] (IO Color) where nodeMethod = Godot.Core.VisualShaderNodeColorConstant.get_constant {-# NOINLINE bindVisualShaderNodeColorConstant_set_constant #-} -- | A @Color@ constant which represents a state of this node. bindVisualShaderNodeColorConstant_set_constant :: MethodBind bindVisualShaderNodeColorConstant_set_constant = unsafePerformIO $ withCString "VisualShaderNodeColorConstant" $ \ clsNamePtr -> withCString "set_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Color@ constant which represents a state of this node. set_constant :: (VisualShaderNodeColorConstant :< cls, Object :< cls) => cls -> Color -> IO () set_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeColorConstant_set_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeColorConstant "set_constant" '[Color] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeColorConstant.set_constant ================================================ FILE: src/Godot/Core/VisualShaderNodeColorFunc.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeColorFunc (Godot.Core.VisualShaderNodeColorFunc._FUNC_GRAYSCALE, Godot.Core.VisualShaderNodeColorFunc._FUNC_SEPIA, Godot.Core.VisualShaderNodeColorFunc.get_function, Godot.Core.VisualShaderNodeColorFunc.set_function) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _FUNC_GRAYSCALE :: Int _FUNC_GRAYSCALE = 0 _FUNC_SEPIA :: Int _FUNC_SEPIA = 1 instance NodeProperty VisualShaderNodeColorFunc "function" Int 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) {-# NOINLINE bindVisualShaderNodeColorFunc_get_function #-} -- | A function to be applied to the input color. See @enum Function@ for options. bindVisualShaderNodeColorFunc_get_function :: MethodBind bindVisualShaderNodeColorFunc_get_function = unsafePerformIO $ withCString "VisualShaderNodeColorFunc" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A function to be applied to the input color. See @enum Function@ for options. get_function :: (VisualShaderNodeColorFunc :< cls, Object :< cls) => cls -> IO Int get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeColorFunc_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeColorFunc "get_function" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeColorFunc.get_function {-# NOINLINE bindVisualShaderNodeColorFunc_set_function #-} -- | A function to be applied to the input color. See @enum Function@ for options. bindVisualShaderNodeColorFunc_set_function :: MethodBind bindVisualShaderNodeColorFunc_set_function = unsafePerformIO $ withCString "VisualShaderNodeColorFunc" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A function to be applied to the input color. See @enum Function@ for options. set_function :: (VisualShaderNodeColorFunc :< cls, Object :< cls) => cls -> Int -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeColorFunc_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeColorFunc "set_function" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeColorFunc.set_function ================================================ FILE: src/Godot/Core/VisualShaderNodeColorOp.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeColorOp (Godot.Core.VisualShaderNodeColorOp._OP_SCREEN, Godot.Core.VisualShaderNodeColorOp._OP_SOFT_LIGHT, Godot.Core.VisualShaderNodeColorOp._OP_DODGE, Godot.Core.VisualShaderNodeColorOp._OP_BURN, Godot.Core.VisualShaderNodeColorOp._OP_HARD_LIGHT, Godot.Core.VisualShaderNodeColorOp._OP_DARKEN, Godot.Core.VisualShaderNodeColorOp._OP_DIFFERENCE, Godot.Core.VisualShaderNodeColorOp._OP_OVERLAY, Godot.Core.VisualShaderNodeColorOp._OP_LIGHTEN, Godot.Core.VisualShaderNodeColorOp.get_operator, Godot.Core.VisualShaderNodeColorOp.set_operator) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _OP_SCREEN :: Int _OP_SCREEN = 0 _OP_SOFT_LIGHT :: Int _OP_SOFT_LIGHT = 7 _OP_DODGE :: Int _OP_DODGE = 5 _OP_BURN :: Int _OP_BURN = 6 _OP_HARD_LIGHT :: Int _OP_HARD_LIGHT = 8 _OP_DARKEN :: Int _OP_DARKEN = 2 _OP_DIFFERENCE :: Int _OP_DIFFERENCE = 1 _OP_OVERLAY :: Int _OP_OVERLAY = 4 _OP_LIGHTEN :: Int _OP_LIGHTEN = 3 instance NodeProperty VisualShaderNodeColorOp "operator" Int 'False where nodeProperty = (get_operator, wrapDroppingSetter set_operator, Nothing) {-# NOINLINE bindVisualShaderNodeColorOp_get_operator #-} -- | An operator to be applied to the inputs. See @enum Operator@ for options. bindVisualShaderNodeColorOp_get_operator :: MethodBind bindVisualShaderNodeColorOp_get_operator = unsafePerformIO $ withCString "VisualShaderNodeColorOp" $ \ clsNamePtr -> withCString "get_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | An operator to be applied to the inputs. See @enum Operator@ for options. get_operator :: (VisualShaderNodeColorOp :< cls, Object :< cls) => cls -> IO Int get_operator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeColorOp_get_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeColorOp "get_operator" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeColorOp.get_operator {-# NOINLINE bindVisualShaderNodeColorOp_set_operator #-} -- | An operator to be applied to the inputs. See @enum Operator@ for options. bindVisualShaderNodeColorOp_set_operator :: MethodBind bindVisualShaderNodeColorOp_set_operator = unsafePerformIO $ withCString "VisualShaderNodeColorOp" $ \ clsNamePtr -> withCString "set_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | An operator to be applied to the inputs. See @enum Operator@ for options. set_operator :: (VisualShaderNodeColorOp :< cls, Object :< cls) => cls -> Int -> IO () set_operator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeColorOp_set_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeColorOp "set_operator" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeColorOp.set_operator ================================================ FILE: src/Godot/Core/VisualShaderNodeColorUniform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeColorUniform () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeUniform() ================================================ FILE: src/Godot/Core/VisualShaderNodeCompare.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeCompare (Godot.Core.VisualShaderNodeCompare._FUNC_GREATER_THAN_EQUAL, Godot.Core.VisualShaderNodeCompare._FUNC_GREATER_THAN, Godot.Core.VisualShaderNodeCompare._CTYPE_SCALAR, Godot.Core.VisualShaderNodeCompare._CTYPE_TRANSFORM, Godot.Core.VisualShaderNodeCompare._FUNC_LESS_THAN, Godot.Core.VisualShaderNodeCompare._FUNC_NOT_EQUAL, Godot.Core.VisualShaderNodeCompare._COND_ANY, Godot.Core.VisualShaderNodeCompare._FUNC_LESS_THAN_EQUAL, Godot.Core.VisualShaderNodeCompare._CTYPE_VECTOR, Godot.Core.VisualShaderNodeCompare._FUNC_EQUAL, Godot.Core.VisualShaderNodeCompare._COND_ALL, Godot.Core.VisualShaderNodeCompare._CTYPE_BOOLEAN, Godot.Core.VisualShaderNodeCompare.get_comparison_type, Godot.Core.VisualShaderNodeCompare.get_condition, Godot.Core.VisualShaderNodeCompare.get_function, Godot.Core.VisualShaderNodeCompare.set_comparison_type, Godot.Core.VisualShaderNodeCompare.set_condition, Godot.Core.VisualShaderNodeCompare.set_function) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _FUNC_GREATER_THAN_EQUAL :: Int _FUNC_GREATER_THAN_EQUAL = 3 _FUNC_GREATER_THAN :: Int _FUNC_GREATER_THAN = 2 _CTYPE_SCALAR :: Int _CTYPE_SCALAR = 0 _CTYPE_TRANSFORM :: Int _CTYPE_TRANSFORM = 3 _FUNC_LESS_THAN :: Int _FUNC_LESS_THAN = 4 _FUNC_NOT_EQUAL :: Int _FUNC_NOT_EQUAL = 1 _COND_ANY :: Int _COND_ANY = 1 _FUNC_LESS_THAN_EQUAL :: Int _FUNC_LESS_THAN_EQUAL = 5 _CTYPE_VECTOR :: Int _CTYPE_VECTOR = 1 _FUNC_EQUAL :: Int _FUNC_EQUAL = 0 _COND_ALL :: Int _COND_ALL = 0 _CTYPE_BOOLEAN :: Int _CTYPE_BOOLEAN = 2 instance NodeProperty VisualShaderNodeCompare "condition" Int 'False where nodeProperty = (get_condition, wrapDroppingSetter set_condition, Nothing) instance NodeProperty VisualShaderNodeCompare "function" Int 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) instance NodeProperty VisualShaderNodeCompare "type" Int 'False where nodeProperty = (get_comparison_type, wrapDroppingSetter set_comparison_type, Nothing) {-# NOINLINE bindVisualShaderNodeCompare_get_comparison_type #-} -- | The type to be used in the comparison. See @enum ComparisonType@ for options. bindVisualShaderNodeCompare_get_comparison_type :: MethodBind bindVisualShaderNodeCompare_get_comparison_type = unsafePerformIO $ withCString "VisualShaderNodeCompare" $ \ clsNamePtr -> withCString "get_comparison_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The type to be used in the comparison. See @enum ComparisonType@ for options. get_comparison_type :: (VisualShaderNodeCompare :< cls, Object :< cls) => cls -> IO Int get_comparison_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCompare_get_comparison_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCompare "get_comparison_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCompare.get_comparison_type {-# NOINLINE bindVisualShaderNodeCompare_get_condition #-} -- | Extra condition which is applied if @type@ is set to @CTYPE_VECTOR@. bindVisualShaderNodeCompare_get_condition :: MethodBind bindVisualShaderNodeCompare_get_condition = unsafePerformIO $ withCString "VisualShaderNodeCompare" $ \ clsNamePtr -> withCString "get_condition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Extra condition which is applied if @type@ is set to @CTYPE_VECTOR@. get_condition :: (VisualShaderNodeCompare :< cls, Object :< cls) => cls -> IO Int get_condition cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCompare_get_condition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCompare "get_condition" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCompare.get_condition {-# NOINLINE bindVisualShaderNodeCompare_get_function #-} -- | A comparison function. See @enum Function@ for options. bindVisualShaderNodeCompare_get_function :: MethodBind bindVisualShaderNodeCompare_get_function = unsafePerformIO $ withCString "VisualShaderNodeCompare" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A comparison function. See @enum Function@ for options. get_function :: (VisualShaderNodeCompare :< cls, Object :< cls) => cls -> IO Int get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCompare_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCompare "get_function" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCompare.get_function {-# NOINLINE bindVisualShaderNodeCompare_set_comparison_type #-} -- | The type to be used in the comparison. See @enum ComparisonType@ for options. bindVisualShaderNodeCompare_set_comparison_type :: MethodBind bindVisualShaderNodeCompare_set_comparison_type = unsafePerformIO $ withCString "VisualShaderNodeCompare" $ \ clsNamePtr -> withCString "set_comparison_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The type to be used in the comparison. See @enum ComparisonType@ for options. set_comparison_type :: (VisualShaderNodeCompare :< cls, Object :< cls) => cls -> Int -> IO () set_comparison_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCompare_set_comparison_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCompare "set_comparison_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeCompare.set_comparison_type {-# NOINLINE bindVisualShaderNodeCompare_set_condition #-} -- | Extra condition which is applied if @type@ is set to @CTYPE_VECTOR@. bindVisualShaderNodeCompare_set_condition :: MethodBind bindVisualShaderNodeCompare_set_condition = unsafePerformIO $ withCString "VisualShaderNodeCompare" $ \ clsNamePtr -> withCString "set_condition" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Extra condition which is applied if @type@ is set to @CTYPE_VECTOR@. set_condition :: (VisualShaderNodeCompare :< cls, Object :< cls) => cls -> Int -> IO () set_condition cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCompare_set_condition (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCompare "set_condition" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeCompare.set_condition {-# NOINLINE bindVisualShaderNodeCompare_set_function #-} -- | A comparison function. See @enum Function@ for options. bindVisualShaderNodeCompare_set_function :: MethodBind bindVisualShaderNodeCompare_set_function = unsafePerformIO $ withCString "VisualShaderNodeCompare" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A comparison function. See @enum Function@ for options. set_function :: (VisualShaderNodeCompare :< cls, Object :< cls) => cls -> Int -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCompare_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCompare "set_function" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeCompare.set_function ================================================ FILE: src/Godot/Core/VisualShaderNodeCubeMap.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeCubeMap (Godot.Core.VisualShaderNodeCubeMap._TYPE_DATA, Godot.Core.VisualShaderNodeCubeMap._SOURCE_PORT, Godot.Core.VisualShaderNodeCubeMap._TYPE_COLOR, Godot.Core.VisualShaderNodeCubeMap._SOURCE_TEXTURE, Godot.Core.VisualShaderNodeCubeMap._TYPE_NORMALMAP, Godot.Core.VisualShaderNodeCubeMap.get_cube_map, Godot.Core.VisualShaderNodeCubeMap.get_source, Godot.Core.VisualShaderNodeCubeMap.get_texture_type, Godot.Core.VisualShaderNodeCubeMap.set_cube_map, Godot.Core.VisualShaderNodeCubeMap.set_source, Godot.Core.VisualShaderNodeCubeMap.set_texture_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _TYPE_DATA :: Int _TYPE_DATA = 0 _SOURCE_PORT :: Int _SOURCE_PORT = 1 _TYPE_COLOR :: Int _TYPE_COLOR = 1 _SOURCE_TEXTURE :: Int _SOURCE_TEXTURE = 0 _TYPE_NORMALMAP :: Int _TYPE_NORMALMAP = 2 instance NodeProperty VisualShaderNodeCubeMap "cube_map" CubeMap 'False where nodeProperty = (get_cube_map, wrapDroppingSetter set_cube_map, Nothing) instance NodeProperty VisualShaderNodeCubeMap "source" Int 'False where nodeProperty = (get_source, wrapDroppingSetter set_source, Nothing) instance NodeProperty VisualShaderNodeCubeMap "texture_type" Int 'False where nodeProperty = (get_texture_type, wrapDroppingSetter set_texture_type, Nothing) {-# NOINLINE bindVisualShaderNodeCubeMap_get_cube_map #-} -- | The @CubeMap@ texture to sample when using @SOURCE_TEXTURE@ as @source@. bindVisualShaderNodeCubeMap_get_cube_map :: MethodBind bindVisualShaderNodeCubeMap_get_cube_map = unsafePerformIO $ withCString "VisualShaderNodeCubeMap" $ \ clsNamePtr -> withCString "get_cube_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @CubeMap@ texture to sample when using @SOURCE_TEXTURE@ as @source@. get_cube_map :: (VisualShaderNodeCubeMap :< cls, Object :< cls) => cls -> IO CubeMap get_cube_map cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCubeMap_get_cube_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCubeMap "get_cube_map" '[] (IO CubeMap) where nodeMethod = Godot.Core.VisualShaderNodeCubeMap.get_cube_map {-# NOINLINE bindVisualShaderNodeCubeMap_get_source #-} -- | Defines which source should be used for the sampling. See @enum Source@ for options. bindVisualShaderNodeCubeMap_get_source :: MethodBind bindVisualShaderNodeCubeMap_get_source = unsafePerformIO $ withCString "VisualShaderNodeCubeMap" $ \ clsNamePtr -> withCString "get_source" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines which source should be used for the sampling. See @enum Source@ for options. get_source :: (VisualShaderNodeCubeMap :< cls, Object :< cls) => cls -> IO Int get_source cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCubeMap_get_source (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCubeMap "get_source" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCubeMap.get_source {-# NOINLINE bindVisualShaderNodeCubeMap_get_texture_type #-} -- | Defines the type of data provided by the source texture. See @enum TextureType@ for options. bindVisualShaderNodeCubeMap_get_texture_type :: MethodBind bindVisualShaderNodeCubeMap_get_texture_type = unsafePerformIO $ withCString "VisualShaderNodeCubeMap" $ \ clsNamePtr -> withCString "get_texture_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the type of data provided by the source texture. See @enum TextureType@ for options. get_texture_type :: (VisualShaderNodeCubeMap :< cls, Object :< cls) => cls -> IO Int get_texture_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCubeMap_get_texture_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCubeMap "get_texture_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCubeMap.get_texture_type {-# NOINLINE bindVisualShaderNodeCubeMap_set_cube_map #-} -- | The @CubeMap@ texture to sample when using @SOURCE_TEXTURE@ as @source@. bindVisualShaderNodeCubeMap_set_cube_map :: MethodBind bindVisualShaderNodeCubeMap_set_cube_map = unsafePerformIO $ withCString "VisualShaderNodeCubeMap" $ \ clsNamePtr -> withCString "set_cube_map" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @CubeMap@ texture to sample when using @SOURCE_TEXTURE@ as @source@. set_cube_map :: (VisualShaderNodeCubeMap :< cls, Object :< cls) => cls -> CubeMap -> IO () set_cube_map cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCubeMap_set_cube_map (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCubeMap "set_cube_map" '[CubeMap] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeCubeMap.set_cube_map {-# NOINLINE bindVisualShaderNodeCubeMap_set_source #-} -- | Defines which source should be used for the sampling. See @enum Source@ for options. bindVisualShaderNodeCubeMap_set_source :: MethodBind bindVisualShaderNodeCubeMap_set_source = unsafePerformIO $ withCString "VisualShaderNodeCubeMap" $ \ clsNamePtr -> withCString "set_source" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines which source should be used for the sampling. See @enum Source@ for options. set_source :: (VisualShaderNodeCubeMap :< cls, Object :< cls) => cls -> Int -> IO () set_source cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCubeMap_set_source (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCubeMap "set_source" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeCubeMap.set_source {-# NOINLINE bindVisualShaderNodeCubeMap_set_texture_type #-} -- | Defines the type of data provided by the source texture. See @enum TextureType@ for options. bindVisualShaderNodeCubeMap_set_texture_type :: MethodBind bindVisualShaderNodeCubeMap_set_texture_type = unsafePerformIO $ withCString "VisualShaderNodeCubeMap" $ \ clsNamePtr -> withCString "set_texture_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the type of data provided by the source texture. See @enum TextureType@ for options. set_texture_type :: (VisualShaderNodeCubeMap :< cls, Object :< cls) => cls -> Int -> IO () set_texture_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCubeMap_set_texture_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCubeMap "set_texture_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeCubeMap.set_texture_type ================================================ FILE: src/Godot/Core/VisualShaderNodeCubeMapUniform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeCubeMapUniform () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeTextureUniform() ================================================ FILE: src/Godot/Core/VisualShaderNodeCustom.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeCustom (Godot.Core.VisualShaderNodeCustom._get_category, Godot.Core.VisualShaderNodeCustom._get_code, Godot.Core.VisualShaderNodeCustom._get_description, Godot.Core.VisualShaderNodeCustom._get_global_code, Godot.Core.VisualShaderNodeCustom._get_input_port_count, Godot.Core.VisualShaderNodeCustom._get_input_port_name, Godot.Core.VisualShaderNodeCustom._get_input_port_type, Godot.Core.VisualShaderNodeCustom._get_name, Godot.Core.VisualShaderNodeCustom._get_output_port_count, Godot.Core.VisualShaderNodeCustom._get_output_port_name, Godot.Core.VisualShaderNodeCustom._get_output_port_type, Godot.Core.VisualShaderNodeCustom._get_return_icon_type, Godot.Core.VisualShaderNodeCustom._get_subcategory) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() {-# NOINLINE bindVisualShaderNodeCustom__get_category #-} -- | Override this method to define the category of the associated custom node in the Visual Shader Editor's members dialog. -- Defining this method is __optional__. If not overridden, the node will be filed under the "Custom" category. bindVisualShaderNodeCustom__get_category :: MethodBind bindVisualShaderNodeCustom__get_category = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_category" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the category of the associated custom node in the Visual Shader Editor's members dialog. -- Defining this method is __optional__. If not overridden, the node will be filed under the "Custom" category. _get_category :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> IO GodotString _get_category cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_category (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_category" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_category {-# NOINLINE bindVisualShaderNodeCustom__get_code #-} -- | Override this method to define the actual shader code of the associated custom node. The shader code should be returned as a string, which can have multiple lines (the @"""@ multiline string construct can be used for convenience). -- The @input_vars@ and @output_vars@ arrays contain the string names of the various input and output variables, as defined by @_get_input_*@ and @_get_output_*@ virtual methods in this class. -- The output ports can be assigned values in the shader code. For example, @return output_vars@0@ + " = " + input_vars@0@ + ";"@. -- You can customize the generated code based on the shader @mode@ (see @enum Shader.Mode@) and/or @type@ (see @enum VisualShader.Type@). -- Defining this method is __required__. bindVisualShaderNodeCustom__get_code :: MethodBind bindVisualShaderNodeCustom__get_code = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the actual shader code of the associated custom node. The shader code should be returned as a string, which can have multiple lines (the @"""@ multiline string construct can be used for convenience). -- The @input_vars@ and @output_vars@ arrays contain the string names of the various input and output variables, as defined by @_get_input_*@ and @_get_output_*@ virtual methods in this class. -- The output ports can be assigned values in the shader code. For example, @return output_vars@0@ + " = " + input_vars@0@ + ";"@. -- You can customize the generated code based on the shader @mode@ (see @enum Shader.Mode@) and/or @type@ (see @enum VisualShader.Type@). -- Defining this method is __required__. _get_code :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> Array -> Array -> Int -> Int -> IO GodotString _get_code cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_code" '[Array, Array, Int, Int] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_code {-# NOINLINE bindVisualShaderNodeCustom__get_description #-} -- | Override this method to define the description of the associated custom node in the Visual Shader Editor's members dialog. -- Defining this method is __optional__. bindVisualShaderNodeCustom__get_description :: MethodBind bindVisualShaderNodeCustom__get_description = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_description" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the description of the associated custom node in the Visual Shader Editor's members dialog. -- Defining this method is __optional__. _get_description :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> IO GodotString _get_description cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_description (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_description" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_description {-# NOINLINE bindVisualShaderNodeCustom__get_global_code #-} -- | Override this method to add shader code on top of the global shader, to define your own standard library of reusable methods, varyings, constants, uniforms, etc. The shader code should be returned as a string, which can have multiple lines (the @"""@ multiline string construct can be used for convenience). -- Be careful with this functionality as it can cause name conflicts with other custom nodes, so be sure to give the defined entities unique names. -- You can customize the generated code based on the shader @mode@ (see @enum Shader.Mode@). -- Defining this method is __optional__. bindVisualShaderNodeCustom__get_global_code :: MethodBind bindVisualShaderNodeCustom__get_global_code = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_global_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to add shader code on top of the global shader, to define your own standard library of reusable methods, varyings, constants, uniforms, etc. The shader code should be returned as a string, which can have multiple lines (the @"""@ multiline string construct can be used for convenience). -- Be careful with this functionality as it can cause name conflicts with other custom nodes, so be sure to give the defined entities unique names. -- You can customize the generated code based on the shader @mode@ (see @enum Shader.Mode@). -- Defining this method is __optional__. _get_global_code :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> Int -> IO GodotString _get_global_code cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_global_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_global_code" '[Int] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_global_code {-# NOINLINE bindVisualShaderNodeCustom__get_input_port_count #-} -- | Override this method to define the amount of input ports of the associated custom node. -- Defining this method is __required__. If not overridden, the node has no input ports. bindVisualShaderNodeCustom__get_input_port_count :: MethodBind bindVisualShaderNodeCustom__get_input_port_count = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_input_port_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the amount of input ports of the associated custom node. -- Defining this method is __required__. If not overridden, the node has no input ports. _get_input_port_count :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> IO Int _get_input_port_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_input_port_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_input_port_count" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_input_port_count {-# NOINLINE bindVisualShaderNodeCustom__get_input_port_name #-} -- | Override this method to define the names of input ports of the associated custom node. The names are used both for the input slots in the editor and as identifiers in the shader code, and are passed in the @input_vars@ array in @method _get_code@. -- Defining this method is __optional__, but recommended. If not overridden, input ports are named as @"in" + str(port)@. bindVisualShaderNodeCustom__get_input_port_name :: MethodBind bindVisualShaderNodeCustom__get_input_port_name = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_input_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the names of input ports of the associated custom node. The names are used both for the input slots in the editor and as identifiers in the shader code, and are passed in the @input_vars@ array in @method _get_code@. -- Defining this method is __optional__, but recommended. If not overridden, input ports are named as @"in" + str(port)@. _get_input_port_name :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> Int -> IO GodotString _get_input_port_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_input_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_input_port_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_input_port_name {-# NOINLINE bindVisualShaderNodeCustom__get_input_port_type #-} -- | Override this method to define the returned type of each input port of the associated custom node (see @enum VisualShaderNode.PortType@ for possible types). -- Defining this method is __optional__, but recommended. If not overridden, input ports will return the @VisualShaderNode.PORT_TYPE_SCALAR@ type. bindVisualShaderNodeCustom__get_input_port_type :: MethodBind bindVisualShaderNodeCustom__get_input_port_type = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_input_port_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the returned type of each input port of the associated custom node (see @enum VisualShaderNode.PortType@ for possible types). -- Defining this method is __optional__, but recommended. If not overridden, input ports will return the @VisualShaderNode.PORT_TYPE_SCALAR@ type. _get_input_port_type :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> Int -> IO Int _get_input_port_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_input_port_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_input_port_type" '[Int] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_input_port_type {-# NOINLINE bindVisualShaderNodeCustom__get_name #-} -- | Override this method to define the name of the associated custom node in the Visual Shader Editor's members dialog and graph. -- Defining this method is __optional__, but recommended. If not overridden, the node will be named as "Unnamed". bindVisualShaderNodeCustom__get_name :: MethodBind bindVisualShaderNodeCustom__get_name = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the name of the associated custom node in the Visual Shader Editor's members dialog and graph. -- Defining this method is __optional__, but recommended. If not overridden, the node will be named as "Unnamed". _get_name :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> IO GodotString _get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_name {-# NOINLINE bindVisualShaderNodeCustom__get_output_port_count #-} -- | Override this method to define the amount of output ports of the associated custom node. -- Defining this method is __required__. If not overridden, the node has no output ports. bindVisualShaderNodeCustom__get_output_port_count :: MethodBind bindVisualShaderNodeCustom__get_output_port_count = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_output_port_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the amount of output ports of the associated custom node. -- Defining this method is __required__. If not overridden, the node has no output ports. _get_output_port_count :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> IO Int _get_output_port_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_output_port_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_output_port_count" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_output_port_count {-# NOINLINE bindVisualShaderNodeCustom__get_output_port_name #-} -- | Override this method to define the names of output ports of the associated custom node. The names are used both for the output slots in the editor and as identifiers in the shader code, and are passed in the @output_vars@ array in @method _get_code@. -- Defining this method is __optional__, but recommended. If not overridden, output ports are named as @"out" + str(port)@. bindVisualShaderNodeCustom__get_output_port_name :: MethodBind bindVisualShaderNodeCustom__get_output_port_name = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_output_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the names of output ports of the associated custom node. The names are used both for the output slots in the editor and as identifiers in the shader code, and are passed in the @output_vars@ array in @method _get_code@. -- Defining this method is __optional__, but recommended. If not overridden, output ports are named as @"out" + str(port)@. _get_output_port_name :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> Int -> IO GodotString _get_output_port_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_output_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_output_port_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_output_port_name {-# NOINLINE bindVisualShaderNodeCustom__get_output_port_type #-} -- | Override this method to define the returned type of each output port of the associated custom node (see @enum VisualShaderNode.PortType@ for possible types). -- Defining this method is __optional__, but recommended. If not overridden, output ports will return the @VisualShaderNode.PORT_TYPE_SCALAR@ type. bindVisualShaderNodeCustom__get_output_port_type :: MethodBind bindVisualShaderNodeCustom__get_output_port_type = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_output_port_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the returned type of each output port of the associated custom node (see @enum VisualShaderNode.PortType@ for possible types). -- Defining this method is __optional__, but recommended. If not overridden, output ports will return the @VisualShaderNode.PORT_TYPE_SCALAR@ type. _get_output_port_type :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> Int -> IO Int _get_output_port_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_output_port_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_output_port_type" '[Int] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_output_port_type {-# NOINLINE bindVisualShaderNodeCustom__get_return_icon_type #-} -- | Override this method to define the return icon of the associated custom node in the Visual Shader Editor's members dialog. -- Defining this method is __optional__. If not overridden, no return icon is shown. bindVisualShaderNodeCustom__get_return_icon_type :: MethodBind bindVisualShaderNodeCustom__get_return_icon_type = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_return_icon_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the return icon of the associated custom node in the Visual Shader Editor's members dialog. -- Defining this method is __optional__. If not overridden, no return icon is shown. _get_return_icon_type :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> IO Int _get_return_icon_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_return_icon_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_return_icon_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_return_icon_type {-# NOINLINE bindVisualShaderNodeCustom__get_subcategory #-} -- | Override this method to define the subcategory of the associated custom node in the Visual Shader Editor's members dialog. -- Defining this method is __optional__. If not overridden, the node will be filed under the root of the main category (see @method _get_category@). bindVisualShaderNodeCustom__get_subcategory :: MethodBind bindVisualShaderNodeCustom__get_subcategory = unsafePerformIO $ withCString "VisualShaderNodeCustom" $ \ clsNamePtr -> withCString "_get_subcategory" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define the subcategory of the associated custom node in the Visual Shader Editor's members dialog. -- Defining this method is __optional__. If not overridden, the node will be filed under the root of the main category (see @method _get_category@). _get_subcategory :: (VisualShaderNodeCustom :< cls, Object :< cls) => cls -> IO GodotString _get_subcategory cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeCustom__get_subcategory (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeCustom "_get_subcategory" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeCustom._get_subcategory ================================================ FILE: src/Godot/Core/VisualShaderNodeDeterminant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeDeterminant () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeDotProduct.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeDotProduct () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeExpression.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeExpression (Godot.Core.VisualShaderNodeExpression.get_expression, Godot.Core.VisualShaderNodeExpression.set_expression) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeGroupBase() instance NodeProperty VisualShaderNodeExpression "expression" GodotString 'False where nodeProperty = (get_expression, wrapDroppingSetter set_expression, Nothing) {-# NOINLINE bindVisualShaderNodeExpression_get_expression #-} -- | An expression in Godot Shading Language, which will be injected at the start of the graph's matching shader function (@vertex@, @fragment@, or @light@), and thus cannot be used to declare functions, varyings, uniforms, or global constants. bindVisualShaderNodeExpression_get_expression :: MethodBind bindVisualShaderNodeExpression_get_expression = unsafePerformIO $ withCString "VisualShaderNodeExpression" $ \ clsNamePtr -> withCString "get_expression" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | An expression in Godot Shading Language, which will be injected at the start of the graph's matching shader function (@vertex@, @fragment@, or @light@), and thus cannot be used to declare functions, varyings, uniforms, or global constants. get_expression :: (VisualShaderNodeExpression :< cls, Object :< cls) => cls -> IO GodotString get_expression cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeExpression_get_expression (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeExpression "get_expression" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeExpression.get_expression {-# NOINLINE bindVisualShaderNodeExpression_set_expression #-} -- | An expression in Godot Shading Language, which will be injected at the start of the graph's matching shader function (@vertex@, @fragment@, or @light@), and thus cannot be used to declare functions, varyings, uniforms, or global constants. bindVisualShaderNodeExpression_set_expression :: MethodBind bindVisualShaderNodeExpression_set_expression = unsafePerformIO $ withCString "VisualShaderNodeExpression" $ \ clsNamePtr -> withCString "set_expression" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | An expression in Godot Shading Language, which will be injected at the start of the graph's matching shader function (@vertex@, @fragment@, or @light@), and thus cannot be used to declare functions, varyings, uniforms, or global constants. set_expression :: (VisualShaderNodeExpression :< cls, Object :< cls) => cls -> GodotString -> IO () set_expression cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeExpression_set_expression (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeExpression "set_expression" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeExpression.set_expression ================================================ FILE: src/Godot/Core/VisualShaderNodeFaceForward.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeFaceForward () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeFresnel.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeFresnel () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeGlobalExpression.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeGlobalExpression () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeExpression() ================================================ FILE: src/Godot/Core/VisualShaderNodeGroupBase.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeGroupBase (Godot.Core.VisualShaderNodeGroupBase.add_input_port, Godot.Core.VisualShaderNodeGroupBase.add_output_port, Godot.Core.VisualShaderNodeGroupBase.clear_input_ports, Godot.Core.VisualShaderNodeGroupBase.clear_output_ports, Godot.Core.VisualShaderNodeGroupBase.get_free_input_port_id, Godot.Core.VisualShaderNodeGroupBase.get_free_output_port_id, Godot.Core.VisualShaderNodeGroupBase.get_input_port_count, Godot.Core.VisualShaderNodeGroupBase.get_inputs, Godot.Core.VisualShaderNodeGroupBase.get_output_port_count, Godot.Core.VisualShaderNodeGroupBase.get_outputs, Godot.Core.VisualShaderNodeGroupBase.get_size, Godot.Core.VisualShaderNodeGroupBase.has_input_port, Godot.Core.VisualShaderNodeGroupBase.has_output_port, Godot.Core.VisualShaderNodeGroupBase.is_valid_port_name, Godot.Core.VisualShaderNodeGroupBase.remove_input_port, Godot.Core.VisualShaderNodeGroupBase.remove_output_port, Godot.Core.VisualShaderNodeGroupBase.set_input_port_name, Godot.Core.VisualShaderNodeGroupBase.set_input_port_type, Godot.Core.VisualShaderNodeGroupBase.set_inputs, Godot.Core.VisualShaderNodeGroupBase.set_output_port_name, Godot.Core.VisualShaderNodeGroupBase.set_output_port_type, Godot.Core.VisualShaderNodeGroupBase.set_outputs, Godot.Core.VisualShaderNodeGroupBase.set_size) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() instance NodeProperty VisualShaderNodeGroupBase "size" Vector2 'False where nodeProperty = (get_size, wrapDroppingSetter set_size, Nothing) {-# NOINLINE bindVisualShaderNodeGroupBase_add_input_port #-} -- | Adds an input port with the specified @type@ (see @enum VisualShaderNode.PortType@) and @name@. bindVisualShaderNodeGroupBase_add_input_port :: MethodBind bindVisualShaderNodeGroupBase_add_input_port = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "add_input_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an input port with the specified @type@ (see @enum VisualShaderNode.PortType@) and @name@. add_input_port :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> Int -> GodotString -> IO () add_input_port cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_add_input_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "add_input_port" '[Int, Int, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.add_input_port {-# NOINLINE bindVisualShaderNodeGroupBase_add_output_port #-} -- | Adds an output port with the specified @type@ (see @enum VisualShaderNode.PortType@) and @name@. bindVisualShaderNodeGroupBase_add_output_port :: MethodBind bindVisualShaderNodeGroupBase_add_output_port = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "add_output_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an output port with the specified @type@ (see @enum VisualShaderNode.PortType@) and @name@. add_output_port :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> Int -> GodotString -> IO () add_output_port cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_add_output_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "add_output_port" '[Int, Int, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.add_output_port {-# NOINLINE bindVisualShaderNodeGroupBase_clear_input_ports #-} -- | Removes all previously specified input ports. bindVisualShaderNodeGroupBase_clear_input_ports :: MethodBind bindVisualShaderNodeGroupBase_clear_input_ports = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "clear_input_ports" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all previously specified input ports. clear_input_ports :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO () clear_input_ports cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_clear_input_ports (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "clear_input_ports" '[] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.clear_input_ports {-# NOINLINE bindVisualShaderNodeGroupBase_clear_output_ports #-} -- | Removes all previously specified output ports. bindVisualShaderNodeGroupBase_clear_output_ports :: MethodBind bindVisualShaderNodeGroupBase_clear_output_ports = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "clear_output_ports" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all previously specified output ports. clear_output_ports :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO () clear_output_ports cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_clear_output_ports (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "clear_output_ports" '[] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.clear_output_ports {-# NOINLINE bindVisualShaderNodeGroupBase_get_free_input_port_id #-} -- | Returns a free input port ID which can be used in @method add_input_port@. bindVisualShaderNodeGroupBase_get_free_input_port_id :: MethodBind bindVisualShaderNodeGroupBase_get_free_input_port_id = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "get_free_input_port_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a free input port ID which can be used in @method add_input_port@. get_free_input_port_id :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO Int get_free_input_port_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_get_free_input_port_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "get_free_input_port_id" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.get_free_input_port_id {-# NOINLINE bindVisualShaderNodeGroupBase_get_free_output_port_id #-} -- | Returns a free output port ID which can be used in @method add_output_port@. bindVisualShaderNodeGroupBase_get_free_output_port_id :: MethodBind bindVisualShaderNodeGroupBase_get_free_output_port_id = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "get_free_output_port_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a free output port ID which can be used in @method add_output_port@. get_free_output_port_id :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO Int get_free_output_port_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_get_free_output_port_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "get_free_output_port_id" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.get_free_output_port_id {-# NOINLINE bindVisualShaderNodeGroupBase_get_input_port_count #-} -- | Returns the number of input ports in use. Alternative for @method get_free_input_port_id@. bindVisualShaderNodeGroupBase_get_input_port_count :: MethodBind bindVisualShaderNodeGroupBase_get_input_port_count = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "get_input_port_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of input ports in use. Alternative for @method get_free_input_port_id@. get_input_port_count :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO Int get_input_port_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_get_input_port_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "get_input_port_count" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.get_input_port_count {-# NOINLINE bindVisualShaderNodeGroupBase_get_inputs #-} -- | Returns a @String@ description of the input ports as as colon-separated list using the format @id,type,name;@ (see @method add_input_port@). bindVisualShaderNodeGroupBase_get_inputs :: MethodBind bindVisualShaderNodeGroupBase_get_inputs = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "get_inputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @String@ description of the input ports as as colon-separated list using the format @id,type,name;@ (see @method add_input_port@). get_inputs :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO GodotString get_inputs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_get_inputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "get_inputs" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.get_inputs {-# NOINLINE bindVisualShaderNodeGroupBase_get_output_port_count #-} -- | Returns the number of output ports in use. Alternative for @method get_free_output_port_id@. bindVisualShaderNodeGroupBase_get_output_port_count :: MethodBind bindVisualShaderNodeGroupBase_get_output_port_count = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "get_output_port_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of output ports in use. Alternative for @method get_free_output_port_id@. get_output_port_count :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO Int get_output_port_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_get_output_port_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "get_output_port_count" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.get_output_port_count {-# NOINLINE bindVisualShaderNodeGroupBase_get_outputs #-} -- | Returns a @String@ description of the output ports as as colon-separated list using the format @id,type,name;@ (see @method add_output_port@). bindVisualShaderNodeGroupBase_get_outputs :: MethodBind bindVisualShaderNodeGroupBase_get_outputs = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "get_outputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @String@ description of the output ports as as colon-separated list using the format @id,type,name;@ (see @method add_output_port@). get_outputs :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO GodotString get_outputs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_get_outputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "get_outputs" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.get_outputs {-# NOINLINE bindVisualShaderNodeGroupBase_get_size #-} -- | The size of the node in the visual shader graph. bindVisualShaderNodeGroupBase_get_size :: MethodBind bindVisualShaderNodeGroupBase_get_size = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "get_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the node in the visual shader graph. get_size :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> IO Vector2 get_size cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_get_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "get_size" '[] (IO Vector2) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.get_size {-# NOINLINE bindVisualShaderNodeGroupBase_has_input_port #-} -- | Returns @true@ if the specified input port exists. bindVisualShaderNodeGroupBase_has_input_port :: MethodBind bindVisualShaderNodeGroupBase_has_input_port = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "has_input_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified input port exists. has_input_port :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> IO Bool has_input_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_has_input_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "has_input_port" '[Int] (IO Bool) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.has_input_port {-# NOINLINE bindVisualShaderNodeGroupBase_has_output_port #-} -- | Returns @true@ if the specified output port exists. bindVisualShaderNodeGroupBase_has_output_port :: MethodBind bindVisualShaderNodeGroupBase_has_output_port = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "has_output_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified output port exists. has_output_port :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> IO Bool has_output_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_has_output_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "has_output_port" '[Int] (IO Bool) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.has_output_port {-# NOINLINE bindVisualShaderNodeGroupBase_is_valid_port_name #-} -- | Returns @true@ if the specified port name does not override an existed port name and is valid within the shader. bindVisualShaderNodeGroupBase_is_valid_port_name :: MethodBind bindVisualShaderNodeGroupBase_is_valid_port_name = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "is_valid_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified port name does not override an existed port name and is valid within the shader. is_valid_port_name :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_valid_port_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_is_valid_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "is_valid_port_name" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.is_valid_port_name {-# NOINLINE bindVisualShaderNodeGroupBase_remove_input_port #-} -- | Removes the specified input port. bindVisualShaderNodeGroupBase_remove_input_port :: MethodBind bindVisualShaderNodeGroupBase_remove_input_port = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "remove_input_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the specified input port. remove_input_port :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> IO () remove_input_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_remove_input_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "remove_input_port" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.remove_input_port {-# NOINLINE bindVisualShaderNodeGroupBase_remove_output_port #-} -- | Removes the specified output port. bindVisualShaderNodeGroupBase_remove_output_port :: MethodBind bindVisualShaderNodeGroupBase_remove_output_port = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "remove_output_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the specified output port. remove_output_port :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> IO () remove_output_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_remove_output_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "remove_output_port" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.remove_output_port {-# NOINLINE bindVisualShaderNodeGroupBase_set_input_port_name #-} -- | Renames the specified input port. bindVisualShaderNodeGroupBase_set_input_port_name :: MethodBind bindVisualShaderNodeGroupBase_set_input_port_name = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "set_input_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Renames the specified input port. set_input_port_name :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_input_port_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_set_input_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "set_input_port_name" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.set_input_port_name {-# NOINLINE bindVisualShaderNodeGroupBase_set_input_port_type #-} -- | Sets the specified input port's type (see @enum VisualShaderNode.PortType@). bindVisualShaderNodeGroupBase_set_input_port_type :: MethodBind bindVisualShaderNodeGroupBase_set_input_port_type = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "set_input_port_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified input port's type (see @enum VisualShaderNode.PortType@). set_input_port_type :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_input_port_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_set_input_port_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "set_input_port_type" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.set_input_port_type {-# NOINLINE bindVisualShaderNodeGroupBase_set_inputs #-} -- | Defines all input ports using a @String@ formatted as a colon-separated list: @id,type,name;@ (see @method add_input_port@). bindVisualShaderNodeGroupBase_set_inputs :: MethodBind bindVisualShaderNodeGroupBase_set_inputs = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "set_inputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines all input ports using a @String@ formatted as a colon-separated list: @id,type,name;@ (see @method add_input_port@). set_inputs :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> GodotString -> IO () set_inputs cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_set_inputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "set_inputs" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.set_inputs {-# NOINLINE bindVisualShaderNodeGroupBase_set_output_port_name #-} -- | Renames the specified output port. bindVisualShaderNodeGroupBase_set_output_port_name :: MethodBind bindVisualShaderNodeGroupBase_set_output_port_name = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "set_output_port_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Renames the specified output port. set_output_port_name :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> GodotString -> IO () set_output_port_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_set_output_port_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "set_output_port_name" '[Int, GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.set_output_port_name {-# NOINLINE bindVisualShaderNodeGroupBase_set_output_port_type #-} -- | Sets the specified output port's type (see @enum VisualShaderNode.PortType@). bindVisualShaderNodeGroupBase_set_output_port_type :: MethodBind bindVisualShaderNodeGroupBase_set_output_port_type = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "set_output_port_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the specified output port's type (see @enum VisualShaderNode.PortType@). set_output_port_type :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Int -> Int -> IO () set_output_port_type cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_set_output_port_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "set_output_port_type" '[Int, Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.set_output_port_type {-# NOINLINE bindVisualShaderNodeGroupBase_set_outputs #-} -- | Defines all output ports using a @String@ formatted as a colon-separated list: @id,type,name;@ (see @method add_output_port@). bindVisualShaderNodeGroupBase_set_outputs :: MethodBind bindVisualShaderNodeGroupBase_set_outputs = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "set_outputs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines all output ports using a @String@ formatted as a colon-separated list: @id,type,name;@ (see @method add_output_port@). set_outputs :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> GodotString -> IO () set_outputs cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_set_outputs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "set_outputs" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.set_outputs {-# NOINLINE bindVisualShaderNodeGroupBase_set_size #-} -- | The size of the node in the visual shader graph. bindVisualShaderNodeGroupBase_set_size :: MethodBind bindVisualShaderNodeGroupBase_set_size = unsafePerformIO $ withCString "VisualShaderNodeGroupBase" $ \ clsNamePtr -> withCString "set_size" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The size of the node in the visual shader graph. set_size :: (VisualShaderNodeGroupBase :< cls, Object :< cls) => cls -> Vector2 -> IO () set_size cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeGroupBase_set_size (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeGroupBase "set_size" '[Vector2] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeGroupBase.set_size ================================================ FILE: src/Godot/Core/VisualShaderNodeIf.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeIf () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeInput.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeInput (Godot.Core.VisualShaderNodeInput.sig_input_type_changed, Godot.Core.VisualShaderNodeInput.get_input_name, Godot.Core.VisualShaderNodeInput.get_input_real_name, Godot.Core.VisualShaderNodeInput.set_input_name) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() sig_input_type_changed :: Godot.Internal.Dispatch.Signal VisualShaderNodeInput sig_input_type_changed = Godot.Internal.Dispatch.Signal "input_type_changed" instance NodeSignal VisualShaderNodeInput "input_type_changed" '[] instance NodeProperty VisualShaderNodeInput "input_name" GodotString 'False where nodeProperty = (get_input_name, wrapDroppingSetter set_input_name, Nothing) {-# NOINLINE bindVisualShaderNodeInput_get_input_name #-} -- | One of the several input constants in lower-case style like: "vertex"(@VERTEX@) or "point_size"(@POINT_SIZE@). bindVisualShaderNodeInput_get_input_name :: MethodBind bindVisualShaderNodeInput_get_input_name = unsafePerformIO $ withCString "VisualShaderNodeInput" $ \ clsNamePtr -> withCString "get_input_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | One of the several input constants in lower-case style like: "vertex"(@VERTEX@) or "point_size"(@POINT_SIZE@). get_input_name :: (VisualShaderNodeInput :< cls, Object :< cls) => cls -> IO GodotString get_input_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeInput_get_input_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeInput "get_input_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeInput.get_input_name {-# NOINLINE bindVisualShaderNodeInput_get_input_real_name #-} bindVisualShaderNodeInput_get_input_real_name :: MethodBind bindVisualShaderNodeInput_get_input_real_name = unsafePerformIO $ withCString "VisualShaderNodeInput" $ \ clsNamePtr -> withCString "get_input_real_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_input_real_name :: (VisualShaderNodeInput :< cls, Object :< cls) => cls -> IO GodotString get_input_real_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeInput_get_input_real_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeInput "get_input_real_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeInput.get_input_real_name {-# NOINLINE bindVisualShaderNodeInput_set_input_name #-} -- | One of the several input constants in lower-case style like: "vertex"(@VERTEX@) or "point_size"(@POINT_SIZE@). bindVisualShaderNodeInput_set_input_name :: MethodBind bindVisualShaderNodeInput_set_input_name = unsafePerformIO $ withCString "VisualShaderNodeInput" $ \ clsNamePtr -> withCString "set_input_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | One of the several input constants in lower-case style like: "vertex"(@VERTEX@) or "point_size"(@POINT_SIZE@). set_input_name :: (VisualShaderNodeInput :< cls, Object :< cls) => cls -> GodotString -> IO () set_input_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeInput_set_input_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeInput "set_input_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeInput.set_input_name ================================================ FILE: src/Godot/Core/VisualShaderNodeIs.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeIs (Godot.Core.VisualShaderNodeIs._FUNC_IS_NAN, Godot.Core.VisualShaderNodeIs._FUNC_IS_INF, Godot.Core.VisualShaderNodeIs.get_function, Godot.Core.VisualShaderNodeIs.set_function) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _FUNC_IS_NAN :: Int _FUNC_IS_NAN = 1 _FUNC_IS_INF :: Int _FUNC_IS_INF = 0 instance NodeProperty VisualShaderNodeIs "function" Int 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) {-# NOINLINE bindVisualShaderNodeIs_get_function #-} -- | The comparison function. See @enum Function@ for options. bindVisualShaderNodeIs_get_function :: MethodBind bindVisualShaderNodeIs_get_function = unsafePerformIO $ withCString "VisualShaderNodeIs" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The comparison function. See @enum Function@ for options. get_function :: (VisualShaderNodeIs :< cls, Object :< cls) => cls -> IO Int get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeIs_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeIs "get_function" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeIs.get_function {-# NOINLINE bindVisualShaderNodeIs_set_function #-} -- | The comparison function. See @enum Function@ for options. bindVisualShaderNodeIs_set_function :: MethodBind bindVisualShaderNodeIs_set_function = unsafePerformIO $ withCString "VisualShaderNodeIs" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The comparison function. See @enum Function@ for options. set_function :: (VisualShaderNodeIs :< cls, Object :< cls) => cls -> Int -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeIs_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeIs "set_function" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeIs.set_function ================================================ FILE: src/Godot/Core/VisualShaderNodeOuterProduct.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeOuterProduct () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeOutput.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeOutput () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarClamp.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarClamp () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarConstant (Godot.Core.VisualShaderNodeScalarConstant.get_constant, Godot.Core.VisualShaderNodeScalarConstant.set_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() instance NodeProperty VisualShaderNodeScalarConstant "constant" Float 'False where nodeProperty = (get_constant, wrapDroppingSetter set_constant, Nothing) {-# NOINLINE bindVisualShaderNodeScalarConstant_get_constant #-} bindVisualShaderNodeScalarConstant_get_constant :: MethodBind bindVisualShaderNodeScalarConstant_get_constant = unsafePerformIO $ withCString "VisualShaderNodeScalarConstant" $ \ clsNamePtr -> withCString "get_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_constant :: (VisualShaderNodeScalarConstant :< cls, Object :< cls) => cls -> IO Float get_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeScalarConstant_get_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeScalarConstant "get_constant" '[] (IO Float) where nodeMethod = Godot.Core.VisualShaderNodeScalarConstant.get_constant {-# NOINLINE bindVisualShaderNodeScalarConstant_set_constant #-} bindVisualShaderNodeScalarConstant_set_constant :: MethodBind bindVisualShaderNodeScalarConstant_set_constant = unsafePerformIO $ withCString "VisualShaderNodeScalarConstant" $ \ clsNamePtr -> withCString "set_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_constant :: (VisualShaderNodeScalarConstant :< cls, Object :< cls) => cls -> Float -> IO () set_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeScalarConstant_set_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeScalarConstant "set_constant" '[Float] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeScalarConstant.set_constant ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarDerivativeFunc.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarDerivativeFunc (Godot.Core.VisualShaderNodeScalarDerivativeFunc._FUNC_SUM, Godot.Core.VisualShaderNodeScalarDerivativeFunc._FUNC_Y, Godot.Core.VisualShaderNodeScalarDerivativeFunc._FUNC_X, Godot.Core.VisualShaderNodeScalarDerivativeFunc.get_function, Godot.Core.VisualShaderNodeScalarDerivativeFunc.set_function) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _FUNC_SUM :: Int _FUNC_SUM = 0 _FUNC_Y :: Int _FUNC_Y = 2 _FUNC_X :: Int _FUNC_X = 1 instance NodeProperty VisualShaderNodeScalarDerivativeFunc "function" Int 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) {-# NOINLINE bindVisualShaderNodeScalarDerivativeFunc_get_function #-} -- | The derivative type. See @enum Function@ for options. bindVisualShaderNodeScalarDerivativeFunc_get_function :: MethodBind bindVisualShaderNodeScalarDerivativeFunc_get_function = unsafePerformIO $ withCString "VisualShaderNodeScalarDerivativeFunc" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The derivative type. See @enum Function@ for options. get_function :: (VisualShaderNodeScalarDerivativeFunc :< cls, Object :< cls) => cls -> IO Int get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeScalarDerivativeFunc_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeScalarDerivativeFunc "get_function" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeScalarDerivativeFunc.get_function {-# NOINLINE bindVisualShaderNodeScalarDerivativeFunc_set_function #-} -- | The derivative type. See @enum Function@ for options. bindVisualShaderNodeScalarDerivativeFunc_set_function :: MethodBind bindVisualShaderNodeScalarDerivativeFunc_set_function = unsafePerformIO $ withCString "VisualShaderNodeScalarDerivativeFunc" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The derivative type. See @enum Function@ for options. set_function :: (VisualShaderNodeScalarDerivativeFunc :< cls, Object :< cls) => cls -> Int -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeScalarDerivativeFunc_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeScalarDerivativeFunc "set_function" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeScalarDerivativeFunc.set_function ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarFunc.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarFunc (Godot.Core.VisualShaderNodeScalarFunc._FUNC_ASINH, Godot.Core.VisualShaderNodeScalarFunc._FUNC_RECIPROCAL, Godot.Core.VisualShaderNodeScalarFunc._FUNC_TRUNC, Godot.Core.VisualShaderNodeScalarFunc._FUNC_TAN, Godot.Core.VisualShaderNodeScalarFunc._FUNC_SQRT, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ATANH, Godot.Core.VisualShaderNodeScalarFunc._FUNC_RADIANS, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ATAN, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ROUNDEVEN, Godot.Core.VisualShaderNodeScalarFunc._FUNC_COS, Godot.Core.VisualShaderNodeScalarFunc._FUNC_DEGREES, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ASIN, Godot.Core.VisualShaderNodeScalarFunc._FUNC_EXP, Godot.Core.VisualShaderNodeScalarFunc._FUNC_LOG2, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ACOSH, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ACOS, Godot.Core.VisualShaderNodeScalarFunc._FUNC_FRAC, Godot.Core.VisualShaderNodeScalarFunc._FUNC_SIGN, Godot.Core.VisualShaderNodeScalarFunc._FUNC_INVERSE_SQRT, Godot.Core.VisualShaderNodeScalarFunc._FUNC_TANH, Godot.Core.VisualShaderNodeScalarFunc._FUNC_CEIL, Godot.Core.VisualShaderNodeScalarFunc._FUNC_LOG, Godot.Core.VisualShaderNodeScalarFunc._FUNC_SINH, Godot.Core.VisualShaderNodeScalarFunc._FUNC_NEGATE, Godot.Core.VisualShaderNodeScalarFunc._FUNC_SIN, Godot.Core.VisualShaderNodeScalarFunc._FUNC_SATURATE, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ROUND, Godot.Core.VisualShaderNodeScalarFunc._FUNC_COSH, Godot.Core.VisualShaderNodeScalarFunc._FUNC_EXP2, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ONEMINUS, Godot.Core.VisualShaderNodeScalarFunc._FUNC_ABS, Godot.Core.VisualShaderNodeScalarFunc._FUNC_FLOOR, Godot.Core.VisualShaderNodeScalarFunc.get_function, Godot.Core.VisualShaderNodeScalarFunc.set_function) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _FUNC_ASINH :: Int _FUNC_ASINH = 21 _FUNC_RECIPROCAL :: Int _FUNC_RECIPROCAL = 28 _FUNC_TRUNC :: Int _FUNC_TRUNC = 30 _FUNC_TAN :: Int _FUNC_TAN = 2 _FUNC_SQRT :: Int _FUNC_SQRT = 11 _FUNC_ATANH :: Int _FUNC_ATANH = 22 _FUNC_RADIANS :: Int _FUNC_RADIANS = 27 _FUNC_ATAN :: Int _FUNC_ATAN = 5 _FUNC_ROUNDEVEN :: Int _FUNC_ROUNDEVEN = 29 _FUNC_COS :: Int _FUNC_COS = 1 _FUNC_DEGREES :: Int _FUNC_DEGREES = 23 _FUNC_ASIN :: Int _FUNC_ASIN = 3 _FUNC_EXP :: Int _FUNC_EXP = 10 _FUNC_LOG2 :: Int _FUNC_LOG2 = 26 _FUNC_ACOSH :: Int _FUNC_ACOSH = 20 _FUNC_ACOS :: Int _FUNC_ACOS = 4 _FUNC_FRAC :: Int _FUNC_FRAC = 17 _FUNC_SIGN :: Int _FUNC_SIGN = 13 _FUNC_INVERSE_SQRT :: Int _FUNC_INVERSE_SQRT = 25 _FUNC_TANH :: Int _FUNC_TANH = 8 _FUNC_CEIL :: Int _FUNC_CEIL = 16 _FUNC_LOG :: Int _FUNC_LOG = 9 _FUNC_SINH :: Int _FUNC_SINH = 6 _FUNC_NEGATE :: Int _FUNC_NEGATE = 19 _FUNC_SIN :: Int _FUNC_SIN = 0 _FUNC_SATURATE :: Int _FUNC_SATURATE = 18 _FUNC_ROUND :: Int _FUNC_ROUND = 15 _FUNC_COSH :: Int _FUNC_COSH = 7 _FUNC_EXP2 :: Int _FUNC_EXP2 = 24 _FUNC_ONEMINUS :: Int _FUNC_ONEMINUS = 31 _FUNC_ABS :: Int _FUNC_ABS = 12 _FUNC_FLOOR :: Int _FUNC_FLOOR = 14 instance NodeProperty VisualShaderNodeScalarFunc "function" Int 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) {-# NOINLINE bindVisualShaderNodeScalarFunc_get_function #-} bindVisualShaderNodeScalarFunc_get_function :: MethodBind bindVisualShaderNodeScalarFunc_get_function = unsafePerformIO $ withCString "VisualShaderNodeScalarFunc" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_function :: (VisualShaderNodeScalarFunc :< cls, Object :< cls) => cls -> IO Int get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeScalarFunc_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeScalarFunc "get_function" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeScalarFunc.get_function {-# NOINLINE bindVisualShaderNodeScalarFunc_set_function #-} bindVisualShaderNodeScalarFunc_set_function :: MethodBind bindVisualShaderNodeScalarFunc_set_function = unsafePerformIO $ withCString "VisualShaderNodeScalarFunc" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_function :: (VisualShaderNodeScalarFunc :< cls, Object :< cls) => cls -> Int -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeScalarFunc_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeScalarFunc "set_function" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeScalarFunc.set_function ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarInterp.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarInterp () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarOp.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarOp (Godot.Core.VisualShaderNodeScalarOp._OP_MUL, Godot.Core.VisualShaderNodeScalarOp._OP_SUB, Godot.Core.VisualShaderNodeScalarOp._OP_MAX, Godot.Core.VisualShaderNodeScalarOp._OP_POW, Godot.Core.VisualShaderNodeScalarOp._OP_MOD, Godot.Core.VisualShaderNodeScalarOp._OP_ADD, Godot.Core.VisualShaderNodeScalarOp._OP_STEP, Godot.Core.VisualShaderNodeScalarOp._OP_MIN, Godot.Core.VisualShaderNodeScalarOp._OP_ATAN2, Godot.Core.VisualShaderNodeScalarOp._OP_DIV, Godot.Core.VisualShaderNodeScalarOp.get_operator, Godot.Core.VisualShaderNodeScalarOp.set_operator) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _OP_MUL :: Int _OP_MUL = 2 _OP_SUB :: Int _OP_SUB = 1 _OP_MAX :: Int _OP_MAX = 6 _OP_POW :: Int _OP_POW = 5 _OP_MOD :: Int _OP_MOD = 4 _OP_ADD :: Int _OP_ADD = 0 _OP_STEP :: Int _OP_STEP = 9 _OP_MIN :: Int _OP_MIN = 7 _OP_ATAN2 :: Int _OP_ATAN2 = 8 _OP_DIV :: Int _OP_DIV = 3 instance NodeProperty VisualShaderNodeScalarOp "operator" Int 'False where nodeProperty = (get_operator, wrapDroppingSetter set_operator, Nothing) {-# NOINLINE bindVisualShaderNodeScalarOp_get_operator #-} bindVisualShaderNodeScalarOp_get_operator :: MethodBind bindVisualShaderNodeScalarOp_get_operator = unsafePerformIO $ withCString "VisualShaderNodeScalarOp" $ \ clsNamePtr -> withCString "get_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_operator :: (VisualShaderNodeScalarOp :< cls, Object :< cls) => cls -> IO Int get_operator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeScalarOp_get_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeScalarOp "get_operator" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeScalarOp.get_operator {-# NOINLINE bindVisualShaderNodeScalarOp_set_operator #-} bindVisualShaderNodeScalarOp_set_operator :: MethodBind bindVisualShaderNodeScalarOp_set_operator = unsafePerformIO $ withCString "VisualShaderNodeScalarOp" $ \ clsNamePtr -> withCString "set_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_operator :: (VisualShaderNodeScalarOp :< cls, Object :< cls) => cls -> Int -> IO () set_operator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeScalarOp_set_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeScalarOp "set_operator" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeScalarOp.set_operator ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarSmoothStep.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarSmoothStep () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarSwitch.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarSwitch () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeSwitch() ================================================ FILE: src/Godot/Core/VisualShaderNodeScalarUniform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeScalarUniform () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeUniform() ================================================ FILE: src/Godot/Core/VisualShaderNodeSwitch.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeSwitch () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeTexture.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTexture (Godot.Core.VisualShaderNodeTexture._SOURCE_DEPTH, Godot.Core.VisualShaderNodeTexture._TYPE_DATA, Godot.Core.VisualShaderNodeTexture._SOURCE_2D_NORMAL, Godot.Core.VisualShaderNodeTexture._SOURCE_PORT, Godot.Core.VisualShaderNodeTexture._SOURCE_SCREEN, Godot.Core.VisualShaderNodeTexture._SOURCE_2D_TEXTURE, Godot.Core.VisualShaderNodeTexture._TYPE_COLOR, Godot.Core.VisualShaderNodeTexture._SOURCE_TEXTURE, Godot.Core.VisualShaderNodeTexture._TYPE_NORMALMAP, Godot.Core.VisualShaderNodeTexture.get_source, Godot.Core.VisualShaderNodeTexture.get_texture, Godot.Core.VisualShaderNodeTexture.get_texture_type, Godot.Core.VisualShaderNodeTexture.set_source, Godot.Core.VisualShaderNodeTexture.set_texture, Godot.Core.VisualShaderNodeTexture.set_texture_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _SOURCE_DEPTH :: Int _SOURCE_DEPTH = 4 _TYPE_DATA :: Int _TYPE_DATA = 0 _SOURCE_2D_NORMAL :: Int _SOURCE_2D_NORMAL = 3 _SOURCE_PORT :: Int _SOURCE_PORT = 5 _SOURCE_SCREEN :: Int _SOURCE_SCREEN = 1 _SOURCE_2D_TEXTURE :: Int _SOURCE_2D_TEXTURE = 2 _TYPE_COLOR :: Int _TYPE_COLOR = 1 _SOURCE_TEXTURE :: Int _SOURCE_TEXTURE = 0 _TYPE_NORMALMAP :: Int _TYPE_NORMALMAP = 2 instance NodeProperty VisualShaderNodeTexture "source" Int 'False where nodeProperty = (get_source, wrapDroppingSetter set_source, Nothing) instance NodeProperty VisualShaderNodeTexture "texture" Texture 'False where nodeProperty = (get_texture, wrapDroppingSetter set_texture, Nothing) instance NodeProperty VisualShaderNodeTexture "texture_type" Int 'False where nodeProperty = (get_texture_type, wrapDroppingSetter set_texture_type, Nothing) {-# NOINLINE bindVisualShaderNodeTexture_get_source #-} -- | Determines the source for the lookup. See @enum Source@ for options. bindVisualShaderNodeTexture_get_source :: MethodBind bindVisualShaderNodeTexture_get_source = unsafePerformIO $ withCString "VisualShaderNodeTexture" $ \ clsNamePtr -> withCString "get_source" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines the source for the lookup. See @enum Source@ for options. get_source :: (VisualShaderNodeTexture :< cls, Object :< cls) => cls -> IO Int get_source cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTexture_get_source (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTexture "get_source" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeTexture.get_source {-# NOINLINE bindVisualShaderNodeTexture_get_texture #-} -- | The source texture, if needed for the selected @source@. bindVisualShaderNodeTexture_get_texture :: MethodBind bindVisualShaderNodeTexture_get_texture = unsafePerformIO $ withCString "VisualShaderNodeTexture" $ \ clsNamePtr -> withCString "get_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The source texture, if needed for the selected @source@. get_texture :: (VisualShaderNodeTexture :< cls, Object :< cls) => cls -> IO Texture get_texture cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTexture_get_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTexture "get_texture" '[] (IO Texture) where nodeMethod = Godot.Core.VisualShaderNodeTexture.get_texture {-# NOINLINE bindVisualShaderNodeTexture_get_texture_type #-} -- | Specifies the type of the texture if @source@ is set to @SOURCE_TEXTURE@. See @enum TextureType@ for options. bindVisualShaderNodeTexture_get_texture_type :: MethodBind bindVisualShaderNodeTexture_get_texture_type = unsafePerformIO $ withCString "VisualShaderNodeTexture" $ \ clsNamePtr -> withCString "get_texture_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the type of the texture if @source@ is set to @SOURCE_TEXTURE@. See @enum TextureType@ for options. get_texture_type :: (VisualShaderNodeTexture :< cls, Object :< cls) => cls -> IO Int get_texture_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTexture_get_texture_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTexture "get_texture_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeTexture.get_texture_type {-# NOINLINE bindVisualShaderNodeTexture_set_source #-} -- | Determines the source for the lookup. See @enum Source@ for options. bindVisualShaderNodeTexture_set_source :: MethodBind bindVisualShaderNodeTexture_set_source = unsafePerformIO $ withCString "VisualShaderNodeTexture" $ \ clsNamePtr -> withCString "set_source" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Determines the source for the lookup. See @enum Source@ for options. set_source :: (VisualShaderNodeTexture :< cls, Object :< cls) => cls -> Int -> IO () set_source cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTexture_set_source (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTexture "set_source" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTexture.set_source {-# NOINLINE bindVisualShaderNodeTexture_set_texture #-} -- | The source texture, if needed for the selected @source@. bindVisualShaderNodeTexture_set_texture :: MethodBind bindVisualShaderNodeTexture_set_texture = unsafePerformIO $ withCString "VisualShaderNodeTexture" $ \ clsNamePtr -> withCString "set_texture" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The source texture, if needed for the selected @source@. set_texture :: (VisualShaderNodeTexture :< cls, Object :< cls) => cls -> Texture -> IO () set_texture cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTexture_set_texture (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTexture "set_texture" '[Texture] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTexture.set_texture {-# NOINLINE bindVisualShaderNodeTexture_set_texture_type #-} -- | Specifies the type of the texture if @source@ is set to @SOURCE_TEXTURE@. See @enum TextureType@ for options. bindVisualShaderNodeTexture_set_texture_type :: MethodBind bindVisualShaderNodeTexture_set_texture_type = unsafePerformIO $ withCString "VisualShaderNodeTexture" $ \ clsNamePtr -> withCString "set_texture_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Specifies the type of the texture if @source@ is set to @SOURCE_TEXTURE@. See @enum TextureType@ for options. set_texture_type :: (VisualShaderNodeTexture :< cls, Object :< cls) => cls -> Int -> IO () set_texture_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTexture_set_texture_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTexture "set_texture_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTexture.set_texture_type ================================================ FILE: src/Godot/Core/VisualShaderNodeTextureUniform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTextureUniform (Godot.Core.VisualShaderNodeTextureUniform._TYPE_DATA, Godot.Core.VisualShaderNodeTextureUniform._TYPE_ANISO, Godot.Core.VisualShaderNodeTextureUniform._COLOR_DEFAULT_WHITE, Godot.Core.VisualShaderNodeTextureUniform._TYPE_COLOR, Godot.Core.VisualShaderNodeTextureUniform._TYPE_NORMALMAP, Godot.Core.VisualShaderNodeTextureUniform._COLOR_DEFAULT_BLACK, Godot.Core.VisualShaderNodeTextureUniform.get_color_default, Godot.Core.VisualShaderNodeTextureUniform.get_texture_type, Godot.Core.VisualShaderNodeTextureUniform.set_color_default, Godot.Core.VisualShaderNodeTextureUniform.set_texture_type) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeUniform() _TYPE_DATA :: Int _TYPE_DATA = 0 _TYPE_ANISO :: Int _TYPE_ANISO = 3 _COLOR_DEFAULT_WHITE :: Int _COLOR_DEFAULT_WHITE = 0 _TYPE_COLOR :: Int _TYPE_COLOR = 1 _TYPE_NORMALMAP :: Int _TYPE_NORMALMAP = 2 _COLOR_DEFAULT_BLACK :: Int _COLOR_DEFAULT_BLACK = 1 instance NodeProperty VisualShaderNodeTextureUniform "color_default" Int 'False where nodeProperty = (get_color_default, wrapDroppingSetter set_color_default, Nothing) instance NodeProperty VisualShaderNodeTextureUniform "texture_type" Int 'False where nodeProperty = (get_texture_type, wrapDroppingSetter set_texture_type, Nothing) {-# NOINLINE bindVisualShaderNodeTextureUniform_get_color_default #-} -- | Sets the default color if no texture is assigned to the uniform. bindVisualShaderNodeTextureUniform_get_color_default :: MethodBind bindVisualShaderNodeTextureUniform_get_color_default = unsafePerformIO $ withCString "VisualShaderNodeTextureUniform" $ \ clsNamePtr -> withCString "get_color_default" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the default color if no texture is assigned to the uniform. get_color_default :: (VisualShaderNodeTextureUniform :< cls, Object :< cls) => cls -> IO Int get_color_default cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTextureUniform_get_color_default (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTextureUniform "get_color_default" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeTextureUniform.get_color_default {-# NOINLINE bindVisualShaderNodeTextureUniform_get_texture_type #-} -- | Defines the type of data provided by the source texture. See @enum TextureType@ for options. bindVisualShaderNodeTextureUniform_get_texture_type :: MethodBind bindVisualShaderNodeTextureUniform_get_texture_type = unsafePerformIO $ withCString "VisualShaderNodeTextureUniform" $ \ clsNamePtr -> withCString "get_texture_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the type of data provided by the source texture. See @enum TextureType@ for options. get_texture_type :: (VisualShaderNodeTextureUniform :< cls, Object :< cls) => cls -> IO Int get_texture_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTextureUniform_get_texture_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTextureUniform "get_texture_type" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeTextureUniform.get_texture_type {-# NOINLINE bindVisualShaderNodeTextureUniform_set_color_default #-} -- | Sets the default color if no texture is assigned to the uniform. bindVisualShaderNodeTextureUniform_set_color_default :: MethodBind bindVisualShaderNodeTextureUniform_set_color_default = unsafePerformIO $ withCString "VisualShaderNodeTextureUniform" $ \ clsNamePtr -> withCString "set_color_default" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the default color if no texture is assigned to the uniform. set_color_default :: (VisualShaderNodeTextureUniform :< cls, Object :< cls) => cls -> Int -> IO () set_color_default cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTextureUniform_set_color_default (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTextureUniform "set_color_default" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTextureUniform.set_color_default {-# NOINLINE bindVisualShaderNodeTextureUniform_set_texture_type #-} -- | Defines the type of data provided by the source texture. See @enum TextureType@ for options. bindVisualShaderNodeTextureUniform_set_texture_type :: MethodBind bindVisualShaderNodeTextureUniform_set_texture_type = unsafePerformIO $ withCString "VisualShaderNodeTextureUniform" $ \ clsNamePtr -> withCString "set_texture_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Defines the type of data provided by the source texture. See @enum TextureType@ for options. set_texture_type :: (VisualShaderNodeTextureUniform :< cls, Object :< cls) => cls -> Int -> IO () set_texture_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTextureUniform_set_texture_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTextureUniform "set_texture_type" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTextureUniform.set_texture_type ================================================ FILE: src/Godot/Core/VisualShaderNodeTextureUniformTriplanar.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTextureUniformTriplanar () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeTextureUniform() ================================================ FILE: src/Godot/Core/VisualShaderNodeTransformCompose.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTransformCompose () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeTransformConstant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTransformConstant (Godot.Core.VisualShaderNodeTransformConstant.get_constant, Godot.Core.VisualShaderNodeTransformConstant.set_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() instance NodeProperty VisualShaderNodeTransformConstant "constant" Transform 'False where nodeProperty = (get_constant, wrapDroppingSetter set_constant, Nothing) {-# NOINLINE bindVisualShaderNodeTransformConstant_get_constant #-} -- | A @Transform@ constant which represents the state of this node. bindVisualShaderNodeTransformConstant_get_constant :: MethodBind bindVisualShaderNodeTransformConstant_get_constant = unsafePerformIO $ withCString "VisualShaderNodeTransformConstant" $ \ clsNamePtr -> withCString "get_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Transform@ constant which represents the state of this node. get_constant :: (VisualShaderNodeTransformConstant :< cls, Object :< cls) => cls -> IO Transform get_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTransformConstant_get_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTransformConstant "get_constant" '[] (IO Transform) where nodeMethod = Godot.Core.VisualShaderNodeTransformConstant.get_constant {-# NOINLINE bindVisualShaderNodeTransformConstant_set_constant #-} -- | A @Transform@ constant which represents the state of this node. bindVisualShaderNodeTransformConstant_set_constant :: MethodBind bindVisualShaderNodeTransformConstant_set_constant = unsafePerformIO $ withCString "VisualShaderNodeTransformConstant" $ \ clsNamePtr -> withCString "set_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Transform@ constant which represents the state of this node. set_constant :: (VisualShaderNodeTransformConstant :< cls, Object :< cls) => cls -> Transform -> IO () set_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTransformConstant_set_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTransformConstant "set_constant" '[Transform] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTransformConstant.set_constant ================================================ FILE: src/Godot/Core/VisualShaderNodeTransformDecompose.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTransformDecompose () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeTransformFunc.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTransformFunc (Godot.Core.VisualShaderNodeTransformFunc._FUNC_TRANSPOSE, Godot.Core.VisualShaderNodeTransformFunc._FUNC_INVERSE, Godot.Core.VisualShaderNodeTransformFunc.get_function, Godot.Core.VisualShaderNodeTransformFunc.set_function) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _FUNC_TRANSPOSE :: Int _FUNC_TRANSPOSE = 1 _FUNC_INVERSE :: Int _FUNC_INVERSE = 0 instance NodeProperty VisualShaderNodeTransformFunc "function" Int 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) {-# NOINLINE bindVisualShaderNodeTransformFunc_get_function #-} -- | The function to be computed. See @enum Function@ for options. bindVisualShaderNodeTransformFunc_get_function :: MethodBind bindVisualShaderNodeTransformFunc_get_function = unsafePerformIO $ withCString "VisualShaderNodeTransformFunc" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The function to be computed. See @enum Function@ for options. get_function :: (VisualShaderNodeTransformFunc :< cls, Object :< cls) => cls -> IO Int get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTransformFunc_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTransformFunc "get_function" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeTransformFunc.get_function {-# NOINLINE bindVisualShaderNodeTransformFunc_set_function #-} -- | The function to be computed. See @enum Function@ for options. bindVisualShaderNodeTransformFunc_set_function :: MethodBind bindVisualShaderNodeTransformFunc_set_function = unsafePerformIO $ withCString "VisualShaderNodeTransformFunc" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The function to be computed. See @enum Function@ for options. set_function :: (VisualShaderNodeTransformFunc :< cls, Object :< cls) => cls -> Int -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTransformFunc_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTransformFunc "set_function" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTransformFunc.set_function ================================================ FILE: src/Godot/Core/VisualShaderNodeTransformMult.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTransformMult (Godot.Core.VisualShaderNodeTransformMult._OP_AxB_COMP, Godot.Core.VisualShaderNodeTransformMult._OP_BxA_COMP, Godot.Core.VisualShaderNodeTransformMult._OP_AxB, Godot.Core.VisualShaderNodeTransformMult._OP_BxA, Godot.Core.VisualShaderNodeTransformMult.get_operator, Godot.Core.VisualShaderNodeTransformMult.set_operator) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _OP_AxB_COMP :: Int _OP_AxB_COMP = 2 _OP_BxA_COMP :: Int _OP_BxA_COMP = 3 _OP_AxB :: Int _OP_AxB = 0 _OP_BxA :: Int _OP_BxA = 1 instance NodeProperty VisualShaderNodeTransformMult "operator" Int 'False where nodeProperty = (get_operator, wrapDroppingSetter set_operator, Nothing) {-# NOINLINE bindVisualShaderNodeTransformMult_get_operator #-} -- | The multiplication type to be performed on the transforms. See @enum Operator@ for options. bindVisualShaderNodeTransformMult_get_operator :: MethodBind bindVisualShaderNodeTransformMult_get_operator = unsafePerformIO $ withCString "VisualShaderNodeTransformMult" $ \ clsNamePtr -> withCString "get_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The multiplication type to be performed on the transforms. See @enum Operator@ for options. get_operator :: (VisualShaderNodeTransformMult :< cls, Object :< cls) => cls -> IO Int get_operator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTransformMult_get_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTransformMult "get_operator" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeTransformMult.get_operator {-# NOINLINE bindVisualShaderNodeTransformMult_set_operator #-} -- | The multiplication type to be performed on the transforms. See @enum Operator@ for options. bindVisualShaderNodeTransformMult_set_operator :: MethodBind bindVisualShaderNodeTransformMult_set_operator = unsafePerformIO $ withCString "VisualShaderNodeTransformMult" $ \ clsNamePtr -> withCString "set_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The multiplication type to be performed on the transforms. See @enum Operator@ for options. set_operator :: (VisualShaderNodeTransformMult :< cls, Object :< cls) => cls -> Int -> IO () set_operator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTransformMult_set_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTransformMult "set_operator" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTransformMult.set_operator ================================================ FILE: src/Godot/Core/VisualShaderNodeTransformUniform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTransformUniform () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeUniform() ================================================ FILE: src/Godot/Core/VisualShaderNodeTransformVecMult.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeTransformVecMult (Godot.Core.VisualShaderNodeTransformVecMult._OP_AxB, Godot.Core.VisualShaderNodeTransformVecMult._OP_BxA, Godot.Core.VisualShaderNodeTransformVecMult._OP_3x3_BxA, Godot.Core.VisualShaderNodeTransformVecMult._OP_3x3_AxB, Godot.Core.VisualShaderNodeTransformVecMult.get_operator, Godot.Core.VisualShaderNodeTransformVecMult.set_operator) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _OP_AxB :: Int _OP_AxB = 0 _OP_BxA :: Int _OP_BxA = 1 _OP_3x3_BxA :: Int _OP_3x3_BxA = 3 _OP_3x3_AxB :: Int _OP_3x3_AxB = 2 instance NodeProperty VisualShaderNodeTransformVecMult "operator" Int 'False where nodeProperty = (get_operator, wrapDroppingSetter set_operator, Nothing) {-# NOINLINE bindVisualShaderNodeTransformVecMult_get_operator #-} -- | The multiplication type to be performed. See @enum Operator@ for options. bindVisualShaderNodeTransformVecMult_get_operator :: MethodBind bindVisualShaderNodeTransformVecMult_get_operator = unsafePerformIO $ withCString "VisualShaderNodeTransformVecMult" $ \ clsNamePtr -> withCString "get_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The multiplication type to be performed. See @enum Operator@ for options. get_operator :: (VisualShaderNodeTransformVecMult :< cls, Object :< cls) => cls -> IO Int get_operator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTransformVecMult_get_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTransformVecMult "get_operator" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeTransformVecMult.get_operator {-# NOINLINE bindVisualShaderNodeTransformVecMult_set_operator #-} -- | The multiplication type to be performed. See @enum Operator@ for options. bindVisualShaderNodeTransformVecMult_set_operator :: MethodBind bindVisualShaderNodeTransformVecMult_set_operator = unsafePerformIO $ withCString "VisualShaderNodeTransformVecMult" $ \ clsNamePtr -> withCString "set_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The multiplication type to be performed. See @enum Operator@ for options. set_operator :: (VisualShaderNodeTransformVecMult :< cls, Object :< cls) => cls -> Int -> IO () set_operator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeTransformVecMult_set_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeTransformVecMult "set_operator" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeTransformVecMult.set_operator ================================================ FILE: src/Godot/Core/VisualShaderNodeUniform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeUniform (Godot.Core.VisualShaderNodeUniform.get_uniform_name, Godot.Core.VisualShaderNodeUniform.set_uniform_name) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() instance NodeProperty VisualShaderNodeUniform "uniform_name" GodotString 'False where nodeProperty = (get_uniform_name, wrapDroppingSetter set_uniform_name, Nothing) {-# NOINLINE bindVisualShaderNodeUniform_get_uniform_name #-} -- | Name of the uniform, by which it can be accessed through the @ShaderMaterial@ properties. bindVisualShaderNodeUniform_get_uniform_name :: MethodBind bindVisualShaderNodeUniform_get_uniform_name = unsafePerformIO $ withCString "VisualShaderNodeUniform" $ \ clsNamePtr -> withCString "get_uniform_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the uniform, by which it can be accessed through the @ShaderMaterial@ properties. get_uniform_name :: (VisualShaderNodeUniform :< cls, Object :< cls) => cls -> IO GodotString get_uniform_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeUniform_get_uniform_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeUniform "get_uniform_name" '[] (IO GodotString) where nodeMethod = Godot.Core.VisualShaderNodeUniform.get_uniform_name {-# NOINLINE bindVisualShaderNodeUniform_set_uniform_name #-} -- | Name of the uniform, by which it can be accessed through the @ShaderMaterial@ properties. bindVisualShaderNodeUniform_set_uniform_name :: MethodBind bindVisualShaderNodeUniform_set_uniform_name = unsafePerformIO $ withCString "VisualShaderNodeUniform" $ \ clsNamePtr -> withCString "set_uniform_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Name of the uniform, by which it can be accessed through the @ShaderMaterial@ properties. set_uniform_name :: (VisualShaderNodeUniform :< cls, Object :< cls) => cls -> GodotString -> IO () set_uniform_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeUniform_set_uniform_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeUniform "set_uniform_name" '[GodotString] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeUniform.set_uniform_name ================================================ FILE: src/Godot/Core/VisualShaderNodeVec3Constant.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVec3Constant (Godot.Core.VisualShaderNodeVec3Constant.get_constant, Godot.Core.VisualShaderNodeVec3Constant.set_constant) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() instance NodeProperty VisualShaderNodeVec3Constant "constant" Vector3 'False where nodeProperty = (get_constant, wrapDroppingSetter set_constant, Nothing) {-# NOINLINE bindVisualShaderNodeVec3Constant_get_constant #-} -- | A @Vector3@ constant which represents the state of this node. bindVisualShaderNodeVec3Constant_get_constant :: MethodBind bindVisualShaderNodeVec3Constant_get_constant = unsafePerformIO $ withCString "VisualShaderNodeVec3Constant" $ \ clsNamePtr -> withCString "get_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Vector3@ constant which represents the state of this node. get_constant :: (VisualShaderNodeVec3Constant :< cls, Object :< cls) => cls -> IO Vector3 get_constant cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeVec3Constant_get_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeVec3Constant "get_constant" '[] (IO Vector3) where nodeMethod = Godot.Core.VisualShaderNodeVec3Constant.get_constant {-# NOINLINE bindVisualShaderNodeVec3Constant_set_constant #-} -- | A @Vector3@ constant which represents the state of this node. bindVisualShaderNodeVec3Constant_set_constant :: MethodBind bindVisualShaderNodeVec3Constant_set_constant = unsafePerformIO $ withCString "VisualShaderNodeVec3Constant" $ \ clsNamePtr -> withCString "set_constant" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A @Vector3@ constant which represents the state of this node. set_constant :: (VisualShaderNodeVec3Constant :< cls, Object :< cls) => cls -> Vector3 -> IO () set_constant cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeVec3Constant_set_constant (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeVec3Constant "set_constant" '[Vector3] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeVec3Constant.set_constant ================================================ FILE: src/Godot/Core/VisualShaderNodeVec3Uniform.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVec3Uniform () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNodeUniform() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorClamp.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorClamp () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorCompose.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorCompose () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorDecompose.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorDecompose () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorDerivativeFunc.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorDerivativeFunc (Godot.Core.VisualShaderNodeVectorDerivativeFunc._FUNC_SUM, Godot.Core.VisualShaderNodeVectorDerivativeFunc._FUNC_Y, Godot.Core.VisualShaderNodeVectorDerivativeFunc._FUNC_X, Godot.Core.VisualShaderNodeVectorDerivativeFunc.get_function, Godot.Core.VisualShaderNodeVectorDerivativeFunc.set_function) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _FUNC_SUM :: Int _FUNC_SUM = 0 _FUNC_Y :: Int _FUNC_Y = 2 _FUNC_X :: Int _FUNC_X = 1 instance NodeProperty VisualShaderNodeVectorDerivativeFunc "function" Int 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) {-# NOINLINE bindVisualShaderNodeVectorDerivativeFunc_get_function #-} -- | A derivative type. See @enum Function@ for options. bindVisualShaderNodeVectorDerivativeFunc_get_function :: MethodBind bindVisualShaderNodeVectorDerivativeFunc_get_function = unsafePerformIO $ withCString "VisualShaderNodeVectorDerivativeFunc" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A derivative type. See @enum Function@ for options. get_function :: (VisualShaderNodeVectorDerivativeFunc :< cls, Object :< cls) => cls -> IO Int get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeVectorDerivativeFunc_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeVectorDerivativeFunc "get_function" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeVectorDerivativeFunc.get_function {-# NOINLINE bindVisualShaderNodeVectorDerivativeFunc_set_function #-} -- | A derivative type. See @enum Function@ for options. bindVisualShaderNodeVectorDerivativeFunc_set_function :: MethodBind bindVisualShaderNodeVectorDerivativeFunc_set_function = unsafePerformIO $ withCString "VisualShaderNodeVectorDerivativeFunc" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | A derivative type. See @enum Function@ for options. set_function :: (VisualShaderNodeVectorDerivativeFunc :< cls, Object :< cls) => cls -> Int -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeVectorDerivativeFunc_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeVectorDerivativeFunc "set_function" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeVectorDerivativeFunc.set_function ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorDistance.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorDistance () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorFunc.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorFunc (Godot.Core.VisualShaderNodeVectorFunc._FUNC_ASINH, Godot.Core.VisualShaderNodeVectorFunc._FUNC_NORMALIZE, Godot.Core.VisualShaderNodeVectorFunc._FUNC_RECIPROCAL, Godot.Core.VisualShaderNodeVectorFunc._FUNC_TRUNC, Godot.Core.VisualShaderNodeVectorFunc._FUNC_TAN, Godot.Core.VisualShaderNodeVectorFunc._FUNC_SQRT, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ATANH, Godot.Core.VisualShaderNodeVectorFunc._FUNC_RADIANS, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ATAN, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ROUNDEVEN, Godot.Core.VisualShaderNodeVectorFunc._FUNC_COS, Godot.Core.VisualShaderNodeVectorFunc._FUNC_DEGREES, Godot.Core.VisualShaderNodeVectorFunc._FUNC_HSV2RGB, Godot.Core.VisualShaderNodeVectorFunc._FUNC_RGB2HSV, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ASIN, Godot.Core.VisualShaderNodeVectorFunc._FUNC_EXP, Godot.Core.VisualShaderNodeVectorFunc._FUNC_LOG2, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ACOSH, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ACOS, Godot.Core.VisualShaderNodeVectorFunc._FUNC_FRAC, Godot.Core.VisualShaderNodeVectorFunc._FUNC_SIGN, Godot.Core.VisualShaderNodeVectorFunc._FUNC_INVERSE_SQRT, Godot.Core.VisualShaderNodeVectorFunc._FUNC_TANH, Godot.Core.VisualShaderNodeVectorFunc._FUNC_CEIL, Godot.Core.VisualShaderNodeVectorFunc._FUNC_LOG, Godot.Core.VisualShaderNodeVectorFunc._FUNC_SINH, Godot.Core.VisualShaderNodeVectorFunc._FUNC_NEGATE, Godot.Core.VisualShaderNodeVectorFunc._FUNC_SIN, Godot.Core.VisualShaderNodeVectorFunc._FUNC_SATURATE, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ROUND, Godot.Core.VisualShaderNodeVectorFunc._FUNC_COSH, Godot.Core.VisualShaderNodeVectorFunc._FUNC_EXP2, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ONEMINUS, Godot.Core.VisualShaderNodeVectorFunc._FUNC_ABS, Godot.Core.VisualShaderNodeVectorFunc._FUNC_FLOOR, Godot.Core.VisualShaderNodeVectorFunc.get_function, Godot.Core.VisualShaderNodeVectorFunc.set_function) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _FUNC_ASINH :: Int _FUNC_ASINH = 10 _FUNC_NORMALIZE :: Int _FUNC_NORMALIZE = 0 _FUNC_RECIPROCAL :: Int _FUNC_RECIPROCAL = 3 _FUNC_TRUNC :: Int _FUNC_TRUNC = 33 _FUNC_TAN :: Int _FUNC_TAN = 31 _FUNC_SQRT :: Int _FUNC_SQRT = 30 _FUNC_ATANH :: Int _FUNC_ATANH = 12 _FUNC_RADIANS :: Int _FUNC_RADIANS = 24 _FUNC_ATAN :: Int _FUNC_ATAN = 11 _FUNC_ROUNDEVEN :: Int _FUNC_ROUNDEVEN = 26 _FUNC_COS :: Int _FUNC_COS = 14 _FUNC_DEGREES :: Int _FUNC_DEGREES = 16 _FUNC_HSV2RGB :: Int _FUNC_HSV2RGB = 5 _FUNC_RGB2HSV :: Int _FUNC_RGB2HSV = 4 _FUNC_ASIN :: Int _FUNC_ASIN = 9 _FUNC_EXP :: Int _FUNC_EXP = 17 _FUNC_LOG2 :: Int _FUNC_LOG2 = 23 _FUNC_ACOSH :: Int _FUNC_ACOSH = 8 _FUNC_ACOS :: Int _FUNC_ACOS = 7 _FUNC_FRAC :: Int _FUNC_FRAC = 20 _FUNC_SIGN :: Int _FUNC_SIGN = 27 _FUNC_INVERSE_SQRT :: Int _FUNC_INVERSE_SQRT = 21 _FUNC_TANH :: Int _FUNC_TANH = 32 _FUNC_CEIL :: Int _FUNC_CEIL = 13 _FUNC_LOG :: Int _FUNC_LOG = 22 _FUNC_SINH :: Int _FUNC_SINH = 29 _FUNC_NEGATE :: Int _FUNC_NEGATE = 2 _FUNC_SIN :: Int _FUNC_SIN = 28 _FUNC_SATURATE :: Int _FUNC_SATURATE = 1 _FUNC_ROUND :: Int _FUNC_ROUND = 25 _FUNC_COSH :: Int _FUNC_COSH = 15 _FUNC_EXP2 :: Int _FUNC_EXP2 = 18 _FUNC_ONEMINUS :: Int _FUNC_ONEMINUS = 34 _FUNC_ABS :: Int _FUNC_ABS = 6 _FUNC_FLOOR :: Int _FUNC_FLOOR = 19 instance NodeProperty VisualShaderNodeVectorFunc "function" Int 'False where nodeProperty = (get_function, wrapDroppingSetter set_function, Nothing) {-# NOINLINE bindVisualShaderNodeVectorFunc_get_function #-} -- | The function to be performed. See @enum Function@ for options. bindVisualShaderNodeVectorFunc_get_function :: MethodBind bindVisualShaderNodeVectorFunc_get_function = unsafePerformIO $ withCString "VisualShaderNodeVectorFunc" $ \ clsNamePtr -> withCString "get_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The function to be performed. See @enum Function@ for options. get_function :: (VisualShaderNodeVectorFunc :< cls, Object :< cls) => cls -> IO Int get_function cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeVectorFunc_get_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeVectorFunc "get_function" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeVectorFunc.get_function {-# NOINLINE bindVisualShaderNodeVectorFunc_set_function #-} -- | The function to be performed. See @enum Function@ for options. bindVisualShaderNodeVectorFunc_set_function :: MethodBind bindVisualShaderNodeVectorFunc_set_function = unsafePerformIO $ withCString "VisualShaderNodeVectorFunc" $ \ clsNamePtr -> withCString "set_function" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The function to be performed. See @enum Function@ for options. set_function :: (VisualShaderNodeVectorFunc :< cls, Object :< cls) => cls -> Int -> IO () set_function cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeVectorFunc_set_function (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeVectorFunc "set_function" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeVectorFunc.set_function ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorInterp.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorInterp () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorLen.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorLen () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorOp.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorOp (Godot.Core.VisualShaderNodeVectorOp._OP_MUL, Godot.Core.VisualShaderNodeVectorOp._OP_SUB, Godot.Core.VisualShaderNodeVectorOp._OP_MAX, Godot.Core.VisualShaderNodeVectorOp._OP_POW, Godot.Core.VisualShaderNodeVectorOp._OP_MOD, Godot.Core.VisualShaderNodeVectorOp._OP_ADD, Godot.Core.VisualShaderNodeVectorOp._OP_REFLECT, Godot.Core.VisualShaderNodeVectorOp._OP_STEP, Godot.Core.VisualShaderNodeVectorOp._OP_MIN, Godot.Core.VisualShaderNodeVectorOp._OP_ATAN2, Godot.Core.VisualShaderNodeVectorOp._OP_DIV, Godot.Core.VisualShaderNodeVectorOp._OP_CROSS, Godot.Core.VisualShaderNodeVectorOp.get_operator, Godot.Core.VisualShaderNodeVectorOp.set_operator) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() _OP_MUL :: Int _OP_MUL = 2 _OP_SUB :: Int _OP_SUB = 1 _OP_MAX :: Int _OP_MAX = 6 _OP_POW :: Int _OP_POW = 5 _OP_MOD :: Int _OP_MOD = 4 _OP_ADD :: Int _OP_ADD = 0 _OP_REFLECT :: Int _OP_REFLECT = 10 _OP_STEP :: Int _OP_STEP = 11 _OP_MIN :: Int _OP_MIN = 7 _OP_ATAN2 :: Int _OP_ATAN2 = 9 _OP_DIV :: Int _OP_DIV = 3 _OP_CROSS :: Int _OP_CROSS = 8 instance NodeProperty VisualShaderNodeVectorOp "operator" Int 'False where nodeProperty = (get_operator, wrapDroppingSetter set_operator, Nothing) {-# NOINLINE bindVisualShaderNodeVectorOp_get_operator #-} -- | The operator to be used. See @enum Operator@ for options. bindVisualShaderNodeVectorOp_get_operator :: MethodBind bindVisualShaderNodeVectorOp_get_operator = unsafePerformIO $ withCString "VisualShaderNodeVectorOp" $ \ clsNamePtr -> withCString "get_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The operator to be used. See @enum Operator@ for options. get_operator :: (VisualShaderNodeVectorOp :< cls, Object :< cls) => cls -> IO Int get_operator cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeVectorOp_get_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeVectorOp "get_operator" '[] (IO Int) where nodeMethod = Godot.Core.VisualShaderNodeVectorOp.get_operator {-# NOINLINE bindVisualShaderNodeVectorOp_set_operator #-} -- | The operator to be used. See @enum Operator@ for options. bindVisualShaderNodeVectorOp_set_operator :: MethodBind bindVisualShaderNodeVectorOp_set_operator = unsafePerformIO $ withCString "VisualShaderNodeVectorOp" $ \ clsNamePtr -> withCString "set_operator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The operator to be used. See @enum Operator@ for options. set_operator :: (VisualShaderNodeVectorOp :< cls, Object :< cls) => cls -> Int -> IO () set_operator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindVisualShaderNodeVectorOp_set_operator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualShaderNodeVectorOp "set_operator" '[Int] (IO ()) where nodeMethod = Godot.Core.VisualShaderNodeVectorOp.set_operator ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorRefract.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorRefract () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorScalarMix.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorScalarMix () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorScalarSmoothStep.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorScalarSmoothStep () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorScalarStep.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorScalarStep () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/VisualShaderNodeVectorSmoothStep.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.VisualShaderNodeVectorSmoothStep () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.VisualShaderNode() ================================================ FILE: src/Godot/Core/WeakRef.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WeakRef (Godot.Core.WeakRef.get_ref) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindWeakRef_get_ref #-} -- | Returns the @Object@ this weakref is referring to. bindWeakRef_get_ref :: MethodBind bindWeakRef_get_ref = unsafePerformIO $ withCString "WeakRef" $ \ clsNamePtr -> withCString "get_ref" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @Object@ this weakref is referring to. get_ref :: (WeakRef :< cls, Object :< cls) => cls -> IO GodotVariant get_ref cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWeakRef_get_ref (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WeakRef "get_ref" '[] (IO GodotVariant) where nodeMethod = Godot.Core.WeakRef.get_ref ================================================ FILE: src/Godot/Core/WebRTCDataChannel.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebRTCDataChannel (Godot.Core.WebRTCDataChannel._STATE_CLOSED, Godot.Core.WebRTCDataChannel._WRITE_MODE_TEXT, Godot.Core.WebRTCDataChannel._STATE_CLOSING, Godot.Core.WebRTCDataChannel._STATE_CONNECTING, Godot.Core.WebRTCDataChannel._STATE_OPEN, Godot.Core.WebRTCDataChannel._WRITE_MODE_BINARY, Godot.Core.WebRTCDataChannel.close, Godot.Core.WebRTCDataChannel.get_id, Godot.Core.WebRTCDataChannel.get_label, Godot.Core.WebRTCDataChannel.get_max_packet_life_time, Godot.Core.WebRTCDataChannel.get_max_retransmits, Godot.Core.WebRTCDataChannel.get_protocol, Godot.Core.WebRTCDataChannel.get_ready_state, Godot.Core.WebRTCDataChannel.get_write_mode, Godot.Core.WebRTCDataChannel.is_negotiated, Godot.Core.WebRTCDataChannel.is_ordered, Godot.Core.WebRTCDataChannel.poll, Godot.Core.WebRTCDataChannel.set_write_mode, Godot.Core.WebRTCDataChannel.was_string_packet) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PacketPeer() _STATE_CLOSED :: Int _STATE_CLOSED = 3 _WRITE_MODE_TEXT :: Int _WRITE_MODE_TEXT = 0 _STATE_CLOSING :: Int _STATE_CLOSING = 2 _STATE_CONNECTING :: Int _STATE_CONNECTING = 0 _STATE_OPEN :: Int _STATE_OPEN = 1 _WRITE_MODE_BINARY :: Int _WRITE_MODE_BINARY = 1 instance NodeProperty WebRTCDataChannel "write_mode" Int 'False where nodeProperty = (get_write_mode, wrapDroppingSetter set_write_mode, Nothing) {-# NOINLINE bindWebRTCDataChannel_close #-} bindWebRTCDataChannel_close :: MethodBind bindWebRTCDataChannel_close = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "close" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr close :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO () close cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_close (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "close" '[] (IO ()) where nodeMethod = Godot.Core.WebRTCDataChannel.close {-# NOINLINE bindWebRTCDataChannel_get_id #-} bindWebRTCDataChannel_get_id :: MethodBind bindWebRTCDataChannel_get_id = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "get_id" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_id :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Int get_id cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_get_id (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "get_id" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCDataChannel.get_id {-# NOINLINE bindWebRTCDataChannel_get_label #-} bindWebRTCDataChannel_get_label :: MethodBind bindWebRTCDataChannel_get_label = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "get_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_label :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO GodotString get_label cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_get_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "get_label" '[] (IO GodotString) where nodeMethod = Godot.Core.WebRTCDataChannel.get_label {-# NOINLINE bindWebRTCDataChannel_get_max_packet_life_time #-} bindWebRTCDataChannel_get_max_packet_life_time :: MethodBind bindWebRTCDataChannel_get_max_packet_life_time = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "get_max_packet_life_time" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_max_packet_life_time :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Int get_max_packet_life_time cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_get_max_packet_life_time (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "get_max_packet_life_time" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCDataChannel.get_max_packet_life_time {-# NOINLINE bindWebRTCDataChannel_get_max_retransmits #-} bindWebRTCDataChannel_get_max_retransmits :: MethodBind bindWebRTCDataChannel_get_max_retransmits = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "get_max_retransmits" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_max_retransmits :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Int get_max_retransmits cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_get_max_retransmits (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "get_max_retransmits" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCDataChannel.get_max_retransmits {-# NOINLINE bindWebRTCDataChannel_get_protocol #-} bindWebRTCDataChannel_get_protocol :: MethodBind bindWebRTCDataChannel_get_protocol = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "get_protocol" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_protocol :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO GodotString get_protocol cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_get_protocol (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "get_protocol" '[] (IO GodotString) where nodeMethod = Godot.Core.WebRTCDataChannel.get_protocol {-# NOINLINE bindWebRTCDataChannel_get_ready_state #-} bindWebRTCDataChannel_get_ready_state :: MethodBind bindWebRTCDataChannel_get_ready_state = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "get_ready_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_ready_state :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Int get_ready_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_get_ready_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "get_ready_state" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCDataChannel.get_ready_state {-# NOINLINE bindWebRTCDataChannel_get_write_mode #-} bindWebRTCDataChannel_get_write_mode :: MethodBind bindWebRTCDataChannel_get_write_mode = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "get_write_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_write_mode :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Int get_write_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_get_write_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "get_write_mode" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCDataChannel.get_write_mode {-# NOINLINE bindWebRTCDataChannel_is_negotiated #-} bindWebRTCDataChannel_is_negotiated :: MethodBind bindWebRTCDataChannel_is_negotiated = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "is_negotiated" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_negotiated :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Bool is_negotiated cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_is_negotiated (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "is_negotiated" '[] (IO Bool) where nodeMethod = Godot.Core.WebRTCDataChannel.is_negotiated {-# NOINLINE bindWebRTCDataChannel_is_ordered #-} bindWebRTCDataChannel_is_ordered :: MethodBind bindWebRTCDataChannel_is_ordered = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "is_ordered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_ordered :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Bool is_ordered cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_is_ordered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "is_ordered" '[] (IO Bool) where nodeMethod = Godot.Core.WebRTCDataChannel.is_ordered {-# NOINLINE bindWebRTCDataChannel_poll #-} bindWebRTCDataChannel_poll :: MethodBind bindWebRTCDataChannel_poll = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "poll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr poll :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Int poll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_poll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "poll" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCDataChannel.poll {-# NOINLINE bindWebRTCDataChannel_set_write_mode #-} bindWebRTCDataChannel_set_write_mode :: MethodBind bindWebRTCDataChannel_set_write_mode = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "set_write_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_write_mode :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> Int -> IO () set_write_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_set_write_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "set_write_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.WebRTCDataChannel.set_write_mode {-# NOINLINE bindWebRTCDataChannel_was_string_packet #-} bindWebRTCDataChannel_was_string_packet :: MethodBind bindWebRTCDataChannel_was_string_packet = unsafePerformIO $ withCString "WebRTCDataChannel" $ \ clsNamePtr -> withCString "was_string_packet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr was_string_packet :: (WebRTCDataChannel :< cls, Object :< cls) => cls -> IO Bool was_string_packet cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCDataChannel_was_string_packet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCDataChannel "was_string_packet" '[] (IO Bool) where nodeMethod = Godot.Core.WebRTCDataChannel.was_string_packet ================================================ FILE: src/Godot/Core/WebRTCDataChannelGDNative.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebRTCDataChannelGDNative () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.WebRTCDataChannel() ================================================ FILE: src/Godot/Core/WebRTCMultiplayer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebRTCMultiplayer (Godot.Core.WebRTCMultiplayer.add_peer, Godot.Core.WebRTCMultiplayer.close, Godot.Core.WebRTCMultiplayer.get_peer, Godot.Core.WebRTCMultiplayer.get_peers, Godot.Core.WebRTCMultiplayer.has_peer, Godot.Core.WebRTCMultiplayer.initialize, Godot.Core.WebRTCMultiplayer.remove_peer) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.NetworkedMultiplayerPeer() {-# NOINLINE bindWebRTCMultiplayer_add_peer #-} bindWebRTCMultiplayer_add_peer :: MethodBind bindWebRTCMultiplayer_add_peer = unsafePerformIO $ withCString "WebRTCMultiplayer" $ \ clsNamePtr -> withCString "add_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_peer :: (WebRTCMultiplayer :< cls, Object :< cls) => cls -> WebRTCPeerConnection -> Int -> Maybe Int -> IO Int add_peer cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantInt (1)) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCMultiplayer_add_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCMultiplayer "add_peer" '[WebRTCPeerConnection, Int, Maybe Int] (IO Int) where nodeMethod = Godot.Core.WebRTCMultiplayer.add_peer {-# NOINLINE bindWebRTCMultiplayer_close #-} bindWebRTCMultiplayer_close :: MethodBind bindWebRTCMultiplayer_close = unsafePerformIO $ withCString "WebRTCMultiplayer" $ \ clsNamePtr -> withCString "close" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr close :: (WebRTCMultiplayer :< cls, Object :< cls) => cls -> IO () close cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCMultiplayer_close (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCMultiplayer "close" '[] (IO ()) where nodeMethod = Godot.Core.WebRTCMultiplayer.close {-# NOINLINE bindWebRTCMultiplayer_get_peer #-} bindWebRTCMultiplayer_get_peer :: MethodBind bindWebRTCMultiplayer_get_peer = unsafePerformIO $ withCString "WebRTCMultiplayer" $ \ clsNamePtr -> withCString "get_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_peer :: (WebRTCMultiplayer :< cls, Object :< cls) => cls -> Int -> IO Dictionary get_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCMultiplayer_get_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCMultiplayer "get_peer" '[Int] (IO Dictionary) where nodeMethod = Godot.Core.WebRTCMultiplayer.get_peer {-# NOINLINE bindWebRTCMultiplayer_get_peers #-} bindWebRTCMultiplayer_get_peers :: MethodBind bindWebRTCMultiplayer_get_peers = unsafePerformIO $ withCString "WebRTCMultiplayer" $ \ clsNamePtr -> withCString "get_peers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_peers :: (WebRTCMultiplayer :< cls, Object :< cls) => cls -> IO Dictionary get_peers cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCMultiplayer_get_peers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCMultiplayer "get_peers" '[] (IO Dictionary) where nodeMethod = Godot.Core.WebRTCMultiplayer.get_peers {-# NOINLINE bindWebRTCMultiplayer_has_peer #-} bindWebRTCMultiplayer_has_peer :: MethodBind bindWebRTCMultiplayer_has_peer = unsafePerformIO $ withCString "WebRTCMultiplayer" $ \ clsNamePtr -> withCString "has_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_peer :: (WebRTCMultiplayer :< cls, Object :< cls) => cls -> Int -> IO Bool has_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCMultiplayer_has_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCMultiplayer "has_peer" '[Int] (IO Bool) where nodeMethod = Godot.Core.WebRTCMultiplayer.has_peer {-# NOINLINE bindWebRTCMultiplayer_initialize #-} bindWebRTCMultiplayer_initialize :: MethodBind bindWebRTCMultiplayer_initialize = unsafePerformIO $ withCString "WebRTCMultiplayer" $ \ clsNamePtr -> withCString "initialize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr initialize :: (WebRTCMultiplayer :< cls, Object :< cls) => cls -> Int -> Maybe Bool -> IO Int initialize cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCMultiplayer_initialize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCMultiplayer "initialize" '[Int, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.WebRTCMultiplayer.initialize {-# NOINLINE bindWebRTCMultiplayer_remove_peer #-} bindWebRTCMultiplayer_remove_peer :: MethodBind bindWebRTCMultiplayer_remove_peer = unsafePerformIO $ withCString "WebRTCMultiplayer" $ \ clsNamePtr -> withCString "remove_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_peer :: (WebRTCMultiplayer :< cls, Object :< cls) => cls -> Int -> IO () remove_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCMultiplayer_remove_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCMultiplayer "remove_peer" '[Int] (IO ()) where nodeMethod = Godot.Core.WebRTCMultiplayer.remove_peer ================================================ FILE: src/Godot/Core/WebRTCPeerConnection.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebRTCPeerConnection (Godot.Core.WebRTCPeerConnection._STATE_CONNECTED, Godot.Core.WebRTCPeerConnection._STATE_CLOSED, Godot.Core.WebRTCPeerConnection._STATE_CONNECTING, Godot.Core.WebRTCPeerConnection._STATE_DISCONNECTED, Godot.Core.WebRTCPeerConnection._STATE_NEW, Godot.Core.WebRTCPeerConnection._STATE_FAILED, Godot.Core.WebRTCPeerConnection.sig_data_channel_received, Godot.Core.WebRTCPeerConnection.sig_ice_candidate_created, Godot.Core.WebRTCPeerConnection.sig_session_description_created, Godot.Core.WebRTCPeerConnection.add_ice_candidate, Godot.Core.WebRTCPeerConnection.close, Godot.Core.WebRTCPeerConnection.create_data_channel, Godot.Core.WebRTCPeerConnection.create_offer, Godot.Core.WebRTCPeerConnection.get_connection_state, Godot.Core.WebRTCPeerConnection.initialize, Godot.Core.WebRTCPeerConnection.poll, Godot.Core.WebRTCPeerConnection.set_local_description, Godot.Core.WebRTCPeerConnection.set_remote_description) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _STATE_CONNECTED :: Int _STATE_CONNECTED = 2 _STATE_CLOSED :: Int _STATE_CLOSED = 5 _STATE_CONNECTING :: Int _STATE_CONNECTING = 1 _STATE_DISCONNECTED :: Int _STATE_DISCONNECTED = 3 _STATE_NEW :: Int _STATE_NEW = 0 _STATE_FAILED :: Int _STATE_FAILED = 4 sig_data_channel_received :: Godot.Internal.Dispatch.Signal WebRTCPeerConnection sig_data_channel_received = Godot.Internal.Dispatch.Signal "data_channel_received" instance NodeSignal WebRTCPeerConnection "data_channel_received" '[Object] sig_ice_candidate_created :: Godot.Internal.Dispatch.Signal WebRTCPeerConnection sig_ice_candidate_created = Godot.Internal.Dispatch.Signal "ice_candidate_created" instance NodeSignal WebRTCPeerConnection "ice_candidate_created" '[GodotString, Int, GodotString] sig_session_description_created :: Godot.Internal.Dispatch.Signal WebRTCPeerConnection sig_session_description_created = Godot.Internal.Dispatch.Signal "session_description_created" instance NodeSignal WebRTCPeerConnection "session_description_created" '[GodotString, GodotString] {-# NOINLINE bindWebRTCPeerConnection_add_ice_candidate #-} bindWebRTCPeerConnection_add_ice_candidate :: MethodBind bindWebRTCPeerConnection_add_ice_candidate = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "add_ice_candidate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_ice_candidate :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> GodotString -> Int -> GodotString -> IO Int add_ice_candidate cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_add_ice_candidate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "add_ice_candidate" '[GodotString, Int, GodotString] (IO Int) where nodeMethod = Godot.Core.WebRTCPeerConnection.add_ice_candidate {-# NOINLINE bindWebRTCPeerConnection_close #-} bindWebRTCPeerConnection_close :: MethodBind bindWebRTCPeerConnection_close = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "close" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr close :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> IO () close cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_close (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "close" '[] (IO ()) where nodeMethod = Godot.Core.WebRTCPeerConnection.close {-# NOINLINE bindWebRTCPeerConnection_create_data_channel #-} bindWebRTCPeerConnection_create_data_channel :: MethodBind bindWebRTCPeerConnection_create_data_channel = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "create_data_channel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr create_data_channel :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> GodotString -> Maybe Dictionary -> IO WebRTCDataChannel create_data_channel cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantDictionary V.empty arg2] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_create_data_channel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "create_data_channel" '[GodotString, Maybe Dictionary] (IO WebRTCDataChannel) where nodeMethod = Godot.Core.WebRTCPeerConnection.create_data_channel {-# NOINLINE bindWebRTCPeerConnection_create_offer #-} bindWebRTCPeerConnection_create_offer :: MethodBind bindWebRTCPeerConnection_create_offer = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "create_offer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr create_offer :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> IO Int create_offer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_create_offer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "create_offer" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCPeerConnection.create_offer {-# NOINLINE bindWebRTCPeerConnection_get_connection_state #-} bindWebRTCPeerConnection_get_connection_state :: MethodBind bindWebRTCPeerConnection_get_connection_state = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "get_connection_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_connection_state :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> IO Int get_connection_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_get_connection_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "get_connection_state" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCPeerConnection.get_connection_state {-# NOINLINE bindWebRTCPeerConnection_initialize #-} bindWebRTCPeerConnection_initialize :: MethodBind bindWebRTCPeerConnection_initialize = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "initialize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr initialize :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> Maybe Dictionary -> IO Int initialize cls arg1 = withVariantArray [defaultedVariant VariantDictionary V.empty arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_initialize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "initialize" '[Maybe Dictionary] (IO Int) where nodeMethod = Godot.Core.WebRTCPeerConnection.initialize {-# NOINLINE bindWebRTCPeerConnection_poll #-} bindWebRTCPeerConnection_poll :: MethodBind bindWebRTCPeerConnection_poll = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "poll" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr poll :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> IO Int poll cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_poll (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "poll" '[] (IO Int) where nodeMethod = Godot.Core.WebRTCPeerConnection.poll {-# NOINLINE bindWebRTCPeerConnection_set_local_description #-} bindWebRTCPeerConnection_set_local_description :: MethodBind bindWebRTCPeerConnection_set_local_description = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "set_local_description" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_local_description :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int set_local_description cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_set_local_description (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "set_local_description" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.WebRTCPeerConnection.set_local_description {-# NOINLINE bindWebRTCPeerConnection_set_remote_description #-} bindWebRTCPeerConnection_set_remote_description :: MethodBind bindWebRTCPeerConnection_set_remote_description = unsafePerformIO $ withCString "WebRTCPeerConnection" $ \ clsNamePtr -> withCString "set_remote_description" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_remote_description :: (WebRTCPeerConnection :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Int set_remote_description cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindWebRTCPeerConnection_set_remote_description (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebRTCPeerConnection "set_remote_description" '[GodotString, GodotString] (IO Int) where nodeMethod = Godot.Core.WebRTCPeerConnection.set_remote_description ================================================ FILE: src/Godot/Core/WebRTCPeerConnectionGDNative.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebRTCPeerConnectionGDNative () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.WebRTCPeerConnection() ================================================ FILE: src/Godot/Core/WebSocketClient.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebSocketClient (Godot.Core.WebSocketClient.sig_connection_closed, Godot.Core.WebSocketClient.sig_connection_error, Godot.Core.WebSocketClient.sig_connection_established, Godot.Core.WebSocketClient.sig_data_received, Godot.Core.WebSocketClient.sig_server_close_request, Godot.Core.WebSocketClient.connect_to_url, Godot.Core.WebSocketClient.disconnect_from_host, Godot.Core.WebSocketClient.get_connected_host, Godot.Core.WebSocketClient.get_connected_port, Godot.Core.WebSocketClient.get_trusted_ssl_certificate, Godot.Core.WebSocketClient.is_verify_ssl_enabled, Godot.Core.WebSocketClient.set_trusted_ssl_certificate, Godot.Core.WebSocketClient.set_verify_ssl_enabled) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.WebSocketMultiplayerPeer() sig_connection_closed :: Godot.Internal.Dispatch.Signal WebSocketClient sig_connection_closed = Godot.Internal.Dispatch.Signal "connection_closed" instance NodeSignal WebSocketClient "connection_closed" '[Bool] sig_connection_error :: Godot.Internal.Dispatch.Signal WebSocketClient sig_connection_error = Godot.Internal.Dispatch.Signal "connection_error" instance NodeSignal WebSocketClient "connection_error" '[] sig_connection_established :: Godot.Internal.Dispatch.Signal WebSocketClient sig_connection_established = Godot.Internal.Dispatch.Signal "connection_established" instance NodeSignal WebSocketClient "connection_established" '[GodotString] sig_data_received :: Godot.Internal.Dispatch.Signal WebSocketClient sig_data_received = Godot.Internal.Dispatch.Signal "data_received" instance NodeSignal WebSocketClient "data_received" '[] sig_server_close_request :: Godot.Internal.Dispatch.Signal WebSocketClient sig_server_close_request = Godot.Internal.Dispatch.Signal "server_close_request" instance NodeSignal WebSocketClient "server_close_request" '[Int, GodotString] instance NodeProperty WebSocketClient "trusted_ssl_certificate" X509Certificate 'False where nodeProperty = (get_trusted_ssl_certificate, wrapDroppingSetter set_trusted_ssl_certificate, Nothing) instance NodeProperty WebSocketClient "verify_ssl" Bool 'False where nodeProperty = (is_verify_ssl_enabled, wrapDroppingSetter set_verify_ssl_enabled, Nothing) {-# NOINLINE bindWebSocketClient_connect_to_url #-} bindWebSocketClient_connect_to_url :: MethodBind bindWebSocketClient_connect_to_url = unsafePerformIO $ withCString "WebSocketClient" $ \ clsNamePtr -> withCString "connect_to_url" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr connect_to_url :: (WebSocketClient :< cls, Object :< cls) => cls -> GodotString -> Maybe PoolStringArray -> Maybe Bool -> Maybe PoolStringArray -> IO Int connect_to_url cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, defaultedVariant VariantPoolStringArray V.empty arg2, maybe (VariantBool False) toVariant arg3, defaultedVariant VariantPoolStringArray V.empty arg4] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketClient_connect_to_url (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketClient "connect_to_url" '[GodotString, Maybe PoolStringArray, Maybe Bool, Maybe PoolStringArray] (IO Int) where nodeMethod = Godot.Core.WebSocketClient.connect_to_url {-# NOINLINE bindWebSocketClient_disconnect_from_host #-} bindWebSocketClient_disconnect_from_host :: MethodBind bindWebSocketClient_disconnect_from_host = unsafePerformIO $ withCString "WebSocketClient" $ \ clsNamePtr -> withCString "disconnect_from_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr disconnect_from_host :: (WebSocketClient :< cls, Object :< cls) => cls -> Maybe Int -> Maybe GodotString -> IO () disconnect_from_host cls arg1 arg2 = withVariantArray [maybe (VariantInt (1000)) toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketClient_disconnect_from_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketClient "disconnect_from_host" '[Maybe Int, Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.WebSocketClient.disconnect_from_host {-# NOINLINE bindWebSocketClient_get_connected_host #-} bindWebSocketClient_get_connected_host :: MethodBind bindWebSocketClient_get_connected_host = unsafePerformIO $ withCString "WebSocketClient" $ \ clsNamePtr -> withCString "get_connected_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_connected_host :: (WebSocketClient :< cls, Object :< cls) => cls -> IO GodotString get_connected_host cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketClient_get_connected_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketClient "get_connected_host" '[] (IO GodotString) where nodeMethod = Godot.Core.WebSocketClient.get_connected_host {-# NOINLINE bindWebSocketClient_get_connected_port #-} bindWebSocketClient_get_connected_port :: MethodBind bindWebSocketClient_get_connected_port = unsafePerformIO $ withCString "WebSocketClient" $ \ clsNamePtr -> withCString "get_connected_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_connected_port :: (WebSocketClient :< cls, Object :< cls) => cls -> IO Int get_connected_port cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketClient_get_connected_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketClient "get_connected_port" '[] (IO Int) where nodeMethod = Godot.Core.WebSocketClient.get_connected_port {-# NOINLINE bindWebSocketClient_get_trusted_ssl_certificate #-} bindWebSocketClient_get_trusted_ssl_certificate :: MethodBind bindWebSocketClient_get_trusted_ssl_certificate = unsafePerformIO $ withCString "WebSocketClient" $ \ clsNamePtr -> withCString "get_trusted_ssl_certificate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_trusted_ssl_certificate :: (WebSocketClient :< cls, Object :< cls) => cls -> IO X509Certificate get_trusted_ssl_certificate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketClient_get_trusted_ssl_certificate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketClient "get_trusted_ssl_certificate" '[] (IO X509Certificate) where nodeMethod = Godot.Core.WebSocketClient.get_trusted_ssl_certificate {-# NOINLINE bindWebSocketClient_is_verify_ssl_enabled #-} bindWebSocketClient_is_verify_ssl_enabled :: MethodBind bindWebSocketClient_is_verify_ssl_enabled = unsafePerformIO $ withCString "WebSocketClient" $ \ clsNamePtr -> withCString "is_verify_ssl_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_verify_ssl_enabled :: (WebSocketClient :< cls, Object :< cls) => cls -> IO Bool is_verify_ssl_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketClient_is_verify_ssl_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketClient "is_verify_ssl_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.WebSocketClient.is_verify_ssl_enabled {-# NOINLINE bindWebSocketClient_set_trusted_ssl_certificate #-} bindWebSocketClient_set_trusted_ssl_certificate :: MethodBind bindWebSocketClient_set_trusted_ssl_certificate = unsafePerformIO $ withCString "WebSocketClient" $ \ clsNamePtr -> withCString "set_trusted_ssl_certificate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_trusted_ssl_certificate :: (WebSocketClient :< cls, Object :< cls) => cls -> X509Certificate -> IO () set_trusted_ssl_certificate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketClient_set_trusted_ssl_certificate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketClient "set_trusted_ssl_certificate" '[X509Certificate] (IO ()) where nodeMethod = Godot.Core.WebSocketClient.set_trusted_ssl_certificate {-# NOINLINE bindWebSocketClient_set_verify_ssl_enabled #-} bindWebSocketClient_set_verify_ssl_enabled :: MethodBind bindWebSocketClient_set_verify_ssl_enabled = unsafePerformIO $ withCString "WebSocketClient" $ \ clsNamePtr -> withCString "set_verify_ssl_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_verify_ssl_enabled :: (WebSocketClient :< cls, Object :< cls) => cls -> Bool -> IO () set_verify_ssl_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketClient_set_verify_ssl_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketClient "set_verify_ssl_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.WebSocketClient.set_verify_ssl_enabled ================================================ FILE: src/Godot/Core/WebSocketMultiplayerPeer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebSocketMultiplayerPeer (Godot.Core.WebSocketMultiplayerPeer.sig_peer_packet, Godot.Core.WebSocketMultiplayerPeer.get_peer, Godot.Core.WebSocketMultiplayerPeer.set_buffers) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.NetworkedMultiplayerPeer() sig_peer_packet :: Godot.Internal.Dispatch.Signal WebSocketMultiplayerPeer sig_peer_packet = Godot.Internal.Dispatch.Signal "peer_packet" instance NodeSignal WebSocketMultiplayerPeer "peer_packet" '[Int] {-# NOINLINE bindWebSocketMultiplayerPeer_get_peer #-} bindWebSocketMultiplayerPeer_get_peer :: MethodBind bindWebSocketMultiplayerPeer_get_peer = unsafePerformIO $ withCString "WebSocketMultiplayerPeer" $ \ clsNamePtr -> withCString "get_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_peer :: (WebSocketMultiplayerPeer :< cls, Object :< cls) => cls -> Int -> IO WebSocketPeer get_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketMultiplayerPeer_get_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketMultiplayerPeer "get_peer" '[Int] (IO WebSocketPeer) where nodeMethod = Godot.Core.WebSocketMultiplayerPeer.get_peer {-# NOINLINE bindWebSocketMultiplayerPeer_set_buffers #-} bindWebSocketMultiplayerPeer_set_buffers :: MethodBind bindWebSocketMultiplayerPeer_set_buffers = unsafePerformIO $ withCString "WebSocketMultiplayerPeer" $ \ clsNamePtr -> withCString "set_buffers" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_buffers :: (WebSocketMultiplayerPeer :< cls, Object :< cls) => cls -> Int -> Int -> Int -> Int -> IO Int set_buffers cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketMultiplayerPeer_set_buffers (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketMultiplayerPeer "set_buffers" '[Int, Int, Int, Int] (IO Int) where nodeMethod = Godot.Core.WebSocketMultiplayerPeer.set_buffers ================================================ FILE: src/Godot/Core/WebSocketPeer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebSocketPeer (Godot.Core.WebSocketPeer._WRITE_MODE_TEXT, Godot.Core.WebSocketPeer._WRITE_MODE_BINARY, Godot.Core.WebSocketPeer.close, Godot.Core.WebSocketPeer.get_connected_host, Godot.Core.WebSocketPeer.get_connected_port, Godot.Core.WebSocketPeer.get_write_mode, Godot.Core.WebSocketPeer.is_connected_to_host, Godot.Core.WebSocketPeer.set_no_delay, Godot.Core.WebSocketPeer.set_write_mode, Godot.Core.WebSocketPeer.was_string_packet) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PacketPeer() _WRITE_MODE_TEXT :: Int _WRITE_MODE_TEXT = 0 _WRITE_MODE_BINARY :: Int _WRITE_MODE_BINARY = 1 {-# NOINLINE bindWebSocketPeer_close #-} bindWebSocketPeer_close :: MethodBind bindWebSocketPeer_close = unsafePerformIO $ withCString "WebSocketPeer" $ \ clsNamePtr -> withCString "close" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr close :: (WebSocketPeer :< cls, Object :< cls) => cls -> Maybe Int -> Maybe GodotString -> IO () close cls arg1 arg2 = withVariantArray [maybe (VariantInt (1000)) toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketPeer_close (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketPeer "close" '[Maybe Int, Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.WebSocketPeer.close {-# NOINLINE bindWebSocketPeer_get_connected_host #-} bindWebSocketPeer_get_connected_host :: MethodBind bindWebSocketPeer_get_connected_host = unsafePerformIO $ withCString "WebSocketPeer" $ \ clsNamePtr -> withCString "get_connected_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_connected_host :: (WebSocketPeer :< cls, Object :< cls) => cls -> IO GodotString get_connected_host cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketPeer_get_connected_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketPeer "get_connected_host" '[] (IO GodotString) where nodeMethod = Godot.Core.WebSocketPeer.get_connected_host {-# NOINLINE bindWebSocketPeer_get_connected_port #-} bindWebSocketPeer_get_connected_port :: MethodBind bindWebSocketPeer_get_connected_port = unsafePerformIO $ withCString "WebSocketPeer" $ \ clsNamePtr -> withCString "get_connected_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_connected_port :: (WebSocketPeer :< cls, Object :< cls) => cls -> IO Int get_connected_port cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketPeer_get_connected_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketPeer "get_connected_port" '[] (IO Int) where nodeMethod = Godot.Core.WebSocketPeer.get_connected_port {-# NOINLINE bindWebSocketPeer_get_write_mode #-} bindWebSocketPeer_get_write_mode :: MethodBind bindWebSocketPeer_get_write_mode = unsafePerformIO $ withCString "WebSocketPeer" $ \ clsNamePtr -> withCString "get_write_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_write_mode :: (WebSocketPeer :< cls, Object :< cls) => cls -> IO Int get_write_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketPeer_get_write_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketPeer "get_write_mode" '[] (IO Int) where nodeMethod = Godot.Core.WebSocketPeer.get_write_mode {-# NOINLINE bindWebSocketPeer_is_connected_to_host #-} bindWebSocketPeer_is_connected_to_host :: MethodBind bindWebSocketPeer_is_connected_to_host = unsafePerformIO $ withCString "WebSocketPeer" $ \ clsNamePtr -> withCString "is_connected_to_host" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_connected_to_host :: (WebSocketPeer :< cls, Object :< cls) => cls -> IO Bool is_connected_to_host cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketPeer_is_connected_to_host (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketPeer "is_connected_to_host" '[] (IO Bool) where nodeMethod = Godot.Core.WebSocketPeer.is_connected_to_host {-# NOINLINE bindWebSocketPeer_set_no_delay #-} bindWebSocketPeer_set_no_delay :: MethodBind bindWebSocketPeer_set_no_delay = unsafePerformIO $ withCString "WebSocketPeer" $ \ clsNamePtr -> withCString "set_no_delay" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_no_delay :: (WebSocketPeer :< cls, Object :< cls) => cls -> Bool -> IO () set_no_delay cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketPeer_set_no_delay (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketPeer "set_no_delay" '[Bool] (IO ()) where nodeMethod = Godot.Core.WebSocketPeer.set_no_delay {-# NOINLINE bindWebSocketPeer_set_write_mode #-} bindWebSocketPeer_set_write_mode :: MethodBind bindWebSocketPeer_set_write_mode = unsafePerformIO $ withCString "WebSocketPeer" $ \ clsNamePtr -> withCString "set_write_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_write_mode :: (WebSocketPeer :< cls, Object :< cls) => cls -> Int -> IO () set_write_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketPeer_set_write_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketPeer "set_write_mode" '[Int] (IO ()) where nodeMethod = Godot.Core.WebSocketPeer.set_write_mode {-# NOINLINE bindWebSocketPeer_was_string_packet #-} bindWebSocketPeer_was_string_packet :: MethodBind bindWebSocketPeer_was_string_packet = unsafePerformIO $ withCString "WebSocketPeer" $ \ clsNamePtr -> withCString "was_string_packet" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr was_string_packet :: (WebSocketPeer :< cls, Object :< cls) => cls -> IO Bool was_string_packet cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketPeer_was_string_packet (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketPeer "was_string_packet" '[] (IO Bool) where nodeMethod = Godot.Core.WebSocketPeer.was_string_packet ================================================ FILE: src/Godot/Core/WebSocketServer.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WebSocketServer (Godot.Core.WebSocketServer.sig_client_close_request, Godot.Core.WebSocketServer.sig_client_connected, Godot.Core.WebSocketServer.sig_client_disconnected, Godot.Core.WebSocketServer.sig_data_received, Godot.Core.WebSocketServer.disconnect_peer, Godot.Core.WebSocketServer.get_bind_ip, Godot.Core.WebSocketServer.get_ca_chain, Godot.Core.WebSocketServer.get_peer_address, Godot.Core.WebSocketServer.get_peer_port, Godot.Core.WebSocketServer.get_private_key, Godot.Core.WebSocketServer.get_ssl_certificate, Godot.Core.WebSocketServer.has_peer, Godot.Core.WebSocketServer.is_listening, Godot.Core.WebSocketServer.listen, Godot.Core.WebSocketServer.set_bind_ip, Godot.Core.WebSocketServer.set_ca_chain, Godot.Core.WebSocketServer.set_private_key, Godot.Core.WebSocketServer.set_ssl_certificate, Godot.Core.WebSocketServer.stop) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.WebSocketMultiplayerPeer() sig_client_close_request :: Godot.Internal.Dispatch.Signal WebSocketServer sig_client_close_request = Godot.Internal.Dispatch.Signal "client_close_request" instance NodeSignal WebSocketServer "client_close_request" '[Int, Int, GodotString] sig_client_connected :: Godot.Internal.Dispatch.Signal WebSocketServer sig_client_connected = Godot.Internal.Dispatch.Signal "client_connected" instance NodeSignal WebSocketServer "client_connected" '[Int, GodotString] sig_client_disconnected :: Godot.Internal.Dispatch.Signal WebSocketServer sig_client_disconnected = Godot.Internal.Dispatch.Signal "client_disconnected" instance NodeSignal WebSocketServer "client_disconnected" '[Int, Bool] sig_data_received :: Godot.Internal.Dispatch.Signal WebSocketServer sig_data_received = Godot.Internal.Dispatch.Signal "data_received" instance NodeSignal WebSocketServer "data_received" '[Int] instance NodeProperty WebSocketServer "bind_ip" GodotString 'False where nodeProperty = (get_bind_ip, wrapDroppingSetter set_bind_ip, Nothing) instance NodeProperty WebSocketServer "ca_chain" X509Certificate 'False where nodeProperty = (get_ca_chain, wrapDroppingSetter set_ca_chain, Nothing) instance NodeProperty WebSocketServer "private_key" CryptoKey 'False where nodeProperty = (get_private_key, wrapDroppingSetter set_private_key, Nothing) instance NodeProperty WebSocketServer "ssl_certificate" X509Certificate 'False where nodeProperty = (get_ssl_certificate, wrapDroppingSetter set_ssl_certificate, Nothing) {-# NOINLINE bindWebSocketServer_disconnect_peer #-} bindWebSocketServer_disconnect_peer :: MethodBind bindWebSocketServer_disconnect_peer = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "disconnect_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr disconnect_peer :: (WebSocketServer :< cls, Object :< cls) => cls -> Int -> Maybe Int -> Maybe GodotString -> IO () disconnect_peer cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantInt (1000)) toVariant arg2, defaultedVariant VariantString "" arg3] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_disconnect_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "disconnect_peer" '[Int, Maybe Int, Maybe GodotString] (IO ()) where nodeMethod = Godot.Core.WebSocketServer.disconnect_peer {-# NOINLINE bindWebSocketServer_get_bind_ip #-} bindWebSocketServer_get_bind_ip :: MethodBind bindWebSocketServer_get_bind_ip = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "get_bind_ip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_bind_ip :: (WebSocketServer :< cls, Object :< cls) => cls -> IO GodotString get_bind_ip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_get_bind_ip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "get_bind_ip" '[] (IO GodotString) where nodeMethod = Godot.Core.WebSocketServer.get_bind_ip {-# NOINLINE bindWebSocketServer_get_ca_chain #-} bindWebSocketServer_get_ca_chain :: MethodBind bindWebSocketServer_get_ca_chain = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "get_ca_chain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_ca_chain :: (WebSocketServer :< cls, Object :< cls) => cls -> IO X509Certificate get_ca_chain cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_get_ca_chain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "get_ca_chain" '[] (IO X509Certificate) where nodeMethod = Godot.Core.WebSocketServer.get_ca_chain {-# NOINLINE bindWebSocketServer_get_peer_address #-} bindWebSocketServer_get_peer_address :: MethodBind bindWebSocketServer_get_peer_address = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "get_peer_address" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_peer_address :: (WebSocketServer :< cls, Object :< cls) => cls -> Int -> IO GodotString get_peer_address cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_get_peer_address (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "get_peer_address" '[Int] (IO GodotString) where nodeMethod = Godot.Core.WebSocketServer.get_peer_address {-# NOINLINE bindWebSocketServer_get_peer_port #-} bindWebSocketServer_get_peer_port :: MethodBind bindWebSocketServer_get_peer_port = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "get_peer_port" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_peer_port :: (WebSocketServer :< cls, Object :< cls) => cls -> Int -> IO Int get_peer_port cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_get_peer_port (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "get_peer_port" '[Int] (IO Int) where nodeMethod = Godot.Core.WebSocketServer.get_peer_port {-# NOINLINE bindWebSocketServer_get_private_key #-} bindWebSocketServer_get_private_key :: MethodBind bindWebSocketServer_get_private_key = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "get_private_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_private_key :: (WebSocketServer :< cls, Object :< cls) => cls -> IO CryptoKey get_private_key cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_get_private_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "get_private_key" '[] (IO CryptoKey) where nodeMethod = Godot.Core.WebSocketServer.get_private_key {-# NOINLINE bindWebSocketServer_get_ssl_certificate #-} bindWebSocketServer_get_ssl_certificate :: MethodBind bindWebSocketServer_get_ssl_certificate = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "get_ssl_certificate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_ssl_certificate :: (WebSocketServer :< cls, Object :< cls) => cls -> IO X509Certificate get_ssl_certificate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_get_ssl_certificate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "get_ssl_certificate" '[] (IO X509Certificate) where nodeMethod = Godot.Core.WebSocketServer.get_ssl_certificate {-# NOINLINE bindWebSocketServer_has_peer #-} bindWebSocketServer_has_peer :: MethodBind bindWebSocketServer_has_peer = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "has_peer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr has_peer :: (WebSocketServer :< cls, Object :< cls) => cls -> Int -> IO Bool has_peer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_has_peer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "has_peer" '[Int] (IO Bool) where nodeMethod = Godot.Core.WebSocketServer.has_peer {-# NOINLINE bindWebSocketServer_is_listening #-} bindWebSocketServer_is_listening :: MethodBind bindWebSocketServer_is_listening = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "is_listening" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_listening :: (WebSocketServer :< cls, Object :< cls) => cls -> IO Bool is_listening cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_is_listening (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "is_listening" '[] (IO Bool) where nodeMethod = Godot.Core.WebSocketServer.is_listening {-# NOINLINE bindWebSocketServer_listen #-} bindWebSocketServer_listen :: MethodBind bindWebSocketServer_listen = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "listen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr listen :: (WebSocketServer :< cls, Object :< cls) => cls -> Int -> Maybe PoolStringArray -> Maybe Bool -> IO Int listen cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, defaultedVariant VariantPoolStringArray V.empty arg2, maybe (VariantBool False) toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_listen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "listen" '[Int, Maybe PoolStringArray, Maybe Bool] (IO Int) where nodeMethod = Godot.Core.WebSocketServer.listen {-# NOINLINE bindWebSocketServer_set_bind_ip #-} bindWebSocketServer_set_bind_ip :: MethodBind bindWebSocketServer_set_bind_ip = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "set_bind_ip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_bind_ip :: (WebSocketServer :< cls, Object :< cls) => cls -> GodotString -> IO () set_bind_ip cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_set_bind_ip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "set_bind_ip" '[GodotString] (IO ()) where nodeMethod = Godot.Core.WebSocketServer.set_bind_ip {-# NOINLINE bindWebSocketServer_set_ca_chain #-} bindWebSocketServer_set_ca_chain :: MethodBind bindWebSocketServer_set_ca_chain = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "set_ca_chain" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_ca_chain :: (WebSocketServer :< cls, Object :< cls) => cls -> X509Certificate -> IO () set_ca_chain cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_set_ca_chain (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "set_ca_chain" '[X509Certificate] (IO ()) where nodeMethod = Godot.Core.WebSocketServer.set_ca_chain {-# NOINLINE bindWebSocketServer_set_private_key #-} bindWebSocketServer_set_private_key :: MethodBind bindWebSocketServer_set_private_key = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "set_private_key" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_private_key :: (WebSocketServer :< cls, Object :< cls) => cls -> CryptoKey -> IO () set_private_key cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_set_private_key (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "set_private_key" '[CryptoKey] (IO ()) where nodeMethod = Godot.Core.WebSocketServer.set_private_key {-# NOINLINE bindWebSocketServer_set_ssl_certificate #-} bindWebSocketServer_set_ssl_certificate :: MethodBind bindWebSocketServer_set_ssl_certificate = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "set_ssl_certificate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_ssl_certificate :: (WebSocketServer :< cls, Object :< cls) => cls -> X509Certificate -> IO () set_ssl_certificate cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_set_ssl_certificate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "set_ssl_certificate" '[X509Certificate] (IO ()) where nodeMethod = Godot.Core.WebSocketServer.set_ssl_certificate {-# NOINLINE bindWebSocketServer_stop #-} bindWebSocketServer_stop :: MethodBind bindWebSocketServer_stop = unsafePerformIO $ withCString "WebSocketServer" $ \ clsNamePtr -> withCString "stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr stop :: (WebSocketServer :< cls, Object :< cls) => cls -> IO () stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWebSocketServer_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WebSocketServer "stop" '[] (IO ()) where nodeMethod = Godot.Core.WebSocketServer.stop ================================================ FILE: src/Godot/Core/WindowDialog.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WindowDialog (Godot.Core.WindowDialog._closed, Godot.Core.WindowDialog._gui_input, Godot.Core.WindowDialog.get_close_button, Godot.Core.WindowDialog.get_resizable, Godot.Core.WindowDialog.get_title, Godot.Core.WindowDialog.set_resizable, Godot.Core.WindowDialog.set_title) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Popup() instance NodeProperty WindowDialog "resizable" Bool 'False where nodeProperty = (get_resizable, wrapDroppingSetter set_resizable, Nothing) instance NodeProperty WindowDialog "window_title" GodotString 'False where nodeProperty = (get_title, wrapDroppingSetter set_title, Nothing) {-# NOINLINE bindWindowDialog__closed #-} bindWindowDialog__closed :: MethodBind bindWindowDialog__closed = unsafePerformIO $ withCString "WindowDialog" $ \ clsNamePtr -> withCString "_closed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _closed :: (WindowDialog :< cls, Object :< cls) => cls -> IO () _closed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWindowDialog__closed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WindowDialog "_closed" '[] (IO ()) where nodeMethod = Godot.Core.WindowDialog._closed {-# NOINLINE bindWindowDialog__gui_input #-} bindWindowDialog__gui_input :: MethodBind bindWindowDialog__gui_input = unsafePerformIO $ withCString "WindowDialog" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (WindowDialog :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWindowDialog__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WindowDialog "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Core.WindowDialog._gui_input {-# NOINLINE bindWindowDialog_get_close_button #-} -- | Returns the close @TextureButton@. bindWindowDialog_get_close_button :: MethodBind bindWindowDialog_get_close_button = unsafePerformIO $ withCString "WindowDialog" $ \ clsNamePtr -> withCString "get_close_button" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the close @TextureButton@. get_close_button :: (WindowDialog :< cls, Object :< cls) => cls -> IO TextureButton get_close_button cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWindowDialog_get_close_button (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WindowDialog "get_close_button" '[] (IO TextureButton) where nodeMethod = Godot.Core.WindowDialog.get_close_button {-# NOINLINE bindWindowDialog_get_resizable #-} -- | If @true@, the user can resize the window. bindWindowDialog_get_resizable :: MethodBind bindWindowDialog_get_resizable = unsafePerformIO $ withCString "WindowDialog" $ \ clsNamePtr -> withCString "get_resizable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the user can resize the window. get_resizable :: (WindowDialog :< cls, Object :< cls) => cls -> IO Bool get_resizable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWindowDialog_get_resizable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WindowDialog "get_resizable" '[] (IO Bool) where nodeMethod = Godot.Core.WindowDialog.get_resizable {-# NOINLINE bindWindowDialog_get_title #-} -- | The text displayed in the window's title bar. bindWindowDialog_get_title :: MethodBind bindWindowDialog_get_title = unsafePerformIO $ withCString "WindowDialog" $ \ clsNamePtr -> withCString "get_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The text displayed in the window's title bar. get_title :: (WindowDialog :< cls, Object :< cls) => cls -> IO GodotString get_title cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWindowDialog_get_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WindowDialog "get_title" '[] (IO GodotString) where nodeMethod = Godot.Core.WindowDialog.get_title {-# NOINLINE bindWindowDialog_set_resizable #-} -- | If @true@, the user can resize the window. bindWindowDialog_set_resizable :: MethodBind bindWindowDialog_set_resizable = unsafePerformIO $ withCString "WindowDialog" $ \ clsNamePtr -> withCString "set_resizable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the user can resize the window. set_resizable :: (WindowDialog :< cls, Object :< cls) => cls -> Bool -> IO () set_resizable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWindowDialog_set_resizable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WindowDialog "set_resizable" '[Bool] (IO ()) where nodeMethod = Godot.Core.WindowDialog.set_resizable {-# NOINLINE bindWindowDialog_set_title #-} -- | The text displayed in the window's title bar. bindWindowDialog_set_title :: MethodBind bindWindowDialog_set_title = unsafePerformIO $ withCString "WindowDialog" $ \ clsNamePtr -> withCString "set_title" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The text displayed in the window's title bar. set_title :: (WindowDialog :< cls, Object :< cls) => cls -> GodotString -> IO () set_title cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWindowDialog_set_title (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WindowDialog "set_title" '[GodotString] (IO ()) where nodeMethod = Godot.Core.WindowDialog.set_title ================================================ FILE: src/Godot/Core/World.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.World (Godot.Core.World.get_direct_space_state, Godot.Core.World.get_environment, Godot.Core.World.get_fallback_environment, Godot.Core.World.get_scenario, Godot.Core.World.get_space, Godot.Core.World.set_environment, Godot.Core.World.set_fallback_environment) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty World "direct_space_state" PhysicsDirectSpaceState 'True where nodeProperty = (get_direct_space_state, (), Nothing) instance NodeProperty World "environment" Environment 'False where nodeProperty = (get_environment, wrapDroppingSetter set_environment, Nothing) instance NodeProperty World "fallback_environment" Environment 'False where nodeProperty = (get_fallback_environment, wrapDroppingSetter set_fallback_environment, Nothing) instance NodeProperty World "scenario" Rid 'True where nodeProperty = (get_scenario, (), Nothing) instance NodeProperty World "space" Rid 'True where nodeProperty = (get_space, (), Nothing) {-# NOINLINE bindWorld_get_direct_space_state #-} -- | Direct access to the world's physics 3D space state. Used for querying current and potential collisions. Must only be accessed from within @_physics_process(delta)@. bindWorld_get_direct_space_state :: MethodBind bindWorld_get_direct_space_state = unsafePerformIO $ withCString "World" $ \ clsNamePtr -> withCString "get_direct_space_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Direct access to the world's physics 3D space state. Used for querying current and potential collisions. Must only be accessed from within @_physics_process(delta)@. get_direct_space_state :: (World :< cls, Object :< cls) => cls -> IO PhysicsDirectSpaceState get_direct_space_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorld_get_direct_space_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World "get_direct_space_state" '[] (IO PhysicsDirectSpaceState) where nodeMethod = Godot.Core.World.get_direct_space_state {-# NOINLINE bindWorld_get_environment #-} -- | The World's @Environment@. bindWorld_get_environment :: MethodBind bindWorld_get_environment = unsafePerformIO $ withCString "World" $ \ clsNamePtr -> withCString "get_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The World's @Environment@. get_environment :: (World :< cls, Object :< cls) => cls -> IO Environment get_environment cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorld_get_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World "get_environment" '[] (IO Environment) where nodeMethod = Godot.Core.World.get_environment {-# NOINLINE bindWorld_get_fallback_environment #-} -- | The World's fallback_environment will be used if the World's @Environment@ fails or is missing. bindWorld_get_fallback_environment :: MethodBind bindWorld_get_fallback_environment = unsafePerformIO $ withCString "World" $ \ clsNamePtr -> withCString "get_fallback_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The World's fallback_environment will be used if the World's @Environment@ fails or is missing. get_fallback_environment :: (World :< cls, Object :< cls) => cls -> IO Environment get_fallback_environment cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorld_get_fallback_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World "get_fallback_environment" '[] (IO Environment) where nodeMethod = Godot.Core.World.get_fallback_environment {-# NOINLINE bindWorld_get_scenario #-} -- | The World's visual scenario. bindWorld_get_scenario :: MethodBind bindWorld_get_scenario = unsafePerformIO $ withCString "World" $ \ clsNamePtr -> withCString "get_scenario" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The World's visual scenario. get_scenario :: (World :< cls, Object :< cls) => cls -> IO Rid get_scenario cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorld_get_scenario (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World "get_scenario" '[] (IO Rid) where nodeMethod = Godot.Core.World.get_scenario {-# NOINLINE bindWorld_get_space #-} -- | The World's physics space. bindWorld_get_space :: MethodBind bindWorld_get_space = unsafePerformIO $ withCString "World" $ \ clsNamePtr -> withCString "get_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The World's physics space. get_space :: (World :< cls, Object :< cls) => cls -> IO Rid get_space cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorld_get_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World "get_space" '[] (IO Rid) where nodeMethod = Godot.Core.World.get_space {-# NOINLINE bindWorld_set_environment #-} -- | The World's @Environment@. bindWorld_set_environment :: MethodBind bindWorld_set_environment = unsafePerformIO $ withCString "World" $ \ clsNamePtr -> withCString "set_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The World's @Environment@. set_environment :: (World :< cls, Object :< cls) => cls -> Environment -> IO () set_environment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWorld_set_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World "set_environment" '[Environment] (IO ()) where nodeMethod = Godot.Core.World.set_environment {-# NOINLINE bindWorld_set_fallback_environment #-} -- | The World's fallback_environment will be used if the World's @Environment@ fails or is missing. bindWorld_set_fallback_environment :: MethodBind bindWorld_set_fallback_environment = unsafePerformIO $ withCString "World" $ \ clsNamePtr -> withCString "set_fallback_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The World's fallback_environment will be used if the World's @Environment@ fails or is missing. set_fallback_environment :: (World :< cls, Object :< cls) => cls -> Environment -> IO () set_fallback_environment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWorld_set_fallback_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World "set_fallback_environment" '[Environment] (IO ()) where nodeMethod = Godot.Core.World.set_fallback_environment ================================================ FILE: src/Godot/Core/World2D.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.World2D (Godot.Core.World2D.get_canvas, Godot.Core.World2D.get_direct_space_state, Godot.Core.World2D.get_space) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() instance NodeProperty World2D "canvas" Rid 'True where nodeProperty = (get_canvas, (), Nothing) instance NodeProperty World2D "direct_space_state" Physics2DDirectSpaceState 'True where nodeProperty = (get_direct_space_state, (), Nothing) instance NodeProperty World2D "space" Rid 'True where nodeProperty = (get_space, (), Nothing) {-# NOINLINE bindWorld2D_get_canvas #-} -- | The @RID@ of this world's canvas resource. Used by the @VisualServer@ for 2D drawing. bindWorld2D_get_canvas :: MethodBind bindWorld2D_get_canvas = unsafePerformIO $ withCString "World2D" $ \ clsNamePtr -> withCString "get_canvas" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @RID@ of this world's canvas resource. Used by the @VisualServer@ for 2D drawing. get_canvas :: (World2D :< cls, Object :< cls) => cls -> IO Rid get_canvas cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorld2D_get_canvas (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World2D "get_canvas" '[] (IO Rid) where nodeMethod = Godot.Core.World2D.get_canvas {-# NOINLINE bindWorld2D_get_direct_space_state #-} -- | Direct access to the world's physics 2D space state. Used for querying current and potential collisions. Must only be accessed from the main thread within @_physics_process(delta)@. bindWorld2D_get_direct_space_state :: MethodBind bindWorld2D_get_direct_space_state = unsafePerformIO $ withCString "World2D" $ \ clsNamePtr -> withCString "get_direct_space_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Direct access to the world's physics 2D space state. Used for querying current and potential collisions. Must only be accessed from the main thread within @_physics_process(delta)@. get_direct_space_state :: (World2D :< cls, Object :< cls) => cls -> IO Physics2DDirectSpaceState get_direct_space_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorld2D_get_direct_space_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World2D "get_direct_space_state" '[] (IO Physics2DDirectSpaceState) where nodeMethod = Godot.Core.World2D.get_direct_space_state {-# NOINLINE bindWorld2D_get_space #-} -- | The @RID@ of this world's physics space resource. Used by the @Physics2DServer@ for 2D physics, treating it as both a space and an area. bindWorld2D_get_space :: MethodBind bindWorld2D_get_space = unsafePerformIO $ withCString "World2D" $ \ clsNamePtr -> withCString "get_space" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @RID@ of this world's physics space resource. Used by the @Physics2DServer@ for 2D physics, treating it as both a space and an area. get_space :: (World2D :< cls, Object :< cls) => cls -> IO Rid get_space cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorld2D_get_space (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod World2D "get_space" '[] (IO Rid) where nodeMethod = Godot.Core.World2D.get_space ================================================ FILE: src/Godot/Core/WorldEnvironment.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.WorldEnvironment (Godot.Core.WorldEnvironment.get_environment, Godot.Core.WorldEnvironment.set_environment) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() instance NodeProperty WorldEnvironment "environment" Environment 'False where nodeProperty = (get_environment, wrapDroppingSetter set_environment, Nothing) {-# NOINLINE bindWorldEnvironment_get_environment #-} -- | The @Environment@ resource used by this @WorldEnvironment@, defining the default properties. bindWorldEnvironment_get_environment :: MethodBind bindWorldEnvironment_get_environment = unsafePerformIO $ withCString "WorldEnvironment" $ \ clsNamePtr -> withCString "get_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Environment@ resource used by this @WorldEnvironment@, defining the default properties. get_environment :: (WorldEnvironment :< cls, Object :< cls) => cls -> IO Environment get_environment cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindWorldEnvironment_get_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WorldEnvironment "get_environment" '[] (IO Environment) where nodeMethod = Godot.Core.WorldEnvironment.get_environment {-# NOINLINE bindWorldEnvironment_set_environment #-} -- | The @Environment@ resource used by this @WorldEnvironment@, defining the default properties. bindWorldEnvironment_set_environment :: MethodBind bindWorldEnvironment_set_environment = unsafePerformIO $ withCString "WorldEnvironment" $ \ clsNamePtr -> withCString "set_environment" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The @Environment@ resource used by this @WorldEnvironment@, defining the default properties. set_environment :: (WorldEnvironment :< cls, Object :< cls) => cls -> Environment -> IO () set_environment cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindWorldEnvironment_set_environment (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod WorldEnvironment "set_environment" '[Environment] (IO ()) where nodeMethod = Godot.Core.WorldEnvironment.set_environment ================================================ FILE: src/Godot/Core/X509Certificate.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.X509Certificate (Godot.Core.X509Certificate.load, Godot.Core.X509Certificate.save) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindX509Certificate_load #-} -- | Loads a certificate from @path@ ("*.crt" file). bindX509Certificate_load :: MethodBind bindX509Certificate_load = unsafePerformIO $ withCString "X509Certificate" $ \ clsNamePtr -> withCString "load" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads a certificate from @path@ ("*.crt" file). load :: (X509Certificate :< cls, Object :< cls) => cls -> GodotString -> IO Int load cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindX509Certificate_load (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod X509Certificate "load" '[GodotString] (IO Int) where nodeMethod = Godot.Core.X509Certificate.load {-# NOINLINE bindX509Certificate_save #-} -- | Saves a certificate to the given @path@ (should be a "*.crt" file). bindX509Certificate_save :: MethodBind bindX509Certificate_save = unsafePerformIO $ withCString "X509Certificate" $ \ clsNamePtr -> withCString "save" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves a certificate to the given @path@ (should be a "*.crt" file). save :: (X509Certificate :< cls, Object :< cls) => cls -> GodotString -> IO Int save cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindX509Certificate_save (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod X509Certificate "save" '[GodotString] (IO Int) where nodeMethod = Godot.Core.X509Certificate.save ================================================ FILE: src/Godot/Core/XMLParser.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.XMLParser (Godot.Core.XMLParser._NODE_UNKNOWN, Godot.Core.XMLParser._NODE_ELEMENT, Godot.Core.XMLParser._NODE_CDATA, Godot.Core.XMLParser._NODE_COMMENT, Godot.Core.XMLParser._NODE_TEXT, Godot.Core.XMLParser._NODE_NONE, Godot.Core.XMLParser._NODE_ELEMENT_END, Godot.Core.XMLParser.get_attribute_count, Godot.Core.XMLParser.get_attribute_name, Godot.Core.XMLParser.get_attribute_value, Godot.Core.XMLParser.get_current_line, Godot.Core.XMLParser.get_named_attribute_value, Godot.Core.XMLParser.get_named_attribute_value_safe, Godot.Core.XMLParser.get_node_data, Godot.Core.XMLParser.get_node_name, Godot.Core.XMLParser.get_node_offset, Godot.Core.XMLParser.get_node_type, Godot.Core.XMLParser.has_attribute, Godot.Core.XMLParser.is_empty, Godot.Core.XMLParser.open, Godot.Core.XMLParser.open_buffer, Godot.Core.XMLParser.read, Godot.Core.XMLParser.seek, Godot.Core.XMLParser.skip_section) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _NODE_UNKNOWN :: Int _NODE_UNKNOWN = 6 _NODE_ELEMENT :: Int _NODE_ELEMENT = 1 _NODE_CDATA :: Int _NODE_CDATA = 5 _NODE_COMMENT :: Int _NODE_COMMENT = 4 _NODE_TEXT :: Int _NODE_TEXT = 3 _NODE_NONE :: Int _NODE_NONE = 0 _NODE_ELEMENT_END :: Int _NODE_ELEMENT_END = 2 {-# NOINLINE bindXMLParser_get_attribute_count #-} -- | Gets the amount of attributes in the current element. bindXMLParser_get_attribute_count :: MethodBind bindXMLParser_get_attribute_count = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_attribute_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the amount of attributes in the current element. get_attribute_count :: (XMLParser :< cls, Object :< cls) => cls -> IO Int get_attribute_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_attribute_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_attribute_count" '[] (IO Int) where nodeMethod = Godot.Core.XMLParser.get_attribute_count {-# NOINLINE bindXMLParser_get_attribute_name #-} -- | Gets the name of the attribute specified by the index in @idx@ argument. bindXMLParser_get_attribute_name :: MethodBind bindXMLParser_get_attribute_name = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_attribute_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the name of the attribute specified by the index in @idx@ argument. get_attribute_name :: (XMLParser :< cls, Object :< cls) => cls -> Int -> IO GodotString get_attribute_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_attribute_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_attribute_name" '[Int] (IO GodotString) where nodeMethod = Godot.Core.XMLParser.get_attribute_name {-# NOINLINE bindXMLParser_get_attribute_value #-} -- | Gets the value of the attribute specified by the index in @idx@ argument. bindXMLParser_get_attribute_value :: MethodBind bindXMLParser_get_attribute_value = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_attribute_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the value of the attribute specified by the index in @idx@ argument. get_attribute_value :: (XMLParser :< cls, Object :< cls) => cls -> Int -> IO GodotString get_attribute_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_attribute_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_attribute_value" '[Int] (IO GodotString) where nodeMethod = Godot.Core.XMLParser.get_attribute_value {-# NOINLINE bindXMLParser_get_current_line #-} -- | Gets the current line in the parsed file (currently not implemented). bindXMLParser_get_current_line :: MethodBind bindXMLParser_get_current_line = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_current_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the current line in the parsed file (currently not implemented). get_current_line :: (XMLParser :< cls, Object :< cls) => cls -> IO Int get_current_line cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_current_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_current_line" '[] (IO Int) where nodeMethod = Godot.Core.XMLParser.get_current_line {-# NOINLINE bindXMLParser_get_named_attribute_value #-} -- | Gets the value of a certain attribute of the current element by name. This will raise an error if the element has no such attribute. bindXMLParser_get_named_attribute_value :: MethodBind bindXMLParser_get_named_attribute_value = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_named_attribute_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the value of a certain attribute of the current element by name. This will raise an error if the element has no such attribute. get_named_attribute_value :: (XMLParser :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_named_attribute_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_named_attribute_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_named_attribute_value" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.XMLParser.get_named_attribute_value {-# NOINLINE bindXMLParser_get_named_attribute_value_safe #-} -- | Gets the value of a certain attribute of the current element by name. This will return an empty @String@ if the attribute is not found. bindXMLParser_get_named_attribute_value_safe :: MethodBind bindXMLParser_get_named_attribute_value_safe = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_named_attribute_value_safe" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the value of a certain attribute of the current element by name. This will return an empty @String@ if the attribute is not found. get_named_attribute_value_safe :: (XMLParser :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_named_attribute_value_safe cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_named_attribute_value_safe (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_named_attribute_value_safe" '[GodotString] (IO GodotString) where nodeMethod = Godot.Core.XMLParser.get_named_attribute_value_safe {-# NOINLINE bindXMLParser_get_node_data #-} -- | Gets the contents of a text node. This will raise an error in any other type of node. bindXMLParser_get_node_data :: MethodBind bindXMLParser_get_node_data = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_node_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the contents of a text node. This will raise an error in any other type of node. get_node_data :: (XMLParser :< cls, Object :< cls) => cls -> IO GodotString get_node_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_node_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_node_data" '[] (IO GodotString) where nodeMethod = Godot.Core.XMLParser.get_node_data {-# NOINLINE bindXMLParser_get_node_name #-} -- | Gets the name of the current element node. This will raise an error if the current node type is neither @NODE_ELEMENT@ nor @NODE_ELEMENT_END@. bindXMLParser_get_node_name :: MethodBind bindXMLParser_get_node_name = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_node_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the name of the current element node. This will raise an error if the current node type is neither @NODE_ELEMENT@ nor @NODE_ELEMENT_END@. get_node_name :: (XMLParser :< cls, Object :< cls) => cls -> IO GodotString get_node_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_node_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_node_name" '[] (IO GodotString) where nodeMethod = Godot.Core.XMLParser.get_node_name {-# NOINLINE bindXMLParser_get_node_offset #-} -- | Gets the byte offset of the current node since the beginning of the file or buffer. bindXMLParser_get_node_offset :: MethodBind bindXMLParser_get_node_offset = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_node_offset" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the byte offset of the current node since the beginning of the file or buffer. get_node_offset :: (XMLParser :< cls, Object :< cls) => cls -> IO Int get_node_offset cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_node_offset (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_node_offset" '[] (IO Int) where nodeMethod = Godot.Core.XMLParser.get_node_offset {-# NOINLINE bindXMLParser_get_node_type #-} -- | Gets the type of the current node. Compare with @enum NodeType@ constants. bindXMLParser_get_node_type :: MethodBind bindXMLParser_get_node_type = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "get_node_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the type of the current node. Compare with @enum NodeType@ constants. get_node_type :: (XMLParser :< cls, Object :< cls) => cls -> IO Int get_node_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_get_node_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "get_node_type" '[] (IO Int) where nodeMethod = Godot.Core.XMLParser.get_node_type {-# NOINLINE bindXMLParser_has_attribute #-} -- | Check whether the current element has a certain attribute. bindXMLParser_has_attribute :: MethodBind bindXMLParser_has_attribute = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "has_attribute" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Check whether the current element has a certain attribute. has_attribute :: (XMLParser :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_attribute cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_has_attribute (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "has_attribute" '[GodotString] (IO Bool) where nodeMethod = Godot.Core.XMLParser.has_attribute {-# NOINLINE bindXMLParser_is_empty #-} -- | Check whether the current element is empty (this only works for completely empty tags, e.g. @@). bindXMLParser_is_empty :: MethodBind bindXMLParser_is_empty = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "is_empty" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Check whether the current element is empty (this only works for completely empty tags, e.g. @@). is_empty :: (XMLParser :< cls, Object :< cls) => cls -> IO Bool is_empty cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_is_empty (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "is_empty" '[] (IO Bool) where nodeMethod = Godot.Core.XMLParser.is_empty {-# NOINLINE bindXMLParser_open #-} -- | Opens an XML file for parsing. This returns an error code. bindXMLParser_open :: MethodBind bindXMLParser_open = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "open" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opens an XML file for parsing. This returns an error code. open :: (XMLParser :< cls, Object :< cls) => cls -> GodotString -> IO Int open cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_open (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "open" '[GodotString] (IO Int) where nodeMethod = Godot.Core.XMLParser.open {-# NOINLINE bindXMLParser_open_buffer #-} -- | Opens an XML raw buffer for parsing. This returns an error code. bindXMLParser_open_buffer :: MethodBind bindXMLParser_open_buffer = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "open_buffer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opens an XML raw buffer for parsing. This returns an error code. open_buffer :: (XMLParser :< cls, Object :< cls) => cls -> PoolByteArray -> IO Int open_buffer cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_open_buffer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "open_buffer" '[PoolByteArray] (IO Int) where nodeMethod = Godot.Core.XMLParser.open_buffer {-# NOINLINE bindXMLParser_read #-} -- | Reads the next node of the file. This returns an error code. bindXMLParser_read :: MethodBind bindXMLParser_read = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "read" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reads the next node of the file. This returns an error code. read :: (XMLParser :< cls, Object :< cls) => cls -> IO Int read cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_read (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "read" '[] (IO Int) where nodeMethod = Godot.Core.XMLParser.read {-# NOINLINE bindXMLParser_seek #-} -- | Moves the buffer cursor to a certain offset (since the beginning) and read the next node there. This returns an error code. bindXMLParser_seek :: MethodBind bindXMLParser_seek = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "seek" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Moves the buffer cursor to a certain offset (since the beginning) and read the next node there. This returns an error code. seek :: (XMLParser :< cls, Object :< cls) => cls -> Int -> IO Int seek cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_seek (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "seek" '[Int] (IO Int) where nodeMethod = Godot.Core.XMLParser.seek {-# NOINLINE bindXMLParser_skip_section #-} -- | Skips the current section. If the node contains other elements, they will be ignored and the cursor will go to the closing of the current element. bindXMLParser_skip_section :: MethodBind bindXMLParser_skip_section = unsafePerformIO $ withCString "XMLParser" $ \ clsNamePtr -> withCString "skip_section" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Skips the current section. If the node contains other elements, they will be ignored and the cursor will go to the closing of the current element. skip_section :: (XMLParser :< cls, Object :< cls) => cls -> IO () skip_section cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindXMLParser_skip_section (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod XMLParser "skip_section" '[] (IO ()) where nodeMethod = Godot.Core.XMLParser.skip_section ================================================ FILE: src/Godot/Core/YSort.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Core.YSort (Godot.Core.YSort.is_sort_enabled, Godot.Core.YSort.set_sort_enabled) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node2D() instance NodeProperty YSort "sort_enabled" Bool 'False where nodeProperty = (is_sort_enabled, wrapDroppingSetter set_sort_enabled, Nothing) {-# NOINLINE bindYSort_is_sort_enabled #-} -- | If @true@, child nodes are sorted, otherwise sorting is disabled. bindYSort_is_sort_enabled :: MethodBind bindYSort_is_sort_enabled = unsafePerformIO $ withCString "YSort" $ \ clsNamePtr -> withCString "is_sort_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, child nodes are sorted, otherwise sorting is disabled. is_sort_enabled :: (YSort :< cls, Object :< cls) => cls -> IO Bool is_sort_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindYSort_is_sort_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod YSort "is_sort_enabled" '[] (IO Bool) where nodeMethod = Godot.Core.YSort.is_sort_enabled {-# NOINLINE bindYSort_set_sort_enabled #-} -- | If @true@, child nodes are sorted, otherwise sorting is disabled. bindYSort_set_sort_enabled :: MethodBind bindYSort_set_sort_enabled = unsafePerformIO $ withCString "YSort" $ \ clsNamePtr -> withCString "set_sort_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, child nodes are sorted, otherwise sorting is disabled. set_sort_enabled :: (YSort :< cls, Object :< cls) => cls -> Bool -> IO () set_sort_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindYSort_set_sort_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod YSort "set_sort_enabled" '[Bool] (IO ()) where nodeMethod = Godot.Core.YSort.set_sort_enabled ================================================ FILE: src/Godot/Gdnative/Internal/Api.hs ================================================ {-# LANGUAGE TemplateHaskell #-} module Godot.Gdnative.Internal.Api where import Data.Aeson hiding (Array,Object) import qualified Data.ByteString.Lazy as BL import Data.IORef import Foreign.C import Language.Haskell.TH import Data.ByteString.Internal (accursedUnutterablePerformIO) import Godot.Gdnative.Internal.Gdnative import Generate gdnativeCoreApiStruct :: GdnativeCoreApiStruct gdnativeCoreApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeCoreApiStructRef gdnativeCore11ApiStruct :: GdnativeCore11ApiStruct gdnativeCore11ApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeCore11ApiStructRef gdnativeCore12ApiStruct :: GdnativeCore12ApiStruct gdnativeCore12ApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeCore12ApiStructRef gdnativeExtNativescriptApiStruct :: GdnativeExtNativescriptApiStruct gdnativeExtNativescriptApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeExtNativescriptApiStructRef gdnativeExtNativescript11ApiStruct :: GdnativeExtNativescript11ApiStruct gdnativeExtNativescript11ApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeExtNativescript11ApiStructRef gdnativeExtPluginscriptApiStruct :: GdnativeExtPluginscriptApiStruct gdnativeExtPluginscriptApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeExtPluginscriptApiStructRef gdnativeExtArvrApiStruct :: GdnativeExtArvrApiStruct gdnativeExtArvrApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeExtArvrApiStructRef gdnativeExtVideodecoderApiStruct :: GdnativeExtVideodecoderApiStruct gdnativeExtVideodecoderApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeExtVideodecoderApiStructRef gdnativeExtNetApiStruct :: GdnativeExtNetApiStruct gdnativeExtNetApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeExtNetApiStructRef gdnativeExtNet32ApiStruct :: GdnativeExtNet32ApiStruct gdnativeExtNet32ApiStruct = accursedUnutterablePerformIO $ readIORef gdnativeExtNet32ApiStructRef $(do maybeApis <- eitherDecode <$> runIO (BL.readFile "godot_headers/gdnative_api.json") case maybeApis of Right apis -> apisToHs apis Left err -> error err) ================================================ FILE: src/Godot/Gdnative/Internal/Gdnative.chs ================================================ {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE AllowAmbiguousTypes, ScopedTypeVariables, GADTs #-} {-# LANGUAGE UnboxedTuples, MagicHash #-} {-# LANGUAGE PatternSynonyms, RecordWildCards #-} {-# OPTIONS_GHC -Wno-name-shadowing #-} module Godot.Gdnative.Internal.Gdnative where import Control.Exception import Control.Monad import Data.Bits import Data.Coerce import Data.IORef import Foreign import Foreign.C import System.IO.Unsafe #include "util.h" #include "gdnative_api_struct.gen.h" {#context prefix = "godot_" #} {#enum godot_error as Error {underscoreToCase} deriving (Show, Eq, Ord, Bounded) #} {#enum godot_variant_type as VariantType {underscoreToCase} deriving (Show, Eq, Ord, Bounded) #} {#enum godot_variant_call_error_error as VariantCallErrorError {underscoreToCase} deriving (Show, Eq, Ord, Bounded) #} {#enum godot_vector3_axis as Vector3Axis {underscoreToCase} deriving (Show, Eq, Ord, Bounded)#} {#enum godot_variant_operator as VariantOperator {underscoreToCase} deriving (Show, Eq, Ord, Bounded)#} {#typedef godot_bool Bool #} type GodotBool = {#type godot_bool#} {#typedef godot_int CInt #} type GodotInt = {#type godot_int#} {#typedef godot_real CFloat #} type GodotReal = {#type godot_real#} {#typedef godot_char_type CWchar #} type CharType = {#type godot_char_type #} {#pointer *godot_aabb as Aabb foreign newtype #} deriving newtype instance Eq Aabb {#pointer *godot_array as Array foreign newtype #} deriving newtype instance Eq Array {#pointer *godot_basis as Basis foreign newtype #} deriving newtype instance Eq Basis {#pointer *godot_char_string as CharString foreign newtype #} deriving newtype instance Eq CharString {#pointer *godot_color as Color foreign newtype #} deriving newtype instance Eq Color {#pointer *godot_dictionary as Dictionary foreign newtype #} deriving newtype instance Eq Dictionary {#pointer *godot_method_bind as MethodBind foreign newtype #} deriving newtype instance Eq MethodBind {#pointer *godot_node_path as NodePath foreign newtype #} deriving newtype instance Eq NodePath {#pointer *godot_plane as Plane foreign newtype #} deriving newtype instance Eq Plane {#pointer *godot_pool_array_read_access as PoolArrayReadAccess foreign newtype #} deriving newtype instance Eq PoolArrayReadAccess {#pointer *godot_pool_array_write_access as PoolArrayWriteAccess foreign newtype #} deriving newtype instance Eq PoolArrayWriteAccess {#pointer *godot_pool_byte_array as PoolByteArray foreign newtype #} deriving newtype instance Eq PoolByteArray {#pointer *godot_pool_color_array as PoolColorArray foreign newtype #} deriving newtype instance Eq PoolColorArray {#pointer *godot_pool_int_array as PoolIntArray foreign newtype #} deriving newtype instance Eq PoolIntArray {#pointer *godot_pool_real_array as PoolRealArray foreign newtype #} deriving newtype instance Eq PoolRealArray {#pointer *godot_pool_string_array as PoolStringArray foreign newtype #} deriving newtype instance Eq PoolStringArray {#pointer *godot_pool_vector2_array as PoolVector2Array foreign newtype #} deriving newtype instance Eq PoolVector2Array {#pointer *godot_pool_vector3_array as PoolVector3Array foreign newtype #} deriving newtype instance Eq PoolVector3Array {#pointer *godot_quat as Quat foreign newtype #} deriving newtype instance Eq Quat {#pointer *godot_rect2 as Rect2 foreign newtype #} deriving newtype instance Eq Rect2 {#pointer *godot_rid as Rid foreign newtype #} deriving newtype instance Eq Rid {#pointer *godot_string as GodotString foreign newtype #} deriving newtype instance Eq GodotString {#pointer *godot_string_name as StringName foreign newtype #} deriving newtype instance Eq StringName {#pointer *godot_transform as Transform foreign newtype #} deriving newtype instance Eq Transform {#pointer *godot_transform2d as Transform2d foreign newtype #} deriving newtype instance Eq Transform2d {#pointer *godot_variant as GodotVariant foreign newtype #} deriving newtype instance Eq GodotVariant {#pointer *godot_vector2 as Vector2 foreign newtype #} deriving newtype instance Eq Vector2 {#pointer *godot_vector3 as Vector3 foreign newtype #} deriving newtype instance Eq Vector3 type PoolByteArrayReadAccess = PoolArrayReadAccess type PoolByteArrayWriteAccess = PoolArrayWriteAccess type PoolColorArrayReadAccess = PoolArrayReadAccess type PoolColorArrayWriteAccess = PoolArrayWriteAccess type PoolIntArrayReadAccess = PoolArrayReadAccess type PoolIntArrayWriteAccess = PoolArrayWriteAccess type PoolRealArrayReadAccess = PoolArrayReadAccess type PoolRealArrayWriteAccess = PoolArrayWriteAccess type PoolStringArrayReadAccess = PoolArrayReadAccess type PoolStringArrayWriteAccess = PoolArrayWriteAccess type PoolVector2ArrayReadAccess = PoolArrayReadAccess type PoolVector2ArrayWriteAccess = PoolArrayWriteAccess type PoolVector3ArrayReadAccess = PoolArrayReadAccess type PoolVector3ArrayWriteAccess = PoolArrayWriteAccess class OpaqueStorable a where opaqueSizeOf :: Int instance OpaqueStorable Aabb where opaqueSizeOf = {#sizeof godot_aabb#} instance OpaqueStorable Array where opaqueSizeOf = {#sizeof godot_array#} instance OpaqueStorable Basis where opaqueSizeOf = {#sizeof godot_basis#} instance OpaqueStorable CharString where opaqueSizeOf = {#sizeof godot_char_string#} instance OpaqueStorable Color where opaqueSizeOf = {#sizeof godot_color#} instance OpaqueStorable Dictionary where opaqueSizeOf = {#sizeof godot_dictionary#} instance OpaqueStorable MethodBind where opaqueSizeOf = {#sizeof godot_method_bind#} instance OpaqueStorable NodePath where opaqueSizeOf = {#sizeof godot_node_path#} instance OpaqueStorable Plane where opaqueSizeOf = {#sizeof godot_plane#} instance OpaqueStorable PoolArrayReadAccess where opaqueSizeOf = {#sizeof godot_pool_array_read_access#} instance OpaqueStorable PoolArrayWriteAccess where opaqueSizeOf = {#sizeof godot_pool_array_write_access#} instance OpaqueStorable PoolByteArray where opaqueSizeOf = {#sizeof godot_pool_byte_array#} instance OpaqueStorable PoolColorArray where opaqueSizeOf = {#sizeof godot_pool_color_array#} instance OpaqueStorable PoolIntArray where opaqueSizeOf = {#sizeof godot_pool_int_array#} instance OpaqueStorable PoolRealArray where opaqueSizeOf = {#sizeof godot_pool_real_array#} instance OpaqueStorable PoolStringArray where opaqueSizeOf = {#sizeof godot_pool_string_array#} instance OpaqueStorable PoolVector2Array where opaqueSizeOf = {#sizeof godot_pool_vector2_array#} instance OpaqueStorable PoolVector3Array where opaqueSizeOf = {#sizeof godot_pool_vector3_array#} instance OpaqueStorable Quat where opaqueSizeOf = {#sizeof godot_quat#} instance OpaqueStorable Rect2 where opaqueSizeOf = {#sizeof godot_rect2#} instance OpaqueStorable Rid where opaqueSizeOf = {#sizeof godot_rid#} instance OpaqueStorable GodotString where opaqueSizeOf = {#sizeof godot_string#} instance OpaqueStorable StringName where opaqueSizeOf = {#sizeof godot_string_name#} instance OpaqueStorable Transform where opaqueSizeOf = {#sizeof godot_transform#} instance OpaqueStorable Transform2d where opaqueSizeOf = {#sizeof godot_transform2d#} instance OpaqueStorable GodotVariant where opaqueSizeOf = {#sizeof godot_variant#} instance OpaqueStorable Vector2 where opaqueSizeOf = {#sizeof godot_vector2#} instance OpaqueStorable Vector3 where opaqueSizeOf = {#sizeof godot_vector3#} data VariantCallError = VariantCallError { variantCallErrorError :: !VariantCallErrorError , variantCallErrorArgument :: !(Maybe CInt) , variantCallErrorExpected :: !(Maybe VariantType) } deriving (Show, Eq, Ord) instance Exception VariantCallError {#pointer *godot_variant_call_error as VariantCallErrorPtr -> VariantCallError#} instance Storable VariantCallError where sizeOf _ = {#sizeof godot_variant_call_error#} alignment _ = {#alignof godot_variant_call_error#} peek ptr = do err <- (toEnum . fromIntegral) <$> {#get godot_variant_call_error->error #} ptr case err of CallErrorCallErrorInvalidArgument -> VariantCallError err <$> (Just <$> {#get godot_variant_call_error->argument #} ptr) <*> ((Just . toEnum . fromIntegral) <$> {#get godot_variant_call_error->expected #} ptr) _ -> return $ VariantCallError err Nothing Nothing poke ptr a = error "can't poke VariantCallError" {#pointer *godot_gdnative_api_struct as GdnativeApiStruct newtype#} deriving newtype instance Eq GdnativeApiStruct deriving newtype instance Storable GdnativeApiStruct {#pointer *godot_gdnative_core_api_struct as GdnativeCoreApiStruct newtype#} deriving newtype instance Eq GdnativeCoreApiStruct deriving newtype instance Storable GdnativeCoreApiStruct {#pointer *godot_gdnative_core_1_1_api_struct as GdnativeCore11ApiStruct newtype#} deriving newtype instance Eq GdnativeCore11ApiStruct deriving newtype instance Storable GdnativeCore11ApiStruct {#pointer *godot_gdnative_core_1_2_api_struct as GdnativeCore12ApiStruct newtype#} deriving newtype instance Eq GdnativeCore12ApiStruct deriving newtype instance Storable GdnativeCore12ApiStruct {#pointer *godot_gdnative_ext_nativescript_api_struct as GdnativeExtNativescriptApiStruct newtype#} deriving newtype instance Eq GdnativeExtNativescriptApiStruct deriving newtype instance Storable GdnativeExtNativescriptApiStruct {#pointer *godot_gdnative_ext_nativescript_1_1_api_struct as GdnativeExtNativescript11ApiStruct newtype#} deriving newtype instance Eq GdnativeExtNativescript11ApiStruct deriving newtype instance Storable GdnativeExtNativescript11ApiStruct {#pointer *godot_gdnative_ext_pluginscript_api_struct as GdnativeExtPluginscriptApiStruct newtype#} deriving newtype instance Eq GdnativeExtPluginscriptApiStruct deriving newtype instance Storable GdnativeExtPluginscriptApiStruct {#pointer *godot_gdnative_ext_arvr_api_struct as GdnativeExtArvrApiStruct newtype#} deriving newtype instance Eq GdnativeExtArvrApiStruct deriving newtype instance Storable GdnativeExtArvrApiStruct {#pointer *godot_gdnative_ext_videodecoder_api_struct as GdnativeExtVideodecoderApiStruct newtype#} deriving newtype instance Eq GdnativeExtVideodecoderApiStruct deriving newtype instance Storable GdnativeExtVideodecoderApiStruct {#pointer *godot_gdnative_ext_net_api_struct as GdnativeExtNetApiStruct newtype#} deriving newtype instance Eq GdnativeExtNetApiStruct deriving newtype instance Storable GdnativeExtNetApiStruct {#pointer *godot_gdnative_ext_net_3_2_api_struct as GdnativeExtNet32ApiStruct newtype#} deriving newtype instance Eq GdnativeExtNet32ApiStruct deriving newtype instance Storable GdnativeExtNet32ApiStruct type ReportVersionMismatchFunc = Object -> CString -> Word64 -> Word64 -> IO () type ReportLoadingErrorFunc = Object -> CString -> IO () {#pointer *godot_object as Object newtype #} deriving newtype instance Show Object deriving newtype instance Eq Object deriving newtype instance Storable Object data GdnativeInitOptions = GdnativeInitOptions { gdnativeInitOptionsInEditor :: !Bool , gdnativeInitOptionsCoreApiHash :: !Word64 , gdnativeInitOptionsEditorApiHash :: !Word64 , gdnativeInitOptionsNoApiHash :: !Word64 , gdnativeInitOptionsReportVersionMismatch :: !ReportVersionMismatchFunc , gdnativeInitOptionsReportLoadingError :: !ReportLoadingErrorFunc , gdnativeInitOptionsGdNativeLibrary :: !Object , gdnativeInitOptionsApiStruct :: !GdnativeCoreApiStruct , gdnativeInitOptionsActiveLibraryPath :: !GodotString } foreign import ccall "dynamic" mkReportVersionMismatchFunc :: FunPtr ReportVersionMismatchFunc -> ReportVersionMismatchFunc foreign import ccall "dynamic" mkReportLoadingErrorFunc :: FunPtr ReportLoadingErrorFunc -> ReportLoadingErrorFunc instance Storable GdnativeInitOptions where sizeOf _ = {#sizeof godot_gdnative_init_options#} alignment _ = {#alignof godot_gdnative_init_options#} peek ptr = GdnativeInitOptions <$> {#get godot_gdnative_init_options->in_editor#} ptr <*> (fromIntegral <$> {#get godot_gdnative_init_options->core_api_hash#} ptr) <*> (fromIntegral <$> {#get godot_gdnative_init_options->editor_api_hash#} ptr) <*> (fromIntegral <$> {#get godot_gdnative_init_options->no_api_hash#} ptr) <*> ((mkReportVersionMismatchFunc . castFunPtrVersion) <$> {#get godot_gdnative_init_options->report_version_mismatch#} ptr) <*> (mkReportLoadingErrorFunc <$> {#get godot_gdnative_init_options->report_loading_error#} ptr) <*> {#get godot_gdnative_init_options->gd_native_library#} ptr <*> {#get godot_gdnative_init_options->api_struct#} ptr <*> (GodotString <$> ({#get godot_gdnative_init_options->active_library_path#} ptr >>= newForeignPtr_)) where castFunPtrVersion :: FunPtr (Object -> Ptr CChar -> Ptr () -> Ptr () -> IO ()) -> FunPtr ReportVersionMismatchFunc castFunPtrVersion = castFunPtr poke _ _ = error "Poking GdNativeInitOptions is unsupported" {#pointer *godot_gdnative_init_options as GdnativeInitOptionsPtr -> GdnativeInitOptions#} data GdnativeTerminateOptions = GdnativeTerminateOptions { gdnativeTerminateOptionsInEditor :: Bool } deriving (Show, Eq, Ord) instance Storable GdnativeTerminateOptions where sizeOf _ = {#sizeof godot_gdnative_terminate_options#} alignment _ = {#alignof godot_gdnative_terminate_options#} peek ptr = GdnativeTerminateOptions <$> {#get godot_gdnative_terminate_options->in_editor#} ptr poke ptr a = {#set godot_gdnative_terminate_options->in_editor#} ptr (gdnativeTerminateOptionsInEditor a) {#pointer *godot_gdnative_terminate_options as GdnativeTerminateOptionsPtr -> GdnativeTerminateOptions#} -- ok so: -- on both SysV x64 and Win64, structs larger than 64bits are passed by pointer -- i.e. the following two are equivalent: {- godot_variant test() { godot_variant var; godot_variant_new_nil(&var); return var; } godot_variant* test2(godot_variant* ret) { godot_variant_new_nil(ret); return ret; } -} -- we're abusing this. remember to return the godotvariant!! type NativeCallCb = FunPtr (Ptr GodotVariant -> Ptr () -> Array -> IO (Ptr GodotVariant)) -- funptrs type ClassConstructor = FunPtr (IO Object) -- stuff that's not opaque (i.e. needs to be Storable'd) but i don't want to deal w/ rn -- pluginscript -- TODO: we don't support pluginscript right now data PluginscriptLanguageDesc instance Storable PluginscriptLanguageDesc where sizeOf _ = {#sizeof godot_pluginscript_language_desc#} alignment _ = {#alignof godot_pluginscript_language_desc#} peek = error "PluginscriptLanguageDesc peek not implemented" poke = error "PluginscriptLanguageDesc poke not implemented" {#pointer *godot_pluginscript_language_desc as PluginscriptLanguageDescPtr -> PluginscriptLanguageDesc#} -- nativescript {#enum godot_property_hint as PropertyHint {underscoreToCase} deriving (Show, Eq, Ord, Bounded) #} {#enum godot_method_rpc_mode as MethodRpcMode {underscoreToCase} deriving (Show, Eq, Ord, Bounded) #} newtype PropertyUsageFlags = PropertyUsageFlags { unPropertyUsageFlags :: CInt } deriving newtype (Show, Eq, Ord, Bits, Storable) pattern PropertyUsageStorage :: PropertyUsageFlags pattern PropertyUsageStorage = PropertyUsageFlags 1 pattern PropertyUsageEditor :: PropertyUsageFlags pattern PropertyUsageEditor = PropertyUsageFlags 2 pattern PropertyUsageNetwork :: PropertyUsageFlags pattern PropertyUsageNetwork = PropertyUsageFlags 4 pattern PropertyUsageEditorHelper :: PropertyUsageFlags pattern PropertyUsageEditorHelper = PropertyUsageFlags 8 pattern PropertyUsageCheckable :: PropertyUsageFlags pattern PropertyUsageCheckable = PropertyUsageFlags 16 pattern PropertyUsageChecked :: PropertyUsageFlags pattern PropertyUsageChecked = PropertyUsageFlags 32 pattern PropertyUsageInternationalized :: PropertyUsageFlags pattern PropertyUsageInternationalized = PropertyUsageFlags 64 pattern PropertyUsageGroup :: PropertyUsageFlags pattern PropertyUsageGroup = PropertyUsageFlags 128 pattern PropertyUsageCategory :: PropertyUsageFlags pattern PropertyUsageCategory = PropertyUsageFlags 256 pattern PropertyUsageStoreIfNonzero :: PropertyUsageFlags pattern PropertyUsageStoreIfNonzero = PropertyUsageFlags 512 pattern PropertyUsageStoreIfNonone :: PropertyUsageFlags pattern PropertyUsageStoreIfNonone = PropertyUsageFlags 1024 pattern PropertyUsageNoInstanceState :: PropertyUsageFlags pattern PropertyUsageNoInstanceState = PropertyUsageFlags 2048 pattern PropertyUsageRestartIfChanged :: PropertyUsageFlags pattern PropertyUsageRestartIfChanged = PropertyUsageFlags 4096 pattern PropertyUsageScriptVariable :: PropertyUsageFlags pattern PropertyUsageScriptVariable = PropertyUsageFlags 8192 pattern PropertyUsageStoreIfNull :: PropertyUsageFlags pattern PropertyUsageStoreIfNull = PropertyUsageFlags 16384 pattern PropertyUsageAnimateAsTrigger :: PropertyUsageFlags pattern PropertyUsageAnimateAsTrigger = PropertyUsageFlags 32768 pattern PropertyUsageUpdateAllIfModified :: PropertyUsageFlags pattern PropertyUsageUpdateAllIfModified = PropertyUsageFlags 65536 godotPropertyUsageDefault :: PropertyUsageFlags godotPropertyUsageDefault = PropertyUsageStorage .|. PropertyUsageEditor .|. PropertyUsageNetwork godotPropertyUsageDefaultIntl :: PropertyUsageFlags godotPropertyUsageDefaultIntl = godotPropertyUsageDefault .|. PropertyUsageInternationalized godotPropertyUsageNoeditor :: PropertyUsageFlags godotPropertyUsageNoeditor = PropertyUsageStorage .|. PropertyUsageNetwork type InstanceCreateFun = Object -> Ptr () -> IO (Ptr ()) type InstanceDestroyFun = Object -> Ptr () -> Ptr () -> IO () type InstanceFreeFun = Ptr () -> IO () foreign import ccall "wrapper" mkInstanceCreateFunPtr :: InstanceCreateFun -> IO (FunPtr InstanceCreateFun) foreign import ccall "wrapper" mkInstanceDestroyFunPtr :: InstanceDestroyFun -> IO (FunPtr InstanceDestroyFun) foreign import ccall "wrapper" mkInstanceFreeFunPtr :: InstanceFreeFun -> IO (FunPtr InstanceFreeFun) data InstanceCreateFunc = InstanceCreateFunc { godotInstanceCreateFunc :: !(FunPtr InstanceCreateFun) , godotInstanceCreateMethodData :: !(Ptr ()) , godotInstanceCreateFreeFunc :: !(FunPtr InstanceFreeFun) } deriving (Show, Eq) instance Storable InstanceCreateFunc where sizeOf _ = {#sizeof godot_instance_create_func#} alignment _ = {#alignof godot_instance_create_func#} peek ptr = InstanceCreateFunc <$> {#get godot_instance_create_func->create_func#} ptr <*> {#get godot_instance_create_func->method_data#} ptr <*> {#get godot_instance_create_func->free_func#} ptr poke ptr InstanceCreateFunc{..} = do {#set godot_instance_create_func->create_func#} ptr godotInstanceCreateFunc {#set godot_instance_create_func->method_data#} ptr godotInstanceCreateMethodData {#set godot_instance_create_func->free_func#} ptr godotInstanceCreateFreeFunc {#pointer *godot_instance_create_func as InstanceCreateFuncPtr -> InstanceCreateFunc #} data InstanceDestroyFunc = InstanceDestroyFunc { godotInstanceDestroyFunc :: !(FunPtr InstanceDestroyFun) , godotInstanceDestroyMethodData :: !(Ptr ()) , godotInstanceDestroyFreeFunc :: !(FunPtr InstanceFreeFun) } deriving (Show, Eq) instance Storable InstanceDestroyFunc where sizeOf _ = {#sizeof godot_instance_destroy_func#} alignment _ = {#alignof godot_instance_destroy_func#} peek ptr = InstanceDestroyFunc <$> {#get godot_instance_destroy_func->destroy_func#} ptr <*> {#get godot_instance_destroy_func->method_data#} ptr <*> {#get godot_instance_destroy_func->free_func#} ptr poke ptr InstanceDestroyFunc{..} = do {#set godot_instance_destroy_func->destroy_func#} ptr godotInstanceDestroyFunc {#set godot_instance_destroy_func->method_data#} ptr godotInstanceDestroyMethodData {#set godot_instance_destroy_func->free_func#} ptr godotInstanceDestroyFreeFunc {#pointer *godot_instance_destroy_func as InstanceDestroyFuncPtr -> InstanceDestroyFunc #} type InstanceMethodFun = Ptr GodotVariant -> Object -> Ptr () -> Ptr () -> CInt -> Ptr (Ptr GodotVariant) -> IO (Ptr GodotVariant) foreign import ccall "wrapper" mkInstanceMethodFunPtr :: InstanceMethodFun -> IO (FunPtr InstanceMethodFun) data InstanceMethod = InstanceMethod { godotInstanceMethod :: !(FunPtr InstanceMethodFun) , godotInstanceMethodData :: !(Ptr ()) , godotInstanceMethodFreeFunc :: !(FunPtr InstanceFreeFun) } deriving (Show, Eq) instance Storable InstanceMethod where sizeOf _ = {#sizeof godot_instance_method#} alignment _ = {#alignof godot_instance_method#} peek ptr = InstanceMethod <$> (castFunPtr <$> {#get godot_instance_method->method#} ptr) <*> {#get godot_instance_method->method_data#} ptr <*> {#get godot_instance_method->free_func#} ptr poke ptr InstanceMethod{..} = do {#set godot_instance_method->method#} ptr (castFunPtr godotInstanceMethod) {#set godot_instance_method->method_data#} ptr godotInstanceMethodData {#set godot_instance_method->free_func#} ptr godotInstanceMethodFreeFunc {#pointer *godot_instance_method as InstanceMethodPtr -> InstanceMethod #} newtype MethodAttributes = MethodAttributes MethodRpcMode deriving newtype (Show, Eq) instance Storable MethodAttributes where sizeOf _ = {#sizeof godot_method_attributes#} alignment _ = {#alignof godot_method_attributes#} peek ptr = (MethodAttributes . toEnum . fromIntegral) <$> {#get godot_method_attributes->rpc_type#} ptr poke ptr (MethodAttributes rpcType) = {#set godot_method_attributes->rpc_type#} ptr (fromIntegral $ fromEnum rpcType) {#pointer *godot_method_attributes as MethodAttributesPtr -> MethodAttributes #} type PropertyGetFun = Ptr GodotVariant -> Object -> Ptr () -> Ptr () -> IO (Ptr GodotVariant) foreign import ccall "wrapper" mkPropertyGetFunPtr :: PropertyGetFun -> IO (FunPtr PropertyGetFun) data PropertyGetFunc = PropertyGetFunc { godotPropertyGetFunc :: !(FunPtr PropertyGetFun) , godotPropertyGetMethodData :: !(Ptr ()) , godotPropertyGetFreeFunc :: !(FunPtr InstanceFreeFun) } deriving (Show, Eq) instance Storable PropertyGetFunc where sizeOf _ = {#sizeof godot_property_get_func#} alignment _ = {#alignof godot_property_get_func#} peek ptr = PropertyGetFunc <$> (castFunPtr <$> {#get godot_property_get_func->get_func#} ptr) <*> {#get godot_property_get_func->method_data#} ptr <*> {#get godot_property_get_func->free_func#} ptr poke ptr PropertyGetFunc{..} = do {#set godot_property_get_func->get_func#} ptr (castFunPtr godotPropertyGetFunc) {#set godot_property_get_func->method_data#} ptr godotPropertyGetMethodData {#set godot_property_get_func->free_func#} ptr godotPropertyGetFreeFunc {#pointer *godot_property_get_func as PropertyGetFuncPtr -> PropertyGetFunc #} type PropertySetFun = Object -> Ptr () -> Ptr () -> Ptr GodotVariant -> IO () foreign import ccall "wrapper" mkPropertySetFunPtr :: PropertySetFun -> IO (FunPtr PropertySetFun) data PropertySetFunc = PropertySetFunc { godotPropertySetFunc :: !(FunPtr PropertySetFun) , godotPropertySetMethodData :: !(Ptr ()) , godotPropertySetFreeFunc :: !(FunPtr InstanceFreeFun) } deriving (Show, Eq) instance Storable PropertySetFunc where sizeOf _ = {#sizeof godot_property_set_func#} alignment _ = {#alignof godot_property_set_func#} peek ptr = PropertySetFunc <$> {#get godot_property_set_func->set_func#} ptr <*> {#get godot_property_set_func->method_data#} ptr <*> {#get godot_property_set_func->free_func#} ptr poke ptr PropertySetFunc{..} = do {#set godot_property_set_func->set_func#} ptr godotPropertySetFunc {#set godot_property_set_func->method_data#} ptr godotPropertySetMethodData {#set godot_property_set_func->free_func#} ptr godotPropertySetFreeFunc {#pointer *godot_property_set_func as PropertySetFuncPtr -> PropertySetFunc #} getOpaqueFromStruct :: forall a b. OpaqueStorable a => (ForeignPtr a -> a) -> Ptr b -> Int -> IO a getOpaqueFromStruct con structPtr offset = do let start = structPtr `plusPtr` offset let size = opaqueSizeOf @a (fptr :: ForeignPtr a) <- mallocForeignPtrBytes size withForeignPtr fptr $ \ptr -> copyBytes ptr start size return $ con fptr setOpaqueFromStruct :: forall a b. (Coercible a (ForeignPtr a), OpaqueStorable a) => Ptr b -> a -> Int -> IO () setOpaqueFromStruct structPtr fptr offset = do let start = structPtr `plusPtr` offset let size = opaqueSizeOf @a withForeignPtr (coerce fptr :: ForeignPtr a) $ \ptr -> copyBytes start ptr size data PropertyAttributes = PropertyAttributes { godotPropertyAttributesRsetType :: !MethodRpcMode , godotPropertyAttributesType :: !GodotInt , godotPropertyAttributesHint :: !PropertyHint , godotPropertyAttributesHintString :: !GodotString , godotPropertyAttributesUsage :: !PropertyUsageFlags , godotPropertyAttributesDefaultValue :: !GodotVariant } instance Storable PropertyAttributes where sizeOf _ = {#sizeof godot_property_attributes#} alignment _ = {#alignof godot_property_attributes#} peek ptr = do godotPropertyAttributesRsetType <- (toEnum . fromIntegral) <$> {#get godot_property_attributes->rset_type#} ptr godotPropertyAttributesType <- {#get godot_property_attributes->type#} ptr godotPropertyAttributesHint <- (toEnum . fromIntegral) <$> {#get godot_property_attributes->hint#} ptr godotPropertyAttributesHintString <- getOpaqueFromStruct GodotString ptr {#offsetof godot_property_attributes->hint_string#} godotPropertyAttributesUsage <- PropertyUsageFlags <$> {#get godot_property_attributes->usage#} ptr godotPropertyAttributesDefaultValue <- getOpaqueFromStruct GodotVariant ptr {#offsetof godot_property_attributes->default_value#} return PropertyAttributes{..} poke ptr PropertyAttributes{..} = do {#set godot_property_attributes->rset_type#} ptr (fromIntegral . fromEnum $ godotPropertyAttributesRsetType) {#set godot_property_attributes->type#} ptr godotPropertyAttributesType {#set godot_property_attributes->hint#} ptr (fromIntegral . fromEnum $ godotPropertyAttributesHint) setOpaqueFromStruct ptr godotPropertyAttributesHintString {#offsetof godot_property_attributes->hint_string#} {#set godot_property_attributes->usage#} ptr (unPropertyUsageFlags godotPropertyAttributesUsage) setOpaqueFromStruct ptr godotPropertyAttributesDefaultValue {#offsetof godot_property_attributes->default_value#} {#pointer *godot_property_attributes as PropertyAttributesPtr -> PropertyAttributes #} data SignalArgument = SignalArgument { godotSignalArgumentName :: !GodotString , godotSignalArgumentType :: !GodotInt , godotSignalArgumentHint :: !PropertyHint , godotSignalArgumentHintString :: !GodotString , godotSignalArgumentUsage :: !PropertyUsageFlags , godotSignalArgumentDefaultValue :: !GodotVariant } instance Storable SignalArgument where sizeOf _ = {#sizeof godot_signal_argument#} alignment _ = {#alignof godot_signal_argument#} peek ptr = do godotSignalArgumentName <- getOpaqueFromStruct GodotString ptr {#offsetof godot_signal_argument->name#} godotSignalArgumentType <- {#get godot_signal_argument->type#} ptr godotSignalArgumentHint <- (toEnum . fromIntegral) <$> {#get godot_signal_argument->hint#} ptr godotSignalArgumentHintString <- getOpaqueFromStruct GodotString ptr {#offsetof godot_signal_argument->hint_string#} godotSignalArgumentUsage <- PropertyUsageFlags <$> {#get godot_signal_argument->usage#} ptr godotSignalArgumentDefaultValue <- getOpaqueFromStruct GodotVariant ptr {#offsetof godot_signal_argument->default_value#} return SignalArgument{..} poke ptr SignalArgument{..} = do setOpaqueFromStruct ptr godotSignalArgumentName {#offsetof godot_signal_argument->name#} {#set godot_signal_argument->type#} ptr godotSignalArgumentType {#set godot_signal_argument->hint#} ptr (fromIntegral . fromEnum $ godotSignalArgumentHint) setOpaqueFromStruct ptr godotSignalArgumentHintString {#offsetof godot_signal_argument->hint_string#} {#set godot_signal_argument->usage#} ptr (unPropertyUsageFlags godotSignalArgumentUsage) setOpaqueFromStruct ptr godotSignalArgumentDefaultValue {#offsetof godot_signal_argument->default_value#} {#pointer *godot_signal_argument as SignalArgumentPtr -> SignalArgument#} data Signal = Signal { godotSignalName :: !GodotString , godotSignalNumArgs :: !CInt , godotSignalArgs :: !(Ptr SignalArgument) , godotSignalNumDefaultArgs :: !CInt , godotSignalDefaultArgs :: !(Ptr GodotVariant) } instance Storable Signal where sizeOf _ = {#sizeof godot_signal#} alignment _ = {#alignof godot_signal#} peek ptr = do godotSignalName <- getOpaqueFromStruct GodotString ptr {#offsetof godot_signal->name#} godotSignalNumArgs <- {#get godot_signal->num_args#} ptr godotSignalArgs <- {#get godot_signal->args#} ptr godotSignalNumDefaultArgs <- {#get godot_signal->num_default_args#} ptr godotSignalDefaultArgs <- {#get godot_signal->default_args#} ptr return Signal{..} poke ptr Signal{..} = do setOpaqueFromStruct ptr godotSignalName {#offsetof godot_signal->name#} {#set godot_signal->num_args#} ptr godotSignalNumArgs {#set godot_signal->args#} ptr godotSignalArgs {#set godot_signal->num_default_args#} ptr godotSignalNumDefaultArgs {#set godot_signal->default_args#} ptr godotSignalDefaultArgs {#pointer *godot_signal as SignalPtr -> Signal#} data InstanceBindingFunctions instance Storable InstanceBindingFunctions where sizeOf _ = {#sizeof godot_instance_binding_functions#} alignment _ = {#sizeof godot_instance_binding_functions#} peek = error "InstanceBindingFunctions peek not implemented" poke = error "InstanceBindingFunctions poke not implemented" {#pointer *godot_instance_binding_functions as InstanceBindingFunctionsPtr -> InstanceBindingFunctions #} data MethodArg instance Storable MethodArg where sizeOf _ = {#sizeof godot_method_arg#} alignment _ = {#sizeof godot_method_arg#} peek = error "MethodArg peek not implemented" poke = error "MethodArg poke not implemented" {#pointer *godot_method_arg as MethodArgPtr -> MethodArg #} --net data NetStreamPeer instance Storable NetStreamPeer where sizeOf _ = {#sizeof godot_net_stream_peer#} alignment _ = {#sizeof godot_net_stream_peer#} peek = error "NetStreamPeer peek not implemented" poke = error "NetStreamPeer poke not implemented" {#pointer *godot_net_stream_peer as NetStreamPeerPtr -> NetStreamPeer #} data NetPacketPeer instance Storable NetPacketPeer where sizeOf _ = {#sizeof godot_net_packet_peer#} alignment _ = {#sizeof godot_net_packet_peer#} peek = error "NetPacketPeer peek not implemented" poke = error "NetPacketPeer poke not implemented" {#pointer *godot_net_packet_peer as NetPacketPeerPtr -> NetPacketPeer #} data NetMultiplayerPeer instance Storable NetMultiplayerPeer where sizeOf _ = {#sizeof godot_net_multiplayer_peer#} alignment _ = {#sizeof godot_net_multiplayer_peer#} peek = error "NetMultiplayerPeer peek not implemented" poke = error "NetMultiplayerPeer poke not implemented" {#pointer *godot_net_multiplayer_peer as NetMultiplayerPeerPtr -> NetMultiplayerPeer #} -- net webrtc data NetWebrtcLibrary instance Storable NetWebrtcLibrary where sizeOf _ = {#sizeof godot_net_webrtc_library#} alignment _ = {#sizeof godot_net_webrtc_library#} peek = error "NetWebrtcLibrary peek not implemented" poke = error "NetWebrtcLibrary poke not implemented" {#pointer *godot_net_webrtc_library as NetWebrtcLibraryPtr -> NetWebrtcLibrary #} data NetWebrtcPeerConnection instance Storable NetWebrtcPeerConnection where sizeOf _ = {#sizeof godot_net_webrtc_peer_connection#} alignment _ = {#sizeof godot_net_webrtc_peer_connection#} peek = error "NetWebrtcPeerConnection peek not implemented" poke = error "NetWebrtcPeerConnection poke not implemented" {#pointer *godot_net_webrtc_peer_connection as NetWebrtcPeerConnectionPtr -> NetWebrtcPeerConnection #} data NetWebrtcDataChannel instance Storable NetWebrtcDataChannel where sizeOf _ = {#sizeof godot_net_webrtc_data_channel#} alignment _ = {#sizeof godot_net_webrtc_data_channel#} peek = error "NetWebrtcDataChannel peek not implemented" poke = error "NetWebrtcDataChannel poke not implemented" {#pointer *godot_net_webrtc_data_channel as NetWebrtcDataChannelPtr -> NetWebrtcDataChannel #} --videodecoder data VideodecoderInterfaceGdnative instance Storable VideodecoderInterfaceGdnative where sizeOf _ = {#sizeof godot_videodecoder_interface_gdnative#} alignment _ = {#sizeof godot_videodecoder_interface_gdnative#} peek = error "VideodecoderInterfaceGdnative peek not implemented" poke = error "VideodecoderInterfaceGdnative poke not implemented" {#pointer *godot_videodecoder_interface_gdnative as VideodecoderInterfaceGdnativePtr -> VideodecoderInterfaceGdnative #} --arvr data ArvrInterfaceGdnative instance Storable ArvrInterfaceGdnative where sizeOf _ = {#sizeof godot_arvr_interface_gdnative#} alignment _ = {#sizeof godot_arvr_interface_gdnative#} peek = error "ArvrInterfaceGdnative peek not implemented" poke = error "ArvrInterfaceGdnative poke not implemented" {#pointer *godot_arvr_interface_gdnative as ArvrInterfaceGdnativePtr -> ArvrInterfaceGdnative #} gdnativeCoreApiStructRef :: IORef GdnativeCoreApiStruct gdnativeCoreApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeCoreApiStructRef too early" {-# NOINLINE gdnativeCoreApiStructRef #-} gdnativeCore11ApiStructRef :: IORef GdnativeCore11ApiStruct gdnativeCore11ApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeCore11ApiStructRef too early" {-# NOINLINE gdnativeCore11ApiStructRef #-} gdnativeLibraryRef :: IORef Object gdnativeLibraryRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeLibraryRef too early" {-# NOINLINE gdnativeLibraryRef #-} gdnativeCore12ApiStructRef :: IORef GdnativeCore12ApiStruct gdnativeCore12ApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeCore12ApiStructRef too early" {-# NOINLINE gdnativeCore12ApiStructRef #-} gdnativeExtNativescriptApiStructRef :: IORef GdnativeExtNativescriptApiStruct gdnativeExtNativescriptApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeExtNativescriptApiStructRef too early" {-# NOINLINE gdnativeExtNativescriptApiStructRef #-} gdnativeExtNativescript11ApiStructRef :: IORef GdnativeExtNativescript11ApiStruct gdnativeExtNativescript11ApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeExtNativescript11ApiStructRef too early" {-# NOINLINE gdnativeExtNativescript11ApiStructRef #-} gdnativeExtPluginscriptApiStructRef :: IORef GdnativeExtPluginscriptApiStruct gdnativeExtPluginscriptApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeExtPluginscriptApiStructRef too early" {-# NOINLINE gdnativeExtPluginscriptApiStructRef #-} gdnativeExtArvrApiStructRef :: IORef GdnativeExtArvrApiStruct gdnativeExtArvrApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeExtArvrApiStructRef too early" {-# NOINLINE gdnativeExtArvrApiStructRef #-} gdnativeExtVideodecoderApiStructRef :: IORef GdnativeExtVideodecoderApiStruct gdnativeExtVideodecoderApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeExtVideodecoderApiStructRef too early" {-# NOINLINE gdnativeExtVideodecoderApiStructRef #-} gdnativeExtNetApiStructRef :: IORef GdnativeExtNetApiStruct gdnativeExtNetApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeExtNetApiStructRef too early" {-# NOINLINE gdnativeExtNetApiStructRef #-} gdnativeExtNet32ApiStructRef :: IORef GdnativeExtNet32ApiStruct gdnativeExtNet32ApiStructRef = unsafePerformIO $ newIORef $ error "attempted to get gdnativeExtNet32ApiStructRef too early" {-# NOINLINE gdnativeExtNet32ApiStructRef #-} initApiStructs :: GdnativeInitOptions -> IO () initApiStructs opts = do let coreApi = gdnativeInitOptionsApiStruct opts writeIORef gdnativeCoreApiStructRef coreApi writeIORef gdnativeLibraryRef $ gdnativeInitOptionsGdNativeLibrary opts findExt GdnativeCore11ApiStruct gdnativeCore11ApiStructRef (coerce coreApi) 1 1 findExt GdnativeCore12ApiStruct gdnativeCore12ApiStructRef (coerce coreApi) 1 2 numExt <- {#get godot_gdnative_core_api_struct->num_extensions #} coreApi extsPtr <- {#get godot_gdnative_core_api_struct->extensions #} coreApi exts <- peekArray (fromIntegral numExt) (castPtr extsPtr :: Ptr GdnativeApiStruct) forM_ exts $ \ext -> do ty <- {#get godot_gdnative_api_struct->type #} ext -- HACK case ty of 1 -> do -- nativescript writeIORef gdnativeExtNativescriptApiStructRef (coerce ext) findExt GdnativeExtNativescript11ApiStruct gdnativeExtNativescript11ApiStructRef (coerce ext) 1 1 2 -> do -- pluginscript writeIORef gdnativeExtPluginscriptApiStructRef (coerce ext) 3 -> return () -- android 4 -> do -- arvr writeIORef gdnativeExtArvrApiStructRef (coerce ext) 5 -> do -- videodecoder writeIORef gdnativeExtVideodecoderApiStructRef (coerce ext) 6 -> do -- net writeIORef gdnativeExtNetApiStructRef (coerce ext) findExt GdnativeExtNet32ApiStruct gdnativeExtNet32ApiStructRef (coerce ext) 3 2 _ -> error $ "Unknown API struct type " ++ show ty where findExt con ref ext reqMajor reqMinor = do next <- {#get godot_gdnative_api_struct->next #} ext when (next /= coerce nullPtr) $ do major <- {#get godot_gdnative_api_struct->version.major #} next minor <- {#get godot_gdnative_api_struct->version.minor #} next if major == reqMajor && minor == reqMinor then writeIORef ref (con $ coerce next) else findExt con ref next reqMajor reqMinor ================================================ FILE: src/Godot/Gdnative/Internal/TH.hs ================================================ {-#LANGUAGE TemplateHaskell#-} module Godot.Gdnative.Internal.TH where import Data.Maybe import Godot.Gdnative.Internal.Gdnative import Language.Haskell.TH import Language.Haskell.TH.Syntax import Foreign import qualified Data.Text as T generateAsVariantInstances :: Q [Dec] generateAsVariantInstances = do (TyConI (DataD _ _ bndrs _ cons _)) <- lookupTypeName "Variant" >>= \(Just x) -> reify x let tys = mapMaybe getCon cons mapM mkInstance tys where getCon (NormalC name [(_, AppT (AppT _ _) ty)]) = Just (name, ty) getCon (NormalC name [(_, ty)]) = Just (name, ty) getCon _ = Nothing mkInstance (name, ty) = instanceD (cxt []) (appT (conT $ mkName "AsVariant") (return ty)) [ valD (varP $ mkName "toVariant") (normalB $ conE $ mkName $ nameBase name) [] , valD (varP $ mkName "fromVariant") (normalB [| \var -> case var of $(conP (mkName $ nameBase name) [varP $ mkName "x"]) -> Just x _ -> Nothing |]) [] , valD (varP $ mkName "variantType") (normalB [| \_ -> $(conE $ mkName $ T.unpack $ T.replace "Variant" "VariantType" $ T.pack $ nameBase name) |]) [] ] ================================================ FILE: src/Godot/Gdnative/Internal/Types.hs ================================================ {-# LANGUAGE BangPatterns, FunctionalDependencies, TypeFamilies, TypeInType, LambdaCase, TypeApplications, AllowAmbiguousTypes #-} module Godot.Gdnative.Internal.Types where import Control.Exception import qualified Data.ByteString as B import qualified Data.ByteString.Unsafe as B import Data.Text (Text) import qualified Data.Text.Encoding as T import Data.Colour import Data.Colour.SRGB import Data.Function ((&)) import Data.Typeable import Data.Coerce import Foreign import Foreign.C import Linear import qualified Data.Vector as V import qualified Data.Map as M import Godot.Gdnative.Internal.Api as I hiding (Rect2,Basis,Transform,Transform2d,Color) import Godot.Gdnative.Internal.Gdnative as I hiding (Rect2,Basis,Transform,Transform2d,Color) import qualified Godot.Gdnative.Internal.Api as G import qualified Godot.Gdnative.Internal.Gdnative as G import Godot.Gdnative.Internal.TH import System.IO.Unsafe data LibType = GodotTy | HaskellTy type family TypeOf (x :: LibType) a -- I'm torn about this instance. Need TH if not using this type instance TypeOf 'GodotTy a = a -- |GodotFFI is a relation between low-level and high-level -- |Godot types, and conversions between them. class GodotFFI low high | low -> high where fromLowLevel :: low -> IO high toLowLevel :: high -> IO low type instance TypeOf 'HaskellTy G.Array = V.Vector GodotVariant instance GodotFFI G.Array (V.Vector GodotVariant) where fromLowLevel arr = do len <- fromIntegral <$> godot_array_size arr V.generateM len (godot_array_get arr . fromIntegral) toLowLevel vec = do arr <- godot_array_new V.mapM_ (godot_array_append arr) vec pure arr type instance TypeOf 'HaskellTy GodotString = Text instance GodotFFI GodotString Text where fromLowLevel str = godot_string_utf8 str >>= \cstr -> T.decodeUtf8 <$> fromCharString cstr where fromCharString cstr = do len <- godot_char_string_length cstr sptr <- godot_char_string_get_data cstr B.packCStringLen (sptr, fromIntegral len) toLowLevel txt = B.unsafeUseAsCStringLen bstr $ \(ptr, len) -> godot_string_chars_to_utf8_with_len ptr (fromIntegral len) where bstr = T.encodeUtf8 txt type instance TypeOf 'HaskellTy Vector2 = V2 Float instance GodotFFI Vector2 (V2 Float) where fromLowLevel v = V2 <$> (realToFrac <$> godot_vector2_get_x v) <*> (realToFrac <$> godot_vector2_get_y v) toLowLevel (V2 x y) = godot_vector2_new (realToFrac x) (realToFrac y) type instance TypeOf 'HaskellTy Vector3 = V3 Float instance GodotFFI Vector3 (V3 Float) where fromLowLevel v = V3 <$> (realToFrac <$> godot_vector3_get_axis v Vector3AxisX) <*> (realToFrac <$> godot_vector3_get_axis v Vector3AxisY) <*> (realToFrac <$> godot_vector3_get_axis v Vector3AxisZ) toLowLevel (V3 x y z) = godot_vector3_new (realToFrac x) (realToFrac y) (realToFrac z) type instance TypeOf 'HaskellTy Quat = Quaternion Float instance GodotFFI Quat (Quaternion Float) where fromLowLevel q = Quaternion <$> (realToFrac <$> godot_quat_get_w q) <*> (V3 <$> (realToFrac <$> godot_quat_get_x q) <*> (realToFrac <$> godot_quat_get_y q) <*> (realToFrac <$> godot_quat_get_z q)) toLowLevel (Quaternion w (V3 x y z)) = godot_quat_new (realToFrac x) (realToFrac y) (realToFrac z) (realToFrac w) type Rect2 = M22 Float type instance TypeOf 'HaskellTy G.Rect2 = Rect2 instance GodotFFI G.Rect2 Rect2 where fromLowLevel r = V2 <$> (fromLowLevel =<< godot_rect2_get_position r) <*> (fromLowLevel =<< godot_rect2_get_size r) toLowLevel (V2 pos size) = do pos' <- toLowLevel pos size' <- toLowLevel size godot_rect2_new_with_position_and_size pos' size' type AABB = M23 Float type instance TypeOf 'HaskellTy Aabb = AABB instance GodotFFI Aabb AABB where fromLowLevel aabb = V2 <$> (fromLowLevel =<< godot_aabb_get_position aabb) <*> (fromLowLevel =<< godot_aabb_get_size aabb) toLowLevel (V2 pos size) = do pos' <- toLowLevel pos size' <- toLowLevel size godot_aabb_new pos' size' -- Axes X, Y and Z are represented by the int constants 0, 1 and 2 respectively (at least for Vector3): -- https://godot.readthedocs.io/en/latest/classes/class_vector3.html?highlight=axis#numeric-constants type Basis = M33 Float type instance TypeOf 'HaskellTy G.Basis = Basis instance GodotFFI G.Basis Basis where fromLowLevel b = V3 <$> (llAxis 0) <*> (llAxis 1) <*> (llAxis 2) where llAxis axis = fromLowLevel =<< godot_basis_get_axis b axis toLowLevel (V3 x y z) = do x' <- toLowLevel x y' <- toLowLevel y z' <- toLowLevel z godot_basis_new_with_rows x' y' z' data Transform = TF { _tfBasis :: Basis, _tfPosition :: V3 Float } type instance TypeOf 'HaskellTy G.Transform = Transform instance GodotFFI G.Transform Transform where fromLowLevel tf = TF <$> (fromLowLevel =<< godot_transform_get_basis tf) <*> (fromLowLevel =<< godot_transform_get_origin tf) toLowLevel (TF basis orig) = do basis' <- toLowLevel basis orig' <- toLowLevel orig godot_transform_new basis' orig' type Basis2d = M22 Float data Transform2d = TF2d { _tf2dX :: V2 Float, _tf2dY :: V2 Float, _tf2dOrigin :: V2 Float } type instance TypeOf 'HaskellTy G.Transform2d = Transform2d instance GodotFFI G.Transform2d Transform2d where fromLowLevel tf = do x <- godot_transform2d_xform_vector2 tf =<< toLowLevel (V2 1 0) y <- godot_transform2d_xform_vector2 tf =<< toLowLevel (V2 0 1) TF2d <$> fromLowLevel x <*> fromLowLevel y <*> (fromLowLevel =<< godot_transform2d_get_origin tf) toLowLevel (TF2d x y o) = do x' <- toLowLevel x y' <- toLowLevel y o' <- toLowLevel o godot_transform2d_new_axis_origin x' o' y' -- This should perhaps be better modeled - FilePath? type instance TypeOf 'HaskellTy G.NodePath = Text instance GodotFFI G.NodePath Text where fromLowLevel np = fromLowLevel =<< godot_node_path_get_name np 0 toLowLevel np = godot_node_path_new =<< toLowLevel np type instance TypeOf 'HaskellTy G.Color = AlphaColour Double instance GodotFFI G.Color (AlphaColour Double) where fromLowLevel c = withOpacity <$> (sRGB <$> (realToFrac <$> godot_color_get_r c) <*> (realToFrac <$> godot_color_get_g c) <*> (realToFrac <$> godot_color_get_b c)) <*> (realToFrac <$> godot_color_get_a c) toLowLevel rgba = toSRGB (rgba `over` black) & \(RGB r g b) -> godot_color_new_rgba (realToFrac r) (realToFrac g) (realToFrac b) (realToFrac $ alphaChannel rgba) type instance TypeOf 'HaskellTy G.PoolStringArray = V.Vector Text instance GodotFFI G.PoolStringArray (V.Vector Text) where fromLowLevel a = do sz <- godot_pool_string_array_size a V.generateM (fromIntegral sz) (\x -> fromLowLevel =<< godot_pool_string_array_get a (fromIntegral x)) toLowLevel v = do p <- godot_pool_string_array_new V.mapM_ (\e -> do s <- toLowLevel e godot_pool_string_array_append p s) v pure p type instance TypeOf 'HaskellTy G.PoolVector2Array = V.Vector (V2 Float) instance GodotFFI G.PoolVector2Array (V.Vector (V2 Float)) where fromLowLevel a = do sz <- godot_pool_vector2_array_size a V.generateM (fromIntegral sz) (\x -> fromLowLevel =<< godot_pool_vector2_array_get a (fromIntegral x)) toLowLevel v = do p <- godot_pool_vector2_array_new V.mapM_ (\e -> do s <- toLowLevel e godot_pool_vector2_array_append p s) v pure p type instance TypeOf 'HaskellTy G.PoolVector3Array = V.Vector (V3 Float) instance GodotFFI G.PoolVector3Array (V.Vector (V3 Float)) where fromLowLevel a = do sz <- godot_pool_vector3_array_size a V.generateM (fromIntegral sz) (\x -> fromLowLevel =<< godot_pool_vector3_array_get a (fromIntegral x)) toLowLevel v = do p <- godot_pool_vector3_array_new V.mapM_ (\e -> do s <- toLowLevel e godot_pool_vector3_array_append p s) v pure p type instance TypeOf 'HaskellTy G.PoolIntArray = V.Vector Int instance GodotFFI G.PoolIntArray (V.Vector Int) where fromLowLevel a = do sz <- godot_pool_int_array_size a V.generateM (fromIntegral sz) (\x -> fromIntegral <$> godot_pool_int_array_get a (fromIntegral x)) toLowLevel v = do p <- godot_pool_int_array_new V.mapM_ (godot_pool_int_array_append p . fromIntegral) v pure p type instance TypeOf 'HaskellTy G.PoolRealArray = V.Vector Float instance GodotFFI G.PoolRealArray (V.Vector Float) where fromLowLevel a = do sz <- godot_pool_real_array_size a V.generateM (fromIntegral sz) (\x -> coerce <$> godot_pool_real_array_get a (fromIntegral x)) toLowLevel v = do p <- godot_pool_real_array_new V.mapM_ (godot_pool_real_array_append p . coerce) v pure p type instance TypeOf 'HaskellTy G.PoolColorArray = V.Vector (AlphaColour Double) instance GodotFFI G.PoolColorArray (V.Vector (AlphaColour Double)) where fromLowLevel a = do sz <- godot_pool_color_array_size a V.generateM (fromIntegral sz) (\x -> fromLowLevel =<< godot_pool_color_array_get a (fromIntegral x)) toLowLevel v = do p <- godot_pool_color_array_new V.mapM_ (\e -> do s <- toLowLevel e godot_pool_color_array_append p s) v pure p type instance TypeOf 'HaskellTy G.Dictionary = V.Vector (GodotVariant, GodotVariant) instance GodotFFI G.Dictionary (V.Vector (GodotVariant, GodotVariant)) where fromLowLevel a = do k <- fromLowLevel =<< godot_dictionary_keys a v <- fromLowLevel =<< godot_dictionary_values a pure $ V.zipWith (,) k v toLowLevel v = do d <- godot_dictionary_new V.mapM_ (\(k,v) -> godot_dictionary_set d k v) v pure d -- Variants data Variant (ty :: LibType) = VariantNil | VariantBool !Bool | VariantInt !Int | VariantReal !Float | VariantString !(TypeOf ty GodotString) | VariantVector2 !(TypeOf ty G.Vector2) | VariantRect2 !(TypeOf ty G.Rect2) | VariantVector3 !(TypeOf ty G.Vector3) | VariantTransform2d !(TypeOf ty G.Transform2d) | VariantPlane !(TypeOf ty G.Plane) | VariantQuat !(TypeOf ty G.Quat) | VariantAabb !(TypeOf ty Aabb) | VariantBasis !(TypeOf ty G.Basis) | VariantTransform !(TypeOf ty G.Transform) | VariantColor !(TypeOf ty G.Color) | VariantNodePath !(TypeOf ty G.NodePath) | VariantRid !(TypeOf ty G.Rid) | VariantObject !(TypeOf ty G.Object) | VariantDictionary !(TypeOf ty G.Dictionary) | VariantArray !(TypeOf ty G.Array) | VariantPoolByteArray !(TypeOf ty G.PoolByteArray) | VariantPoolIntArray !(TypeOf ty G.PoolIntArray) | VariantPoolRealArray !(TypeOf ty G.PoolRealArray) | VariantPoolStringArray !(TypeOf ty G.PoolStringArray) | VariantPoolVector2Array !(TypeOf ty G.PoolVector2Array) | VariantPoolVector3Array !(TypeOf ty G.PoolVector3Array) | VariantPoolColorArray !(TypeOf ty G.PoolColorArray) instance GodotFFI GodotVariant (Variant 'GodotTy) where fromLowLevel var = godot_variant_get_type var >>= \case VariantTypeNil -> return VariantNil VariantTypeBool -> VariantBool . (/= 0) <$> godot_variant_as_bool var VariantTypeInt -> VariantInt . fromIntegral <$> godot_variant_as_int var VariantTypeReal -> VariantReal . realToFrac <$> godot_variant_as_real var VariantTypeString -> VariantString <$> godot_variant_as_string var VariantTypeVector2 -> VariantVector2 <$> godot_variant_as_vector2 var VariantTypeRect2 -> VariantRect2 <$> godot_variant_as_rect2 var VariantTypeVector3 -> VariantVector3 <$> godot_variant_as_vector3 var VariantTypeTransform2d -> VariantTransform2d <$> godot_variant_as_transform2d var VariantTypePlane -> VariantPlane <$> godot_variant_as_plane var VariantTypeQuat -> VariantQuat <$> godot_variant_as_quat var VariantTypeAabb -> VariantAabb <$> godot_variant_as_aabb var VariantTypeBasis -> VariantBasis <$> godot_variant_as_basis var VariantTypeTransform -> VariantTransform <$> godot_variant_as_transform var VariantTypeColor -> VariantColor <$> godot_variant_as_color var VariantTypeNodePath -> VariantNodePath <$> godot_variant_as_node_path var VariantTypeRid -> VariantRid <$> godot_variant_as_rid var VariantTypeObject -> VariantObject <$> godot_variant_as_object var VariantTypeDictionary -> VariantDictionary <$> godot_variant_as_dictionary var VariantTypeArray -> VariantArray <$> godot_variant_as_array var VariantTypePoolByteArray -> VariantPoolByteArray <$> godot_variant_as_pool_byte_array var VariantTypePoolIntArray -> VariantPoolIntArray <$> godot_variant_as_pool_int_array var VariantTypePoolRealArray -> VariantPoolRealArray <$> godot_variant_as_pool_real_array var VariantTypePoolStringArray -> VariantPoolStringArray <$> godot_variant_as_pool_string_array var VariantTypePoolVector2Array -> VariantPoolVector2Array <$> godot_variant_as_pool_vector2_array var VariantTypePoolVector3Array -> VariantPoolVector3Array <$> godot_variant_as_pool_vector3_array var VariantTypePoolColorArray -> VariantPoolColorArray <$> godot_variant_as_pool_color_array var toLowLevel VariantNil = godot_variant_new_nil toLowLevel (VariantBool b) = godot_variant_new_bool . fromIntegral $ fromEnum b toLowLevel (VariantInt i) = godot_variant_new_int (fromIntegral i) toLowLevel (VariantReal r) = godot_variant_new_real (realToFrac r) toLowLevel (VariantString x) = godot_variant_new_string x toLowLevel (VariantVector2 x) = godot_variant_new_vector2 x toLowLevel (VariantRect2 x) = godot_variant_new_rect2 x toLowLevel (VariantVector3 x) = godot_variant_new_vector3 x toLowLevel (VariantTransform2d x) = godot_variant_new_transform2d x toLowLevel (VariantPlane x) = godot_variant_new_plane x toLowLevel (VariantQuat x) = godot_variant_new_quat x toLowLevel (VariantAabb x) = godot_variant_new_aabb x toLowLevel (VariantBasis x) = godot_variant_new_basis x toLowLevel (VariantTransform x) = godot_variant_new_transform x toLowLevel (VariantColor x) = godot_variant_new_color x toLowLevel (VariantNodePath x) = godot_variant_new_node_path x toLowLevel (VariantRid x) = godot_variant_new_rid x toLowLevel (VariantObject x) = godot_variant_new_object x toLowLevel (VariantDictionary x) = godot_variant_new_dictionary x toLowLevel (VariantArray x) = godot_variant_new_array x toLowLevel (VariantPoolByteArray x) = godot_variant_new_pool_byte_array x toLowLevel (VariantPoolIntArray x) = godot_variant_new_pool_int_array x toLowLevel (VariantPoolRealArray x) = godot_variant_new_pool_real_array x toLowLevel (VariantPoolStringArray x) = godot_variant_new_pool_string_array x toLowLevel (VariantPoolVector2Array x) = godot_variant_new_pool_vector2_array x toLowLevel (VariantPoolVector3Array x) = godot_variant_new_pool_vector3_array x toLowLevel (VariantPoolColorArray x) = godot_variant_new_pool_color_array x withVariantArray :: [Variant 'GodotTy] -> ((Ptr (Ptr GodotVariant), CInt) -> IO a) -> IO a withVariantArray vars mtd = allocaArray (length vars) $ \arrPtr -> withVars vars 0 arrPtr mtd where withVars (x:xs) n arrPtr mtd = do vt <- toLowLevel x res <- withGodotVariant vt $ \vtPtr -> do poke (advancePtr arrPtr n) vtPtr withVars xs (n+1) arrPtr mtd godot_variant_destroy vt return res withVars [] n arrPtr mtd = mtd (arrPtr, fromIntegral n) defaultedVariant :: (GodotFFI t high, AsVariant a) => (t -> Variant 'GodotTy) -> high -> Maybe a -> Variant 'GodotTy defaultedVariant ty o = maybe (ty $ unsafePerformIO $ toLowLevel o) toVariant {-# NOINLINE defaultedVariant #-} throwIfErr :: VariantCallError -> IO () throwIfErr err = case variantCallErrorError err of CallErrorCallOk -> return () _ -> throwIO err class AsVariant a where toVariant :: a -> Variant 'GodotTy fromVariant :: Variant 'GodotTy -> Maybe a variantType :: a -> VariantType instance AsVariant () where toVariant _ = VariantNil fromVariant VariantNil = Just () fromVariant _ = Nothing variantType _ = VariantTypeNil instance AsVariant GodotVariant where toVariant v = let !res = unsafePerformIO $ fromLowLevel v in res fromVariant v = let !res = unsafePerformIO $ toLowLevel v in Just res variantType v = let !res = unsafePerformIO $ godot_variant_get_type v in res $(generateAsVariantInstances) toGodotVariant :: forall a. (Typeable a, AsVariant a) => a -> IO GodotVariant toGodotVariant = toLowLevel . toVariant fromGodotVariant :: forall a. (Typeable a, AsVariant a) => GodotVariant -> IO a fromGodotVariant var = do res <- fromVariant <$> fromLowLevel var case res of Just x -> x `seq` return x Nothing -> do haveTy <- godot_variant_get_type var let expTy = typeOf (undefined :: a) error $ "Error in API: couldn't fromVariant. have: " ++ show haveTy ++ ", expected: " ++ show expTy ================================================ FILE: src/Godot/Gdnative/Internal.hs ================================================ module Godot.Gdnative.Internal (module M) where import Godot.Gdnative.Internal.Gdnative as M import Godot.Gdnative.Internal.Api as M import Godot.Gdnative.Internal.Types as M hiding (Rect2,Basis,Transform,Transform2d,Color,Signal) ================================================ FILE: src/Godot/Gdnative.hs ================================================ module Godot.Gdnative(module T, module I) where import Godot.Gdnative.Internal.Types as T import Godot.Gdnative.Internal as I hiding (Rect2,Basis,Transform,Transform2d,NodePath,Color,Signal,PropertyAttributes,SignalArgument) ================================================ FILE: src/Godot/Internal/Dispatch.hs ================================================ {-# LANGUAGE TemplateHaskell, AllowAmbiguousTypes #-} module Godot.Internal.Dispatch(HasBaseClass(..),(:<)(..),Signal(..),deriveBase,NodeSignal, NodeMethod(..),NodeProperty(..),ListToFun(..),OptionalSetter(..), ClassProperty(..),PropertyAttributes(..), wrapIndexedGetter,wrapIndexedSetter, wrapDroppingSetter) where import Data.Text (Text) import GHC.TypeLits as T import Godot.Gdnative.Internal.Gdnative hiding (Signal,PropertyAttributes) import Godot.Gdnative.Internal.Types import Language.Haskell.TH import Language.Haskell.TH.Datatype import Control.Monad import Data.List import Data.Typeable -- | Establishes 'child` as a child of BaseClass child` class HasBaseClass child where type BaseClass child super :: child -> BaseClass child -- | This is here to make signals accessible to the type system -- You will have to define this for your own objects as well, eg: -- instance NodeSignal Player "on_start" [] class NodeSignal node (name :: Symbol) (args :: [*]) | node name -> args type family ListToFun (l :: [*]) ret where ListToFun (h:t) ret = h -> ListToFun t ret ListToFun '[] ret = ret -- | This is here to make methods accessible to the type system -- You will have to define this for your own objects as well, eg: -- instance NodeMethod Player "on_start" [] Int where -- nodeMethod = on_start class NodeMethod node (name :: Symbol) (args :: [*]) (ret :: *) | node name -> args, node name -> ret where nodeMethod :: node -> ListToFun args ret type family OptionalSetter (ro :: Bool) ty where OptionalSetter 'True ty = () OptionalSetter 'False ty = ty wrapIndexedGetter :: Int -> (node -> Int -> IO ty) -> (node -> IO ty) wrapIndexedGetter i f node = f node i wrapIndexedSetter :: Int -> (node -> Int -> ty -> IO a) -> (node -> ty -> IO ()) wrapIndexedSetter i f node ty = f node i ty >> pure () -- | This exists because one property in api.json StreamTexture load_path -- doesn't obey the rules that al other functions do, its setter, @load@, -- returns (IO Int) instead of (IO ()) wrapDroppingSetter :: (node -> ty -> IO a) -> (node -> ty -> IO ()) wrapDroppingSetter f node ty = f node ty >> pure () data PropertyAttributes = PropertyAttributes { propertySetType :: !MethodRpcMode , propertyType :: !VariantType , propertyHint :: !PropertyHint , propertyHintString :: !Text , propertyUsage :: !PropertyUsageFlags , propertyDefaultValue :: !(Variant 'GodotTy) } data ClassProperty cls = ClassProperty { propertyName :: Text , propertyAttrs :: PropertyAttributes , propertySetter :: Object -> cls -> GodotVariant -> IO () , propertyGetter :: Object -> cls -> IO GodotVariant } -- | A setter and getter exposed to Haskell along with optional data need to implement this property in Godot. -- User-defined attributes must have this additioanl data, but properties that already exist in Godot do not. class (Typeable ty, AsVariant ty) => NodeProperty node (name :: Symbol) ty (ro :: Bool) | node name -> ty, node name -> ro where nodeProperty :: (node -> IO ty ,OptionalSetter ro (node -> ty -> IO ()) ,Maybe (Object -> node -> IO GodotVariant ,Object -> node -> GodotVariant -> IO () ,PropertyAttributes)) -- | You should use this as @deriveBase ''Ty@ to create all the required parent -- instances of '(:<)' for upcasting your data. deriveBase :: Name -> Q [Dec] deriveBase ty = do rdt <- reifyDatatype ty let appliedTy = appsT (ConT ty) [ case typeBinder of PlainTV n -> VarT n KindedTV n _ -> VarT n | typeBinder <- datatypeVars rdt ] r <- reify ''BaseClass case r of FamilyI _ instDecs -> do liftM nub $ concatQ (\(child,parent) -> do liftM2 (++) [d|instance $(pure appliedTy) :< $(pure appliedTy) where upcast = id|] (parentInstances instDecs child child)) $ relevantTySynEqns (map (\(TySynInstD eqn) -> eqn) instDecs) (ConT ty) -- | Subclass relation. Instances should be automatically derived with -- 'deriveBase'. You can define instances yourself, but you should ensure that -- they are transitive (if A :< B and B :< C then you should also define A :< -- C). class parent :< child where upcast :: child -> parent instance Object :< Object where upcast = id newtype Signal a = Signal Text deriving (Show, Eq) appsT :: Type -> [Type] -> Type appsT t [] = t appsT t (x:xs) = appsT (AppT t x) xs relevantTySynEqns :: [TySynEqn] -> Type -> [(Type,Type)] relevantTySynEqns [] _ = [] relevantTySynEqns (TySynEqn _ (AppT _ child) parent:ts) ty | isRelevant child ty = (child,parent):relevantTySynEqns ts ty | otherwise = relevantTySynEqns ts ty where isRelevant (AppT t _) ty = isRelevant t ty isRelevant t@(ConT _) ty = t == ty isRelevant t ty = error $ "Unhandled type family member " ++ show t ++ " when making parent instances for type " ++ show ty relevantTySynEqns x ty = error $ "Unhandled type member " ++ show x ++ " when deriving parent instances for type " ++ show ty compatible :: Type -> Type -> Bool compatible (AppT at at') (AppT bt bt') = compatible at bt && compatible at' bt' compatible a@(ConT _) b@(ConT _) = a == b -- NB Only true because we don't handle foralls compatible (VarT _) (VarT _) = True compatible a b = a == b parentInstances :: [InstanceDec] -> Type -> Type -> Q [Dec] parentInstances instDecs superType targetType = concat <$> (mapM (\(child,parent) -> if parent == targetType then pure [] else (liftM2 (++) [d|instance $(pure parent) :< $(pure targetType) where upcast = upcast . super|] (if parent == superType then pure [] else (parentInstances instDecs parent targetType)))) $ filter (\(child,parent) -> compatible superType child) $ map (\(TySynInstD (TySynEqn _ (AppT _ child) parent)) -> (child,parent)) instDecs) concatQ f l = concat <$> mapM f l ================================================ FILE: src/Godot/Nativescript.hs ================================================ {-# LANGUAGE BangPatterns #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE RecursiveDo #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE LambdaCase #-} module Godot.Nativescript ( ClassName , GFunc , GdnativeHandle , NativeScript(..) , ClassMethod(..) , ClassProperty(..) , ClassSignal(..) , RPC(..) , Registerer(..) , PropertyAttributes(..) , SignalArgument(..) , deriveBase , func , method , method0 , method1 , method2 , method3 , method4 , method5 , nameOf , registerClass , registerProperty , registerSignal , registerMethod , signal , tryCast , tryCast' , tryObjectCast , asNativeScript , convertClassName , unConvertClassName , getNode , getNodeNativeScript , new , newNativeScript , getSingleton , getEngine , copyVariant , scriptDesc , defaultExports , await , WrapperStablePtr(..) , createMVarProperty , guardError , getError , GodotError(..) ) where import Control.Monad import Data.Typeable import Data.Text ( Text ) import qualified Data.Text as T import Data.Vector ( Vector ) import qualified Data.Vector as Vec import qualified Data.Vector as V import Data.Function ( (&) ) import qualified Data.Set as S import Control.Concurrent.MVar import Foreign hiding (void,new) import Foreign.C hiding (new) import System.Environment import System.IO.Unsafe import qualified Godot.Gdnative.Internal as GNI import Godot.Gdnative import Godot.Internal.Dispatch import Data.Maybe ( fromMaybe ) import qualified Foreign.Marshal as F import qualified Foreign.Marshal.Utils as F import qualified Foreign.C as Foreign import qualified Godot.Api as Api import qualified Data.Map.Strict as M import Data.Coerce import qualified Godot.Core.NativeScript as NativeScript import Godot.Core.GlobalConstants import Godot.Core.ClassDB import Godot.Core.Engine import Godot.Core.Node import Godot.Core.Object as Object import Godot.Core.Reference import Data.IORef import Foreign.StablePtr import Control.Monad.Extra import Control.Exception import Data.Maybe type GdnativeHandle = Ptr () data GodotError = GFailed -- ^ Generic error. | GUnavailable -- ^ Unavailable error. | GUnconfigured -- ^ Unconfigured error. | GUnauthorized -- ^ Unauthorized error. | GParameterRangeError -- ^ Parameter range error. | GOutOfMemory -- ^ Out of memory (OOM) error. | GFileNotFound -- ^ File: Not found error. | GFileBadDrive -- ^ File: Bad drive error. | GFileBadPath -- ^ File: Bad path error. | GFileNoPermission -- ^ File: No permission error. | GFileAlreadyInUse -- ^ File: Already in use error. | GFileCantOpen -- ^ File: Can't open error. | GFileCantWrite -- ^ File: Can't write error. | GFileCantRead -- ^ File: Can't read error. | GFileUnrecognized -- ^ File: Unrecognized error. | GFileCorrupt -- ^ File: Corrupt error. | GFileMissingDependencies -- ^ File: Missing dependencies error. | GFileEof -- ^ File: End of file (EOF) error. | GCantOpen -- ^ Can't open error. | GCantCreate -- ^ Can't create error. | GQueryFailed -- ^ Query failed error. | GAlreadyInUse -- ^ Already in use error. | GLocked -- ^ Locked error. | GTimeout -- ^ Timeout error. | GCantConnect -- ^ Can't connect error. | GCantResolve -- ^ Can't resolve error. | GConnectionError -- ^ Connection error. | GCantAcquireResource -- ^ Can't acquire resource error. | GCantFork -- ^ Can't fork process error. | GInvalidData -- ^ Invalid data error. | GInvalidParameter -- ^ Invalid parameter error. | GAlreadyExists -- ^ Already exists error. | GDoesNotExist -- ^ Does not exist error. | GDatabaseCantRead -- ^ Database: Read error. | GDatabaseCantWrite -- ^ Database: Write error. | GCompilationFailed -- ^ Compilation failed error. | GMethodNotFound -- ^ Method not found error. | GLinkFailed -- ^ Linking failed error. | GScriptFailed -- ^ Script failed error. | GCyclicLink -- ^ Cycling link (import cycle) error. | GInvalidDeclaration -- ^ Invalid declaration error. | GDuplicateSymbol -- ^ Duplicate symbol error. | GParseError -- ^ Parse error. | GBusy -- ^ Busy error. | GSkip -- ^ Skip error. | GHelp -- ^ Help error. | GBug -- ^ Bug error. | GPrinterOnFire -- ^ Printer on fire error. (This is an easter egg, no engine methods return this error code.) deriving (Show, Eq, Typeable) instance Exception GodotError getError :: Int -> Maybe GodotError getError e | e == _OK = Nothing | e == _FAILED = Just GFailed | e == _ERR_UNAVAILABLE = Just GUnavailable | e == _ERR_UNCONFIGURED = Just GUnconfigured | e == _ERR_UNAUTHORIZED = Just GUnauthorized | e == _ERR_PARAMETER_RANGE_ERROR = Just GParameterRangeError | e == _ERR_OUT_OF_MEMORY = Just GOutOfMemory | e == _ERR_FILE_NOT_FOUND = Just GFileNotFound | e == _ERR_FILE_BAD_DRIVE = Just GFileBadDrive | e == _ERR_FILE_BAD_PATH = Just GFileBadPath | e == _ERR_FILE_NO_PERMISSION = Just GFileNoPermission | e == _ERR_FILE_ALREADY_IN_USE = Just GFileAlreadyInUse | e == _ERR_FILE_CANT_OPEN = Just GFileCantOpen | e == _ERR_FILE_CANT_WRITE = Just GFileCantWrite | e == _ERR_FILE_CANT_READ = Just GFileCantRead | e == _ERR_FILE_UNRECOGNIZED = Just GFileUnrecognized | e == _ERR_FILE_CORRUPT = Just GFileCorrupt | e == _ERR_FILE_MISSING_DEPENDENCIES = Just GFileMissingDependencies | e == _ERR_FILE_EOF = Just GFileEof | e == _ERR_CANT_OPEN = Just GCantOpen | e == _ERR_CANT_CREATE = Just GCantCreate | e == _ERR_QUERY_FAILED = Just GQueryFailed | e == _ERR_ALREADY_IN_USE = Just GAlreadyInUse | e == _ERR_LOCKED = Just GLocked | e == _ERR_TIMEOUT = Just GTimeout | e == _ERR_CANT_CONNECT = Just GCantConnect | e == _ERR_CANT_RESOLVE = Just GCantResolve | e == _ERR_CONNECTION_ERROR = Just GConnectionError | e == _ERR_CANT_ACQUIRE_RESOURCE = Just GCantAcquireResource | e == _ERR_CANT_FORK = Just GCantFork | e == _ERR_INVALID_DATA = Just GInvalidData | e == _ERR_INVALID_PARAMETER = Just GInvalidParameter | e == _ERR_ALREADY_EXISTS = Just GAlreadyExists | e == _ERR_DOES_NOT_EXIST = Just GDoesNotExist | e == _ERR_DATABASE_CANT_READ = Just GDatabaseCantRead | e == _ERR_DATABASE_CANT_WRITE = Just GDatabaseCantWrite | e == _ERR_COMPILATION_FAILED = Just GCompilationFailed | e == _ERR_METHOD_NOT_FOUND = Just GMethodNotFound | e == _ERR_LINK_FAILED = Just GLinkFailed | e == _ERR_SCRIPT_FAILED = Just GScriptFailed | e == _ERR_CYCLIC_LINK = Just GCyclicLink | e == _ERR_INVALID_DECLARATION = Just GInvalidDeclaration | e == _ERR_DUPLICATE_SYMBOL = Just GDuplicateSymbol | e == _ERR_PARSE_ERROR = Just GParseError | e == _ERR_BUSY = Just GBusy | e == _ERR_SKIP = Just GSkip | e == _ERR_HELP = Just GHelp | e == _ERR_BUG = Just GBug | e == _ERR_PRINTER_ON_FIRE = Just GPrinterOnFire | otherwise = error $ "Unknown Godot error; this is a bug in the Haskell bindings: " ++ show e guardError :: Int -> () guardError = maybe () throw . getError {-| 'NativeScript' defines a new Godot class. First you must create an instance of 'HasBaseClass' for inheritance and upcasting to parent class. Then you'll need an instance of 'NativeScript'. Finally, the splice 'deriveBase' handles creating all the parent-child relationships. To actually use your class, you'll need to register it with 'registerClass'. TODO Check that this example still works Example usage: @ data MyClass1 = MyClass1 { _mc1Obj :: Node , _mc1Time :: MVar Float } instance HasBaseClass MyClass1 where type BaseClass MyClass1 = Node super (MyClass1 p _) = p instance NativeScript MyClass1 where classInit p = MyClass1 p <$> newMVar 0 classMethods = [ func NoRPC "_ready" $ \self [] -> do sigName <- toLowLevel "on_MyClass1_ready" :: IO GodotString msg <- toLowLevel ("MyClass1 is ready" :: Text) :: IO GodotString let msgVt = toVariant msg G.emit_signal (upcast self :: Object) sigName [msgVt] , func NoRPC "_process" $ \self [deltaVt] -> do delta <- fromVariant deltaVt atomically $ modifyMVar' (_mc1Time self) $ \t -> t + delta ] classSignals = [ signal "on_MyClass1_ready" [("msg", VariantTypeString)] ] deriveBase ''Myclass1 @ -} class (HasBaseClass cls, Typeable cls, Typeable (BaseClass cls), Object :< cls) => NativeScript cls where classInit :: BaseClass cls -> IO cls className :: ClassName cls className = nameOf @cls classMethods :: [ClassMethod cls] classSignals :: [ClassSignal] classSignals = [] classProperties :: [ClassProperty cls] classProperties = [] asObj :: cls -> Object asObj = upcast type ClassSignal = (Text, [SignalArgument]) type ClassName a = Text nameOf :: forall a . Typeable a => ClassName a nameOf = T.pack $ convertClassName $ show $ typeRep $ Proxy @a type GFunc cls = cls -> Vector GodotVariant -> IO GodotVariant data ClassMethod cls where ClassMethod :: { methodRPCMode :: RPC , methodName :: Text , methodFunc :: GFunc cls } -> ClassMethod cls data RPC = NoRPC | Remote | Sync | Master | Slave data RegTy = GClass | GMethod | GSignal | GProperty data family Registerer (x :: RegTy) cls data instance Registerer 'GClass cls = NativeScript cls => RegClass GdnativeHandle (BaseClass cls -> IO cls) data instance Registerer 'GMethod cls = NativeScript cls => RegMethod GdnativeHandle (ClassMethod cls) data instance Registerer 'GSignal cls = NativeScript cls => RegSignal GdnativeHandle (Text, [SignalArgument]) data instance Registerer 'GProperty cls = NativeScript cls => RegProperty GdnativeHandle (ClassProperty cls) -- | Convenient way of registering a class with all its methods. -- Used like: @registerClass $ RegClass desc $ classInit \\@MyClass@ registerClass :: forall a . (NativeScript a, Typeable (BaseClass a), AsVariant (BaseClass a)) => Registerer 'GClass a -> IO () registerClass (RegClass desc constr) = do regClass desc (nameOf @(BaseClass a)) clsInit $ \_ _ -> return () forM_ (classMethods @a) regMtd forM_ (classSignals @a) regSignal forM_ (classProperties @a) regProperty where clsInit :: Object -> IO a clsInit obj = tryObjectCast obj >>= \(Just a) -> constr (a :: BaseClass a) clsName = className @a regMtd mtd@ClassMethod {..} = do registerMethod (RegMethod desc mtd :: Registerer 'GMethod a) d <- isJust <$> lookupEnv "HS_GODOT_DEBUG" when d $ putStrLn $ T.unpack $ T.unwords ["Registering method", methodName, "to class", clsName] regSignal sgn@(signalName, _) = do registerSignal (RegSignal desc sgn :: Registerer 'GSignal a) d <- isJust <$> lookupEnv "HS_GODOT_DEBUG" when d $ putStrLn $ T.unpack $ T.unwords ["Registering signal", signalName, "to class", clsName] regProperty prp = do registerProperty (RegProperty desc prp :: Registerer 'GProperty a) d <- isJust <$> lookupEnv "HS_GODOT_DEBUG" when d $ putStrLn $ T.unpack $ T.unwords ["Registering property", propertyName prp, "to class", clsName] regClass pHandle base create destroy = do createFun <- mkInstanceCreateFunPtr $ \ins _ -> create ins >>= newStablePtr >>= (return . castStablePtrToPtr) destroyFun <- mkInstanceDestroyFunPtr $ \ins _ objPtr -> do let stPtr = castPtrToStablePtr objPtr obj <- deRefStablePtr stPtr freeStablePtr stPtr destroy ins obj rec createFreeFun <- mkInstanceFreeFunPtr $ \_ -> freeHaskellFunPtr createFun >> freeHaskellFunPtr createFreeFun destroyFreeFun <- mkInstanceFreeFunPtr $ \_ -> freeHaskellFunPtr destroyFun >> freeHaskellFunPtr destroyFreeFun let createFunObj = InstanceCreateFunc createFun nullPtr createFreeFun let destroyFunObj = InstanceDestroyFunc destroyFun nullPtr destroyFreeFun let tyFingerprint = typeRepFingerprint $ typeRep (Proxy @a) tyPtr <- F.new tyFingerprint d <- isJust <$> lookupEnv "HS_GODOT_DEBUG" when d $ putStrLn $ T.unpack $ T.unwords ["Registering class", clsName] withCString (T.unpack clsName) $ \namePtr -> withCString (T.unpack base) $ \basePtr -> do godot_nativescript_register_class pHandle namePtr basePtr createFunObj destroyFunObj godot_nativescript_set_type_tag pHandle namePtr (castPtr tyPtr) tryCast :: forall b a. (Object :< a, a :< b, Typeable b, AsVariant b) => a -> IO (Maybe b) tryCast = tryObjectCast . upcast tryCast' :: forall out x. (Typeable out, AsVariant out, Object :< x, x :< out) => x -> IO out tryCast' o = fromJust <$> tryCast o convertClassName name = case name of -- TODO Derive these automatically. Don't think we store if a -- class is a singleton anywhere. "ClassDB" -> "_ClassDB" "Marshalls" -> "_Marshalls" "VisualScriptEditor" -> "_VisualScriptEditor" "OS" -> "_OS" "Engine" -> "_Engine" "Geometry" -> "_Geometry" "JSON" -> "_JSON" "ResourceLoader" -> "_ResourceLoader" "ResourceSaver" -> "_ResourceSaver" x -> x unConvertClassName name = case name of -- TODO Derive these automatically. Don't think we store if a -- class is a singleton anywhere. "_ClassDB" -> "ClassDB" "_Marshalls" -> "Marshalls" "_VisualScriptEditor" -> "VisualScriptEditor" "_OS" -> "OS" "_Engine" -> "Engine" "_Geometry" -> "Geometry" "_JSON" -> "JSON" "_ResourceLoader" -> "ResourceLoader" "_ResourceSaver" -> "ResourceSaver" x -> x singletonTable :: MVar (M.Map Text Object) singletonTable = unsafePerformIO $ newMVar M.empty -- | Godot exposes some functionality through singletons. You'll often need to -- talk to the GodotInput singeton for example. Use this as 'getSingleton @GodotInput'. getSingleton :: forall a . (Typeable a, AsVariant a, Object :< a) => IO (Maybe a) getSingleton = do let name = unConvertClassName $ nameOf @a table <- readMVar singletonTable case M.lookup name table of Just o -> tryCast o Nothing -> do ge <- getEngine -- FIXME ANDREI I don't understand what convertClassName is doing here? It seems wrong. -- o <- get_singleton ge =<< toLowLevel (convertClassName name) o <- get_singleton ge =<< toLowLevel name modifyMVar_ singletonTable (\m -> pure (M.insert name o m)) tryCast o getEngine :: IO Api.Engine getEngine = GNI.godot_global_get_singleton & Foreign.withCString "Engine" >>= \o -> tryCast o >>= \case Just ge -> return ge Nothing -> (get_class o :: IO GodotString) >>= fromLowLevel >>= error . ("Couldn't get Engine singleton :( got: " ++) . T.unpack tryObjectCast :: forall a . (Typeable a, AsVariant a) => Object -> IO (Maybe a) tryObjectCast obj = do isCls <- Object.is_class obj =<< toLowLevel (nameOf @a) if isCls then do asGVt <- toLowLevel $ toVariant obj :: IO GodotVariant Just <$> fromGodotVariant asGVt else return Nothing asNativeScript :: forall a . NativeScript a => Object -> IO (Maybe a) asNativeScript obj = do tyPtr <- godot_nativescript_get_type_tag obj tyFingerprint <- peek (castPtr tyPtr) if tyFingerprint == typeRepFingerprint (typeRep (Proxy @a)) then Just <$> (godot_nativescript_get_userdata obj >>= (deRefStablePtr . castPtrToStablePtr)) else pure Nothing copyVariant :: Ptr GodotVariant -- ^ destination -> Ptr GodotVariant -- ^ source -> IO () copyVariant dest src = copyBytes dest src (opaqueSizeOf @GodotVariant) {-| This makes defining class member methods much easier and similar to GDScript. Without dependent types we can't enforce that the right number of arguments are passed. The pattern-match below is non-total for syntactic simplicity. Example usage: @ func NoRPC "_unhandled_input" $ \self [evObj] -> (fromVariant evObj :: IO Object) >>= asClass InputEventKey "InputEventKey" >>= flip whenJust (handleInputKey self) @ -} func :: (NativeScript cls, AsVariant a) => RPC -> Text -> (cls -> [GodotVariant] -> IO a) -> ClassMethod cls func rpc mthdName fn = ClassMethod rpc mthdName $ \self args -> toLowLevel . toVariant =<< fn self (Vec.toList args) -- | Quick shortcut to make a new local method with arguments passed as -- 'Variant's in a list. method :: (NativeScript cls, AsVariant a) => Text -> (cls -> [GodotVariant] -> IO a) -> ClassMethod cls method = func NoRPC -- | Quick shortcut to make a new local method with no argumnets. method0 :: (NativeScript cls, AsVariant a) => Text -> (cls -> IO a) -> ClassMethod cls method0 name fn = func NoRPC name (\s [] -> fn s) -- | Quick shortcut to make a new local method that takes 1 argument, 'Variant's -- are unwrapped into their types before being passed in. method1 :: (NativeScript cls, AsVariant a, AsVariant o1, Typeable o1) => Text -> (cls -> o1 -> IO a) -> ClassMethod cls method1 name fn = func NoRPC name (\s [o1] -> do a1 <- fromGodotVariant o1 fn s a1) -- | Quick shortcut to make a new local method that takes 2 arguments, 'Variant's -- are unwrapped into their types before being passed in. method2 :: (NativeScript cls, AsVariant a, AsVariant o1, Typeable o1, AsVariant o2, Typeable o2) => Text -> (cls -> o1 -> o2 -> IO a) -> ClassMethod cls method2 name fn = func NoRPC name (\s [o1,o2] -> do a1 <- fromGodotVariant o1 a2 <- fromGodotVariant o2 fn s a1 a2) -- | Quick shortcut to make a new local method that takes 3 arguments, 'Variant's -- are unwrapped into their types before being passed in. method3 :: (NativeScript cls, AsVariant a, AsVariant o1, Typeable o1, AsVariant o2, Typeable o2, AsVariant o3, Typeable o3) => Text -> (cls -> o1 -> o2 -> o3 -> IO a) -> ClassMethod cls method3 name fn = func NoRPC name (\s [o1,o2,o3] -> do a1 <- fromGodotVariant o1 a2 <- fromGodotVariant o2 a3 <- fromGodotVariant o3 fn s a1 a2 a3) -- | Quick shortcut to make a new local method that takes 4 arguments, 'Variant's -- are unwrapped into their types before being passed in. method4 :: (NativeScript cls, AsVariant a, AsVariant o1, Typeable o1, AsVariant o2, Typeable o2 , AsVariant o3, Typeable o3, AsVariant o4, Typeable o4) => Text -> (cls -> o1 -> o2 -> o3 -> o4 -> IO a) -> ClassMethod cls method4 name fn = func NoRPC name (\s [o1,o2,o3,o4] -> do a1 <- fromGodotVariant o1 a2 <- fromGodotVariant o2 a3 <- fromGodotVariant o3 a4 <- fromGodotVariant o4 fn s a1 a2 a3 a4) -- | Quick shortcut to make a new local method that takes 5 arguments, 'Variant's -- are unwrapped into their types before being passed in. method5 :: (NativeScript cls, AsVariant a, AsVariant o1, Typeable o1, AsVariant o2, Typeable o2 , AsVariant o3, Typeable o3, AsVariant o4, Typeable o4, AsVariant o5, Typeable o5) => Text -> (cls -> o1 -> o2 -> o3 -> o4 -> o5 -> IO a) -> ClassMethod cls method5 name fn = func NoRPC name (\s [o1,o2,o3,o4,o5] -> do a1 <- fromGodotVariant o1 a2 <- fromGodotVariant o2 a3 <- fromGodotVariant o3 a4 <- fromGodotVariant o4 a5 <- fromGodotVariant o5 fn s a1 a2 a3 a4 a5) registerMethod :: forall a . NativeScript a => Registerer 'GMethod a -> IO () registerMethod (RegMethod desc ClassMethod {..}) = do methodFun <- mkInstanceMethodFunPtr $ \outPtr _ins _ objPtr numArgs argsPtr -> do obj <- deRefStablePtr $ castPtrToStablePtr objPtr ptrs <- V.fromList <$> peekArray (fromIntegral numArgs) argsPtr args <- V.forM ptrs $ \ptr -> do oldVar <- GodotVariant <$> newForeignPtr_ ptr godot_variant_new_copy oldVar res <- methodFunc obj args withGodotVariant res $ copyVariant outPtr return outPtr rec methodFreeFun <- mkInstanceFreeFunPtr $ \_ -> freeHaskellFunPtr methodFun >> freeHaskellFunPtr methodFreeFun let methodObj = InstanceMethod methodFun nullPtr methodFreeFun withCString (T.unpack $ nameOf @a) $ \clsNamePtr -> withCString (T.unpack methodName) $ \mtdNamePtr -> godot_nativescript_register_method desc clsNamePtr mtdNamePtr (MethodAttributes rpcMode) methodObj where rpcMode = case methodRPCMode of NoRPC -> MethodRpcModeDisabled Remote -> MethodRpcModeRemote Sync -> MethodRpcModeSync Master -> MethodRpcModeMaster Slave -> MethodRpcModeSlave asPropertyAttributes :: PropertyAttributes -> IO GNI.PropertyAttributes asPropertyAttributes PropertyAttributes {..} = do hintStr <- toLowLevel propertyHintString def <- toLowLevel propertyDefaultValue return $ GNI.PropertyAttributes { godotPropertyAttributesRsetType = propertySetType , godotPropertyAttributesType = fromIntegral $ fromEnum propertyType , godotPropertyAttributesHint = propertyHint , godotPropertyAttributesHintString = hintStr , godotPropertyAttributesUsage = propertyUsage , godotPropertyAttributesDefaultValue = def } registerProperty :: forall a . NativeScript a => Registerer 'GProperty a -> IO () registerProperty (RegProperty desc (ClassProperty path attr setter getter)) = do setFun <- mkPropertySetFunPtr $ \ins _ objPtr valPtr -> do obj <- deRefStablePtr $ castPtrToStablePtr objPtr val <- newForeignPtr_ valPtr setter ins obj (GodotVariant val) getFun <- mkPropertyGetFunPtr $ \outPtr ins _ objPtr -> do obj <- deRefStablePtr $ castPtrToStablePtr objPtr res <- getter ins obj withGodotVariant res $ copyVariant outPtr return outPtr rec setFreeFun <- mkInstanceFreeFunPtr $ \_ -> freeHaskellFunPtr setFun >> freeHaskellFunPtr setFreeFun getFreeFun <- mkInstanceFreeFunPtr $ \_ -> freeHaskellFunPtr getFun >> freeHaskellFunPtr getFreeFun godotAttr <- asPropertyAttributes attr withCString (T.unpack $ nameOf @a) $ \clsNamePtr -> withCString (T.unpack path) $ \pathPtr -> godot_nativescript_register_property desc clsNamePtr pathPtr godotAttr (PropertySetFunc setFun nullPtr setFreeFun) (PropertyGetFunc getFun nullPtr getFreeFun) createMVarProperty :: (Typeable v, AsVariant v) => Text -> (t -> MVar v) -- ^ We typically can't do IO (for initialisation) when calling this, in -- which case we need to annotate the type without providing a value. -> Either VariantType v -> ClassProperty t createMVarProperty name fieldName tyOrVal = ClassProperty { propertyName = name , propertyAttrs = PropertyAttributes MethodRpcModeDisabled (fst vTyVt) PropertyHintNone "" godotPropertyUsageDefault (snd vTyVt) , propertySetter = \_ c (var :: GodotVariant) -> do variant <- fromLowLevel var -- TODO This is required to avoid memory corruption. Haskell cannot hold -- pointers to Godot objects unless the runtime already has a live -- reference to that object. It will otherwise be freed at some point! -- -- This solution works, but only for most Godot Objects. We could add -- more cases here, but a much better way would be to implement a Ref -- type to hold such objects. Coming soon to stores near you. case variant of VariantObject o -> onRefObj reference o _ -> pure False obj <- fromGodotVariant var let mvar = fieldName c isEmpty <- isEmptyMVar mvar if isEmpty then putMVar mvar obj else toVariant <$> swapMVar mvar obj >>= \case VariantObject oldObj@(Object ptr) -> do unreffed <- onRefObj unreference oldObj -- lazy evaluation ftw when (nullPtr /= ptr && unreffed) $ Object.free oldObj _ -> pure () , propertyGetter = \_ c -> toLowLevel . toVariant =<< readMVar (fieldName c) } where onRefObj :: (Api.Reference -> IO a) -> Object -> IO a onRefObj f o = tryObjectCast @Api.Reference o >>= \case Just ref -> f ref Nothing -> error "Variant object not a reference" vTyVt :: (VariantType, Variant 'GodotTy) vTyVt = case tyOrVal of Left VariantTypeObject -> (VariantTypeObject, VariantObject (Object nullPtr)) Left vTy -> (vTy, VariantNil) Right val -> (variantType val, toVariant val) data SignalArgument = SignalArgument { signalArgumentName :: !Text , signalArgumentType :: !VariantType , signalArgumentHint :: !PropertyHint , signalArgumentHintString :: !Text , signalArgumentUsage :: !PropertyUsageFlags , signalArgumentDefaultValue :: !(Variant 'GodotTy) } asSignalArgument :: SignalArgument -> IO GNI.SignalArgument asSignalArgument SignalArgument {..} = do name <- toLowLevel signalArgumentName let ty = fromIntegral $ fromEnum signalArgumentType hintStr <- toLowLevel signalArgumentHintString def <- toLowLevel signalArgumentDefaultValue return $ GNI.SignalArgument name ty signalArgumentHint hintStr signalArgumentUsage def -- | Example usage: -- @ -- signal "on_pulse" [("source", VariantTypeVector3), ("affected", VariantTypeObject)] -- @ signal :: Text -> [(Text, VariantType)] -> (Text, [SignalArgument]) signal sigName sigArgs = (sigName, uncurry toSigArg <$> sigArgs) where toSigArg :: Text -> VariantType -> SignalArgument toSigArg argName ty = do SignalArgument { signalArgumentName = argName , signalArgumentType = ty , signalArgumentHint = PropertyHintNone , signalArgumentHintString = T.pack "" , signalArgumentUsage = godotPropertyUsageDefault , signalArgumentDefaultValue = VariantNil } -- TODO: Also allow hints and default args? registerSignal :: forall a . NativeScript a => Registerer 'GSignal a -> IO () registerSignal (RegSignal desc (signalName, signalArgs)) = do gdArgs <- mapM asSignalArgument signalArgs let defaultArgs = [] withArrayLen gdArgs $ \gdArgsLen gdArgsPtr -> withVariantArray' defaultArgs $ \(defArgsPtr, defArgsLen) -> withCString (T.unpack $ nameOf @a) $ \clsNamePtr -> do gdSigName <- toLowLevel signalName godot_nativescript_register_signal desc clsNamePtr $ GNI.Signal gdSigName (fromIntegral gdArgsLen) gdArgsPtr (fromIntegral defArgsLen) defArgsPtr where withVariantArray' :: [Variant 'GodotTy] -> ((Ptr GodotVariant, CInt) -> IO b) -> IO b withVariantArray' vars mtd = allocaBytes (opaqueSizeOf @GodotVariant * length vars) $ \arrPtr -> withVars vars 0 arrPtr mtd withVars (x : xs) n arrPtr mtd = do vt <- toLowLevel x withGodotVariant vt $ \vtPtr -> do copyVariant (arrPtr `plusPtr` (n * opaqueSizeOf @GodotVariant)) vtPtr withVars xs (n + 1) arrPtr mtd withVars [] n arrPtr mtd = mtd (arrPtr, fromIntegral n) foreign import ccall "dynamic" call_godot_class_constructor_ :: FunPtr (IO (Object)) -> IO (Object) -- | Instantiate an object new :: forall o. (Object :< o, Typeable o, AsVariant o) => IO (Maybe o) new = do con <- Foreign.withCString (T.unpack $ nameOf @o) godot_get_class_constructor if con == nullFunPtr then pure Nothing else tryCast =<< call_godot_class_constructor_ con newNativeScript :: forall a. NativeScript a => IO (Maybe a) newNativeScript = do let name = nameOf @a Just nativescript <- new @Api.NativeScript Just gdnlib <- tryCast @Api.GDNativeLibrary =<< readIORef gdnativeLibraryRef NativeScript.set_library nativescript gdnlib NativeScript.set_class_name nativescript =<< toLowLevel name no <- fromGodotVariant =<< NativeScript.new nativescript [] asNativeScript no getNode :: forall b cls. (Object :< cls, Api.Node :< cls, Api.Node :< b, Typeable b, AsVariant b) => cls -> Text -> IO b getNode self name = do n :: Api.Node <- get_node_or_null self =<< toLowLevel name x <- tryCast n case x of Just r -> pure r _ -> error "Error, getNode failed" getNodeNativeScript :: forall b child. (NativeScript b, Api.Node :< child, Object :< child) => child -> Text -> IO b getNodeNativeScript self name = do n <- get_node self =<< toLowLevel name x <- asNativeScript $ upcast @Object n case x of Just r -> pure r _ -> error "Error, getNode' failed" -- | The descriptor, Godot file resource path, of the current script. Some -- GNative API functions need access to this. scriptDesc :: MVar GodotString {-# NOINLINE scriptDesc #-} scriptDesc = unsafePerformIO newEmptyMVar -- | Called for you in the setup code. defaultExports :: GdnativeHandle -> IO () defaultExports desc = do desc' <- newForeignPtr_ desc cpy <- godot_string_new_copy (coerce desc' :: GodotString) putMVar scriptDesc cpy registerClass $ RegClass desc $ classInit @WrapperStablePtr pure () -- | Ask an object to wait for a signal on a target. When the signal is trigged call the given function -- For example, to get a callback when a timer fires you could do something like -- @ await self timer "timeout" (\self -> print "Timer fired!") @ await :: forall cls source target a. (NativeScript cls, Object :< cls, Object :< target, AsVariant a) => cls -> target -> Text -> (cls -> IO a) -> IO () await self target signal fn = do desc <- readMVar scriptDesc (Just w) <- newNativeScript @WrapperStablePtr unlessM (has_method self =<< toLowLevel "__script_callback") $ do withForeignPtr (coerce desc) (\rawDesc -> registerMethod (RegMethod (coerce rawDesc) (method1 "__script_callback" (\self o -> do (Just w) <- asNativeScript @WrapperStablePtr o sptr <- takeMVar $ _wrapperStablePtr w fn :: (cls -> IO a) <- deRefStablePtr (castPtrToStablePtr (castStablePtrToPtr sptr)) fn self freeStablePtr sptr)))) fnptr <- newStablePtr fn putMVar (_wrapperStablePtr w) (castPtrToStablePtr (castStablePtrToPtr fnptr)) fnBind <- toGodotVariant (upcast @Object w) guardError <$> (join $ connect target <$> toLowLevel signal <*> pure (upcast self) <*> toLowLevel "__script_callback" <*> (Just <$> toLowLevel (V.singleton fnBind)) <*> pure (Just _CONNECT_ONESHOT)) -- | Sometimes we really have to pass in a Haskell pointer to Godot, -- particularly for callbacks. data WrapperStablePtr = WrapperStablePtr { _wrapperStablePtrBase :: Object , _wrapperStablePtr :: MVar (StablePtr ()) } instance HasBaseClass WrapperStablePtr where type BaseClass WrapperStablePtr = Object super = _wrapperStablePtrBase instance NativeScript WrapperStablePtr where classInit base = WrapperStablePtr base <$> newEmptyMVar classMethods = [] deriveBase ''WrapperStablePtr ================================================ FILE: src/Godot/Tools/AnimationTrackEditPlugin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.AnimationTrackEditPlugin () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() ================================================ FILE: src/Godot/Tools/EditorExportPlugin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorExportPlugin (Godot.Tools.EditorExportPlugin._export_begin, Godot.Tools.EditorExportPlugin._export_end, Godot.Tools.EditorExportPlugin._export_file, Godot.Tools.EditorExportPlugin.add_file, Godot.Tools.EditorExportPlugin.add_ios_bundle_file, Godot.Tools.EditorExportPlugin.add_ios_cpp_code, Godot.Tools.EditorExportPlugin.add_ios_framework, Godot.Tools.EditorExportPlugin.add_ios_linker_flags, Godot.Tools.EditorExportPlugin.add_ios_plist_content, Godot.Tools.EditorExportPlugin.add_shared_object, Godot.Tools.EditorExportPlugin.skip) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindEditorExportPlugin__export_begin #-} -- | Virtual method to be overridden by the user. It is called when the export starts and provides all information about the export. bindEditorExportPlugin__export_begin :: MethodBind bindEditorExportPlugin__export_begin = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "_export_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method to be overridden by the user. It is called when the export starts and provides all information about the export. _export_begin :: (EditorExportPlugin :< cls, Object :< cls) => cls -> PoolStringArray -> Bool -> GodotString -> Int -> IO () _export_begin cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin__export_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "_export_begin" '[PoolStringArray, Bool, GodotString, Int] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin._export_begin {-# NOINLINE bindEditorExportPlugin__export_end #-} -- | Virtual method to be overridden by the user. Called when the export is finished. bindEditorExportPlugin__export_end :: MethodBind bindEditorExportPlugin__export_end = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "_export_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Virtual method to be overridden by the user. Called when the export is finished. _export_end :: (EditorExportPlugin :< cls, Object :< cls) => cls -> IO () _export_end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin__export_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "_export_end" '[] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin._export_end {-# NOINLINE bindEditorExportPlugin__export_file #-} bindEditorExportPlugin__export_file :: MethodBind bindEditorExportPlugin__export_file = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "_export_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _export_file :: (EditorExportPlugin :< cls, Object :< cls) => cls -> GodotString -> GodotString -> PoolStringArray -> IO () _export_file cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin__export_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "_export_file" '[GodotString, GodotString, PoolStringArray] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin._export_file {-# NOINLINE bindEditorExportPlugin_add_file #-} bindEditorExportPlugin_add_file :: MethodBind bindEditorExportPlugin_add_file = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "add_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_file :: (EditorExportPlugin :< cls, Object :< cls) => cls -> GodotString -> PoolByteArray -> Bool -> IO () add_file cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin_add_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "add_file" '[GodotString, PoolByteArray, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin.add_file {-# NOINLINE bindEditorExportPlugin_add_ios_bundle_file #-} bindEditorExportPlugin_add_ios_bundle_file :: MethodBind bindEditorExportPlugin_add_ios_bundle_file = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "add_ios_bundle_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_ios_bundle_file :: (EditorExportPlugin :< cls, Object :< cls) => cls -> GodotString -> IO () add_ios_bundle_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin_add_ios_bundle_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "add_ios_bundle_file" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin.add_ios_bundle_file {-# NOINLINE bindEditorExportPlugin_add_ios_cpp_code #-} bindEditorExportPlugin_add_ios_cpp_code :: MethodBind bindEditorExportPlugin_add_ios_cpp_code = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "add_ios_cpp_code" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_ios_cpp_code :: (EditorExportPlugin :< cls, Object :< cls) => cls -> GodotString -> IO () add_ios_cpp_code cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin_add_ios_cpp_code (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "add_ios_cpp_code" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin.add_ios_cpp_code {-# NOINLINE bindEditorExportPlugin_add_ios_framework #-} -- | Adds a static library (*.a) or dynamic library (*.dylib, *.framework) to Linking Phase in iOS's Xcode project. bindEditorExportPlugin_add_ios_framework :: MethodBind bindEditorExportPlugin_add_ios_framework = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "add_ios_framework" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a static library (*.a) or dynamic library (*.dylib, *.framework) to Linking Phase in iOS's Xcode project. add_ios_framework :: (EditorExportPlugin :< cls, Object :< cls) => cls -> GodotString -> IO () add_ios_framework cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin_add_ios_framework (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "add_ios_framework" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin.add_ios_framework {-# NOINLINE bindEditorExportPlugin_add_ios_linker_flags #-} bindEditorExportPlugin_add_ios_linker_flags :: MethodBind bindEditorExportPlugin_add_ios_linker_flags = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "add_ios_linker_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_ios_linker_flags :: (EditorExportPlugin :< cls, Object :< cls) => cls -> GodotString -> IO () add_ios_linker_flags cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin_add_ios_linker_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "add_ios_linker_flags" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin.add_ios_linker_flags {-# NOINLINE bindEditorExportPlugin_add_ios_plist_content #-} bindEditorExportPlugin_add_ios_plist_content :: MethodBind bindEditorExportPlugin_add_ios_plist_content = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "add_ios_plist_content" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_ios_plist_content :: (EditorExportPlugin :< cls, Object :< cls) => cls -> GodotString -> IO () add_ios_plist_content cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin_add_ios_plist_content (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "add_ios_plist_content" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin.add_ios_plist_content {-# NOINLINE bindEditorExportPlugin_add_shared_object #-} bindEditorExportPlugin_add_shared_object :: MethodBind bindEditorExportPlugin_add_shared_object = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "add_shared_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_shared_object :: (EditorExportPlugin :< cls, Object :< cls) => cls -> GodotString -> PoolStringArray -> IO () add_shared_object cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin_add_shared_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "add_shared_object" '[GodotString, PoolStringArray] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin.add_shared_object {-# NOINLINE bindEditorExportPlugin_skip #-} bindEditorExportPlugin_skip :: MethodBind bindEditorExportPlugin_skip = unsafePerformIO $ withCString "EditorExportPlugin" $ \ clsNamePtr -> withCString "skip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr skip :: (EditorExportPlugin :< cls, Object :< cls) => cls -> IO () skip cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorExportPlugin_skip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorExportPlugin "skip" '[] (IO ()) where nodeMethod = Godot.Tools.EditorExportPlugin.skip ================================================ FILE: src/Godot/Tools/EditorFeatureProfile.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorFeatureProfile (Godot.Tools.EditorFeatureProfile._FEATURE_FILESYSTEM_DOCK, Godot.Tools.EditorFeatureProfile._FEATURE_3D, Godot.Tools.EditorFeatureProfile._FEATURE_MAX, Godot.Tools.EditorFeatureProfile._FEATURE_SCRIPT, Godot.Tools.EditorFeatureProfile._FEATURE_SCENE_TREE, Godot.Tools.EditorFeatureProfile._FEATURE_NODE_DOCK, Godot.Tools.EditorFeatureProfile._FEATURE_IMPORT_DOCK, Godot.Tools.EditorFeatureProfile._FEATURE_ASSET_LIB, Godot.Tools.EditorFeatureProfile.get_feature_name, Godot.Tools.EditorFeatureProfile.is_class_disabled, Godot.Tools.EditorFeatureProfile.is_class_editor_disabled, Godot.Tools.EditorFeatureProfile.is_class_property_disabled, Godot.Tools.EditorFeatureProfile.is_feature_disabled, Godot.Tools.EditorFeatureProfile.load_from_file, Godot.Tools.EditorFeatureProfile.save_to_file, Godot.Tools.EditorFeatureProfile.set_disable_class, Godot.Tools.EditorFeatureProfile.set_disable_class_editor, Godot.Tools.EditorFeatureProfile.set_disable_class_property, Godot.Tools.EditorFeatureProfile.set_disable_feature) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _FEATURE_FILESYSTEM_DOCK :: Int _FEATURE_FILESYSTEM_DOCK = 6 _FEATURE_3D :: Int _FEATURE_3D = 0 _FEATURE_MAX :: Int _FEATURE_MAX = 7 _FEATURE_SCRIPT :: Int _FEATURE_SCRIPT = 1 _FEATURE_SCENE_TREE :: Int _FEATURE_SCENE_TREE = 3 _FEATURE_NODE_DOCK :: Int _FEATURE_NODE_DOCK = 5 _FEATURE_IMPORT_DOCK :: Int _FEATURE_IMPORT_DOCK = 4 _FEATURE_ASSET_LIB :: Int _FEATURE_ASSET_LIB = 2 {-# NOINLINE bindEditorFeatureProfile_get_feature_name #-} -- | Returns the specified @feature@'s human-readable name. bindEditorFeatureProfile_get_feature_name :: MethodBind bindEditorFeatureProfile_get_feature_name = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "get_feature_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the specified @feature@'s human-readable name. get_feature_name :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> Int -> IO GodotString get_feature_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_get_feature_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "get_feature_name" '[Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorFeatureProfile.get_feature_name {-# NOINLINE bindEditorFeatureProfile_is_class_disabled #-} -- | Returns @true@ if the class specified by @class_name@ is disabled. When disabled, the class won't appear in the Create New Node dialog. bindEditorFeatureProfile_is_class_disabled :: MethodBind bindEditorFeatureProfile_is_class_disabled = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "is_class_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the class specified by @class_name@ is disabled. When disabled, the class won't appear in the Create New Node dialog. is_class_disabled :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_class_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_is_class_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "is_class_disabled" '[GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorFeatureProfile.is_class_disabled {-# NOINLINE bindEditorFeatureProfile_is_class_editor_disabled #-} -- | Returns @true@ if editing for the class specified by @class_name@ is disabled. When disabled, the class will still appear in the Create New Node dialog but the inspector will be read-only when selecting a node that extends the class. bindEditorFeatureProfile_is_class_editor_disabled :: MethodBind bindEditorFeatureProfile_is_class_editor_disabled = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "is_class_editor_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if editing for the class specified by @class_name@ is disabled. When disabled, the class will still appear in the Create New Node dialog but the inspector will be read-only when selecting a node that extends the class. is_class_editor_disabled :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_class_editor_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_is_class_editor_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "is_class_editor_disabled" '[GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorFeatureProfile.is_class_editor_disabled {-# NOINLINE bindEditorFeatureProfile_is_class_property_disabled #-} -- | Returns @true@ if @property@ is disabled in the class specified by @class_name@. When a property is disabled, it won't appear in the inspector when selecting a node that extends the class specified by @class_name@. bindEditorFeatureProfile_is_class_property_disabled :: MethodBind bindEditorFeatureProfile_is_class_property_disabled = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "is_class_property_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if @property@ is disabled in the class specified by @class_name@. When a property is disabled, it won't appear in the inspector when selecting a node that extends the class specified by @class_name@. is_class_property_disabled :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO Bool is_class_property_disabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_is_class_property_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "is_class_property_disabled" '[GodotString, GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorFeatureProfile.is_class_property_disabled {-# NOINLINE bindEditorFeatureProfile_is_feature_disabled #-} -- | Returns @true@ if the @feature@ is disabled. When a feature is disabled, it will disappear from the editor entirely. bindEditorFeatureProfile_is_feature_disabled :: MethodBind bindEditorFeatureProfile_is_feature_disabled = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "is_feature_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the @feature@ is disabled. When a feature is disabled, it will disappear from the editor entirely. is_feature_disabled :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> Int -> IO Bool is_feature_disabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_is_feature_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "is_feature_disabled" '[Int] (IO Bool) where nodeMethod = Godot.Tools.EditorFeatureProfile.is_feature_disabled {-# NOINLINE bindEditorFeatureProfile_load_from_file #-} -- | Loads an editor feature profile from a file. The file must follow the JSON format obtained by using the feature profile manager's __Export__ button or the @method save_to_file@ method. bindEditorFeatureProfile_load_from_file :: MethodBind bindEditorFeatureProfile_load_from_file = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "load_from_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Loads an editor feature profile from a file. The file must follow the JSON format obtained by using the feature profile manager's __Export__ button or the @method save_to_file@ method. load_from_file :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> GodotString -> IO Int load_from_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_load_from_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "load_from_file" '[GodotString] (IO Int) where nodeMethod = Godot.Tools.EditorFeatureProfile.load_from_file {-# NOINLINE bindEditorFeatureProfile_save_to_file #-} -- | Saves the editor feature profile to a file in JSON format. It can then be imported using the feature profile manager's __Import__ button or the @method load_from_file@ button. bindEditorFeatureProfile_save_to_file :: MethodBind bindEditorFeatureProfile_save_to_file = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "save_to_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the editor feature profile to a file in JSON format. It can then be imported using the feature profile manager's __Import__ button or the @method load_from_file@ button. save_to_file :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> GodotString -> IO Int save_to_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_save_to_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "save_to_file" '[GodotString] (IO Int) where nodeMethod = Godot.Tools.EditorFeatureProfile.save_to_file {-# NOINLINE bindEditorFeatureProfile_set_disable_class #-} -- | If @disable@ is @true@, disables the class specified by @class_name@. When disabled, the class won't appear in the Create New Node dialog. bindEditorFeatureProfile_set_disable_class :: MethodBind bindEditorFeatureProfile_set_disable_class = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "set_disable_class" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @disable@ is @true@, disables the class specified by @class_name@. When disabled, the class won't appear in the Create New Node dialog. set_disable_class :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> GodotString -> Bool -> IO () set_disable_class cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_set_disable_class (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "set_disable_class" '[GodotString, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorFeatureProfile.set_disable_class {-# NOINLINE bindEditorFeatureProfile_set_disable_class_editor #-} -- | If @disable@ is @true@, disables editing for the class specified by @class_name@. When disabled, the class will still appear in the Create New Node dialog but the inspector will be read-only when selecting a node that extends the class. bindEditorFeatureProfile_set_disable_class_editor :: MethodBind bindEditorFeatureProfile_set_disable_class_editor = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "set_disable_class_editor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @disable@ is @true@, disables editing for the class specified by @class_name@. When disabled, the class will still appear in the Create New Node dialog but the inspector will be read-only when selecting a node that extends the class. set_disable_class_editor :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> GodotString -> Bool -> IO () set_disable_class_editor cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_set_disable_class_editor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "set_disable_class_editor" '[GodotString, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorFeatureProfile.set_disable_class_editor {-# NOINLINE bindEditorFeatureProfile_set_disable_class_property #-} -- | If @disable@ is @true@, disables editing for @property@ in the class specified by @class_name@. When a property is disabled, it won't appear in the inspector when selecting a node that extends the class specified by @class_name@. bindEditorFeatureProfile_set_disable_class_property :: MethodBind bindEditorFeatureProfile_set_disable_class_property = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "set_disable_class_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @disable@ is @true@, disables editing for @property@ in the class specified by @class_name@. When a property is disabled, it won't appear in the inspector when selecting a node that extends the class specified by @class_name@. set_disable_class_property :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Bool -> IO () set_disable_class_property cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_set_disable_class_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "set_disable_class_property" '[GodotString, GodotString, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorFeatureProfile.set_disable_class_property {-# NOINLINE bindEditorFeatureProfile_set_disable_feature #-} -- | If @disable@ is @true@, disables the editor feature specified in @feature@. When a feature is disabled, it will disappear from the editor entirely. bindEditorFeatureProfile_set_disable_feature :: MethodBind bindEditorFeatureProfile_set_disable_feature = unsafePerformIO $ withCString "EditorFeatureProfile" $ \ clsNamePtr -> withCString "set_disable_feature" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @disable@ is @true@, disables the editor feature specified in @feature@. When a feature is disabled, it will disappear from the editor entirely. set_disable_feature :: (EditorFeatureProfile :< cls, Object :< cls) => cls -> Int -> Bool -> IO () set_disable_feature cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFeatureProfile_set_disable_feature (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFeatureProfile "set_disable_feature" '[Int, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorFeatureProfile.set_disable_feature ================================================ FILE: src/Godot/Tools/EditorFileDialog.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorFileDialog (Godot.Tools.EditorFileDialog._ACCESS_RESOURCES, Godot.Tools.EditorFileDialog._DISPLAY_THUMBNAILS, Godot.Tools.EditorFileDialog._MODE_OPEN_FILES, Godot.Tools.EditorFileDialog._MODE_OPEN_FILE, Godot.Tools.EditorFileDialog._MODE_SAVE_FILE, Godot.Tools.EditorFileDialog._DISPLAY_LIST, Godot.Tools.EditorFileDialog._ACCESS_USERDATA, Godot.Tools.EditorFileDialog._ACCESS_FILESYSTEM, Godot.Tools.EditorFileDialog._MODE_OPEN_DIR, Godot.Tools.EditorFileDialog._MODE_OPEN_ANY, Godot.Tools.EditorFileDialog.sig_dir_selected, Godot.Tools.EditorFileDialog.sig_file_selected, Godot.Tools.EditorFileDialog.sig_files_selected, Godot.Tools.EditorFileDialog._action_pressed, Godot.Tools.EditorFileDialog._cancel_pressed, Godot.Tools.EditorFileDialog._dir_entered, Godot.Tools.EditorFileDialog._favorite_move_down, Godot.Tools.EditorFileDialog._favorite_move_up, Godot.Tools.EditorFileDialog._favorite_pressed, Godot.Tools.EditorFileDialog._favorite_selected, Godot.Tools.EditorFileDialog._file_entered, Godot.Tools.EditorFileDialog._filter_selected, Godot.Tools.EditorFileDialog._go_back, Godot.Tools.EditorFileDialog._go_forward, Godot.Tools.EditorFileDialog._go_up, Godot.Tools.EditorFileDialog._item_db_selected, Godot.Tools.EditorFileDialog._item_list_item_rmb_selected, Godot.Tools.EditorFileDialog._item_list_rmb_clicked, Godot.Tools.EditorFileDialog._item_menu_id_pressed, Godot.Tools.EditorFileDialog._item_selected, Godot.Tools.EditorFileDialog._items_clear_selection, Godot.Tools.EditorFileDialog._make_dir, Godot.Tools.EditorFileDialog._make_dir_confirm, Godot.Tools.EditorFileDialog._multi_selected, Godot.Tools.EditorFileDialog._recent_selected, Godot.Tools.EditorFileDialog._save_confirm_pressed, Godot.Tools.EditorFileDialog._select_drive, Godot.Tools.EditorFileDialog._thumbnail_done, Godot.Tools.EditorFileDialog._thumbnail_result, Godot.Tools.EditorFileDialog._unhandled_input, Godot.Tools.EditorFileDialog._update_dir, Godot.Tools.EditorFileDialog._update_file_list, Godot.Tools.EditorFileDialog._update_file_name, Godot.Tools.EditorFileDialog.add_filter, Godot.Tools.EditorFileDialog.clear_filters, Godot.Tools.EditorFileDialog.get_access, Godot.Tools.EditorFileDialog.get_current_dir, Godot.Tools.EditorFileDialog.get_current_file, Godot.Tools.EditorFileDialog.get_current_path, Godot.Tools.EditorFileDialog.get_display_mode, Godot.Tools.EditorFileDialog.get_mode, Godot.Tools.EditorFileDialog.get_vbox, Godot.Tools.EditorFileDialog.invalidate, Godot.Tools.EditorFileDialog.is_overwrite_warning_disabled, Godot.Tools.EditorFileDialog.is_showing_hidden_files, Godot.Tools.EditorFileDialog.set_access, Godot.Tools.EditorFileDialog.set_current_dir, Godot.Tools.EditorFileDialog.set_current_file, Godot.Tools.EditorFileDialog.set_current_path, Godot.Tools.EditorFileDialog.set_disable_overwrite_warning, Godot.Tools.EditorFileDialog.set_display_mode, Godot.Tools.EditorFileDialog.set_mode, Godot.Tools.EditorFileDialog.set_show_hidden_files) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ConfirmationDialog() _ACCESS_RESOURCES :: Int _ACCESS_RESOURCES = 0 _DISPLAY_THUMBNAILS :: Int _DISPLAY_THUMBNAILS = 0 _MODE_OPEN_FILES :: Int _MODE_OPEN_FILES = 1 _MODE_OPEN_FILE :: Int _MODE_OPEN_FILE = 0 _MODE_SAVE_FILE :: Int _MODE_SAVE_FILE = 4 _DISPLAY_LIST :: Int _DISPLAY_LIST = 1 _ACCESS_USERDATA :: Int _ACCESS_USERDATA = 1 _ACCESS_FILESYSTEM :: Int _ACCESS_FILESYSTEM = 2 _MODE_OPEN_DIR :: Int _MODE_OPEN_DIR = 2 _MODE_OPEN_ANY :: Int _MODE_OPEN_ANY = 3 -- | Emitted when a directory is selected. sig_dir_selected :: Godot.Internal.Dispatch.Signal EditorFileDialog sig_dir_selected = Godot.Internal.Dispatch.Signal "dir_selected" instance NodeSignal EditorFileDialog "dir_selected" '[GodotString] -- | Emitted when a file is selected. sig_file_selected :: Godot.Internal.Dispatch.Signal EditorFileDialog sig_file_selected = Godot.Internal.Dispatch.Signal "file_selected" instance NodeSignal EditorFileDialog "file_selected" '[GodotString] -- | Emitted when multiple files are selected. sig_files_selected :: Godot.Internal.Dispatch.Signal EditorFileDialog sig_files_selected = Godot.Internal.Dispatch.Signal "files_selected" instance NodeSignal EditorFileDialog "files_selected" '[PoolStringArray] instance NodeProperty EditorFileDialog "access" Int 'False where nodeProperty = (get_access, wrapDroppingSetter set_access, Nothing) instance NodeProperty EditorFileDialog "current_dir" GodotString 'False where nodeProperty = (get_current_dir, wrapDroppingSetter set_current_dir, Nothing) instance NodeProperty EditorFileDialog "current_file" GodotString 'False where nodeProperty = (get_current_file, wrapDroppingSetter set_current_file, Nothing) instance NodeProperty EditorFileDialog "current_path" GodotString 'False where nodeProperty = (get_current_path, wrapDroppingSetter set_current_path, Nothing) instance NodeProperty EditorFileDialog "disable_overwrite_warning" Bool 'False where nodeProperty = (is_overwrite_warning_disabled, wrapDroppingSetter set_disable_overwrite_warning, Nothing) instance NodeProperty EditorFileDialog "display_mode" Int 'False where nodeProperty = (get_display_mode, wrapDroppingSetter set_display_mode, Nothing) instance NodeProperty EditorFileDialog "mode" Int 'False where nodeProperty = (get_mode, wrapDroppingSetter set_mode, Nothing) instance NodeProperty EditorFileDialog "show_hidden_files" Bool 'False where nodeProperty = (is_showing_hidden_files, wrapDroppingSetter set_show_hidden_files, Nothing) {-# NOINLINE bindEditorFileDialog__action_pressed #-} bindEditorFileDialog__action_pressed :: MethodBind bindEditorFileDialog__action_pressed = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_action_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _action_pressed :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _action_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__action_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_action_pressed" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._action_pressed {-# NOINLINE bindEditorFileDialog__cancel_pressed #-} bindEditorFileDialog__cancel_pressed :: MethodBind bindEditorFileDialog__cancel_pressed = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_cancel_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _cancel_pressed :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _cancel_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__cancel_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_cancel_pressed" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._cancel_pressed {-# NOINLINE bindEditorFileDialog__dir_entered #-} bindEditorFileDialog__dir_entered :: MethodBind bindEditorFileDialog__dir_entered = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_dir_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _dir_entered :: (EditorFileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _dir_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__dir_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_dir_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._dir_entered {-# NOINLINE bindEditorFileDialog__favorite_move_down #-} bindEditorFileDialog__favorite_move_down :: MethodBind bindEditorFileDialog__favorite_move_down = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_favorite_move_down" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _favorite_move_down :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _favorite_move_down cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__favorite_move_down (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_favorite_move_down" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._favorite_move_down {-# NOINLINE bindEditorFileDialog__favorite_move_up #-} bindEditorFileDialog__favorite_move_up :: MethodBind bindEditorFileDialog__favorite_move_up = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_favorite_move_up" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _favorite_move_up :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _favorite_move_up cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__favorite_move_up (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_favorite_move_up" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._favorite_move_up {-# NOINLINE bindEditorFileDialog__favorite_pressed #-} bindEditorFileDialog__favorite_pressed :: MethodBind bindEditorFileDialog__favorite_pressed = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_favorite_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _favorite_pressed :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _favorite_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__favorite_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_favorite_pressed" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._favorite_pressed {-# NOINLINE bindEditorFileDialog__favorite_selected #-} bindEditorFileDialog__favorite_selected :: MethodBind bindEditorFileDialog__favorite_selected = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_favorite_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _favorite_selected :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () _favorite_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__favorite_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_favorite_selected" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._favorite_selected {-# NOINLINE bindEditorFileDialog__file_entered #-} bindEditorFileDialog__file_entered :: MethodBind bindEditorFileDialog__file_entered = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_file_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _file_entered :: (EditorFileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _file_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__file_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_file_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._file_entered {-# NOINLINE bindEditorFileDialog__filter_selected #-} bindEditorFileDialog__filter_selected :: MethodBind bindEditorFileDialog__filter_selected = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_filter_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _filter_selected :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () _filter_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__filter_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_filter_selected" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._filter_selected {-# NOINLINE bindEditorFileDialog__go_back #-} bindEditorFileDialog__go_back :: MethodBind bindEditorFileDialog__go_back = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_go_back" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _go_back :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _go_back cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__go_back (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_go_back" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._go_back {-# NOINLINE bindEditorFileDialog__go_forward #-} bindEditorFileDialog__go_forward :: MethodBind bindEditorFileDialog__go_forward = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_go_forward" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _go_forward :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _go_forward cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__go_forward (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_go_forward" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._go_forward {-# NOINLINE bindEditorFileDialog__go_up #-} bindEditorFileDialog__go_up :: MethodBind bindEditorFileDialog__go_up = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_go_up" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _go_up :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _go_up cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__go_up (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_go_up" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._go_up {-# NOINLINE bindEditorFileDialog__item_db_selected #-} bindEditorFileDialog__item_db_selected :: MethodBind bindEditorFileDialog__item_db_selected = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_item_db_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _item_db_selected :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () _item_db_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__item_db_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_item_db_selected" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._item_db_selected {-# NOINLINE bindEditorFileDialog__item_list_item_rmb_selected #-} bindEditorFileDialog__item_list_item_rmb_selected :: MethodBind bindEditorFileDialog__item_list_item_rmb_selected = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_item_list_item_rmb_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _item_list_item_rmb_selected :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> Vector2 -> IO () _item_list_item_rmb_selected cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__item_list_item_rmb_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_item_list_item_rmb_selected" '[Int, Vector2] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._item_list_item_rmb_selected {-# NOINLINE bindEditorFileDialog__item_list_rmb_clicked #-} bindEditorFileDialog__item_list_rmb_clicked :: MethodBind bindEditorFileDialog__item_list_rmb_clicked = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_item_list_rmb_clicked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _item_list_rmb_clicked :: (EditorFileDialog :< cls, Object :< cls) => cls -> Vector2 -> IO () _item_list_rmb_clicked cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__item_list_rmb_clicked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_item_list_rmb_clicked" '[Vector2] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._item_list_rmb_clicked {-# NOINLINE bindEditorFileDialog__item_menu_id_pressed #-} bindEditorFileDialog__item_menu_id_pressed :: MethodBind bindEditorFileDialog__item_menu_id_pressed = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_item_menu_id_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _item_menu_id_pressed :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () _item_menu_id_pressed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__item_menu_id_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_item_menu_id_pressed" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._item_menu_id_pressed {-# NOINLINE bindEditorFileDialog__item_selected #-} bindEditorFileDialog__item_selected :: MethodBind bindEditorFileDialog__item_selected = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_item_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _item_selected :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () _item_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__item_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_item_selected" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._item_selected {-# NOINLINE bindEditorFileDialog__items_clear_selection #-} bindEditorFileDialog__items_clear_selection :: MethodBind bindEditorFileDialog__items_clear_selection = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_items_clear_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _items_clear_selection :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _items_clear_selection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__items_clear_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_items_clear_selection" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._items_clear_selection {-# NOINLINE bindEditorFileDialog__make_dir #-} bindEditorFileDialog__make_dir :: MethodBind bindEditorFileDialog__make_dir = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_make_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _make_dir :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _make_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__make_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_make_dir" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._make_dir {-# NOINLINE bindEditorFileDialog__make_dir_confirm #-} bindEditorFileDialog__make_dir_confirm :: MethodBind bindEditorFileDialog__make_dir_confirm = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_make_dir_confirm" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _make_dir_confirm :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _make_dir_confirm cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__make_dir_confirm (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_make_dir_confirm" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._make_dir_confirm {-# NOINLINE bindEditorFileDialog__multi_selected #-} bindEditorFileDialog__multi_selected :: MethodBind bindEditorFileDialog__multi_selected = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_multi_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _multi_selected :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> Bool -> IO () _multi_selected cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__multi_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_multi_selected" '[Int, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._multi_selected {-# NOINLINE bindEditorFileDialog__recent_selected #-} bindEditorFileDialog__recent_selected :: MethodBind bindEditorFileDialog__recent_selected = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_recent_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _recent_selected :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () _recent_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__recent_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_recent_selected" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._recent_selected {-# NOINLINE bindEditorFileDialog__save_confirm_pressed #-} bindEditorFileDialog__save_confirm_pressed :: MethodBind bindEditorFileDialog__save_confirm_pressed = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_save_confirm_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _save_confirm_pressed :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _save_confirm_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__save_confirm_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_save_confirm_pressed" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._save_confirm_pressed {-# NOINLINE bindEditorFileDialog__select_drive #-} bindEditorFileDialog__select_drive :: MethodBind bindEditorFileDialog__select_drive = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_select_drive" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _select_drive :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () _select_drive cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__select_drive (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_select_drive" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._select_drive {-# NOINLINE bindEditorFileDialog__thumbnail_done #-} bindEditorFileDialog__thumbnail_done :: MethodBind bindEditorFileDialog__thumbnail_done = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_thumbnail_done" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _thumbnail_done :: (EditorFileDialog :< cls, Object :< cls) => cls -> GodotString -> Texture -> Texture -> GodotVariant -> IO () _thumbnail_done cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__thumbnail_done (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_thumbnail_done" '[GodotString, Texture, Texture, GodotVariant] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._thumbnail_done {-# NOINLINE bindEditorFileDialog__thumbnail_result #-} bindEditorFileDialog__thumbnail_result :: MethodBind bindEditorFileDialog__thumbnail_result = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_thumbnail_result" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _thumbnail_result :: (EditorFileDialog :< cls, Object :< cls) => cls -> GodotString -> Texture -> Texture -> GodotVariant -> IO () _thumbnail_result cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__thumbnail_result (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_thumbnail_result" '[GodotString, Texture, Texture, GodotVariant] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._thumbnail_result {-# NOINLINE bindEditorFileDialog__unhandled_input #-} bindEditorFileDialog__unhandled_input :: MethodBind bindEditorFileDialog__unhandled_input = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _unhandled_input :: (EditorFileDialog :< cls, Object :< cls) => cls -> InputEvent -> IO () _unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_unhandled_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._unhandled_input {-# NOINLINE bindEditorFileDialog__update_dir #-} bindEditorFileDialog__update_dir :: MethodBind bindEditorFileDialog__update_dir = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_update_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_dir :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _update_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__update_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_update_dir" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._update_dir {-# NOINLINE bindEditorFileDialog__update_file_list #-} bindEditorFileDialog__update_file_list :: MethodBind bindEditorFileDialog__update_file_list = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_update_file_list" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_file_list :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _update_file_list cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__update_file_list (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_update_file_list" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._update_file_list {-# NOINLINE bindEditorFileDialog__update_file_name #-} bindEditorFileDialog__update_file_name :: MethodBind bindEditorFileDialog__update_file_name = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "_update_file_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_file_name :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () _update_file_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog__update_file_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "_update_file_name" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog._update_file_name {-# NOINLINE bindEditorFileDialog_add_filter #-} -- | Adds a comma-delimited file extension filter option to the @EditorFileDialog@ with an optional semi-colon-delimited label. -- For example, @"*.tscn, *.scn; Scenes"@ results in filter text "Scenes (*.tscn, *.scn)". bindEditorFileDialog_add_filter :: MethodBind bindEditorFileDialog_add_filter = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "add_filter" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a comma-delimited file extension filter option to the @EditorFileDialog@ with an optional semi-colon-delimited label. -- For example, @"*.tscn, *.scn; Scenes"@ results in filter text "Scenes (*.tscn, *.scn)". add_filter :: (EditorFileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () add_filter cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_add_filter (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "add_filter" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.add_filter {-# NOINLINE bindEditorFileDialog_clear_filters #-} -- | Removes all filters except for "All Files (*)". bindEditorFileDialog_clear_filters :: MethodBind bindEditorFileDialog_clear_filters = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "clear_filters" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes all filters except for "All Files (*)". clear_filters :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () clear_filters cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_clear_filters (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "clear_filters" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.clear_filters {-# NOINLINE bindEditorFileDialog_get_access #-} -- | The location from which the user may select a file, including @res://@, @user://@, and the local file system. bindEditorFileDialog_get_access :: MethodBind bindEditorFileDialog_get_access = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "get_access" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The location from which the user may select a file, including @res://@, @user://@, and the local file system. get_access :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO Int get_access cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_get_access (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "get_access" '[] (IO Int) where nodeMethod = Godot.Tools.EditorFileDialog.get_access {-# NOINLINE bindEditorFileDialog_get_current_dir #-} -- | The currently occupied directory. bindEditorFileDialog_get_current_dir :: MethodBind bindEditorFileDialog_get_current_dir = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "get_current_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently occupied directory. get_current_dir :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO GodotString get_current_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_get_current_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "get_current_dir" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileDialog.get_current_dir {-# NOINLINE bindEditorFileDialog_get_current_file #-} -- | The currently selected file. bindEditorFileDialog_get_current_file :: MethodBind bindEditorFileDialog_get_current_file = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "get_current_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected file. get_current_file :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO GodotString get_current_file cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_get_current_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "get_current_file" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileDialog.get_current_file {-# NOINLINE bindEditorFileDialog_get_current_path #-} -- | The file system path in the address bar. bindEditorFileDialog_get_current_path :: MethodBind bindEditorFileDialog_get_current_path = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "get_current_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The file system path in the address bar. get_current_path :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO GodotString get_current_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_get_current_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "get_current_path" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileDialog.get_current_path {-# NOINLINE bindEditorFileDialog_get_display_mode #-} -- | The view format in which the @EditorFileDialog@ displays resources to the user. bindEditorFileDialog_get_display_mode :: MethodBind bindEditorFileDialog_get_display_mode = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "get_display_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The view format in which the @EditorFileDialog@ displays resources to the user. get_display_mode :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO Int get_display_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_get_display_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "get_display_mode" '[] (IO Int) where nodeMethod = Godot.Tools.EditorFileDialog.get_display_mode {-# NOINLINE bindEditorFileDialog_get_mode #-} -- | The purpose of the @EditorFileDialog@, which defines the allowed behaviors. bindEditorFileDialog_get_mode :: MethodBind bindEditorFileDialog_get_mode = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "get_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The purpose of the @EditorFileDialog@, which defines the allowed behaviors. get_mode :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO Int get_mode cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_get_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "get_mode" '[] (IO Int) where nodeMethod = Godot.Tools.EditorFileDialog.get_mode {-# NOINLINE bindEditorFileDialog_get_vbox #-} -- | Returns the @VBoxContainer@ used to display the file system. bindEditorFileDialog_get_vbox :: MethodBind bindEditorFileDialog_get_vbox = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "get_vbox" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @VBoxContainer@ used to display the file system. get_vbox :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO VBoxContainer get_vbox cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_get_vbox (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "get_vbox" '[] (IO VBoxContainer) where nodeMethod = Godot.Tools.EditorFileDialog.get_vbox {-# NOINLINE bindEditorFileDialog_invalidate #-} -- | Notify the @EditorFileDialog@ that its view of the data is no longer accurate. Updates the view contents on next view update. bindEditorFileDialog_invalidate :: MethodBind bindEditorFileDialog_invalidate = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "invalidate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Notify the @EditorFileDialog@ that its view of the data is no longer accurate. Updates the view contents on next view update. invalidate :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO () invalidate cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_invalidate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "invalidate" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.invalidate {-# NOINLINE bindEditorFileDialog_is_overwrite_warning_disabled #-} -- | If @true@, the @EditorFileDialog@ will not warn the user before overwriting files. bindEditorFileDialog_is_overwrite_warning_disabled :: MethodBind bindEditorFileDialog_is_overwrite_warning_disabled = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "is_overwrite_warning_disabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @EditorFileDialog@ will not warn the user before overwriting files. is_overwrite_warning_disabled :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO Bool is_overwrite_warning_disabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_is_overwrite_warning_disabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "is_overwrite_warning_disabled" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorFileDialog.is_overwrite_warning_disabled {-# NOINLINE bindEditorFileDialog_is_showing_hidden_files #-} -- | If @true@, hidden files and directories will be visible in the @EditorFileDialog@. bindEditorFileDialog_is_showing_hidden_files :: MethodBind bindEditorFileDialog_is_showing_hidden_files = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "is_showing_hidden_files" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hidden files and directories will be visible in the @EditorFileDialog@. is_showing_hidden_files :: (EditorFileDialog :< cls, Object :< cls) => cls -> IO Bool is_showing_hidden_files cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_is_showing_hidden_files (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "is_showing_hidden_files" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorFileDialog.is_showing_hidden_files {-# NOINLINE bindEditorFileDialog_set_access #-} -- | The location from which the user may select a file, including @res://@, @user://@, and the local file system. bindEditorFileDialog_set_access :: MethodBind bindEditorFileDialog_set_access = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "set_access" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The location from which the user may select a file, including @res://@, @user://@, and the local file system. set_access :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () set_access cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_set_access (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "set_access" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.set_access {-# NOINLINE bindEditorFileDialog_set_current_dir #-} -- | The currently occupied directory. bindEditorFileDialog_set_current_dir :: MethodBind bindEditorFileDialog_set_current_dir = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "set_current_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently occupied directory. set_current_dir :: (EditorFileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () set_current_dir cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_set_current_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "set_current_dir" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.set_current_dir {-# NOINLINE bindEditorFileDialog_set_current_file #-} -- | The currently selected file. bindEditorFileDialog_set_current_file :: MethodBind bindEditorFileDialog_set_current_file = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "set_current_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The currently selected file. set_current_file :: (EditorFileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () set_current_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_set_current_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "set_current_file" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.set_current_file {-# NOINLINE bindEditorFileDialog_set_current_path #-} -- | The file system path in the address bar. bindEditorFileDialog_set_current_path :: MethodBind bindEditorFileDialog_set_current_path = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "set_current_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The file system path in the address bar. set_current_path :: (EditorFileDialog :< cls, Object :< cls) => cls -> GodotString -> IO () set_current_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_set_current_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "set_current_path" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.set_current_path {-# NOINLINE bindEditorFileDialog_set_disable_overwrite_warning #-} -- | If @true@, the @EditorFileDialog@ will not warn the user before overwriting files. bindEditorFileDialog_set_disable_overwrite_warning :: MethodBind bindEditorFileDialog_set_disable_overwrite_warning = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "set_disable_overwrite_warning" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, the @EditorFileDialog@ will not warn the user before overwriting files. set_disable_overwrite_warning :: (EditorFileDialog :< cls, Object :< cls) => cls -> Bool -> IO () set_disable_overwrite_warning cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_set_disable_overwrite_warning (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "set_disable_overwrite_warning" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.set_disable_overwrite_warning {-# NOINLINE bindEditorFileDialog_set_display_mode #-} -- | The view format in which the @EditorFileDialog@ displays resources to the user. bindEditorFileDialog_set_display_mode :: MethodBind bindEditorFileDialog_set_display_mode = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "set_display_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The view format in which the @EditorFileDialog@ displays resources to the user. set_display_mode :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () set_display_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_set_display_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "set_display_mode" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.set_display_mode {-# NOINLINE bindEditorFileDialog_set_mode #-} -- | The purpose of the @EditorFileDialog@, which defines the allowed behaviors. bindEditorFileDialog_set_mode :: MethodBind bindEditorFileDialog_set_mode = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "set_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | The purpose of the @EditorFileDialog@, which defines the allowed behaviors. set_mode :: (EditorFileDialog :< cls, Object :< cls) => cls -> Int -> IO () set_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_set_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "set_mode" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.set_mode {-# NOINLINE bindEditorFileDialog_set_show_hidden_files #-} -- | If @true@, hidden files and directories will be visible in the @EditorFileDialog@. bindEditorFileDialog_set_show_hidden_files :: MethodBind bindEditorFileDialog_set_show_hidden_files = unsafePerformIO $ withCString "EditorFileDialog" $ \ clsNamePtr -> withCString "set_show_hidden_files" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, hidden files and directories will be visible in the @EditorFileDialog@. set_show_hidden_files :: (EditorFileDialog :< cls, Object :< cls) => cls -> Bool -> IO () set_show_hidden_files cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileDialog_set_show_hidden_files (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileDialog "set_show_hidden_files" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorFileDialog.set_show_hidden_files ================================================ FILE: src/Godot/Tools/EditorFileSystem.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorFileSystem (Godot.Tools.EditorFileSystem.sig_filesystem_changed, Godot.Tools.EditorFileSystem.sig_resources_reimported, Godot.Tools.EditorFileSystem.sig_resources_reload, Godot.Tools.EditorFileSystem.sig_sources_changed, Godot.Tools.EditorFileSystem.get_file_type, Godot.Tools.EditorFileSystem.get_filesystem, Godot.Tools.EditorFileSystem.get_filesystem_path, Godot.Tools.EditorFileSystem.get_scanning_progress, Godot.Tools.EditorFileSystem.is_scanning, Godot.Tools.EditorFileSystem.scan, Godot.Tools.EditorFileSystem.scan_sources, Godot.Tools.EditorFileSystem.update_file, Godot.Tools.EditorFileSystem.update_script_classes) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() -- | Emitted if the filesystem changed. sig_filesystem_changed :: Godot.Internal.Dispatch.Signal EditorFileSystem sig_filesystem_changed = Godot.Internal.Dispatch.Signal "filesystem_changed" instance NodeSignal EditorFileSystem "filesystem_changed" '[] -- | Remitted if a resource is reimported. sig_resources_reimported :: Godot.Internal.Dispatch.Signal EditorFileSystem sig_resources_reimported = Godot.Internal.Dispatch.Signal "resources_reimported" instance NodeSignal EditorFileSystem "resources_reimported" '[PoolStringArray] -- | Emitted if at least one resource is reloaded when the filesystem is scanned. sig_resources_reload :: Godot.Internal.Dispatch.Signal EditorFileSystem sig_resources_reload = Godot.Internal.Dispatch.Signal "resources_reload" instance NodeSignal EditorFileSystem "resources_reload" '[PoolStringArray] -- | Emitted if the source of any imported file changed. sig_sources_changed :: Godot.Internal.Dispatch.Signal EditorFileSystem sig_sources_changed = Godot.Internal.Dispatch.Signal "sources_changed" instance NodeSignal EditorFileSystem "sources_changed" '[Bool] {-# NOINLINE bindEditorFileSystem_get_file_type #-} -- | Gets the type of the file, given the full path. bindEditorFileSystem_get_file_type :: MethodBind bindEditorFileSystem_get_file_type = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "get_file_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the type of the file, given the full path. get_file_type :: (EditorFileSystem :< cls, Object :< cls) => cls -> GodotString -> IO GodotString get_file_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_get_file_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "get_file_type" '[GodotString] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileSystem.get_file_type {-# NOINLINE bindEditorFileSystem_get_filesystem #-} -- | Gets the root directory object. bindEditorFileSystem_get_filesystem :: MethodBind bindEditorFileSystem_get_filesystem = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "get_filesystem" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the root directory object. get_filesystem :: (EditorFileSystem :< cls, Object :< cls) => cls -> IO EditorFileSystemDirectory get_filesystem cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_get_filesystem (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "get_filesystem" '[] (IO EditorFileSystemDirectory) where nodeMethod = Godot.Tools.EditorFileSystem.get_filesystem {-# NOINLINE bindEditorFileSystem_get_filesystem_path #-} -- | Returns a view into the filesystem at @path@. bindEditorFileSystem_get_filesystem_path :: MethodBind bindEditorFileSystem_get_filesystem_path = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "get_filesystem_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a view into the filesystem at @path@. get_filesystem_path :: (EditorFileSystem :< cls, Object :< cls) => cls -> GodotString -> IO EditorFileSystemDirectory get_filesystem_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_get_filesystem_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "get_filesystem_path" '[GodotString] (IO EditorFileSystemDirectory) where nodeMethod = Godot.Tools.EditorFileSystem.get_filesystem_path {-# NOINLINE bindEditorFileSystem_get_scanning_progress #-} -- | Returns the scan progress for 0 to 1 if the FS is being scanned. bindEditorFileSystem_get_scanning_progress :: MethodBind bindEditorFileSystem_get_scanning_progress = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "get_scanning_progress" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the scan progress for 0 to 1 if the FS is being scanned. get_scanning_progress :: (EditorFileSystem :< cls, Object :< cls) => cls -> IO Float get_scanning_progress cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_get_scanning_progress (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "get_scanning_progress" '[] (IO Float) where nodeMethod = Godot.Tools.EditorFileSystem.get_scanning_progress {-# NOINLINE bindEditorFileSystem_is_scanning #-} -- | Returns @true@ of the filesystem is being scanned. bindEditorFileSystem_is_scanning :: MethodBind bindEditorFileSystem_is_scanning = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "is_scanning" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ of the filesystem is being scanned. is_scanning :: (EditorFileSystem :< cls, Object :< cls) => cls -> IO Bool is_scanning cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_is_scanning (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "is_scanning" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorFileSystem.is_scanning {-# NOINLINE bindEditorFileSystem_scan #-} -- | Scan the filesystem for changes. bindEditorFileSystem_scan :: MethodBind bindEditorFileSystem_scan = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "scan" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scan the filesystem for changes. scan :: (EditorFileSystem :< cls, Object :< cls) => cls -> IO () scan cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_scan (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "scan" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileSystem.scan {-# NOINLINE bindEditorFileSystem_scan_sources #-} -- | Check if the source of any imported resource changed. bindEditorFileSystem_scan_sources :: MethodBind bindEditorFileSystem_scan_sources = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "scan_sources" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Check if the source of any imported resource changed. scan_sources :: (EditorFileSystem :< cls, Object :< cls) => cls -> IO () scan_sources cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_scan_sources (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "scan_sources" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileSystem.scan_sources {-# NOINLINE bindEditorFileSystem_update_file #-} -- | Update a file information. Call this if an external program (not Godot) modified the file. bindEditorFileSystem_update_file :: MethodBind bindEditorFileSystem_update_file = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "update_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Update a file information. Call this if an external program (not Godot) modified the file. update_file :: (EditorFileSystem :< cls, Object :< cls) => cls -> GodotString -> IO () update_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_update_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "update_file" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorFileSystem.update_file {-# NOINLINE bindEditorFileSystem_update_script_classes #-} -- | Scans the script files and updates the list of custom class names. bindEditorFileSystem_update_script_classes :: MethodBind bindEditorFileSystem_update_script_classes = unsafePerformIO $ withCString "EditorFileSystem" $ \ clsNamePtr -> withCString "update_script_classes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Scans the script files and updates the list of custom class names. update_script_classes :: (EditorFileSystem :< cls, Object :< cls) => cls -> IO () update_script_classes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystem_update_script_classes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystem "update_script_classes" '[] (IO ()) where nodeMethod = Godot.Tools.EditorFileSystem.update_script_classes ================================================ FILE: src/Godot/Tools/EditorFileSystemDirectory.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorFileSystemDirectory (Godot.Tools.EditorFileSystemDirectory.find_dir_index, Godot.Tools.EditorFileSystemDirectory.find_file_index, Godot.Tools.EditorFileSystemDirectory.get_file, Godot.Tools.EditorFileSystemDirectory.get_file_count, Godot.Tools.EditorFileSystemDirectory.get_file_import_is_valid, Godot.Tools.EditorFileSystemDirectory.get_file_path, Godot.Tools.EditorFileSystemDirectory.get_file_script_class_extends, Godot.Tools.EditorFileSystemDirectory.get_file_script_class_name, Godot.Tools.EditorFileSystemDirectory.get_file_type, Godot.Tools.EditorFileSystemDirectory.get_name, Godot.Tools.EditorFileSystemDirectory.get_parent, Godot.Tools.EditorFileSystemDirectory.get_path, Godot.Tools.EditorFileSystemDirectory.get_subdir, Godot.Tools.EditorFileSystemDirectory.get_subdir_count) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindEditorFileSystemDirectory_find_dir_index #-} -- | Returns the index of the directory with name @name@ or @-1@ if not found. bindEditorFileSystemDirectory_find_dir_index :: MethodBind bindEditorFileSystemDirectory_find_dir_index = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "find_dir_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the directory with name @name@ or @-1@ if not found. find_dir_index :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> GodotString -> IO Int find_dir_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_find_dir_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "find_dir_index" '[GodotString] (IO Int) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.find_dir_index {-# NOINLINE bindEditorFileSystemDirectory_find_file_index #-} -- | Returns the index of the file with name @name@ or @-1@ if not found. bindEditorFileSystemDirectory_find_file_index :: MethodBind bindEditorFileSystemDirectory_find_file_index = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "find_file_index" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the index of the file with name @name@ or @-1@ if not found. find_file_index :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> GodotString -> IO Int find_file_index cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_find_file_index (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "find_file_index" '[GodotString] (IO Int) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.find_file_index {-# NOINLINE bindEditorFileSystemDirectory_get_file #-} -- | Returns the name of the file at index @idx@. bindEditorFileSystemDirectory_get_file :: MethodBind bindEditorFileSystemDirectory_get_file = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the file at index @idx@. get_file :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> Int -> IO GodotString get_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_file" '[Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_file {-# NOINLINE bindEditorFileSystemDirectory_get_file_count #-} -- | Returns the number of files in this directory. bindEditorFileSystemDirectory_get_file_count :: MethodBind bindEditorFileSystemDirectory_get_file_count = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_file_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of files in this directory. get_file_count :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> IO Int get_file_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_file_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_file_count" '[] (IO Int) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_file_count {-# NOINLINE bindEditorFileSystemDirectory_get_file_import_is_valid #-} -- | Returns @true@ if the file at index @idx@ imported properly. bindEditorFileSystemDirectory_get_file_import_is_valid :: MethodBind bindEditorFileSystemDirectory_get_file_import_is_valid = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_file_import_is_valid" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the file at index @idx@ imported properly. get_file_import_is_valid :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> Int -> IO Bool get_file_import_is_valid cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_file_import_is_valid (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_file_import_is_valid" '[Int] (IO Bool) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_file_import_is_valid {-# NOINLINE bindEditorFileSystemDirectory_get_file_path #-} -- | Returns the path to the file at index @idx@. bindEditorFileSystemDirectory_get_file_path :: MethodBind bindEditorFileSystemDirectory_get_file_path = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_file_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to the file at index @idx@. get_file_path :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> Int -> IO GodotString get_file_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_file_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_file_path" '[Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_file_path {-# NOINLINE bindEditorFileSystemDirectory_get_file_script_class_extends #-} -- | Returns the base class of the script class defined in the file at index @idx@. If the file doesn't define a script class using the @class_name@ syntax, this will return an empty string. bindEditorFileSystemDirectory_get_file_script_class_extends :: MethodBind bindEditorFileSystemDirectory_get_file_script_class_extends = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_file_script_class_extends" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the base class of the script class defined in the file at index @idx@. If the file doesn't define a script class using the @class_name@ syntax, this will return an empty string. get_file_script_class_extends :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> Int -> IO GodotString get_file_script_class_extends cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_file_script_class_extends (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_file_script_class_extends" '[Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_file_script_class_extends {-# NOINLINE bindEditorFileSystemDirectory_get_file_script_class_name #-} -- | Returns the name of the script class defined in the file at index @idx@. If the file doesn't define a script class using the @class_name@ syntax, this will return an empty string. bindEditorFileSystemDirectory_get_file_script_class_name :: MethodBind bindEditorFileSystemDirectory_get_file_script_class_name = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_file_script_class_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the script class defined in the file at index @idx@. If the file doesn't define a script class using the @class_name@ syntax, this will return an empty string. get_file_script_class_name :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> Int -> IO GodotString get_file_script_class_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_file_script_class_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_file_script_class_name" '[Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_file_script_class_name {-# NOINLINE bindEditorFileSystemDirectory_get_file_type #-} -- | Returns the file extension of the file at index @idx@. bindEditorFileSystemDirectory_get_file_type :: MethodBind bindEditorFileSystemDirectory_get_file_type = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_file_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the file extension of the file at index @idx@. get_file_type :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> Int -> IO GodotString get_file_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_file_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_file_type" '[Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_file_type {-# NOINLINE bindEditorFileSystemDirectory_get_name #-} -- | Returns the name of this directory. bindEditorFileSystemDirectory_get_name :: MethodBind bindEditorFileSystemDirectory_get_name = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of this directory. get_name :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> IO GodotString get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_name {-# NOINLINE bindEditorFileSystemDirectory_get_parent #-} -- | Returns the parent directory for this directory or @null@ if called on a directory at @res://@ or @user://@. bindEditorFileSystemDirectory_get_parent :: MethodBind bindEditorFileSystemDirectory_get_parent = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_parent" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the parent directory for this directory or @null@ if called on a directory at @res://@ or @user://@. get_parent :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> IO EditorFileSystemDirectory get_parent cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_parent (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_parent" '[] (IO EditorFileSystemDirectory) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_parent {-# NOINLINE bindEditorFileSystemDirectory_get_path #-} -- | Returns the path to this directory. bindEditorFileSystemDirectory_get_path :: MethodBind bindEditorFileSystemDirectory_get_path = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path to this directory. get_path :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> IO GodotString get_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_path" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_path {-# NOINLINE bindEditorFileSystemDirectory_get_subdir #-} -- | Returns the subdirectory at index @idx@. bindEditorFileSystemDirectory_get_subdir :: MethodBind bindEditorFileSystemDirectory_get_subdir = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_subdir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the subdirectory at index @idx@. get_subdir :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> Int -> IO EditorFileSystemDirectory get_subdir cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_subdir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_subdir" '[Int] (IO EditorFileSystemDirectory) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_subdir {-# NOINLINE bindEditorFileSystemDirectory_get_subdir_count #-} -- | Returns the number of subdirectories in this directory. bindEditorFileSystemDirectory_get_subdir_count :: MethodBind bindEditorFileSystemDirectory_get_subdir_count = unsafePerformIO $ withCString "EditorFileSystemDirectory" $ \ clsNamePtr -> withCString "get_subdir_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the number of subdirectories in this directory. get_subdir_count :: (EditorFileSystemDirectory :< cls, Object :< cls) => cls -> IO Int get_subdir_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorFileSystemDirectory_get_subdir_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorFileSystemDirectory "get_subdir_count" '[] (IO Int) where nodeMethod = Godot.Tools.EditorFileSystemDirectory.get_subdir_count ================================================ FILE: src/Godot/Tools/EditorImportPlugin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorImportPlugin (Godot.Tools.EditorImportPlugin.get_import_options, Godot.Tools.EditorImportPlugin.get_import_order, Godot.Tools.EditorImportPlugin.get_importer_name, Godot.Tools.EditorImportPlugin.get_option_visibility, Godot.Tools.EditorImportPlugin.get_preset_count, Godot.Tools.EditorImportPlugin.get_preset_name, Godot.Tools.EditorImportPlugin.get_priority, Godot.Tools.EditorImportPlugin.get_recognized_extensions, Godot.Tools.EditorImportPlugin.get_resource_type, Godot.Tools.EditorImportPlugin.get_save_extension, Godot.Tools.EditorImportPlugin.get_visible_name, Godot.Tools.EditorImportPlugin.import') where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ResourceImporter() {-# NOINLINE bindEditorImportPlugin_get_import_options #-} -- | Gets the options and default values for the preset at this index. Returns an Array of Dictionaries with the following keys: @name@, @default_value@, @property_hint@ (optional), @hint_string@ (optional), @usage@ (optional). bindEditorImportPlugin_get_import_options :: MethodBind bindEditorImportPlugin_get_import_options = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_import_options" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the options and default values for the preset at this index. Returns an Array of Dictionaries with the following keys: @name@, @default_value@, @property_hint@ (optional), @hint_string@ (optional), @usage@ (optional). get_import_options :: (EditorImportPlugin :< cls, Object :< cls) => cls -> Int -> IO Array get_import_options cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_import_options (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_import_options" '[Int] (IO Array) where nodeMethod = Godot.Tools.EditorImportPlugin.get_import_options {-# NOINLINE bindEditorImportPlugin_get_import_order #-} -- | Gets the order of this importer to be run when importing resources. Higher values will be called later. Use this to ensure the importer runs after the dependencies are already imported. bindEditorImportPlugin_get_import_order :: MethodBind bindEditorImportPlugin_get_import_order = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_import_order" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the order of this importer to be run when importing resources. Higher values will be called later. Use this to ensure the importer runs after the dependencies are already imported. get_import_order :: (EditorImportPlugin :< cls, Object :< cls) => cls -> IO Int get_import_order cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_import_order (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_import_order" '[] (IO Int) where nodeMethod = Godot.Tools.EditorImportPlugin.get_import_order {-# NOINLINE bindEditorImportPlugin_get_importer_name #-} -- | Gets the unique name of the importer. bindEditorImportPlugin_get_importer_name :: MethodBind bindEditorImportPlugin_get_importer_name = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_importer_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the unique name of the importer. get_importer_name :: (EditorImportPlugin :< cls, Object :< cls) => cls -> IO GodotString get_importer_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_importer_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_importer_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorImportPlugin.get_importer_name {-# NOINLINE bindEditorImportPlugin_get_option_visibility #-} -- | This method can be overridden to hide specific import options if conditions are met. This is mainly useful for hiding options that depend on others if one of them is disabled. For example: -- -- @ -- -- func get_option_visibility(option, options): -- # Only show the lossy quality setting if the compression mode is set to "Lossy". -- if option == "compress/lossy_quality" and options.has("compress/mode"): -- return int(options@"compress/mode"@) == COMPRESS_LOSSY -- -- return true -- -- @ -- -- Return @true@ to make all options always visible. bindEditorImportPlugin_get_option_visibility :: MethodBind bindEditorImportPlugin_get_option_visibility = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_option_visibility" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This method can be overridden to hide specific import options if conditions are met. This is mainly useful for hiding options that depend on others if one of them is disabled. For example: -- -- @ -- -- func get_option_visibility(option, options): -- # Only show the lossy quality setting if the compression mode is set to "Lossy". -- if option == "compress/lossy_quality" and options.has("compress/mode"): -- return int(options@"compress/mode"@) == COMPRESS_LOSSY -- -- return true -- -- @ -- -- Return @true@ to make all options always visible. get_option_visibility :: (EditorImportPlugin :< cls, Object :< cls) => cls -> GodotString -> Dictionary -> IO Bool get_option_visibility cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_option_visibility (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_option_visibility" '[GodotString, Dictionary] (IO Bool) where nodeMethod = Godot.Tools.EditorImportPlugin.get_option_visibility {-# NOINLINE bindEditorImportPlugin_get_preset_count #-} -- | Gets the number of initial presets defined by the plugin. Use @method get_import_options@ to get the default options for the preset and @method get_preset_name@ to get the name of the preset. bindEditorImportPlugin_get_preset_count :: MethodBind bindEditorImportPlugin_get_preset_count = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_preset_count" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the number of initial presets defined by the plugin. Use @method get_import_options@ to get the default options for the preset and @method get_preset_name@ to get the name of the preset. get_preset_count :: (EditorImportPlugin :< cls, Object :< cls) => cls -> IO Int get_preset_count cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_preset_count (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_preset_count" '[] (IO Int) where nodeMethod = Godot.Tools.EditorImportPlugin.get_preset_count {-# NOINLINE bindEditorImportPlugin_get_preset_name #-} -- | Gets the name of the options preset at this index. bindEditorImportPlugin_get_preset_name :: MethodBind bindEditorImportPlugin_get_preset_name = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_preset_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the name of the options preset at this index. get_preset_name :: (EditorImportPlugin :< cls, Object :< cls) => cls -> Int -> IO GodotString get_preset_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_preset_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_preset_name" '[Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorImportPlugin.get_preset_name {-# NOINLINE bindEditorImportPlugin_get_priority #-} -- | Gets the priority of this plugin for the recognized extension. Higher priority plugins will be preferred. The default priority is @1.0@. bindEditorImportPlugin_get_priority :: MethodBind bindEditorImportPlugin_get_priority = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the priority of this plugin for the recognized extension. Higher priority plugins will be preferred. The default priority is @1.0@. get_priority :: (EditorImportPlugin :< cls, Object :< cls) => cls -> IO Float get_priority cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_priority" '[] (IO Float) where nodeMethod = Godot.Tools.EditorImportPlugin.get_priority {-# NOINLINE bindEditorImportPlugin_get_recognized_extensions #-} -- | Gets the list of file extensions to associate with this loader (case-insensitive). e.g. @@"obj"@@. bindEditorImportPlugin_get_recognized_extensions :: MethodBind bindEditorImportPlugin_get_recognized_extensions = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_recognized_extensions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the list of file extensions to associate with this loader (case-insensitive). e.g. @@"obj"@@. get_recognized_extensions :: (EditorImportPlugin :< cls, Object :< cls) => cls -> IO Array get_recognized_extensions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_recognized_extensions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_recognized_extensions" '[] (IO Array) where nodeMethod = Godot.Tools.EditorImportPlugin.get_recognized_extensions {-# NOINLINE bindEditorImportPlugin_get_resource_type #-} -- | Gets the Godot resource type associated with this loader. e.g. @"Mesh"@ or @"Animation"@. bindEditorImportPlugin_get_resource_type :: MethodBind bindEditorImportPlugin_get_resource_type = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_resource_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the Godot resource type associated with this loader. e.g. @"Mesh"@ or @"Animation"@. get_resource_type :: (EditorImportPlugin :< cls, Object :< cls) => cls -> IO GodotString get_resource_type cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_resource_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_resource_type" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorImportPlugin.get_resource_type {-# NOINLINE bindEditorImportPlugin_get_save_extension #-} -- | Gets the extension used to save this resource in the @.import@ directory. bindEditorImportPlugin_get_save_extension :: MethodBind bindEditorImportPlugin_get_save_extension = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_save_extension" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the extension used to save this resource in the @.import@ directory. get_save_extension :: (EditorImportPlugin :< cls, Object :< cls) => cls -> IO GodotString get_save_extension cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_save_extension (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_save_extension" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorImportPlugin.get_save_extension {-# NOINLINE bindEditorImportPlugin_get_visible_name #-} -- | Gets the name to display in the import window. bindEditorImportPlugin_get_visible_name :: MethodBind bindEditorImportPlugin_get_visible_name = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "get_visible_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the name to display in the import window. get_visible_name :: (EditorImportPlugin :< cls, Object :< cls) => cls -> IO GodotString get_visible_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_get_visible_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "get_visible_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorImportPlugin.get_visible_name {-# NOINLINE bindEditorImportPlugin_import' #-} -- | Imports @source_file@ into @save_path@ with the import @options@ specified. The @platform_variants@ and @gen_files@ arrays will be modified by this function. -- This method must be overridden to do the actual importing work. See this class' description for an example of overriding this method. bindEditorImportPlugin_import' :: MethodBind bindEditorImportPlugin_import' = unsafePerformIO $ withCString "EditorImportPlugin" $ \ clsNamePtr -> withCString "import" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Imports @source_file@ into @save_path@ with the import @options@ specified. The @platform_variants@ and @gen_files@ arrays will be modified by this function. -- This method must be overridden to do the actual importing work. See this class' description for an example of overriding this method. import' :: (EditorImportPlugin :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Dictionary -> Array -> Array -> IO Int import' cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindEditorImportPlugin_import' (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorImportPlugin "import" '[GodotString, GodotString, Dictionary, Array, Array] (IO Int) where nodeMethod = Godot.Tools.EditorImportPlugin.import' ================================================ FILE: src/Godot/Tools/EditorInspector.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorInspector (Godot.Tools.EditorInspector.sig_object_id_selected, Godot.Tools.EditorInspector.sig_property_edited, Godot.Tools.EditorInspector.sig_property_keyed, Godot.Tools.EditorInspector.sig_property_selected, Godot.Tools.EditorInspector.sig_property_toggled, Godot.Tools.EditorInspector.sig_resource_selected, Godot.Tools.EditorInspector.sig_restart_requested, Godot.Tools.EditorInspector._edit_request_change, Godot.Tools.EditorInspector._feature_profile_changed, Godot.Tools.EditorInspector._filter_changed, Godot.Tools.EditorInspector._multiple_properties_changed, Godot.Tools.EditorInspector._node_removed, Godot.Tools.EditorInspector._object_id_selected, Godot.Tools.EditorInspector._property_changed, Godot.Tools.EditorInspector._property_changed_update_all, Godot.Tools.EditorInspector._property_checked, Godot.Tools.EditorInspector._property_keyed, Godot.Tools.EditorInspector._property_keyed_with_value, Godot.Tools.EditorInspector._property_selected, Godot.Tools.EditorInspector._resource_selected, Godot.Tools.EditorInspector._vscroll_changed, Godot.Tools.EditorInspector.refresh) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ScrollContainer() -- | Emitted when the Edit button of an @Object@ has been pressed in the inspector. This is mainly used in the remote scene tree inspector. sig_object_id_selected :: Godot.Internal.Dispatch.Signal EditorInspector sig_object_id_selected = Godot.Internal.Dispatch.Signal "object_id_selected" instance NodeSignal EditorInspector "object_id_selected" '[Int] -- | Emitted when a property is edited in the inspector. sig_property_edited :: Godot.Internal.Dispatch.Signal EditorInspector sig_property_edited = Godot.Internal.Dispatch.Signal "property_edited" instance NodeSignal EditorInspector "property_edited" '[GodotString] -- | Emitted when a property is keyed in the inspector. Properties can be keyed by clicking the "key" icon next to a property when the Animation panel is toggled. sig_property_keyed :: Godot.Internal.Dispatch.Signal EditorInspector sig_property_keyed = Godot.Internal.Dispatch.Signal "property_keyed" instance NodeSignal EditorInspector "property_keyed" '[GodotString] -- | Emitted when a property is selected in the inspector. sig_property_selected :: Godot.Internal.Dispatch.Signal EditorInspector sig_property_selected = Godot.Internal.Dispatch.Signal "property_selected" instance NodeSignal EditorInspector "property_selected" '[GodotString] -- | Emitted when a boolean property is toggled in the inspector. -- __Note:__ This signal is never emitted if the internal @autoclear@ property enabled. Since this property is always enabled in the editor inspector, this signal is never emitted by the editor itself. sig_property_toggled :: Godot.Internal.Dispatch.Signal EditorInspector sig_property_toggled = Godot.Internal.Dispatch.Signal "property_toggled" instance NodeSignal EditorInspector "property_toggled" '[GodotString, Bool] -- | Emitted when a resource is selected in the inspector. sig_resource_selected :: Godot.Internal.Dispatch.Signal EditorInspector sig_resource_selected = Godot.Internal.Dispatch.Signal "resource_selected" instance NodeSignal EditorInspector "resource_selected" '[Object, GodotString] -- | Emitted when a property that requires a restart to be applied is edited in the inspector. This is only used in the Project Settings and Editor Settings. sig_restart_requested :: Godot.Internal.Dispatch.Signal EditorInspector sig_restart_requested = Godot.Internal.Dispatch.Signal "restart_requested" instance NodeSignal EditorInspector "restart_requested" '[] {-# NOINLINE bindEditorInspector__edit_request_change #-} bindEditorInspector__edit_request_change :: MethodBind bindEditorInspector__edit_request_change = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_edit_request_change" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _edit_request_change :: (EditorInspector :< cls, Object :< cls) => cls -> Object -> GodotString -> IO () _edit_request_change cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__edit_request_change (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_edit_request_change" '[Object, GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._edit_request_change {-# NOINLINE bindEditorInspector__feature_profile_changed #-} bindEditorInspector__feature_profile_changed :: MethodBind bindEditorInspector__feature_profile_changed = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_feature_profile_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _feature_profile_changed :: (EditorInspector :< cls, Object :< cls) => cls -> IO () _feature_profile_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__feature_profile_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_feature_profile_changed" '[] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._feature_profile_changed {-# NOINLINE bindEditorInspector__filter_changed #-} bindEditorInspector__filter_changed :: MethodBind bindEditorInspector__filter_changed = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_filter_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _filter_changed :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> IO () _filter_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__filter_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_filter_changed" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._filter_changed {-# NOINLINE bindEditorInspector__multiple_properties_changed #-} bindEditorInspector__multiple_properties_changed :: MethodBind bindEditorInspector__multiple_properties_changed = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_multiple_properties_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _multiple_properties_changed :: (EditorInspector :< cls, Object :< cls) => cls -> PoolStringArray -> Array -> IO () _multiple_properties_changed cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__multiple_properties_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_multiple_properties_changed" '[PoolStringArray, Array] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._multiple_properties_changed {-# NOINLINE bindEditorInspector__node_removed #-} bindEditorInspector__node_removed :: MethodBind bindEditorInspector__node_removed = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_node_removed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _node_removed :: (EditorInspector :< cls, Object :< cls) => cls -> Node -> IO () _node_removed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__node_removed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_node_removed" '[Node] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._node_removed {-# NOINLINE bindEditorInspector__object_id_selected #-} bindEditorInspector__object_id_selected :: MethodBind bindEditorInspector__object_id_selected = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_object_id_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _object_id_selected :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () _object_id_selected cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__object_id_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_object_id_selected" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._object_id_selected {-# NOINLINE bindEditorInspector__property_changed #-} bindEditorInspector__property_changed :: MethodBind bindEditorInspector__property_changed = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_property_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _property_changed :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> Maybe GodotString -> Maybe Bool -> IO () _property_changed cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantString "" arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__property_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_property_changed" '[GodotString, GodotVariant, Maybe GodotString, Maybe Bool] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._property_changed {-# NOINLINE bindEditorInspector__property_changed_update_all #-} bindEditorInspector__property_changed_update_all :: MethodBind bindEditorInspector__property_changed_update_all = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_property_changed_update_all" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _property_changed_update_all :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> GodotString -> Bool -> IO () _property_changed_update_all cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__property_changed_update_all (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_property_changed_update_all" '[GodotString, GodotVariant, GodotString, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._property_changed_update_all {-# NOINLINE bindEditorInspector__property_checked #-} bindEditorInspector__property_checked :: MethodBind bindEditorInspector__property_checked = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_property_checked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _property_checked :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> Bool -> IO () _property_checked cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__property_checked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_property_checked" '[GodotString, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._property_checked {-# NOINLINE bindEditorInspector__property_keyed #-} bindEditorInspector__property_keyed :: MethodBind bindEditorInspector__property_keyed = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_property_keyed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _property_keyed :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> Bool -> IO () _property_keyed cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__property_keyed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_property_keyed" '[GodotString, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._property_keyed {-# NOINLINE bindEditorInspector__property_keyed_with_value #-} bindEditorInspector__property_keyed_with_value :: MethodBind bindEditorInspector__property_keyed_with_value = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_property_keyed_with_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _property_keyed_with_value :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> Bool -> IO () _property_keyed_with_value cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__property_keyed_with_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_property_keyed_with_value" '[GodotString, GodotVariant, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._property_keyed_with_value {-# NOINLINE bindEditorInspector__property_selected #-} bindEditorInspector__property_selected :: MethodBind bindEditorInspector__property_selected = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_property_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _property_selected :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> Int -> IO () _property_selected cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__property_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_property_selected" '[GodotString, Int] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._property_selected {-# NOINLINE bindEditorInspector__resource_selected #-} bindEditorInspector__resource_selected :: MethodBind bindEditorInspector__resource_selected = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_resource_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _resource_selected :: (EditorInspector :< cls, Object :< cls) => cls -> GodotString -> Resource -> IO () _resource_selected cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__resource_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_resource_selected" '[GodotString, Resource] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._resource_selected {-# NOINLINE bindEditorInspector__vscroll_changed #-} bindEditorInspector__vscroll_changed :: MethodBind bindEditorInspector__vscroll_changed = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "_vscroll_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _vscroll_changed :: (EditorInspector :< cls, Object :< cls) => cls -> Float -> IO () _vscroll_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector__vscroll_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "_vscroll_changed" '[Float] (IO ()) where nodeMethod = Godot.Tools.EditorInspector._vscroll_changed {-# NOINLINE bindEditorInspector_refresh #-} -- | Refreshes the inspector. -- __Note:__ To save on CPU resources, calling this method will do nothing if the time specified in @docks/property_editor/auto_refresh_interval@ editor setting hasn't passed yet since this method was last called. (By default, this interval is set to 0.3 seconds.) bindEditorInspector_refresh :: MethodBind bindEditorInspector_refresh = unsafePerformIO $ withCString "EditorInspector" $ \ clsNamePtr -> withCString "refresh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Refreshes the inspector. -- __Note:__ To save on CPU resources, calling this method will do nothing if the time specified in @docks/property_editor/auto_refresh_interval@ editor setting hasn't passed yet since this method was last called. (By default, this interval is set to 0.3 seconds.) refresh :: (EditorInspector :< cls, Object :< cls) => cls -> IO () refresh cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspector_refresh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspector "refresh" '[] (IO ()) where nodeMethod = Godot.Tools.EditorInspector.refresh ================================================ FILE: src/Godot/Tools/EditorInspectorPlugin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorInspectorPlugin (Godot.Tools.EditorInspectorPlugin.add_custom_control, Godot.Tools.EditorInspectorPlugin.add_property_editor, Godot.Tools.EditorInspectorPlugin.add_property_editor_for_multiple_properties, Godot.Tools.EditorInspectorPlugin.can_handle, Godot.Tools.EditorInspectorPlugin.parse_begin, Godot.Tools.EditorInspectorPlugin.parse_category, Godot.Tools.EditorInspectorPlugin.parse_end, Godot.Tools.EditorInspectorPlugin.parse_property) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindEditorInspectorPlugin_add_custom_control #-} -- | Adds a custom control, not necessarily a property editor. bindEditorInspectorPlugin_add_custom_control :: MethodBind bindEditorInspectorPlugin_add_custom_control = unsafePerformIO $ withCString "EditorInspectorPlugin" $ \ clsNamePtr -> withCString "add_custom_control" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a custom control, not necessarily a property editor. add_custom_control :: (EditorInspectorPlugin :< cls, Object :< cls) => cls -> Control -> IO () add_custom_control cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspectorPlugin_add_custom_control (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspectorPlugin "add_custom_control" '[Control] (IO ()) where nodeMethod = Godot.Tools.EditorInspectorPlugin.add_custom_control {-# NOINLINE bindEditorInspectorPlugin_add_property_editor #-} -- | Adds a property editor, this must inherit @EditorProperty@. bindEditorInspectorPlugin_add_property_editor :: MethodBind bindEditorInspectorPlugin_add_property_editor = unsafePerformIO $ withCString "EditorInspectorPlugin" $ \ clsNamePtr -> withCString "add_property_editor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a property editor, this must inherit @EditorProperty@. add_property_editor :: (EditorInspectorPlugin :< cls, Object :< cls) => cls -> GodotString -> Control -> IO () add_property_editor cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspectorPlugin_add_property_editor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspectorPlugin "add_property_editor" '[GodotString, Control] (IO ()) where nodeMethod = Godot.Tools.EditorInspectorPlugin.add_property_editor {-# NOINLINE bindEditorInspectorPlugin_add_property_editor_for_multiple_properties #-} -- | Adds an editor that allows modifying multiple properties, this must inherit @EditorProperty@. bindEditorInspectorPlugin_add_property_editor_for_multiple_properties :: MethodBind bindEditorInspectorPlugin_add_property_editor_for_multiple_properties = unsafePerformIO $ withCString "EditorInspectorPlugin" $ \ clsNamePtr -> withCString "add_property_editor_for_multiple_properties" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an editor that allows modifying multiple properties, this must inherit @EditorProperty@. add_property_editor_for_multiple_properties :: (EditorInspectorPlugin :< cls, Object :< cls) => cls -> GodotString -> PoolStringArray -> Control -> IO () add_property_editor_for_multiple_properties cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspectorPlugin_add_property_editor_for_multiple_properties (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspectorPlugin "add_property_editor_for_multiple_properties" '[GodotString, PoolStringArray, Control] (IO ()) where nodeMethod = Godot.Tools.EditorInspectorPlugin.add_property_editor_for_multiple_properties {-# NOINLINE bindEditorInspectorPlugin_can_handle #-} -- | Returns @true@ if this object can be handled by this plugin. bindEditorInspectorPlugin_can_handle :: MethodBind bindEditorInspectorPlugin_can_handle = unsafePerformIO $ withCString "EditorInspectorPlugin" $ \ clsNamePtr -> withCString "can_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this object can be handled by this plugin. can_handle :: (EditorInspectorPlugin :< cls, Object :< cls) => cls -> Object -> IO Bool can_handle cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspectorPlugin_can_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspectorPlugin "can_handle" '[Object] (IO Bool) where nodeMethod = Godot.Tools.EditorInspectorPlugin.can_handle {-# NOINLINE bindEditorInspectorPlugin_parse_begin #-} -- | Called to allow adding controls at the beginning of the list. bindEditorInspectorPlugin_parse_begin :: MethodBind bindEditorInspectorPlugin_parse_begin = unsafePerformIO $ withCString "EditorInspectorPlugin" $ \ clsNamePtr -> withCString "parse_begin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called to allow adding controls at the beginning of the list. parse_begin :: (EditorInspectorPlugin :< cls, Object :< cls) => cls -> Object -> IO () parse_begin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspectorPlugin_parse_begin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspectorPlugin "parse_begin" '[Object] (IO ()) where nodeMethod = Godot.Tools.EditorInspectorPlugin.parse_begin {-# NOINLINE bindEditorInspectorPlugin_parse_category #-} -- | Called to allow adding controls at the beginning of the category. bindEditorInspectorPlugin_parse_category :: MethodBind bindEditorInspectorPlugin_parse_category = unsafePerformIO $ withCString "EditorInspectorPlugin" $ \ clsNamePtr -> withCString "parse_category" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called to allow adding controls at the beginning of the category. parse_category :: (EditorInspectorPlugin :< cls, Object :< cls) => cls -> Object -> GodotString -> IO () parse_category cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspectorPlugin_parse_category (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspectorPlugin "parse_category" '[Object, GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorInspectorPlugin.parse_category {-# NOINLINE bindEditorInspectorPlugin_parse_end #-} -- | Called to allow adding controls at the end of the list. bindEditorInspectorPlugin_parse_end :: MethodBind bindEditorInspectorPlugin_parse_end = unsafePerformIO $ withCString "EditorInspectorPlugin" $ \ clsNamePtr -> withCString "parse_end" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called to allow adding controls at the end of the list. parse_end :: (EditorInspectorPlugin :< cls, Object :< cls) => cls -> IO () parse_end cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspectorPlugin_parse_end (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspectorPlugin "parse_end" '[] (IO ()) where nodeMethod = Godot.Tools.EditorInspectorPlugin.parse_end {-# NOINLINE bindEditorInspectorPlugin_parse_property #-} -- | Called to allow adding property specific editors to the inspector. Usually these inherit @EditorProperty@. Returning @true@ removes the built-in editor for this property, otherwise allows to insert a custom editor before the built-in one. bindEditorInspectorPlugin_parse_property :: MethodBind bindEditorInspectorPlugin_parse_property = unsafePerformIO $ withCString "EditorInspectorPlugin" $ \ clsNamePtr -> withCString "parse_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called to allow adding property specific editors to the inspector. Usually these inherit @EditorProperty@. Returning @true@ removes the built-in editor for this property, otherwise allows to insert a custom editor before the built-in one. parse_property :: (EditorInspectorPlugin :< cls, Object :< cls) => cls -> Object -> Int -> GodotString -> Int -> GodotString -> Int -> IO Bool parse_property cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInspectorPlugin_parse_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInspectorPlugin "parse_property" '[Object, Int, GodotString, Int, GodotString, Int] (IO Bool) where nodeMethod = Godot.Tools.EditorInspectorPlugin.parse_property ================================================ FILE: src/Godot/Tools/EditorInterface.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorInterface (Godot.Tools.EditorInterface.edit_resource, Godot.Tools.EditorInterface.get_base_control, Godot.Tools.EditorInterface.get_current_path, Godot.Tools.EditorInterface.get_edited_scene_root, Godot.Tools.EditorInterface.get_editor_settings, Godot.Tools.EditorInterface.get_editor_viewport, Godot.Tools.EditorInterface.get_inspector, Godot.Tools.EditorInterface.get_open_scenes, Godot.Tools.EditorInterface.get_resource_filesystem, Godot.Tools.EditorInterface.get_resource_previewer, Godot.Tools.EditorInterface.get_script_editor, Godot.Tools.EditorInterface.get_selected_path, Godot.Tools.EditorInterface.get_selection, Godot.Tools.EditorInterface.inspect_object, Godot.Tools.EditorInterface.is_plugin_enabled, Godot.Tools.EditorInterface.make_mesh_previews, Godot.Tools.EditorInterface.open_scene_from_path, Godot.Tools.EditorInterface.reload_scene_from_path, Godot.Tools.EditorInterface.save_scene, Godot.Tools.EditorInterface.save_scene_as, Godot.Tools.EditorInterface.select_file, Godot.Tools.EditorInterface.set_distraction_free_mode, Godot.Tools.EditorInterface.set_main_screen_editor, Godot.Tools.EditorInterface.set_plugin_enabled) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() {-# NOINLINE bindEditorInterface_edit_resource #-} -- | Edits the given @Resource@. bindEditorInterface_edit_resource :: MethodBind bindEditorInterface_edit_resource = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "edit_resource" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Edits the given @Resource@. edit_resource :: (EditorInterface :< cls, Object :< cls) => cls -> Resource -> IO () edit_resource cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_edit_resource (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "edit_resource" '[Resource] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.edit_resource {-# NOINLINE bindEditorInterface_get_base_control #-} -- | Returns the main container of Godot editor's window. For example, you can use it to retrieve the size of the container and place your controls accordingly. bindEditorInterface_get_base_control :: MethodBind bindEditorInterface_get_base_control = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_base_control" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the main container of Godot editor's window. For example, you can use it to retrieve the size of the container and place your controls accordingly. get_base_control :: (EditorInterface :< cls, Object :< cls) => cls -> IO Control get_base_control cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_base_control (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_base_control" '[] (IO Control) where nodeMethod = Godot.Tools.EditorInterface.get_base_control {-# NOINLINE bindEditorInterface_get_current_path #-} -- | Returns the current path being viewed in the @FileSystemDock@. bindEditorInterface_get_current_path :: MethodBind bindEditorInterface_get_current_path = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_current_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the current path being viewed in the @FileSystemDock@. get_current_path :: (EditorInterface :< cls, Object :< cls) => cls -> IO GodotString get_current_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_current_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_current_path" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorInterface.get_current_path {-# NOINLINE bindEditorInterface_get_edited_scene_root #-} -- | Returns the edited (current) scene's root @Node@. bindEditorInterface_get_edited_scene_root :: MethodBind bindEditorInterface_get_edited_scene_root = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_edited_scene_root" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the edited (current) scene's root @Node@. get_edited_scene_root :: (EditorInterface :< cls, Object :< cls) => cls -> IO Node get_edited_scene_root cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_edited_scene_root (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_edited_scene_root" '[] (IO Node) where nodeMethod = Godot.Tools.EditorInterface.get_edited_scene_root {-# NOINLINE bindEditorInterface_get_editor_settings #-} -- | Returns the editor's @EditorSettings@ instance. bindEditorInterface_get_editor_settings :: MethodBind bindEditorInterface_get_editor_settings = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_editor_settings" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the editor's @EditorSettings@ instance. get_editor_settings :: (EditorInterface :< cls, Object :< cls) => cls -> IO EditorSettings get_editor_settings cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_editor_settings (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_editor_settings" '[] (IO EditorSettings) where nodeMethod = Godot.Tools.EditorInterface.get_editor_settings {-# NOINLINE bindEditorInterface_get_editor_viewport #-} -- | Returns the main editor control. Use this as a parent for main screens. -- __Note:__ This returns the main editor control containing the whole editor, not the 2D or 3D viewports specifically. bindEditorInterface_get_editor_viewport :: MethodBind bindEditorInterface_get_editor_viewport = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_editor_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the main editor control. Use this as a parent for main screens. -- __Note:__ This returns the main editor control containing the whole editor, not the 2D or 3D viewports specifically. get_editor_viewport :: (EditorInterface :< cls, Object :< cls) => cls -> IO Control get_editor_viewport cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_editor_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_editor_viewport" '[] (IO Control) where nodeMethod = Godot.Tools.EditorInterface.get_editor_viewport {-# NOINLINE bindEditorInterface_get_inspector #-} -- | Returns the editor's @EditorInspector@ instance. bindEditorInterface_get_inspector :: MethodBind bindEditorInterface_get_inspector = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_inspector" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the editor's @EditorInspector@ instance. get_inspector :: (EditorInterface :< cls, Object :< cls) => cls -> IO EditorInspector get_inspector cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_inspector (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_inspector" '[] (IO EditorInspector) where nodeMethod = Godot.Tools.EditorInterface.get_inspector {-# NOINLINE bindEditorInterface_get_open_scenes #-} -- | Returns an @Array@ with the file paths of the currently opened scenes. bindEditorInterface_get_open_scenes :: MethodBind bindEditorInterface_get_open_scenes = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_open_scenes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ with the file paths of the currently opened scenes. get_open_scenes :: (EditorInterface :< cls, Object :< cls) => cls -> IO Array get_open_scenes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_open_scenes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_open_scenes" '[] (IO Array) where nodeMethod = Godot.Tools.EditorInterface.get_open_scenes {-# NOINLINE bindEditorInterface_get_resource_filesystem #-} -- | Returns the editor's @EditorFileSystem@ instance. bindEditorInterface_get_resource_filesystem :: MethodBind bindEditorInterface_get_resource_filesystem = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_resource_filesystem" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the editor's @EditorFileSystem@ instance. get_resource_filesystem :: (EditorInterface :< cls, Object :< cls) => cls -> IO EditorFileSystem get_resource_filesystem cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_resource_filesystem (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_resource_filesystem" '[] (IO EditorFileSystem) where nodeMethod = Godot.Tools.EditorInterface.get_resource_filesystem {-# NOINLINE bindEditorInterface_get_resource_previewer #-} -- | Returns the editor's @EditorResourcePreview@ instance. bindEditorInterface_get_resource_previewer :: MethodBind bindEditorInterface_get_resource_previewer = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_resource_previewer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the editor's @EditorResourcePreview@ instance. get_resource_previewer :: (EditorInterface :< cls, Object :< cls) => cls -> IO EditorResourcePreview get_resource_previewer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_resource_previewer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_resource_previewer" '[] (IO EditorResourcePreview) where nodeMethod = Godot.Tools.EditorInterface.get_resource_previewer {-# NOINLINE bindEditorInterface_get_script_editor #-} -- | Returns the editor's @ScriptEditor@ instance. bindEditorInterface_get_script_editor :: MethodBind bindEditorInterface_get_script_editor = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_script_editor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the editor's @ScriptEditor@ instance. get_script_editor :: (EditorInterface :< cls, Object :< cls) => cls -> IO ScriptEditor get_script_editor cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_script_editor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_script_editor" '[] (IO ScriptEditor) where nodeMethod = Godot.Tools.EditorInterface.get_script_editor {-# NOINLINE bindEditorInterface_get_selected_path #-} -- | Returns the path of the directory currently selected in the @FileSystemDock@. If a file is selected, its base directory will be returned using @method String.get_base_dir@ instead. bindEditorInterface_get_selected_path :: MethodBind bindEditorInterface_get_selected_path = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_selected_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the path of the directory currently selected in the @FileSystemDock@. If a file is selected, its base directory will be returned using @method String.get_base_dir@ instead. get_selected_path :: (EditorInterface :< cls, Object :< cls) => cls -> IO GodotString get_selected_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_selected_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_selected_path" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorInterface.get_selected_path {-# NOINLINE bindEditorInterface_get_selection #-} -- | Returns the editor's @EditorSelection@ instance. bindEditorInterface_get_selection :: MethodBind bindEditorInterface_get_selection = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "get_selection" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the editor's @EditorSelection@ instance. get_selection :: (EditorInterface :< cls, Object :< cls) => cls -> IO EditorSelection get_selection cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_get_selection (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "get_selection" '[] (IO EditorSelection) where nodeMethod = Godot.Tools.EditorInterface.get_selection {-# NOINLINE bindEditorInterface_inspect_object #-} -- | Shows the given property on the given @object@ in the editor's Inspector dock. bindEditorInterface_inspect_object :: MethodBind bindEditorInterface_inspect_object = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "inspect_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shows the given property on the given @object@ in the editor's Inspector dock. inspect_object :: (EditorInterface :< cls, Object :< cls) => cls -> Object -> Maybe GodotString -> IO () inspect_object cls arg1 arg2 = withVariantArray [toVariant arg1, defaultedVariant VariantString "" arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_inspect_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "inspect_object" '[Object, Maybe GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.inspect_object {-# NOINLINE bindEditorInterface_is_plugin_enabled #-} -- | Returns @true@ if the specified @plugin@ is enabled. The plugin name is the same as its directory name. bindEditorInterface_is_plugin_enabled :: MethodBind bindEditorInterface_is_plugin_enabled = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "is_plugin_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the specified @plugin@ is enabled. The plugin name is the same as its directory name. is_plugin_enabled :: (EditorInterface :< cls, Object :< cls) => cls -> GodotString -> IO Bool is_plugin_enabled cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_is_plugin_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "is_plugin_enabled" '[GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorInterface.is_plugin_enabled {-# NOINLINE bindEditorInterface_make_mesh_previews #-} -- | Returns mesh previews rendered at the given size as an @Array@ of @Texture@s. bindEditorInterface_make_mesh_previews :: MethodBind bindEditorInterface_make_mesh_previews = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "make_mesh_previews" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns mesh previews rendered at the given size as an @Array@ of @Texture@s. make_mesh_previews :: (EditorInterface :< cls, Object :< cls) => cls -> Array -> Int -> IO Array make_mesh_previews cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_make_mesh_previews (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "make_mesh_previews" '[Array, Int] (IO Array) where nodeMethod = Godot.Tools.EditorInterface.make_mesh_previews {-# NOINLINE bindEditorInterface_open_scene_from_path #-} -- | Opens the scene at the given path. bindEditorInterface_open_scene_from_path :: MethodBind bindEditorInterface_open_scene_from_path = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "open_scene_from_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Opens the scene at the given path. open_scene_from_path :: (EditorInterface :< cls, Object :< cls) => cls -> GodotString -> IO () open_scene_from_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_open_scene_from_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "open_scene_from_path" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.open_scene_from_path {-# NOINLINE bindEditorInterface_reload_scene_from_path #-} -- | Reloads the scene at the given path. bindEditorInterface_reload_scene_from_path :: MethodBind bindEditorInterface_reload_scene_from_path = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "reload_scene_from_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Reloads the scene at the given path. reload_scene_from_path :: (EditorInterface :< cls, Object :< cls) => cls -> GodotString -> IO () reload_scene_from_path cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_reload_scene_from_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "reload_scene_from_path" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.reload_scene_from_path {-# NOINLINE bindEditorInterface_save_scene #-} -- | Saves the scene. Returns either @OK@ or @ERR_CANT_CREATE@ (see @@GlobalScope@ constants). bindEditorInterface_save_scene :: MethodBind bindEditorInterface_save_scene = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "save_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the scene. Returns either @OK@ or @ERR_CANT_CREATE@ (see @@GlobalScope@ constants). save_scene :: (EditorInterface :< cls, Object :< cls) => cls -> IO Int save_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_save_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "save_scene" '[] (IO Int) where nodeMethod = Godot.Tools.EditorInterface.save_scene {-# NOINLINE bindEditorInterface_save_scene_as #-} -- | Saves the scene as a file at @path@. bindEditorInterface_save_scene_as :: MethodBind bindEditorInterface_save_scene_as = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "save_scene_as" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Saves the scene as a file at @path@. save_scene_as :: (EditorInterface :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO () save_scene_as cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool True) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_save_scene_as (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "save_scene_as" '[GodotString, Maybe Bool] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.save_scene_as {-# NOINLINE bindEditorInterface_select_file #-} -- | Selects the file, with the path provided by @file@, in the FileSystem dock. bindEditorInterface_select_file :: MethodBind bindEditorInterface_select_file = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "select_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Selects the file, with the path provided by @file@, in the FileSystem dock. select_file :: (EditorInterface :< cls, Object :< cls) => cls -> GodotString -> IO () select_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_select_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "select_file" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.select_file {-# NOINLINE bindEditorInterface_set_distraction_free_mode #-} -- | If @true@, enables distraction-free mode which hides side docks to increase the space available for the main view. bindEditorInterface_set_distraction_free_mode :: MethodBind bindEditorInterface_set_distraction_free_mode = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "set_distraction_free_mode" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If @true@, enables distraction-free mode which hides side docks to increase the space available for the main view. set_distraction_free_mode :: (EditorInterface :< cls, Object :< cls) => cls -> Bool -> IO () set_distraction_free_mode cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_set_distraction_free_mode (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "set_distraction_free_mode" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.set_distraction_free_mode {-# NOINLINE bindEditorInterface_set_main_screen_editor #-} -- | Sets the editor's current main screen to the one specified in @name@. @name@ must match the text of the tab in question exactly (@2D@, @3D@, @Script@, @AssetLib@). bindEditorInterface_set_main_screen_editor :: MethodBind bindEditorInterface_set_main_screen_editor = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "set_main_screen_editor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the editor's current main screen to the one specified in @name@. @name@ must match the text of the tab in question exactly (@2D@, @3D@, @Script@, @AssetLib@). set_main_screen_editor :: (EditorInterface :< cls, Object :< cls) => cls -> GodotString -> IO () set_main_screen_editor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_set_main_screen_editor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "set_main_screen_editor" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.set_main_screen_editor {-# NOINLINE bindEditorInterface_set_plugin_enabled #-} -- | Sets the enabled status of a plugin. The plugin name is the same as its directory name. bindEditorInterface_set_plugin_enabled :: MethodBind bindEditorInterface_set_plugin_enabled = unsafePerformIO $ withCString "EditorInterface" $ \ clsNamePtr -> withCString "set_plugin_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the enabled status of a plugin. The plugin name is the same as its directory name. set_plugin_enabled :: (EditorInterface :< cls, Object :< cls) => cls -> GodotString -> Bool -> IO () set_plugin_enabled cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorInterface_set_plugin_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorInterface "set_plugin_enabled" '[GodotString, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorInterface.set_plugin_enabled ================================================ FILE: src/Godot/Tools/EditorNavigationMeshGenerator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorNavigationMeshGenerator (Godot.Tools.EditorNavigationMeshGenerator.bake, Godot.Tools.EditorNavigationMeshGenerator.clear) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindEditorNavigationMeshGenerator_bake #-} bindEditorNavigationMeshGenerator_bake :: MethodBind bindEditorNavigationMeshGenerator_bake = unsafePerformIO $ withCString "EditorNavigationMeshGenerator" $ \ clsNamePtr -> withCString "bake" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr bake :: (EditorNavigationMeshGenerator :< cls, Object :< cls) => cls -> NavigationMesh -> Node -> IO () bake cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorNavigationMeshGenerator_bake (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorNavigationMeshGenerator "bake" '[NavigationMesh, Node] (IO ()) where nodeMethod = Godot.Tools.EditorNavigationMeshGenerator.bake {-# NOINLINE bindEditorNavigationMeshGenerator_clear #-} bindEditorNavigationMeshGenerator_clear :: MethodBind bindEditorNavigationMeshGenerator_clear = unsafePerformIO $ withCString "EditorNavigationMeshGenerator" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr clear :: (EditorNavigationMeshGenerator :< cls, Object :< cls) => cls -> NavigationMesh -> IO () clear cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorNavigationMeshGenerator_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorNavigationMeshGenerator "clear" '[NavigationMesh] (IO ()) where nodeMethod = Godot.Tools.EditorNavigationMeshGenerator.clear ================================================ FILE: src/Godot/Tools/EditorPlugin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorPlugin (Godot.Tools.EditorPlugin._CONTAINER_SPATIAL_EDITOR_SIDE_LEFT, Godot.Tools.EditorPlugin._CONTAINER_SPATIAL_EDITOR_BOTTOM, Godot.Tools.EditorPlugin._DOCK_SLOT_LEFT_UR, Godot.Tools.EditorPlugin._CONTAINER_SPATIAL_EDITOR_SIDE_RIGHT, Godot.Tools.EditorPlugin._DOCK_SLOT_LEFT_BL, Godot.Tools.EditorPlugin._CONTAINER_PROJECT_SETTING_TAB_LEFT, Godot.Tools.EditorPlugin._CONTAINER_SPATIAL_EDITOR_MENU, Godot.Tools.EditorPlugin._DOCK_SLOT_RIGHT_BR, Godot.Tools.EditorPlugin._CONTAINER_PROJECT_SETTING_TAB_RIGHT, Godot.Tools.EditorPlugin._DOCK_SLOT_RIGHT_BL, Godot.Tools.EditorPlugin._CONTAINER_CANVAS_EDITOR_BOTTOM, Godot.Tools.EditorPlugin._CONTAINER_CANVAS_EDITOR_SIDE_LEFT, Godot.Tools.EditorPlugin._CONTAINER_PROPERTY_EDITOR_BOTTOM, Godot.Tools.EditorPlugin._CONTAINER_TOOLBAR, Godot.Tools.EditorPlugin._DOCK_SLOT_RIGHT_UL, Godot.Tools.EditorPlugin._DOCK_SLOT_RIGHT_UR, Godot.Tools.EditorPlugin._DOCK_SLOT_LEFT_UL, Godot.Tools.EditorPlugin._CONTAINER_CANVAS_EDITOR_MENU, Godot.Tools.EditorPlugin._CONTAINER_CANVAS_EDITOR_SIDE_RIGHT, Godot.Tools.EditorPlugin._DOCK_SLOT_LEFT_BR, Godot.Tools.EditorPlugin._DOCK_SLOT_MAX, Godot.Tools.EditorPlugin.sig_main_screen_changed, Godot.Tools.EditorPlugin.sig_resource_saved, Godot.Tools.EditorPlugin.sig_scene_changed, Godot.Tools.EditorPlugin.sig_scene_closed, Godot.Tools.EditorPlugin.add_autoload_singleton, Godot.Tools.EditorPlugin.add_control_to_bottom_panel, Godot.Tools.EditorPlugin.add_control_to_container, Godot.Tools.EditorPlugin.add_control_to_dock, Godot.Tools.EditorPlugin.add_custom_type, Godot.Tools.EditorPlugin.add_export_plugin, Godot.Tools.EditorPlugin.add_import_plugin, Godot.Tools.EditorPlugin.add_inspector_plugin, Godot.Tools.EditorPlugin.add_scene_import_plugin, Godot.Tools.EditorPlugin.add_spatial_gizmo_plugin, Godot.Tools.EditorPlugin.add_tool_menu_item, Godot.Tools.EditorPlugin.add_tool_submenu_item, Godot.Tools.EditorPlugin.apply_changes, Godot.Tools.EditorPlugin.build, Godot.Tools.EditorPlugin.clear, Godot.Tools.EditorPlugin.disable_plugin, Godot.Tools.EditorPlugin.edit, Godot.Tools.EditorPlugin.enable_plugin, Godot.Tools.EditorPlugin.forward_canvas_draw_over_viewport, Godot.Tools.EditorPlugin.forward_canvas_force_draw_over_viewport, Godot.Tools.EditorPlugin.forward_canvas_gui_input, Godot.Tools.EditorPlugin.forward_spatial_gui_input, Godot.Tools.EditorPlugin.get_breakpoints, Godot.Tools.EditorPlugin.get_editor_interface, Godot.Tools.EditorPlugin.get_plugin_icon, Godot.Tools.EditorPlugin.get_plugin_name, Godot.Tools.EditorPlugin.get_script_create_dialog, Godot.Tools.EditorPlugin.get_state, Godot.Tools.EditorPlugin.get_undo_redo, Godot.Tools.EditorPlugin.get_window_layout, Godot.Tools.EditorPlugin.handles, Godot.Tools.EditorPlugin.has_main_screen, Godot.Tools.EditorPlugin.hide_bottom_panel, Godot.Tools.EditorPlugin.make_bottom_panel_item_visible, Godot.Tools.EditorPlugin.make_visible, Godot.Tools.EditorPlugin.queue_save_layout, Godot.Tools.EditorPlugin.remove_autoload_singleton, Godot.Tools.EditorPlugin.remove_control_from_bottom_panel, Godot.Tools.EditorPlugin.remove_control_from_container, Godot.Tools.EditorPlugin.remove_control_from_docks, Godot.Tools.EditorPlugin.remove_custom_type, Godot.Tools.EditorPlugin.remove_export_plugin, Godot.Tools.EditorPlugin.remove_import_plugin, Godot.Tools.EditorPlugin.remove_inspector_plugin, Godot.Tools.EditorPlugin.remove_scene_import_plugin, Godot.Tools.EditorPlugin.remove_spatial_gizmo_plugin, Godot.Tools.EditorPlugin.remove_tool_menu_item, Godot.Tools.EditorPlugin.save_external_data, Godot.Tools.EditorPlugin.set_force_draw_over_forwarding_enabled, Godot.Tools.EditorPlugin.set_input_event_forwarding_always_enabled, Godot.Tools.EditorPlugin.set_state, Godot.Tools.EditorPlugin.set_window_layout, Godot.Tools.EditorPlugin.update_overlays) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() _CONTAINER_SPATIAL_EDITOR_SIDE_LEFT :: Int _CONTAINER_SPATIAL_EDITOR_SIDE_LEFT = 2 _CONTAINER_SPATIAL_EDITOR_BOTTOM :: Int _CONTAINER_SPATIAL_EDITOR_BOTTOM = 4 _DOCK_SLOT_LEFT_UR :: Int _DOCK_SLOT_LEFT_UR = 2 _CONTAINER_SPATIAL_EDITOR_SIDE_RIGHT :: Int _CONTAINER_SPATIAL_EDITOR_SIDE_RIGHT = 3 _DOCK_SLOT_LEFT_BL :: Int _DOCK_SLOT_LEFT_BL = 1 _CONTAINER_PROJECT_SETTING_TAB_LEFT :: Int _CONTAINER_PROJECT_SETTING_TAB_LEFT = 10 _CONTAINER_SPATIAL_EDITOR_MENU :: Int _CONTAINER_SPATIAL_EDITOR_MENU = 1 _DOCK_SLOT_RIGHT_BR :: Int _DOCK_SLOT_RIGHT_BR = 7 _CONTAINER_PROJECT_SETTING_TAB_RIGHT :: Int _CONTAINER_PROJECT_SETTING_TAB_RIGHT = 11 _DOCK_SLOT_RIGHT_BL :: Int _DOCK_SLOT_RIGHT_BL = 5 _CONTAINER_CANVAS_EDITOR_BOTTOM :: Int _CONTAINER_CANVAS_EDITOR_BOTTOM = 8 _CONTAINER_CANVAS_EDITOR_SIDE_LEFT :: Int _CONTAINER_CANVAS_EDITOR_SIDE_LEFT = 6 _CONTAINER_PROPERTY_EDITOR_BOTTOM :: Int _CONTAINER_PROPERTY_EDITOR_BOTTOM = 9 _CONTAINER_TOOLBAR :: Int _CONTAINER_TOOLBAR = 0 _DOCK_SLOT_RIGHT_UL :: Int _DOCK_SLOT_RIGHT_UL = 4 _DOCK_SLOT_RIGHT_UR :: Int _DOCK_SLOT_RIGHT_UR = 6 _DOCK_SLOT_LEFT_UL :: Int _DOCK_SLOT_LEFT_UL = 0 _CONTAINER_CANVAS_EDITOR_MENU :: Int _CONTAINER_CANVAS_EDITOR_MENU = 5 _CONTAINER_CANVAS_EDITOR_SIDE_RIGHT :: Int _CONTAINER_CANVAS_EDITOR_SIDE_RIGHT = 7 _DOCK_SLOT_LEFT_BR :: Int _DOCK_SLOT_LEFT_BR = 3 _DOCK_SLOT_MAX :: Int _DOCK_SLOT_MAX = 8 -- | Emitted when user changes the workspace (__2D__, __3D__, __Script__, __AssetLib__). Also works with custom screens defined by plugins. sig_main_screen_changed :: Godot.Internal.Dispatch.Signal EditorPlugin sig_main_screen_changed = Godot.Internal.Dispatch.Signal "main_screen_changed" instance NodeSignal EditorPlugin "main_screen_changed" '[GodotString] sig_resource_saved :: Godot.Internal.Dispatch.Signal EditorPlugin sig_resource_saved = Godot.Internal.Dispatch.Signal "resource_saved" instance NodeSignal EditorPlugin "resource_saved" '[Resource] -- | Emitted when the scene is changed in the editor. The argument will return the root node of the scene that has just become active. If this scene is new and empty, the argument will be @null@. sig_scene_changed :: Godot.Internal.Dispatch.Signal EditorPlugin sig_scene_changed = Godot.Internal.Dispatch.Signal "scene_changed" instance NodeSignal EditorPlugin "scene_changed" '[Node] -- | Emitted when user closes a scene. The argument is file path to a closed scene. sig_scene_closed :: Godot.Internal.Dispatch.Signal EditorPlugin sig_scene_closed = Godot.Internal.Dispatch.Signal "scene_closed" instance NodeSignal EditorPlugin "scene_closed" '[GodotString] {-# NOINLINE bindEditorPlugin_add_autoload_singleton #-} -- | Adds a script at @path@ to the Autoload list as @name@. bindEditorPlugin_add_autoload_singleton :: MethodBind bindEditorPlugin_add_autoload_singleton = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_autoload_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a script at @path@ to the Autoload list as @name@. add_autoload_singleton :: (EditorPlugin :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () add_autoload_singleton cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_autoload_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_autoload_singleton" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_autoload_singleton {-# NOINLINE bindEditorPlugin_add_control_to_bottom_panel #-} -- | Adds a control to the bottom panel (together with Output, Debug, Animation, etc). Returns a reference to the button added. It's up to you to hide/show the button when needed. When your plugin is deactivated, make sure to remove your custom control with @method remove_control_from_bottom_panel@ and free it with @method Node.queue_free@. bindEditorPlugin_add_control_to_bottom_panel :: MethodBind bindEditorPlugin_add_control_to_bottom_panel = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_control_to_bottom_panel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a control to the bottom panel (together with Output, Debug, Animation, etc). Returns a reference to the button added. It's up to you to hide/show the button when needed. When your plugin is deactivated, make sure to remove your custom control with @method remove_control_from_bottom_panel@ and free it with @method Node.queue_free@. add_control_to_bottom_panel :: (EditorPlugin :< cls, Object :< cls) => cls -> Control -> GodotString -> IO ToolButton add_control_to_bottom_panel cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_control_to_bottom_panel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_control_to_bottom_panel" '[Control, GodotString] (IO ToolButton) where nodeMethod = Godot.Tools.EditorPlugin.add_control_to_bottom_panel {-# NOINLINE bindEditorPlugin_add_control_to_container #-} -- | Adds a custom control to a container (see @enum CustomControlContainer@). There are many locations where custom controls can be added in the editor UI. -- Please remember that you have to manage the visibility of your custom controls yourself (and likely hide it after adding it). -- When your plugin is deactivated, make sure to remove your custom control with @method remove_control_from_container@ and free it with @method Node.queue_free@. bindEditorPlugin_add_control_to_container :: MethodBind bindEditorPlugin_add_control_to_container = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_control_to_container" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a custom control to a container (see @enum CustomControlContainer@). There are many locations where custom controls can be added in the editor UI. -- Please remember that you have to manage the visibility of your custom controls yourself (and likely hide it after adding it). -- When your plugin is deactivated, make sure to remove your custom control with @method remove_control_from_container@ and free it with @method Node.queue_free@. add_control_to_container :: (EditorPlugin :< cls, Object :< cls) => cls -> Int -> Control -> IO () add_control_to_container cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_control_to_container (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_control_to_container" '[Int, Control] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_control_to_container {-# NOINLINE bindEditorPlugin_add_control_to_dock #-} -- | Adds the control to a specific dock slot (see @enum DockSlot@ for options). -- If the dock is repositioned and as long as the plugin is active, the editor will save the dock position on further sessions. -- When your plugin is deactivated, make sure to remove your custom control with @method remove_control_from_docks@ and free it with @method Node.queue_free@. bindEditorPlugin_add_control_to_dock :: MethodBind bindEditorPlugin_add_control_to_dock = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_control_to_dock" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the control to a specific dock slot (see @enum DockSlot@ for options). -- If the dock is repositioned and as long as the plugin is active, the editor will save the dock position on further sessions. -- When your plugin is deactivated, make sure to remove your custom control with @method remove_control_from_docks@ and free it with @method Node.queue_free@. add_control_to_dock :: (EditorPlugin :< cls, Object :< cls) => cls -> Int -> Control -> IO () add_control_to_dock cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_control_to_dock (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_control_to_dock" '[Int, Control] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_control_to_dock {-# NOINLINE bindEditorPlugin_add_custom_type #-} -- | Adds a custom type, which will appear in the list of nodes or resources. An icon can be optionally passed. -- When given node or resource is selected, the base type will be instanced (ie, "Spatial", "Control", "Resource"), then the script will be loaded and set to this object. -- You can use the virtual method @method handles@ to check if your custom object is being edited by checking the script or using the @is@ keyword. -- During run-time, this will be a simple object with a script so this function does not need to be called then. bindEditorPlugin_add_custom_type :: MethodBind bindEditorPlugin_add_custom_type = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_custom_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a custom type, which will appear in the list of nodes or resources. An icon can be optionally passed. -- When given node or resource is selected, the base type will be instanced (ie, "Spatial", "Control", "Resource"), then the script will be loaded and set to this object. -- You can use the virtual method @method handles@ to check if your custom object is being edited by checking the script or using the @is@ keyword. -- During run-time, this will be a simple object with a script so this function does not need to be called then. add_custom_type :: (EditorPlugin :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Script -> Texture -> IO () add_custom_type cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_custom_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_custom_type" '[GodotString, GodotString, Script, Texture] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_custom_type {-# NOINLINE bindEditorPlugin_add_export_plugin #-} bindEditorPlugin_add_export_plugin :: MethodBind bindEditorPlugin_add_export_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_export_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_export_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorExportPlugin -> IO () add_export_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_export_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_export_plugin" '[EditorExportPlugin] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_export_plugin {-# NOINLINE bindEditorPlugin_add_import_plugin #-} bindEditorPlugin_add_import_plugin :: MethodBind bindEditorPlugin_add_import_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_import_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_import_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorImportPlugin -> IO () add_import_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_import_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_import_plugin" '[EditorImportPlugin] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_import_plugin {-# NOINLINE bindEditorPlugin_add_inspector_plugin #-} bindEditorPlugin_add_inspector_plugin :: MethodBind bindEditorPlugin_add_inspector_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_inspector_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_inspector_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorInspectorPlugin -> IO () add_inspector_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_inspector_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_inspector_plugin" '[EditorInspectorPlugin] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_inspector_plugin {-# NOINLINE bindEditorPlugin_add_scene_import_plugin #-} bindEditorPlugin_add_scene_import_plugin :: MethodBind bindEditorPlugin_add_scene_import_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_scene_import_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_scene_import_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorSceneImporter -> IO () add_scene_import_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_scene_import_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_scene_import_plugin" '[EditorSceneImporter] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_scene_import_plugin {-# NOINLINE bindEditorPlugin_add_spatial_gizmo_plugin #-} bindEditorPlugin_add_spatial_gizmo_plugin :: MethodBind bindEditorPlugin_add_spatial_gizmo_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_spatial_gizmo_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_spatial_gizmo_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorSpatialGizmoPlugin -> IO () add_spatial_gizmo_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_spatial_gizmo_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_spatial_gizmo_plugin" '[EditorSpatialGizmoPlugin] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_spatial_gizmo_plugin {-# NOINLINE bindEditorPlugin_add_tool_menu_item #-} -- | Adds a custom menu item to __Project > Tools__ as @name@ that calls @callback@ on an instance of @handler@ with a parameter @ud@ when user activates it. bindEditorPlugin_add_tool_menu_item :: MethodBind bindEditorPlugin_add_tool_menu_item = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_tool_menu_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a custom menu item to __Project > Tools__ as @name@ that calls @callback@ on an instance of @handler@ with a parameter @ud@ when user activates it. add_tool_menu_item :: (EditorPlugin :< cls, Object :< cls) => cls -> GodotString -> Object -> GodotString -> Maybe GodotVariant -> IO () add_tool_menu_item cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_tool_menu_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_tool_menu_item" '[GodotString, Object, GodotString, Maybe GodotVariant] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_tool_menu_item {-# NOINLINE bindEditorPlugin_add_tool_submenu_item #-} -- | Adds a custom submenu under __Project > Tools >__ @name@. @submenu@ should be an object of class @PopupMenu@. This submenu should be cleaned up using @remove_tool_menu_item(name)@. bindEditorPlugin_add_tool_submenu_item :: MethodBind bindEditorPlugin_add_tool_submenu_item = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "add_tool_submenu_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a custom submenu under __Project > Tools >__ @name@. @submenu@ should be an object of class @PopupMenu@. This submenu should be cleaned up using @remove_tool_menu_item(name)@. add_tool_submenu_item :: (EditorPlugin :< cls, Object :< cls) => cls -> GodotString -> Object -> IO () add_tool_submenu_item cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_add_tool_submenu_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "add_tool_submenu_item" '[GodotString, Object] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.add_tool_submenu_item {-# NOINLINE bindEditorPlugin_apply_changes #-} -- | This method is called when the editor is about to save the project, switch to another tab, etc. It asks the plugin to apply any pending state changes to ensure consistency. -- This is used, for example, in shader editors to let the plugin know that it must apply the shader code being written by the user to the object. bindEditorPlugin_apply_changes :: MethodBind bindEditorPlugin_apply_changes = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "apply_changes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This method is called when the editor is about to save the project, switch to another tab, etc. It asks the plugin to apply any pending state changes to ensure consistency. -- This is used, for example, in shader editors to let the plugin know that it must apply the shader code being written by the user to the object. apply_changes :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () apply_changes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_apply_changes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "apply_changes" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.apply_changes {-# NOINLINE bindEditorPlugin_build #-} bindEditorPlugin_build :: MethodBind bindEditorPlugin_build = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "build" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr build :: (EditorPlugin :< cls, Object :< cls) => cls -> IO Bool build cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_build (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "build" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorPlugin.build {-# NOINLINE bindEditorPlugin_clear #-} -- | Clear all the state and reset the object being edited to zero. This ensures your plugin does not keep editing a currently existing node, or a node from the wrong scene. bindEditorPlugin_clear :: MethodBind bindEditorPlugin_clear = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear all the state and reset the object being edited to zero. This ensures your plugin does not keep editing a currently existing node, or a node from the wrong scene. clear :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "clear" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.clear {-# NOINLINE bindEditorPlugin_disable_plugin #-} -- | Called by the engine when the user disables the @EditorPlugin@ in the Plugin tab of the project settings window. bindEditorPlugin_disable_plugin :: MethodBind bindEditorPlugin_disable_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "disable_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called by the engine when the user disables the @EditorPlugin@ in the Plugin tab of the project settings window. disable_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () disable_plugin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_disable_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "disable_plugin" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.disable_plugin {-# NOINLINE bindEditorPlugin_edit #-} -- | This function is used for plugins that edit specific object types (nodes or resources). It requests the editor to edit the given object. bindEditorPlugin_edit :: MethodBind bindEditorPlugin_edit = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "edit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This function is used for plugins that edit specific object types (nodes or resources). It requests the editor to edit the given object. edit :: (EditorPlugin :< cls, Object :< cls) => cls -> Object -> IO () edit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_edit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "edit" '[Object] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.edit {-# NOINLINE bindEditorPlugin_enable_plugin #-} -- | Called by the engine when the user enables the @EditorPlugin@ in the Plugin tab of the project settings window. bindEditorPlugin_enable_plugin :: MethodBind bindEditorPlugin_enable_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "enable_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called by the engine when the user enables the @EditorPlugin@ in the Plugin tab of the project settings window. enable_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () enable_plugin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_enable_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "enable_plugin" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.enable_plugin {-# NOINLINE bindEditorPlugin_forward_canvas_draw_over_viewport #-} bindEditorPlugin_forward_canvas_draw_over_viewport :: MethodBind bindEditorPlugin_forward_canvas_draw_over_viewport = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "forward_canvas_draw_over_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr forward_canvas_draw_over_viewport :: (EditorPlugin :< cls, Object :< cls) => cls -> Control -> IO () forward_canvas_draw_over_viewport cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_forward_canvas_draw_over_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "forward_canvas_draw_over_viewport" '[Control] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.forward_canvas_draw_over_viewport {-# NOINLINE bindEditorPlugin_forward_canvas_force_draw_over_viewport #-} bindEditorPlugin_forward_canvas_force_draw_over_viewport :: MethodBind bindEditorPlugin_forward_canvas_force_draw_over_viewport = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "forward_canvas_force_draw_over_viewport" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr forward_canvas_force_draw_over_viewport :: (EditorPlugin :< cls, Object :< cls) => cls -> Control -> IO () forward_canvas_force_draw_over_viewport cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_forward_canvas_force_draw_over_viewport (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "forward_canvas_force_draw_over_viewport" '[Control] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.forward_canvas_force_draw_over_viewport {-# NOINLINE bindEditorPlugin_forward_canvas_gui_input #-} -- | Called when there is a root node in the current edited scene, @method handles@ is implemented and an @InputEvent@ happens in the 2D viewport. Intercepts the @InputEvent@, if @return true@ @EditorPlugin@ consumes the @event@, otherwise forwards @event@ to other Editor classes. Example: -- -- @ -- -- # Prevents the InputEvent to reach other Editor classes -- func forward_canvas_gui_input(event): -- var forward = true -- return forward -- -- @ -- -- Must @return false@ in order to forward the @InputEvent@ to other Editor classes. Example: -- -- @ -- -- # Consumes InputEventMouseMotion and forwards other InputEvent types -- func forward_canvas_gui_input(event): -- var forward = false -- if event is InputEventMouseMotion: -- forward = true -- return forward -- -- @ bindEditorPlugin_forward_canvas_gui_input :: MethodBind bindEditorPlugin_forward_canvas_gui_input = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "forward_canvas_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when there is a root node in the current edited scene, @method handles@ is implemented and an @InputEvent@ happens in the 2D viewport. Intercepts the @InputEvent@, if @return true@ @EditorPlugin@ consumes the @event@, otherwise forwards @event@ to other Editor classes. Example: -- -- @ -- -- # Prevents the InputEvent to reach other Editor classes -- func forward_canvas_gui_input(event): -- var forward = true -- return forward -- -- @ -- -- Must @return false@ in order to forward the @InputEvent@ to other Editor classes. Example: -- -- @ -- -- # Consumes InputEventMouseMotion and forwards other InputEvent types -- func forward_canvas_gui_input(event): -- var forward = false -- if event is InputEventMouseMotion: -- forward = true -- return forward -- -- @ forward_canvas_gui_input :: (EditorPlugin :< cls, Object :< cls) => cls -> InputEvent -> IO Bool forward_canvas_gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_forward_canvas_gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "forward_canvas_gui_input" '[InputEvent] (IO Bool) where nodeMethod = Godot.Tools.EditorPlugin.forward_canvas_gui_input {-# NOINLINE bindEditorPlugin_forward_spatial_gui_input #-} -- | Called when there is a root node in the current edited scene, @method handles@ is implemented and an @InputEvent@ happens in the 3D viewport. Intercepts the @InputEvent@, if @return true@ @EditorPlugin@ consumes the @event@, otherwise forwards @event@ to other Editor classes. Example: -- -- @ -- -- # Prevents the InputEvent to reach other Editor classes -- func forward_spatial_gui_input(camera, event): -- var forward = true -- return forward -- -- @ -- -- Must @return false@ in order to forward the @InputEvent@ to other Editor classes. Example: -- -- @ -- -- # Consumes InputEventMouseMotion and forwards other InputEvent types -- func forward_spatial_gui_input(camera, event): -- var forward = false -- if event is InputEventMouseMotion: -- forward = true -- return forward -- -- @ bindEditorPlugin_forward_spatial_gui_input :: MethodBind bindEditorPlugin_forward_spatial_gui_input = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "forward_spatial_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called when there is a root node in the current edited scene, @method handles@ is implemented and an @InputEvent@ happens in the 3D viewport. Intercepts the @InputEvent@, if @return true@ @EditorPlugin@ consumes the @event@, otherwise forwards @event@ to other Editor classes. Example: -- -- @ -- -- # Prevents the InputEvent to reach other Editor classes -- func forward_spatial_gui_input(camera, event): -- var forward = true -- return forward -- -- @ -- -- Must @return false@ in order to forward the @InputEvent@ to other Editor classes. Example: -- -- @ -- -- # Consumes InputEventMouseMotion and forwards other InputEvent types -- func forward_spatial_gui_input(camera, event): -- var forward = false -- if event is InputEventMouseMotion: -- forward = true -- return forward -- -- @ forward_spatial_gui_input :: (EditorPlugin :< cls, Object :< cls) => cls -> Camera -> InputEvent -> IO Bool forward_spatial_gui_input cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_forward_spatial_gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "forward_spatial_gui_input" '[Camera, InputEvent] (IO Bool) where nodeMethod = Godot.Tools.EditorPlugin.forward_spatial_gui_input {-# NOINLINE bindEditorPlugin_get_breakpoints #-} -- | This is for editors that edit script-based objects. You can return a list of breakpoints in the format (@script:line@), for example: @res://path_to_script.gd:25@. bindEditorPlugin_get_breakpoints :: MethodBind bindEditorPlugin_get_breakpoints = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "get_breakpoints" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This is for editors that edit script-based objects. You can return a list of breakpoints in the format (@script:line@), for example: @res://path_to_script.gd:25@. get_breakpoints :: (EditorPlugin :< cls, Object :< cls) => cls -> IO PoolStringArray get_breakpoints cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_get_breakpoints (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "get_breakpoints" '[] (IO PoolStringArray) where nodeMethod = Godot.Tools.EditorPlugin.get_breakpoints {-# NOINLINE bindEditorPlugin_get_editor_interface #-} -- | Returns the @EditorInterface@ object that gives you control over Godot editor's window and its functionalities. bindEditorPlugin_get_editor_interface :: MethodBind bindEditorPlugin_get_editor_interface = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "get_editor_interface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @EditorInterface@ object that gives you control over Godot editor's window and its functionalities. get_editor_interface :: (EditorPlugin :< cls, Object :< cls) => cls -> IO EditorInterface get_editor_interface cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_get_editor_interface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "get_editor_interface" '[] (IO EditorInterface) where nodeMethod = Godot.Tools.EditorPlugin.get_editor_interface {-# NOINLINE bindEditorPlugin_get_plugin_icon #-} -- | Override this method in your plugin to return a @Texture@ in order to give it an icon. -- For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons. -- Ideally, the plugin icon should be white with a transparent background and 16x16 pixels in size. -- -- @ -- -- func get_plugin_icon(): -- # You can use a custom icon: -- return preload("res://addons/my_plugin/my_plugin_icon.svg") -- # Or use a built-in icon: -- return get_editor_interface().get_base_control().get_icon("Node", "EditorIcons") -- -- @ bindEditorPlugin_get_plugin_icon :: MethodBind bindEditorPlugin_get_plugin_icon = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "get_plugin_icon" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method in your plugin to return a @Texture@ in order to give it an icon. -- For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons. -- Ideally, the plugin icon should be white with a transparent background and 16x16 pixels in size. -- -- @ -- -- func get_plugin_icon(): -- # You can use a custom icon: -- return preload("res://addons/my_plugin/my_plugin_icon.svg") -- # Or use a built-in icon: -- return get_editor_interface().get_base_control().get_icon("Node", "EditorIcons") -- -- @ get_plugin_icon :: (EditorPlugin :< cls, Object :< cls) => cls -> IO Object get_plugin_icon cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_get_plugin_icon (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "get_plugin_icon" '[] (IO Object) where nodeMethod = Godot.Tools.EditorPlugin.get_plugin_icon {-# NOINLINE bindEditorPlugin_get_plugin_name #-} -- | Override this method in your plugin to provide the name of the plugin when displayed in the Godot editor. -- For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons. bindEditorPlugin_get_plugin_name :: MethodBind bindEditorPlugin_get_plugin_name = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "get_plugin_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method in your plugin to provide the name of the plugin when displayed in the Godot editor. -- For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons. get_plugin_name :: (EditorPlugin :< cls, Object :< cls) => cls -> IO GodotString get_plugin_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_get_plugin_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "get_plugin_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorPlugin.get_plugin_name {-# NOINLINE bindEditorPlugin_get_script_create_dialog #-} -- | Gets the Editor's dialogue used for making scripts. -- __Note:__ Users can configure it before use. bindEditorPlugin_get_script_create_dialog :: MethodBind bindEditorPlugin_get_script_create_dialog = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "get_script_create_dialog" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the Editor's dialogue used for making scripts. -- __Note:__ Users can configure it before use. get_script_create_dialog :: (EditorPlugin :< cls, Object :< cls) => cls -> IO ScriptCreateDialog get_script_create_dialog cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_get_script_create_dialog (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "get_script_create_dialog" '[] (IO ScriptCreateDialog) where nodeMethod = Godot.Tools.EditorPlugin.get_script_create_dialog {-# NOINLINE bindEditorPlugin_get_state #-} -- | Gets the state of your plugin editor. This is used when saving the scene (so state is kept when opening it again) and for switching tabs (so state can be restored when the tab returns). bindEditorPlugin_get_state :: MethodBind bindEditorPlugin_get_state = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "get_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the state of your plugin editor. This is used when saving the scene (so state is kept when opening it again) and for switching tabs (so state can be restored when the tab returns). get_state :: (EditorPlugin :< cls, Object :< cls) => cls -> IO Dictionary get_state cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_get_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "get_state" '[] (IO Dictionary) where nodeMethod = Godot.Tools.EditorPlugin.get_state {-# NOINLINE bindEditorPlugin_get_undo_redo #-} -- | Gets the undo/redo object. Most actions in the editor can be undoable, so use this object to make sure this happens when it's worth it. bindEditorPlugin_get_undo_redo :: MethodBind bindEditorPlugin_get_undo_redo = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "get_undo_redo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the undo/redo object. Most actions in the editor can be undoable, so use this object to make sure this happens when it's worth it. get_undo_redo :: (EditorPlugin :< cls, Object :< cls) => cls -> IO UndoRedo get_undo_redo cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_get_undo_redo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "get_undo_redo" '[] (IO UndoRedo) where nodeMethod = Godot.Tools.EditorPlugin.get_undo_redo {-# NOINLINE bindEditorPlugin_get_window_layout #-} -- | Gets the GUI layout of the plugin. This is used to save the project's editor layout when @method queue_save_layout@ is called or the editor layout was changed(For example changing the position of a dock). bindEditorPlugin_get_window_layout :: MethodBind bindEditorPlugin_get_window_layout = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "get_window_layout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the GUI layout of the plugin. This is used to save the project's editor layout when @method queue_save_layout@ is called or the editor layout was changed(For example changing the position of a dock). get_window_layout :: (EditorPlugin :< cls, Object :< cls) => cls -> ConfigFile -> IO () get_window_layout cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_get_window_layout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "get_window_layout" '[ConfigFile] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.get_window_layout {-# NOINLINE bindEditorPlugin_handles #-} -- | Implement this function if your plugin edits a specific type of object (Resource or Node). If you return @true@, then you will get the functions @method edit@ and @method make_visible@ called when the editor requests them. If you have declared the methods @method forward_canvas_gui_input@ and @method forward_spatial_gui_input@ these will be called too. bindEditorPlugin_handles :: MethodBind bindEditorPlugin_handles = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "handles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Implement this function if your plugin edits a specific type of object (Resource or Node). If you return @true@, then you will get the functions @method edit@ and @method make_visible@ called when the editor requests them. If you have declared the methods @method forward_canvas_gui_input@ and @method forward_spatial_gui_input@ these will be called too. handles :: (EditorPlugin :< cls, Object :< cls) => cls -> Object -> IO Bool handles cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_handles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "handles" '[Object] (IO Bool) where nodeMethod = Godot.Tools.EditorPlugin.handles {-# NOINLINE bindEditorPlugin_has_main_screen #-} -- | Returns @true@ if this is a main screen editor plugin (it goes in the workspace selector together with __2D__, __3D__, __Script__ and __AssetLib__). bindEditorPlugin_has_main_screen :: MethodBind bindEditorPlugin_has_main_screen = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "has_main_screen" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if this is a main screen editor plugin (it goes in the workspace selector together with __2D__, __3D__, __Script__ and __AssetLib__). has_main_screen :: (EditorPlugin :< cls, Object :< cls) => cls -> IO Bool has_main_screen cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_has_main_screen (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "has_main_screen" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorPlugin.has_main_screen {-# NOINLINE bindEditorPlugin_hide_bottom_panel #-} bindEditorPlugin_hide_bottom_panel :: MethodBind bindEditorPlugin_hide_bottom_panel = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "hide_bottom_panel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr hide_bottom_panel :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () hide_bottom_panel cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_hide_bottom_panel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "hide_bottom_panel" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.hide_bottom_panel {-# NOINLINE bindEditorPlugin_make_bottom_panel_item_visible #-} bindEditorPlugin_make_bottom_panel_item_visible :: MethodBind bindEditorPlugin_make_bottom_panel_item_visible = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "make_bottom_panel_item_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr make_bottom_panel_item_visible :: (EditorPlugin :< cls, Object :< cls) => cls -> Control -> IO () make_bottom_panel_item_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_make_bottom_panel_item_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "make_bottom_panel_item_visible" '[Control] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.make_bottom_panel_item_visible {-# NOINLINE bindEditorPlugin_make_visible #-} -- | This function will be called when the editor is requested to become visible. It is used for plugins that edit a specific object type. -- Remember that you have to manage the visibility of all your editor controls manually. bindEditorPlugin_make_visible :: MethodBind bindEditorPlugin_make_visible = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "make_visible" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This function will be called when the editor is requested to become visible. It is used for plugins that edit a specific object type. -- Remember that you have to manage the visibility of all your editor controls manually. make_visible :: (EditorPlugin :< cls, Object :< cls) => cls -> Bool -> IO () make_visible cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_make_visible (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "make_visible" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.make_visible {-# NOINLINE bindEditorPlugin_queue_save_layout #-} -- | Queue save the project's editor layout. bindEditorPlugin_queue_save_layout :: MethodBind bindEditorPlugin_queue_save_layout = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "queue_save_layout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Queue save the project's editor layout. queue_save_layout :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () queue_save_layout cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_queue_save_layout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "queue_save_layout" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.queue_save_layout {-# NOINLINE bindEditorPlugin_remove_autoload_singleton #-} -- | Removes an Autoload @name@ from the list. bindEditorPlugin_remove_autoload_singleton :: MethodBind bindEditorPlugin_remove_autoload_singleton = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_autoload_singleton" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes an Autoload @name@ from the list. remove_autoload_singleton :: (EditorPlugin :< cls, Object :< cls) => cls -> GodotString -> IO () remove_autoload_singleton cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_autoload_singleton (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_autoload_singleton" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_autoload_singleton {-# NOINLINE bindEditorPlugin_remove_control_from_bottom_panel #-} -- | Removes the control from the bottom panel. You have to manually @method Node.queue_free@ the control. bindEditorPlugin_remove_control_from_bottom_panel :: MethodBind bindEditorPlugin_remove_control_from_bottom_panel = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_control_from_bottom_panel" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the control from the bottom panel. You have to manually @method Node.queue_free@ the control. remove_control_from_bottom_panel :: (EditorPlugin :< cls, Object :< cls) => cls -> Control -> IO () remove_control_from_bottom_panel cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_control_from_bottom_panel (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_control_from_bottom_panel" '[Control] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_control_from_bottom_panel {-# NOINLINE bindEditorPlugin_remove_control_from_container #-} -- | Removes the control from the specified container. You have to manually @method Node.queue_free@ the control. bindEditorPlugin_remove_control_from_container :: MethodBind bindEditorPlugin_remove_control_from_container = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_control_from_container" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the control from the specified container. You have to manually @method Node.queue_free@ the control. remove_control_from_container :: (EditorPlugin :< cls, Object :< cls) => cls -> Int -> Control -> IO () remove_control_from_container cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_control_from_container (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_control_from_container" '[Int, Control] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_control_from_container {-# NOINLINE bindEditorPlugin_remove_control_from_docks #-} -- | Removes the control from the dock. You have to manually @method Node.queue_free@ the control. bindEditorPlugin_remove_control_from_docks :: MethodBind bindEditorPlugin_remove_control_from_docks = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_control_from_docks" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes the control from the dock. You have to manually @method Node.queue_free@ the control. remove_control_from_docks :: (EditorPlugin :< cls, Object :< cls) => cls -> Control -> IO () remove_control_from_docks cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_control_from_docks (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_control_from_docks" '[Control] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_control_from_docks {-# NOINLINE bindEditorPlugin_remove_custom_type #-} -- | Removes a custom type added by @method add_custom_type@. bindEditorPlugin_remove_custom_type :: MethodBind bindEditorPlugin_remove_custom_type = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_custom_type" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a custom type added by @method add_custom_type@. remove_custom_type :: (EditorPlugin :< cls, Object :< cls) => cls -> GodotString -> IO () remove_custom_type cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_custom_type (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_custom_type" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_custom_type {-# NOINLINE bindEditorPlugin_remove_export_plugin #-} bindEditorPlugin_remove_export_plugin :: MethodBind bindEditorPlugin_remove_export_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_export_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_export_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorExportPlugin -> IO () remove_export_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_export_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_export_plugin" '[EditorExportPlugin] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_export_plugin {-# NOINLINE bindEditorPlugin_remove_import_plugin #-} bindEditorPlugin_remove_import_plugin :: MethodBind bindEditorPlugin_remove_import_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_import_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_import_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorImportPlugin -> IO () remove_import_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_import_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_import_plugin" '[EditorImportPlugin] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_import_plugin {-# NOINLINE bindEditorPlugin_remove_inspector_plugin #-} bindEditorPlugin_remove_inspector_plugin :: MethodBind bindEditorPlugin_remove_inspector_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_inspector_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_inspector_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorInspectorPlugin -> IO () remove_inspector_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_inspector_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_inspector_plugin" '[EditorInspectorPlugin] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_inspector_plugin {-# NOINLINE bindEditorPlugin_remove_scene_import_plugin #-} bindEditorPlugin_remove_scene_import_plugin :: MethodBind bindEditorPlugin_remove_scene_import_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_scene_import_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_scene_import_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorSceneImporter -> IO () remove_scene_import_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_scene_import_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_scene_import_plugin" '[EditorSceneImporter] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_scene_import_plugin {-# NOINLINE bindEditorPlugin_remove_spatial_gizmo_plugin #-} bindEditorPlugin_remove_spatial_gizmo_plugin :: MethodBind bindEditorPlugin_remove_spatial_gizmo_plugin = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_spatial_gizmo_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_spatial_gizmo_plugin :: (EditorPlugin :< cls, Object :< cls) => cls -> EditorSpatialGizmoPlugin -> IO () remove_spatial_gizmo_plugin cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_spatial_gizmo_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_spatial_gizmo_plugin" '[EditorSpatialGizmoPlugin] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_spatial_gizmo_plugin {-# NOINLINE bindEditorPlugin_remove_tool_menu_item #-} -- | Removes a menu @name@ from __Project > Tools__. bindEditorPlugin_remove_tool_menu_item :: MethodBind bindEditorPlugin_remove_tool_menu_item = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "remove_tool_menu_item" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a menu @name@ from __Project > Tools__. remove_tool_menu_item :: (EditorPlugin :< cls, Object :< cls) => cls -> GodotString -> IO () remove_tool_menu_item cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_remove_tool_menu_item (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "remove_tool_menu_item" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.remove_tool_menu_item {-# NOINLINE bindEditorPlugin_save_external_data #-} -- | This method is called after the editor saves the project or when it's closed. It asks the plugin to save edited external scenes/resources. bindEditorPlugin_save_external_data :: MethodBind bindEditorPlugin_save_external_data = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "save_external_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This method is called after the editor saves the project or when it's closed. It asks the plugin to save edited external scenes/resources. save_external_data :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () save_external_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_save_external_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "save_external_data" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.save_external_data {-# NOINLINE bindEditorPlugin_set_force_draw_over_forwarding_enabled #-} bindEditorPlugin_set_force_draw_over_forwarding_enabled :: MethodBind bindEditorPlugin_set_force_draw_over_forwarding_enabled = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "set_force_draw_over_forwarding_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_force_draw_over_forwarding_enabled :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () set_force_draw_over_forwarding_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_set_force_draw_over_forwarding_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "set_force_draw_over_forwarding_enabled" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.set_force_draw_over_forwarding_enabled {-# NOINLINE bindEditorPlugin_set_input_event_forwarding_always_enabled #-} -- | Use this method if you always want to receive inputs from 3D view screen inside @method forward_spatial_gui_input@. It might be especially usable if your plugin will want to use raycast in the scene. bindEditorPlugin_set_input_event_forwarding_always_enabled :: MethodBind bindEditorPlugin_set_input_event_forwarding_always_enabled = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "set_input_event_forwarding_always_enabled" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Use this method if you always want to receive inputs from 3D view screen inside @method forward_spatial_gui_input@. It might be especially usable if your plugin will want to use raycast in the scene. set_input_event_forwarding_always_enabled :: (EditorPlugin :< cls, Object :< cls) => cls -> IO () set_input_event_forwarding_always_enabled cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_set_input_event_forwarding_always_enabled (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "set_input_event_forwarding_always_enabled" '[] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.set_input_event_forwarding_always_enabled {-# NOINLINE bindEditorPlugin_set_state #-} -- | Restore the state saved by @method get_state@. bindEditorPlugin_set_state :: MethodBind bindEditorPlugin_set_state = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "set_state" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Restore the state saved by @method get_state@. set_state :: (EditorPlugin :< cls, Object :< cls) => cls -> Dictionary -> IO () set_state cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_set_state (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "set_state" '[Dictionary] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.set_state {-# NOINLINE bindEditorPlugin_set_window_layout #-} -- | Restore the plugin GUI layout saved by @method get_window_layout@. bindEditorPlugin_set_window_layout :: MethodBind bindEditorPlugin_set_window_layout = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "set_window_layout" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Restore the plugin GUI layout saved by @method get_window_layout@. set_window_layout :: (EditorPlugin :< cls, Object :< cls) => cls -> ConfigFile -> IO () set_window_layout cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_set_window_layout (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "set_window_layout" '[ConfigFile] (IO ()) where nodeMethod = Godot.Tools.EditorPlugin.set_window_layout {-# NOINLINE bindEditorPlugin_update_overlays #-} -- | Updates the overlays of the editor (2D/3D) viewport. bindEditorPlugin_update_overlays :: MethodBind bindEditorPlugin_update_overlays = unsafePerformIO $ withCString "EditorPlugin" $ \ clsNamePtr -> withCString "update_overlays" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Updates the overlays of the editor (2D/3D) viewport. update_overlays :: (EditorPlugin :< cls, Object :< cls) => cls -> IO Int update_overlays cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorPlugin_update_overlays (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorPlugin "update_overlays" '[] (IO Int) where nodeMethod = Godot.Tools.EditorPlugin.update_overlays ================================================ FILE: src/Godot/Tools/EditorProperty.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorProperty (Godot.Tools.EditorProperty.sig_multiple_properties_changed, Godot.Tools.EditorProperty.sig_object_id_selected, Godot.Tools.EditorProperty.sig_property_changed, Godot.Tools.EditorProperty.sig_property_checked, Godot.Tools.EditorProperty.sig_property_keyed, Godot.Tools.EditorProperty.sig_property_keyed_with_value, Godot.Tools.EditorProperty.sig_resource_selected, Godot.Tools.EditorProperty.sig_selected, Godot.Tools.EditorProperty._focusable_focused, Godot.Tools.EditorProperty._gui_input, Godot.Tools.EditorProperty.add_focusable, Godot.Tools.EditorProperty.emit_changed, Godot.Tools.EditorProperty.get_edited_object, Godot.Tools.EditorProperty.get_edited_property, Godot.Tools.EditorProperty.get_label, Godot.Tools.EditorProperty.get_tooltip_text, Godot.Tools.EditorProperty.is_checkable, Godot.Tools.EditorProperty.is_checked, Godot.Tools.EditorProperty.is_draw_red, Godot.Tools.EditorProperty.is_keying, Godot.Tools.EditorProperty.is_read_only, Godot.Tools.EditorProperty.set_bottom_editor, Godot.Tools.EditorProperty.set_checkable, Godot.Tools.EditorProperty.set_checked, Godot.Tools.EditorProperty.set_draw_red, Godot.Tools.EditorProperty.set_keying, Godot.Tools.EditorProperty.set_label, Godot.Tools.EditorProperty.set_read_only, Godot.Tools.EditorProperty.update_property) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Container() -- | Emit it if you want multiple properties modified at the same time. Do not use if added via @method EditorInspectorPlugin.parse_property@. sig_multiple_properties_changed :: Godot.Internal.Dispatch.Signal EditorProperty sig_multiple_properties_changed = Godot.Internal.Dispatch.Signal "multiple_properties_changed" instance NodeSignal EditorProperty "multiple_properties_changed" '[PoolStringArray, Array] -- | Used by sub-inspectors. Emit it if what was selected was an Object ID. sig_object_id_selected :: Godot.Internal.Dispatch.Signal EditorProperty sig_object_id_selected = Godot.Internal.Dispatch.Signal "object_id_selected" instance NodeSignal EditorProperty "object_id_selected" '[GodotString, Int] -- | Do not emit this manually, use the @method emit_changed@ method instead. sig_property_changed :: Godot.Internal.Dispatch.Signal EditorProperty sig_property_changed = Godot.Internal.Dispatch.Signal "property_changed" instance NodeSignal EditorProperty "property_changed" '[GodotString, GodotVariant] -- | Emitted when a property was checked. Used internally. sig_property_checked :: Godot.Internal.Dispatch.Signal EditorProperty sig_property_checked = Godot.Internal.Dispatch.Signal "property_checked" instance NodeSignal EditorProperty "property_checked" '[GodotString, GodotString] -- | Emit it if you want to add this value as an animation key (check for keying being enabled first). sig_property_keyed :: Godot.Internal.Dispatch.Signal EditorProperty sig_property_keyed = Godot.Internal.Dispatch.Signal "property_keyed" instance NodeSignal EditorProperty "property_keyed" '[GodotString] -- | Emit it if you want to key a property with a single value. sig_property_keyed_with_value :: Godot.Internal.Dispatch.Signal EditorProperty sig_property_keyed_with_value = Godot.Internal.Dispatch.Signal "property_keyed_with_value" instance NodeSignal EditorProperty "property_keyed_with_value" '[GodotString, GodotVariant] -- | If you want a sub-resource to be edited, emit this signal with the resource. sig_resource_selected :: Godot.Internal.Dispatch.Signal EditorProperty sig_resource_selected = Godot.Internal.Dispatch.Signal "resource_selected" instance NodeSignal EditorProperty "resource_selected" '[GodotString, Resource] -- | Emitted when selected. Used internally. sig_selected :: Godot.Internal.Dispatch.Signal EditorProperty sig_selected = Godot.Internal.Dispatch.Signal "selected" instance NodeSignal EditorProperty "selected" '[GodotString, Int] instance NodeProperty EditorProperty "checkable" Bool 'False where nodeProperty = (is_checkable, wrapDroppingSetter set_checkable, Nothing) instance NodeProperty EditorProperty "checked" Bool 'False where nodeProperty = (is_checked, wrapDroppingSetter set_checked, Nothing) instance NodeProperty EditorProperty "draw_red" Bool 'False where nodeProperty = (is_draw_red, wrapDroppingSetter set_draw_red, Nothing) instance NodeProperty EditorProperty "keying" Bool 'False where nodeProperty = (is_keying, wrapDroppingSetter set_keying, Nothing) instance NodeProperty EditorProperty "label" GodotString 'False where nodeProperty = (get_label, wrapDroppingSetter set_label, Nothing) instance NodeProperty EditorProperty "read_only" Bool 'False where nodeProperty = (is_read_only, wrapDroppingSetter set_read_only, Nothing) {-# NOINLINE bindEditorProperty__focusable_focused #-} bindEditorProperty__focusable_focused :: MethodBind bindEditorProperty__focusable_focused = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "_focusable_focused" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _focusable_focused :: (EditorProperty :< cls, Object :< cls) => cls -> Int -> IO () _focusable_focused cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty__focusable_focused (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "_focusable_focused" '[Int] (IO ()) where nodeMethod = Godot.Tools.EditorProperty._focusable_focused {-# NOINLINE bindEditorProperty__gui_input #-} bindEditorProperty__gui_input :: MethodBind bindEditorProperty__gui_input = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (EditorProperty :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Tools.EditorProperty._gui_input {-# NOINLINE bindEditorProperty_add_focusable #-} -- | If any of the controls added can gain keyboard focus, add it here. This ensures that focus will be restored if the inspector is refreshed. bindEditorProperty_add_focusable :: MethodBind bindEditorProperty_add_focusable = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "add_focusable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If any of the controls added can gain keyboard focus, add it here. This ensures that focus will be restored if the inspector is refreshed. add_focusable :: (EditorProperty :< cls, Object :< cls) => cls -> Control -> IO () add_focusable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_add_focusable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "add_focusable" '[Control] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.add_focusable {-# NOINLINE bindEditorProperty_emit_changed #-} -- | If one or several properties have changed, this must be called. @field@ is used in case your editor can modify fields separately (as an example, Vector3.x). The @changing@ argument avoids the editor requesting this property to be refreshed (leave as @false@ if unsure). bindEditorProperty_emit_changed :: MethodBind bindEditorProperty_emit_changed = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "emit_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If one or several properties have changed, this must be called. @field@ is used in case your editor can modify fields separately (as an example, Vector3.x). The @changing@ argument avoids the editor requesting this property to be refreshed (leave as @false@ if unsure). emit_changed :: (EditorProperty :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> Maybe GodotString -> Maybe Bool -> IO () emit_changed cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, defaultedVariant VariantString "" arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_emit_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "emit_changed" '[GodotString, GodotVariant, Maybe GodotString, Maybe Bool] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.emit_changed {-# NOINLINE bindEditorProperty_get_edited_object #-} -- | Gets the edited object. bindEditorProperty_get_edited_object :: MethodBind bindEditorProperty_get_edited_object = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "get_edited_object" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the edited object. get_edited_object :: (EditorProperty :< cls, Object :< cls) => cls -> IO Object get_edited_object cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_get_edited_object (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "get_edited_object" '[] (IO Object) where nodeMethod = Godot.Tools.EditorProperty.get_edited_object {-# NOINLINE bindEditorProperty_get_edited_property #-} -- | Gets the edited property. If your editor is for a single property (added via @method EditorInspectorPlugin.parse_property@), then this will return the property. bindEditorProperty_get_edited_property :: MethodBind bindEditorProperty_get_edited_property = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "get_edited_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the edited property. If your editor is for a single property (added via @method EditorInspectorPlugin.parse_property@), then this will return the property. get_edited_property :: (EditorProperty :< cls, Object :< cls) => cls -> IO GodotString get_edited_property cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_get_edited_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "get_edited_property" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorProperty.get_edited_property {-# NOINLINE bindEditorProperty_get_label #-} -- | Set this property to change the label (if you want to show one). bindEditorProperty_get_label :: MethodBind bindEditorProperty_get_label = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "get_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Set this property to change the label (if you want to show one). get_label :: (EditorProperty :< cls, Object :< cls) => cls -> IO GodotString get_label cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_get_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "get_label" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorProperty.get_label {-# NOINLINE bindEditorProperty_get_tooltip_text #-} -- | Override if you want to allow a custom tooltip over your property. bindEditorProperty_get_tooltip_text :: MethodBind bindEditorProperty_get_tooltip_text = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "get_tooltip_text" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override if you want to allow a custom tooltip over your property. get_tooltip_text :: (EditorProperty :< cls, Object :< cls) => cls -> IO GodotString get_tooltip_text cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_get_tooltip_text (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "get_tooltip_text" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorProperty.get_tooltip_text {-# NOINLINE bindEditorProperty_is_checkable #-} -- | Used by the inspector, set to @true@ when the property is checkable. bindEditorProperty_is_checkable :: MethodBind bindEditorProperty_is_checkable = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "is_checkable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property is checkable. is_checkable :: (EditorProperty :< cls, Object :< cls) => cls -> IO Bool is_checkable cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_is_checkable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "is_checkable" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorProperty.is_checkable {-# NOINLINE bindEditorProperty_is_checked #-} -- | Used by the inspector, set to @true@ when the property is checked. bindEditorProperty_is_checked :: MethodBind bindEditorProperty_is_checked = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "is_checked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property is checked. is_checked :: (EditorProperty :< cls, Object :< cls) => cls -> IO Bool is_checked cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_is_checked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "is_checked" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorProperty.is_checked {-# NOINLINE bindEditorProperty_is_draw_red #-} -- | Used by the inspector, set to @true@ when the property must draw with error color. This is used for editable children's properties. bindEditorProperty_is_draw_red :: MethodBind bindEditorProperty_is_draw_red = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "is_draw_red" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property must draw with error color. This is used for editable children's properties. is_draw_red :: (EditorProperty :< cls, Object :< cls) => cls -> IO Bool is_draw_red cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_is_draw_red (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "is_draw_red" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorProperty.is_draw_red {-# NOINLINE bindEditorProperty_is_keying #-} -- | Used by the inspector, set to @true@ when the property can add keys for animation. bindEditorProperty_is_keying :: MethodBind bindEditorProperty_is_keying = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "is_keying" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property can add keys for animation. is_keying :: (EditorProperty :< cls, Object :< cls) => cls -> IO Bool is_keying cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_is_keying (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "is_keying" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorProperty.is_keying {-# NOINLINE bindEditorProperty_is_read_only #-} -- | Used by the inspector, set to @true@ when the property is read-only. bindEditorProperty_is_read_only :: MethodBind bindEditorProperty_is_read_only = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "is_read_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property is read-only. is_read_only :: (EditorProperty :< cls, Object :< cls) => cls -> IO Bool is_read_only cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_is_read_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "is_read_only" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorProperty.is_read_only {-# NOINLINE bindEditorProperty_set_bottom_editor #-} -- | Adds controls with this function if you want them on the bottom (below the label). bindEditorProperty_set_bottom_editor :: MethodBind bindEditorProperty_set_bottom_editor = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "set_bottom_editor" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds controls with this function if you want them on the bottom (below the label). set_bottom_editor :: (EditorProperty :< cls, Object :< cls) => cls -> Control -> IO () set_bottom_editor cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_set_bottom_editor (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "set_bottom_editor" '[Control] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.set_bottom_editor {-# NOINLINE bindEditorProperty_set_checkable #-} -- | Used by the inspector, set to @true@ when the property is checkable. bindEditorProperty_set_checkable :: MethodBind bindEditorProperty_set_checkable = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "set_checkable" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property is checkable. set_checkable :: (EditorProperty :< cls, Object :< cls) => cls -> Bool -> IO () set_checkable cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_set_checkable (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "set_checkable" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.set_checkable {-# NOINLINE bindEditorProperty_set_checked #-} -- | Used by the inspector, set to @true@ when the property is checked. bindEditorProperty_set_checked :: MethodBind bindEditorProperty_set_checked = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "set_checked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property is checked. set_checked :: (EditorProperty :< cls, Object :< cls) => cls -> Bool -> IO () set_checked cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_set_checked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "set_checked" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.set_checked {-# NOINLINE bindEditorProperty_set_draw_red #-} -- | Used by the inspector, set to @true@ when the property must draw with error color. This is used for editable children's properties. bindEditorProperty_set_draw_red :: MethodBind bindEditorProperty_set_draw_red = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "set_draw_red" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property must draw with error color. This is used for editable children's properties. set_draw_red :: (EditorProperty :< cls, Object :< cls) => cls -> Bool -> IO () set_draw_red cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_set_draw_red (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "set_draw_red" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.set_draw_red {-# NOINLINE bindEditorProperty_set_keying #-} -- | Used by the inspector, set to @true@ when the property can add keys for animation. bindEditorProperty_set_keying :: MethodBind bindEditorProperty_set_keying = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "set_keying" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property can add keys for animation. set_keying :: (EditorProperty :< cls, Object :< cls) => cls -> Bool -> IO () set_keying cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_set_keying (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "set_keying" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.set_keying {-# NOINLINE bindEditorProperty_set_label #-} -- | Set this property to change the label (if you want to show one). bindEditorProperty_set_label :: MethodBind bindEditorProperty_set_label = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "set_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Set this property to change the label (if you want to show one). set_label :: (EditorProperty :< cls, Object :< cls) => cls -> GodotString -> IO () set_label cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_set_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "set_label" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.set_label {-# NOINLINE bindEditorProperty_set_read_only #-} -- | Used by the inspector, set to @true@ when the property is read-only. bindEditorProperty_set_read_only :: MethodBind bindEditorProperty_set_read_only = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "set_read_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Used by the inspector, set to @true@ when the property is read-only. set_read_only :: (EditorProperty :< cls, Object :< cls) => cls -> Bool -> IO () set_read_only cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_set_read_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "set_read_only" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.set_read_only {-# NOINLINE bindEditorProperty_update_property #-} -- | When this virtual function is called, you must update your editor. bindEditorProperty_update_property :: MethodBind bindEditorProperty_update_property = unsafePerformIO $ withCString "EditorProperty" $ \ clsNamePtr -> withCString "update_property" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | When this virtual function is called, you must update your editor. update_property :: (EditorProperty :< cls, Object :< cls) => cls -> IO () update_property cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorProperty_update_property (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorProperty "update_property" '[] (IO ()) where nodeMethod = Godot.Tools.EditorProperty.update_property ================================================ FILE: src/Godot/Tools/EditorResourceConversionPlugin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorResourceConversionPlugin (Godot.Tools.EditorResourceConversionPlugin._convert, Godot.Tools.EditorResourceConversionPlugin._converts_to) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindEditorResourceConversionPlugin__convert #-} bindEditorResourceConversionPlugin__convert :: MethodBind bindEditorResourceConversionPlugin__convert = unsafePerformIO $ withCString "EditorResourceConversionPlugin" $ \ clsNamePtr -> withCString "_convert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _convert :: (EditorResourceConversionPlugin :< cls, Object :< cls) => cls -> Resource -> IO Resource _convert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourceConversionPlugin__convert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourceConversionPlugin "_convert" '[Resource] (IO Resource) where nodeMethod = Godot.Tools.EditorResourceConversionPlugin._convert {-# NOINLINE bindEditorResourceConversionPlugin__converts_to #-} bindEditorResourceConversionPlugin__converts_to :: MethodBind bindEditorResourceConversionPlugin__converts_to = unsafePerformIO $ withCString "EditorResourceConversionPlugin" $ \ clsNamePtr -> withCString "_converts_to" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _converts_to :: (EditorResourceConversionPlugin :< cls, Object :< cls) => cls -> IO GodotString _converts_to cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourceConversionPlugin__converts_to (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourceConversionPlugin "_converts_to" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorResourceConversionPlugin._converts_to ================================================ FILE: src/Godot/Tools/EditorResourcePreview.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorResourcePreview (Godot.Tools.EditorResourcePreview.sig_preview_invalidated, Godot.Tools.EditorResourcePreview._preview_ready, Godot.Tools.EditorResourcePreview.add_preview_generator, Godot.Tools.EditorResourcePreview.check_for_invalidation, Godot.Tools.EditorResourcePreview.queue_edited_resource_preview, Godot.Tools.EditorResourcePreview.queue_resource_preview, Godot.Tools.EditorResourcePreview.remove_preview_generator) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Node() -- | Emitted if a preview was invalidated (changed). @path@ corresponds to the path of the preview. sig_preview_invalidated :: Godot.Internal.Dispatch.Signal EditorResourcePreview sig_preview_invalidated = Godot.Internal.Dispatch.Signal "preview_invalidated" instance NodeSignal EditorResourcePreview "preview_invalidated" '[GodotString] {-# NOINLINE bindEditorResourcePreview__preview_ready #-} bindEditorResourcePreview__preview_ready :: MethodBind bindEditorResourcePreview__preview_ready = unsafePerformIO $ withCString "EditorResourcePreview" $ \ clsNamePtr -> withCString "_preview_ready" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _preview_ready :: (EditorResourcePreview :< cls, Object :< cls) => cls -> GodotString -> Texture -> Texture -> Int -> GodotString -> GodotVariant -> IO () _preview_ready cls arg1 arg2 arg3 arg4 arg5 arg6 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4, toVariant arg5, toVariant arg6] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreview__preview_ready (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreview "_preview_ready" '[GodotString, Texture, Texture, Int, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Tools.EditorResourcePreview._preview_ready {-# NOINLINE bindEditorResourcePreview_add_preview_generator #-} -- | Create an own, custom preview generator. bindEditorResourcePreview_add_preview_generator :: MethodBind bindEditorResourcePreview_add_preview_generator = unsafePerformIO $ withCString "EditorResourcePreview" $ \ clsNamePtr -> withCString "add_preview_generator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Create an own, custom preview generator. add_preview_generator :: (EditorResourcePreview :< cls, Object :< cls) => cls -> EditorResourcePreviewGenerator -> IO () add_preview_generator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreview_add_preview_generator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreview "add_preview_generator" '[EditorResourcePreviewGenerator] (IO ()) where nodeMethod = Godot.Tools.EditorResourcePreview.add_preview_generator {-# NOINLINE bindEditorResourcePreview_check_for_invalidation #-} -- | Check if the resource changed, if so, it will be invalidated and the corresponding signal emitted. bindEditorResourcePreview_check_for_invalidation :: MethodBind bindEditorResourcePreview_check_for_invalidation = unsafePerformIO $ withCString "EditorResourcePreview" $ \ clsNamePtr -> withCString "check_for_invalidation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Check if the resource changed, if so, it will be invalidated and the corresponding signal emitted. check_for_invalidation :: (EditorResourcePreview :< cls, Object :< cls) => cls -> GodotString -> IO () check_for_invalidation cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreview_check_for_invalidation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreview "check_for_invalidation" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorResourcePreview.check_for_invalidation {-# NOINLINE bindEditorResourcePreview_queue_edited_resource_preview #-} -- | Queue a resource being edited for preview (using an instance). Once the preview is ready, your receiver.receiver_func will be called either containing the preview texture or an empty texture (if no preview was possible). Callback must have the format: (path,texture,userdata). Userdata can be anything. bindEditorResourcePreview_queue_edited_resource_preview :: MethodBind bindEditorResourcePreview_queue_edited_resource_preview = unsafePerformIO $ withCString "EditorResourcePreview" $ \ clsNamePtr -> withCString "queue_edited_resource_preview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Queue a resource being edited for preview (using an instance). Once the preview is ready, your receiver.receiver_func will be called either containing the preview texture or an empty texture (if no preview was possible). Callback must have the format: (path,texture,userdata). Userdata can be anything. queue_edited_resource_preview :: (EditorResourcePreview :< cls, Object :< cls) => cls -> Resource -> Object -> GodotString -> GodotVariant -> IO () queue_edited_resource_preview cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreview_queue_edited_resource_preview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreview "queue_edited_resource_preview" '[Resource, Object, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Tools.EditorResourcePreview.queue_edited_resource_preview {-# NOINLINE bindEditorResourcePreview_queue_resource_preview #-} -- | Queue a resource file for preview (using a path). Once the preview is ready, your receiver.receiver_func will be called either containing the preview texture or an empty texture (if no preview was possible). Callback must have the format: (path,texture,userdata). Userdata can be anything. bindEditorResourcePreview_queue_resource_preview :: MethodBind bindEditorResourcePreview_queue_resource_preview = unsafePerformIO $ withCString "EditorResourcePreview" $ \ clsNamePtr -> withCString "queue_resource_preview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Queue a resource file for preview (using a path). Once the preview is ready, your receiver.receiver_func will be called either containing the preview texture or an empty texture (if no preview was possible). Callback must have the format: (path,texture,userdata). Userdata can be anything. queue_resource_preview :: (EditorResourcePreview :< cls, Object :< cls) => cls -> GodotString -> Object -> GodotString -> GodotVariant -> IO () queue_resource_preview cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreview_queue_resource_preview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreview "queue_resource_preview" '[GodotString, Object, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Tools.EditorResourcePreview.queue_resource_preview {-# NOINLINE bindEditorResourcePreview_remove_preview_generator #-} -- | Removes a custom preview generator. bindEditorResourcePreview_remove_preview_generator :: MethodBind bindEditorResourcePreview_remove_preview_generator = unsafePerformIO $ withCString "EditorResourcePreview" $ \ clsNamePtr -> withCString "remove_preview_generator" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a custom preview generator. remove_preview_generator :: (EditorResourcePreview :< cls, Object :< cls) => cls -> EditorResourcePreviewGenerator -> IO () remove_preview_generator cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreview_remove_preview_generator (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreview "remove_preview_generator" '[EditorResourcePreviewGenerator] (IO ()) where nodeMethod = Godot.Tools.EditorResourcePreview.remove_preview_generator ================================================ FILE: src/Godot/Tools/EditorResourcePreviewGenerator.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorResourcePreviewGenerator (Godot.Tools.EditorResourcePreviewGenerator.can_generate_small_preview, Godot.Tools.EditorResourcePreviewGenerator.generate, Godot.Tools.EditorResourcePreviewGenerator.generate_from_path, Godot.Tools.EditorResourcePreviewGenerator.generate_small_preview_automatically, Godot.Tools.EditorResourcePreviewGenerator.handles) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindEditorResourcePreviewGenerator_can_generate_small_preview #-} -- | If this function returns @true@, the generator will call @method generate@ or @method generate_from_path@ for small previews as well. -- By default, it returns @false@. bindEditorResourcePreviewGenerator_can_generate_small_preview :: MethodBind bindEditorResourcePreviewGenerator_can_generate_small_preview = unsafePerformIO $ withCString "EditorResourcePreviewGenerator" $ \ clsNamePtr -> withCString "can_generate_small_preview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If this function returns @true@, the generator will call @method generate@ or @method generate_from_path@ for small previews as well. -- By default, it returns @false@. can_generate_small_preview :: (EditorResourcePreviewGenerator :< cls, Object :< cls) => cls -> IO Bool can_generate_small_preview cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreviewGenerator_can_generate_small_preview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreviewGenerator "can_generate_small_preview" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorResourcePreviewGenerator.can_generate_small_preview {-# NOINLINE bindEditorResourcePreviewGenerator_generate #-} -- | Generate a preview from a given resource with the specified size. This must always be implemented. -- Returning an empty texture is an OK way to fail and let another generator take care. -- Care must be taken because this function is always called from a thread (not the main thread). bindEditorResourcePreviewGenerator_generate :: MethodBind bindEditorResourcePreviewGenerator_generate = unsafePerformIO $ withCString "EditorResourcePreviewGenerator" $ \ clsNamePtr -> withCString "generate" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generate a preview from a given resource with the specified size. This must always be implemented. -- Returning an empty texture is an OK way to fail and let another generator take care. -- Care must be taken because this function is always called from a thread (not the main thread). generate :: (EditorResourcePreviewGenerator :< cls, Object :< cls) => cls -> Resource -> Vector2 -> IO Texture generate cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreviewGenerator_generate (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreviewGenerator "generate" '[Resource, Vector2] (IO Texture) where nodeMethod = Godot.Tools.EditorResourcePreviewGenerator.generate {-# NOINLINE bindEditorResourcePreviewGenerator_generate_from_path #-} -- | Generate a preview directly from a path with the specified size. Implementing this is optional, as default code will load and call @method generate@. -- Returning an empty texture is an OK way to fail and let another generator take care. -- Care must be taken because this function is always called from a thread (not the main thread). bindEditorResourcePreviewGenerator_generate_from_path :: MethodBind bindEditorResourcePreviewGenerator_generate_from_path = unsafePerformIO $ withCString "EditorResourcePreviewGenerator" $ \ clsNamePtr -> withCString "generate_from_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Generate a preview directly from a path with the specified size. Implementing this is optional, as default code will load and call @method generate@. -- Returning an empty texture is an OK way to fail and let another generator take care. -- Care must be taken because this function is always called from a thread (not the main thread). generate_from_path :: (EditorResourcePreviewGenerator :< cls, Object :< cls) => cls -> GodotString -> Vector2 -> IO Texture generate_from_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreviewGenerator_generate_from_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreviewGenerator "generate_from_path" '[GodotString, Vector2] (IO Texture) where nodeMethod = Godot.Tools.EditorResourcePreviewGenerator.generate_from_path {-# NOINLINE bindEditorResourcePreviewGenerator_generate_small_preview_automatically #-} -- | If this function returns @true@, the generator will automatically generate the small previews from the normal preview texture generated by the methods @method generate@ or @method generate_from_path@. -- By default, it returns @false@. bindEditorResourcePreviewGenerator_generate_small_preview_automatically :: MethodBind bindEditorResourcePreviewGenerator_generate_small_preview_automatically = unsafePerformIO $ withCString "EditorResourcePreviewGenerator" $ \ clsNamePtr -> withCString "generate_small_preview_automatically" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | If this function returns @true@, the generator will automatically generate the small previews from the normal preview texture generated by the methods @method generate@ or @method generate_from_path@. -- By default, it returns @false@. generate_small_preview_automatically :: (EditorResourcePreviewGenerator :< cls, Object :< cls) => cls -> IO Bool generate_small_preview_automatically cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreviewGenerator_generate_small_preview_automatically (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreviewGenerator "generate_small_preview_automatically" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorResourcePreviewGenerator.generate_small_preview_automatically {-# NOINLINE bindEditorResourcePreviewGenerator_handles #-} -- | Returns @true@ if your generator supports the resource of type @type@. bindEditorResourcePreviewGenerator_handles :: MethodBind bindEditorResourcePreviewGenerator_handles = unsafePerformIO $ withCString "EditorResourcePreviewGenerator" $ \ clsNamePtr -> withCString "handles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if your generator supports the resource of type @type@. handles :: (EditorResourcePreviewGenerator :< cls, Object :< cls) => cls -> GodotString -> IO Bool handles cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorResourcePreviewGenerator_handles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorResourcePreviewGenerator "handles" '[GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorResourcePreviewGenerator.handles ================================================ FILE: src/Godot/Tools/EditorSceneImporter.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorSceneImporter (Godot.Tools.EditorSceneImporter._IMPORT_MATERIALS_IN_INSTANCES, Godot.Tools.EditorSceneImporter._IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS, Godot.Tools.EditorSceneImporter._IMPORT_USE_COMPRESSION, Godot.Tools.EditorSceneImporter._IMPORT_FAIL_ON_MISSING_DEPENDENCIES, Godot.Tools.EditorSceneImporter._IMPORT_ANIMATION, Godot.Tools.EditorSceneImporter._IMPORT_SCENE, Godot.Tools.EditorSceneImporter._IMPORT_ANIMATION_KEEP_VALUE_TRACKS, Godot.Tools.EditorSceneImporter._IMPORT_ANIMATION_DETECT_LOOP, Godot.Tools.EditorSceneImporter._IMPORT_ANIMATION_OPTIMIZE, Godot.Tools.EditorSceneImporter._IMPORT_GENERATE_TANGENT_ARRAYS, Godot.Tools.EditorSceneImporter._get_extensions, Godot.Tools.EditorSceneImporter._get_import_flags, Godot.Tools.EditorSceneImporter._import_animation, Godot.Tools.EditorSceneImporter._import_scene, Godot.Tools.EditorSceneImporter.import_animation_from_other_importer, Godot.Tools.EditorSceneImporter.import_scene_from_other_importer) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() _IMPORT_MATERIALS_IN_INSTANCES :: Int _IMPORT_MATERIALS_IN_INSTANCES = 1024 _IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS :: Int _IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS = 16 _IMPORT_USE_COMPRESSION :: Int _IMPORT_USE_COMPRESSION = 2048 _IMPORT_FAIL_ON_MISSING_DEPENDENCIES :: Int _IMPORT_FAIL_ON_MISSING_DEPENDENCIES = 512 _IMPORT_ANIMATION :: Int _IMPORT_ANIMATION = 2 _IMPORT_SCENE :: Int _IMPORT_SCENE = 1 _IMPORT_ANIMATION_KEEP_VALUE_TRACKS :: Int _IMPORT_ANIMATION_KEEP_VALUE_TRACKS = 32 _IMPORT_ANIMATION_DETECT_LOOP :: Int _IMPORT_ANIMATION_DETECT_LOOP = 4 _IMPORT_ANIMATION_OPTIMIZE :: Int _IMPORT_ANIMATION_OPTIMIZE = 8 _IMPORT_GENERATE_TANGENT_ARRAYS :: Int _IMPORT_GENERATE_TANGENT_ARRAYS = 256 {-# NOINLINE bindEditorSceneImporter__get_extensions #-} bindEditorSceneImporter__get_extensions :: MethodBind bindEditorSceneImporter__get_extensions = unsafePerformIO $ withCString "EditorSceneImporter" $ \ clsNamePtr -> withCString "_get_extensions" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_extensions :: (EditorSceneImporter :< cls, Object :< cls) => cls -> IO Array _get_extensions cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSceneImporter__get_extensions (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSceneImporter "_get_extensions" '[] (IO Array) where nodeMethod = Godot.Tools.EditorSceneImporter._get_extensions {-# NOINLINE bindEditorSceneImporter__get_import_flags #-} bindEditorSceneImporter__get_import_flags :: MethodBind bindEditorSceneImporter__get_import_flags = unsafePerformIO $ withCString "EditorSceneImporter" $ \ clsNamePtr -> withCString "_get_import_flags" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_import_flags :: (EditorSceneImporter :< cls, Object :< cls) => cls -> IO Int _get_import_flags cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSceneImporter__get_import_flags (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSceneImporter "_get_import_flags" '[] (IO Int) where nodeMethod = Godot.Tools.EditorSceneImporter._get_import_flags {-# NOINLINE bindEditorSceneImporter__import_animation #-} bindEditorSceneImporter__import_animation :: MethodBind bindEditorSceneImporter__import_animation = unsafePerformIO $ withCString "EditorSceneImporter" $ \ clsNamePtr -> withCString "_import_animation" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _import_animation :: (EditorSceneImporter :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> IO Animation _import_animation cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSceneImporter__import_animation (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSceneImporter "_import_animation" '[GodotString, Int, Int] (IO Animation) where nodeMethod = Godot.Tools.EditorSceneImporter._import_animation {-# NOINLINE bindEditorSceneImporter__import_scene #-} bindEditorSceneImporter__import_scene :: MethodBind bindEditorSceneImporter__import_scene = unsafePerformIO $ withCString "EditorSceneImporter" $ \ clsNamePtr -> withCString "_import_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _import_scene :: (EditorSceneImporter :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> IO Node _import_scene cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSceneImporter__import_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSceneImporter "_import_scene" '[GodotString, Int, Int] (IO Node) where nodeMethod = Godot.Tools.EditorSceneImporter._import_scene {-# NOINLINE bindEditorSceneImporter_import_animation_from_other_importer #-} bindEditorSceneImporter_import_animation_from_other_importer :: MethodBind bindEditorSceneImporter_import_animation_from_other_importer = unsafePerformIO $ withCString "EditorSceneImporter" $ \ clsNamePtr -> withCString "import_animation_from_other_importer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr import_animation_from_other_importer :: (EditorSceneImporter :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> IO Animation import_animation_from_other_importer cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSceneImporter_import_animation_from_other_importer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSceneImporter "import_animation_from_other_importer" '[GodotString, Int, Int] (IO Animation) where nodeMethod = Godot.Tools.EditorSceneImporter.import_animation_from_other_importer {-# NOINLINE bindEditorSceneImporter_import_scene_from_other_importer #-} bindEditorSceneImporter_import_scene_from_other_importer :: MethodBind bindEditorSceneImporter_import_scene_from_other_importer = unsafePerformIO $ withCString "EditorSceneImporter" $ \ clsNamePtr -> withCString "import_scene_from_other_importer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr import_scene_from_other_importer :: (EditorSceneImporter :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> IO Node import_scene_from_other_importer cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSceneImporter_import_scene_from_other_importer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSceneImporter "import_scene_from_other_importer" '[GodotString, Int, Int] (IO Node) where nodeMethod = Godot.Tools.EditorSceneImporter.import_scene_from_other_importer ================================================ FILE: src/Godot/Tools/EditorSceneImporterAssimp.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorSceneImporterAssimp () where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Tools.EditorSceneImporter() ================================================ FILE: src/Godot/Tools/EditorScenePostImport.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorScenePostImport (Godot.Tools.EditorScenePostImport.get_source_file, Godot.Tools.EditorScenePostImport.get_source_folder, Godot.Tools.EditorScenePostImport.post_import) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindEditorScenePostImport_get_source_file #-} -- | Returns the source file path which got imported (e.g. @res://scene.dae@). bindEditorScenePostImport_get_source_file :: MethodBind bindEditorScenePostImport_get_source_file = unsafePerformIO $ withCString "EditorScenePostImport" $ \ clsNamePtr -> withCString "get_source_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the source file path which got imported (e.g. @res://scene.dae@). get_source_file :: (EditorScenePostImport :< cls, Object :< cls) => cls -> IO GodotString get_source_file cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorScenePostImport_get_source_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorScenePostImport "get_source_file" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorScenePostImport.get_source_file {-# NOINLINE bindEditorScenePostImport_get_source_folder #-} -- | Returns the resource folder the imported scene file is located in. bindEditorScenePostImport_get_source_folder :: MethodBind bindEditorScenePostImport_get_source_folder = unsafePerformIO $ withCString "EditorScenePostImport" $ \ clsNamePtr -> withCString "get_source_folder" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the resource folder the imported scene file is located in. get_source_folder :: (EditorScenePostImport :< cls, Object :< cls) => cls -> IO GodotString get_source_folder cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorScenePostImport_get_source_folder (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorScenePostImport "get_source_folder" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorScenePostImport.get_source_folder {-# NOINLINE bindEditorScenePostImport_post_import #-} -- | Called after the scene was imported. This method must return the modified version of the scene. bindEditorScenePostImport_post_import :: MethodBind bindEditorScenePostImport_post_import = unsafePerformIO $ withCString "EditorScenePostImport" $ \ clsNamePtr -> withCString "post_import" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Called after the scene was imported. This method must return the modified version of the scene. post_import :: (EditorScenePostImport :< cls, Object :< cls) => cls -> Object -> IO Object post_import cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorScenePostImport_post_import (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorScenePostImport "post_import" '[Object] (IO Object) where nodeMethod = Godot.Tools.EditorScenePostImport.post_import ================================================ FILE: src/Godot/Tools/EditorScript.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorScript (Godot.Tools.EditorScript._run, Godot.Tools.EditorScript.add_root_node, Godot.Tools.EditorScript.get_editor_interface, Godot.Tools.EditorScript.get_scene) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Reference() {-# NOINLINE bindEditorScript__run #-} -- | This method is executed by the Editor when __File > Run__ is used. bindEditorScript__run :: MethodBind bindEditorScript__run = unsafePerformIO $ withCString "EditorScript" $ \ clsNamePtr -> withCString "_run" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This method is executed by the Editor when __File > Run__ is used. _run :: (EditorScript :< cls, Object :< cls) => cls -> IO () _run cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorScript__run (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorScript "_run" '[] (IO ()) where nodeMethod = Godot.Tools.EditorScript._run {-# NOINLINE bindEditorScript_add_root_node #-} -- | Adds @node@ as a child of the root node in the editor context. -- __Warning:__ The implementation of this method is currently disabled. bindEditorScript_add_root_node :: MethodBind bindEditorScript_add_root_node = unsafePerformIO $ withCString "EditorScript" $ \ clsNamePtr -> withCString "add_root_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds @node@ as a child of the root node in the editor context. -- __Warning:__ The implementation of this method is currently disabled. add_root_node :: (EditorScript :< cls, Object :< cls) => cls -> Node -> IO () add_root_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorScript_add_root_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorScript "add_root_node" '[Node] (IO ()) where nodeMethod = Godot.Tools.EditorScript.add_root_node {-# NOINLINE bindEditorScript_get_editor_interface #-} -- | Returns the @EditorInterface@ singleton instance. bindEditorScript_get_editor_interface :: MethodBind bindEditorScript_get_editor_interface = unsafePerformIO $ withCString "EditorScript" $ \ clsNamePtr -> withCString "get_editor_interface" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @EditorInterface@ singleton instance. get_editor_interface :: (EditorScript :< cls, Object :< cls) => cls -> IO EditorInterface get_editor_interface cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorScript_get_editor_interface (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorScript "get_editor_interface" '[] (IO EditorInterface) where nodeMethod = Godot.Tools.EditorScript.get_editor_interface {-# NOINLINE bindEditorScript_get_scene #-} -- | Returns the Editor's currently active scene. bindEditorScript_get_scene :: MethodBind bindEditorScript_get_scene = unsafePerformIO $ withCString "EditorScript" $ \ clsNamePtr -> withCString "get_scene" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the Editor's currently active scene. get_scene :: (EditorScript :< cls, Object :< cls) => cls -> IO Node get_scene cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorScript_get_scene (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorScript "get_scene" '[] (IO Node) where nodeMethod = Godot.Tools.EditorScript.get_scene ================================================ FILE: src/Godot/Tools/EditorSelection.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorSelection (Godot.Tools.EditorSelection.sig_selection_changed, Godot.Tools.EditorSelection._emit_change, Godot.Tools.EditorSelection._node_removed, Godot.Tools.EditorSelection.add_node, Godot.Tools.EditorSelection.clear, Godot.Tools.EditorSelection.get_selected_nodes, Godot.Tools.EditorSelection.get_transformable_selected_nodes, Godot.Tools.EditorSelection.remove_node) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() -- | Emitted when the selection changes. sig_selection_changed :: Godot.Internal.Dispatch.Signal EditorSelection sig_selection_changed = Godot.Internal.Dispatch.Signal "selection_changed" instance NodeSignal EditorSelection "selection_changed" '[] {-# NOINLINE bindEditorSelection__emit_change #-} bindEditorSelection__emit_change :: MethodBind bindEditorSelection__emit_change = unsafePerformIO $ withCString "EditorSelection" $ \ clsNamePtr -> withCString "_emit_change" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _emit_change :: (EditorSelection :< cls, Object :< cls) => cls -> IO () _emit_change cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSelection__emit_change (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSelection "_emit_change" '[] (IO ()) where nodeMethod = Godot.Tools.EditorSelection._emit_change {-# NOINLINE bindEditorSelection__node_removed #-} bindEditorSelection__node_removed :: MethodBind bindEditorSelection__node_removed = unsafePerformIO $ withCString "EditorSelection" $ \ clsNamePtr -> withCString "_node_removed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _node_removed :: (EditorSelection :< cls, Object :< cls) => cls -> Node -> IO () _node_removed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSelection__node_removed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSelection "_node_removed" '[Node] (IO ()) where nodeMethod = Godot.Tools.EditorSelection._node_removed {-# NOINLINE bindEditorSelection_add_node #-} -- | Adds a node to the selection. bindEditorSelection_add_node :: MethodBind bindEditorSelection_add_node = unsafePerformIO $ withCString "EditorSelection" $ \ clsNamePtr -> withCString "add_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a node to the selection. add_node :: (EditorSelection :< cls, Object :< cls) => cls -> Node -> IO () add_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSelection_add_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSelection "add_node" '[Node] (IO ()) where nodeMethod = Godot.Tools.EditorSelection.add_node {-# NOINLINE bindEditorSelection_clear #-} -- | Clear the selection. bindEditorSelection_clear :: MethodBind bindEditorSelection_clear = unsafePerformIO $ withCString "EditorSelection" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Clear the selection. clear :: (EditorSelection :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSelection_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSelection "clear" '[] (IO ()) where nodeMethod = Godot.Tools.EditorSelection.clear {-# NOINLINE bindEditorSelection_get_selected_nodes #-} -- | Gets the list of selected nodes. bindEditorSelection_get_selected_nodes :: MethodBind bindEditorSelection_get_selected_nodes = unsafePerformIO $ withCString "EditorSelection" $ \ clsNamePtr -> withCString "get_selected_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the list of selected nodes. get_selected_nodes :: (EditorSelection :< cls, Object :< cls) => cls -> IO Array get_selected_nodes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSelection_get_selected_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSelection "get_selected_nodes" '[] (IO Array) where nodeMethod = Godot.Tools.EditorSelection.get_selected_nodes {-# NOINLINE bindEditorSelection_get_transformable_selected_nodes #-} -- | Gets the list of selected nodes, optimized for transform operations (i.e. moving them, rotating, etc). This list avoids situations where a node is selected and also child/grandchild. bindEditorSelection_get_transformable_selected_nodes :: MethodBind bindEditorSelection_get_transformable_selected_nodes = unsafePerformIO $ withCString "EditorSelection" $ \ clsNamePtr -> withCString "get_transformable_selected_nodes" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the list of selected nodes, optimized for transform operations (i.e. moving them, rotating, etc). This list avoids situations where a node is selected and also child/grandchild. get_transformable_selected_nodes :: (EditorSelection :< cls, Object :< cls) => cls -> IO Array get_transformable_selected_nodes cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSelection_get_transformable_selected_nodes (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSelection "get_transformable_selected_nodes" '[] (IO Array) where nodeMethod = Godot.Tools.EditorSelection.get_transformable_selected_nodes {-# NOINLINE bindEditorSelection_remove_node #-} -- | Removes a node from the selection. bindEditorSelection_remove_node :: MethodBind bindEditorSelection_remove_node = unsafePerformIO $ withCString "EditorSelection" $ \ clsNamePtr -> withCString "remove_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes a node from the selection. remove_node :: (EditorSelection :< cls, Object :< cls) => cls -> Node -> IO () remove_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSelection_remove_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSelection "remove_node" '[Node] (IO ()) where nodeMethod = Godot.Tools.EditorSelection.remove_node ================================================ FILE: src/Godot/Tools/EditorSettings.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorSettings (Godot.Tools.EditorSettings._NOTIFICATION_EDITOR_SETTINGS_CHANGED, Godot.Tools.EditorSettings.sig_settings_changed, Godot.Tools.EditorSettings.add_property_info, Godot.Tools.EditorSettings.erase, Godot.Tools.EditorSettings.get_favorites, Godot.Tools.EditorSettings.get_project_metadata, Godot.Tools.EditorSettings.get_project_settings_dir, Godot.Tools.EditorSettings.get_recent_dirs, Godot.Tools.EditorSettings.get_setting, Godot.Tools.EditorSettings.get_settings_dir, Godot.Tools.EditorSettings.has_setting, Godot.Tools.EditorSettings.property_can_revert, Godot.Tools.EditorSettings.property_get_revert, Godot.Tools.EditorSettings.set_favorites, Godot.Tools.EditorSettings.set_initial_value, Godot.Tools.EditorSettings.set_project_metadata, Godot.Tools.EditorSettings.set_recent_dirs, Godot.Tools.EditorSettings.set_setting) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() _NOTIFICATION_EDITOR_SETTINGS_CHANGED :: Int _NOTIFICATION_EDITOR_SETTINGS_CHANGED = 10000 -- | Emitted after any editor setting has changed. sig_settings_changed :: Godot.Internal.Dispatch.Signal EditorSettings sig_settings_changed = Godot.Internal.Dispatch.Signal "settings_changed" instance NodeSignal EditorSettings "settings_changed" '[] {-# NOINLINE bindEditorSettings_add_property_info #-} -- | Adds a custom property info to a property. The dictionary must contain: -- - @name@: @String@ (the name of the property) -- - @type@: @int@ (see @enum Variant.Type@) -- - optionally @hint@: @int@ (see @enum PropertyHint@) and @hint_string@: @String@ -- __Example:__ -- -- @ -- -- editor_settings.set("category/property_name", 0) -- -- var property_info = { -- "name": "category/property_name", -- "type": TYPE_INT, -- "hint": PROPERTY_HINT_ENUM, -- "hint_string": "one,two,three" -- } -- -- editor_settings.add_property_info(property_info) -- -- @ bindEditorSettings_add_property_info :: MethodBind bindEditorSettings_add_property_info = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "add_property_info" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a custom property info to a property. The dictionary must contain: -- - @name@: @String@ (the name of the property) -- - @type@: @int@ (see @enum Variant.Type@) -- - optionally @hint@: @int@ (see @enum PropertyHint@) and @hint_string@: @String@ -- __Example:__ -- -- @ -- -- editor_settings.set("category/property_name", 0) -- -- var property_info = { -- "name": "category/property_name", -- "type": TYPE_INT, -- "hint": PROPERTY_HINT_ENUM, -- "hint_string": "one,two,three" -- } -- -- editor_settings.add_property_info(property_info) -- -- @ add_property_info :: (EditorSettings :< cls, Object :< cls) => cls -> Dictionary -> IO () add_property_info cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_add_property_info (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "add_property_info" '[Dictionary] (IO ()) where nodeMethod = Godot.Tools.EditorSettings.add_property_info {-# NOINLINE bindEditorSettings_erase #-} -- | Erases the setting whose name is specified by @property@. bindEditorSettings_erase :: MethodBind bindEditorSettings_erase = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "erase" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Erases the setting whose name is specified by @property@. erase :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> IO () erase cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_erase (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "erase" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorSettings.erase {-# NOINLINE bindEditorSettings_get_favorites #-} -- | Returns the list of favorite files and directories for this project. bindEditorSettings_get_favorites :: MethodBind bindEditorSettings_get_favorites = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "get_favorites" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of favorite files and directories for this project. get_favorites :: (EditorSettings :< cls, Object :< cls) => cls -> IO PoolStringArray get_favorites cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_get_favorites (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "get_favorites" '[] (IO PoolStringArray) where nodeMethod = Godot.Tools.EditorSettings.get_favorites {-# NOINLINE bindEditorSettings_get_project_metadata #-} -- | Returns project-specific metadata for the @section@ and @key@ specified. If the metadata doesn't exist, @default@ will be returned instead. See also @method set_project_metadata@. bindEditorSettings_get_project_metadata :: MethodBind bindEditorSettings_get_project_metadata = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "get_project_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns project-specific metadata for the @section@ and @key@ specified. If the metadata doesn't exist, @default@ will be returned instead. See also @method set_project_metadata@. get_project_metadata :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Maybe GodotVariant -> IO GodotVariant get_project_metadata cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, maybe VariantNil toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_get_project_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "get_project_metadata" '[GodotString, GodotString, Maybe GodotVariant] (IO GodotVariant) where nodeMethod = Godot.Tools.EditorSettings.get_project_metadata {-# NOINLINE bindEditorSettings_get_project_settings_dir #-} -- | Returns the project-specific settings path. Projects all have a unique subdirectory inside the settings path where project-specific settings are saved. bindEditorSettings_get_project_settings_dir :: MethodBind bindEditorSettings_get_project_settings_dir = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "get_project_settings_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the project-specific settings path. Projects all have a unique subdirectory inside the settings path where project-specific settings are saved. get_project_settings_dir :: (EditorSettings :< cls, Object :< cls) => cls -> IO GodotString get_project_settings_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_get_project_settings_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "get_project_settings_dir" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorSettings.get_project_settings_dir {-# NOINLINE bindEditorSettings_get_recent_dirs #-} -- | Returns the list of recently visited folders in the file dialog for this project. bindEditorSettings_get_recent_dirs :: MethodBind bindEditorSettings_get_recent_dirs = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "get_recent_dirs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the list of recently visited folders in the file dialog for this project. get_recent_dirs :: (EditorSettings :< cls, Object :< cls) => cls -> IO PoolStringArray get_recent_dirs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_get_recent_dirs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "get_recent_dirs" '[] (IO PoolStringArray) where nodeMethod = Godot.Tools.EditorSettings.get_recent_dirs {-# NOINLINE bindEditorSettings_get_setting #-} -- | Returns the value of the setting specified by @name@. This is equivalent to using @method Object.get@ on the EditorSettings instance. bindEditorSettings_get_setting :: MethodBind bindEditorSettings_get_setting = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "get_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the value of the setting specified by @name@. This is equivalent to using @method Object.get@ on the EditorSettings instance. get_setting :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant get_setting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_get_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "get_setting" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Tools.EditorSettings.get_setting {-# NOINLINE bindEditorSettings_get_settings_dir #-} -- | Gets the global settings path for the engine. Inside this path, you can find some standard paths such as: -- @settings/tmp@ - Used for temporary storage of files -- @settings/templates@ - Where export templates are located bindEditorSettings_get_settings_dir :: MethodBind bindEditorSettings_get_settings_dir = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "get_settings_dir" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the global settings path for the engine. Inside this path, you can find some standard paths such as: -- @settings/tmp@ - Used for temporary storage of files -- @settings/templates@ - Where export templates are located get_settings_dir :: (EditorSettings :< cls, Object :< cls) => cls -> IO GodotString get_settings_dir cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_get_settings_dir (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "get_settings_dir" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorSettings.get_settings_dir {-# NOINLINE bindEditorSettings_has_setting #-} -- | Returns @true@ if the setting specified by @name@ exists, @false@ otherwise. bindEditorSettings_has_setting :: MethodBind bindEditorSettings_has_setting = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "has_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the setting specified by @name@ exists, @false@ otherwise. has_setting :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> IO Bool has_setting cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_has_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "has_setting" '[GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorSettings.has_setting {-# NOINLINE bindEditorSettings_property_can_revert #-} -- | Returns @true@ if the setting specified by @name@ can have its value reverted to the default value, @false@ otherwise. When this method returns @true@, a Revert button will display next to the setting in the Editor Settings. bindEditorSettings_property_can_revert :: MethodBind bindEditorSettings_property_can_revert = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "property_can_revert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the setting specified by @name@ can have its value reverted to the default value, @false@ otherwise. When this method returns @true@, a Revert button will display next to the setting in the Editor Settings. property_can_revert :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> IO Bool property_can_revert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_property_can_revert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "property_can_revert" '[GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorSettings.property_can_revert {-# NOINLINE bindEditorSettings_property_get_revert #-} -- | Returns the default value of the setting specified by @name@. This is the value that would be applied when clicking the Revert button in the Editor Settings. bindEditorSettings_property_get_revert :: MethodBind bindEditorSettings_property_get_revert = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "property_get_revert" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the default value of the setting specified by @name@. This is the value that would be applied when clicking the Revert button in the Editor Settings. property_get_revert :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> IO GodotVariant property_get_revert cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_property_get_revert (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "property_get_revert" '[GodotString] (IO GodotVariant) where nodeMethod = Godot.Tools.EditorSettings.property_get_revert {-# NOINLINE bindEditorSettings_set_favorites #-} -- | Sets the list of favorite files and directories for this project. bindEditorSettings_set_favorites :: MethodBind bindEditorSettings_set_favorites = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "set_favorites" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the list of favorite files and directories for this project. set_favorites :: (EditorSettings :< cls, Object :< cls) => cls -> PoolStringArray -> IO () set_favorites cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_set_favorites (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "set_favorites" '[PoolStringArray] (IO ()) where nodeMethod = Godot.Tools.EditorSettings.set_favorites {-# NOINLINE bindEditorSettings_set_initial_value #-} -- | Sets the initial value of the setting specified by @name@ to @value@. This is used to provide a value for the Revert button in the Editor Settings. If @update_current@ is true, the current value of the setting will be set to @value@ as well. bindEditorSettings_set_initial_value :: MethodBind bindEditorSettings_set_initial_value = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "set_initial_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the initial value of the setting specified by @name@ to @value@. This is used to provide a value for the Revert button in the Editor Settings. If @update_current@ is true, the current value of the setting will be set to @value@ as well. set_initial_value :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> Bool -> IO () set_initial_value cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_set_initial_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "set_initial_value" '[GodotString, GodotVariant, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSettings.set_initial_value {-# NOINLINE bindEditorSettings_set_project_metadata #-} -- | Sets project-specific metadata with the @section@, @key@ and @data@ specified. This metadata is stored outside the project folder and therefore won't be checked into version control. See also @method get_project_metadata@. bindEditorSettings_set_project_metadata :: MethodBind bindEditorSettings_set_project_metadata = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "set_project_metadata" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets project-specific metadata with the @section@, @key@ and @data@ specified. This metadata is stored outside the project folder and therefore won't be checked into version control. See also @method get_project_metadata@. set_project_metadata :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> GodotString -> GodotVariant -> IO () set_project_metadata cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_set_project_metadata (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "set_project_metadata" '[GodotString, GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Tools.EditorSettings.set_project_metadata {-# NOINLINE bindEditorSettings_set_recent_dirs #-} -- | Sets the list of recently visited folders in the file dialog for this project. bindEditorSettings_set_recent_dirs :: MethodBind bindEditorSettings_set_recent_dirs = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "set_recent_dirs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the list of recently visited folders in the file dialog for this project. set_recent_dirs :: (EditorSettings :< cls, Object :< cls) => cls -> PoolStringArray -> IO () set_recent_dirs cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_set_recent_dirs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "set_recent_dirs" '[PoolStringArray] (IO ()) where nodeMethod = Godot.Tools.EditorSettings.set_recent_dirs {-# NOINLINE bindEditorSettings_set_setting #-} -- | Sets the @value@ of the setting specified by @name@. This is equivalent to using @method Object.set@ on the EditorSettings instance. bindEditorSettings_set_setting :: MethodBind bindEditorSettings_set_setting = unsafePerformIO $ withCString "EditorSettings" $ \ clsNamePtr -> withCString "set_setting" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the @value@ of the setting specified by @name@. This is equivalent to using @method Object.set@ on the EditorSettings instance. set_setting :: (EditorSettings :< cls, Object :< cls) => cls -> GodotString -> GodotVariant -> IO () set_setting cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSettings_set_setting (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSettings "set_setting" '[GodotString, GodotVariant] (IO ()) where nodeMethod = Godot.Tools.EditorSettings.set_setting ================================================ FILE: src/Godot/Tools/EditorSpatialGizmo.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorSpatialGizmo (Godot.Tools.EditorSpatialGizmo.add_collision_segments, Godot.Tools.EditorSpatialGizmo.add_collision_triangles, Godot.Tools.EditorSpatialGizmo.add_handles, Godot.Tools.EditorSpatialGizmo.add_lines, Godot.Tools.EditorSpatialGizmo.add_mesh, Godot.Tools.EditorSpatialGizmo.add_unscaled_billboard, Godot.Tools.EditorSpatialGizmo.clear, Godot.Tools.EditorSpatialGizmo.commit_handle, Godot.Tools.EditorSpatialGizmo.get_handle_name, Godot.Tools.EditorSpatialGizmo.get_handle_value, Godot.Tools.EditorSpatialGizmo.get_plugin, Godot.Tools.EditorSpatialGizmo.get_spatial_node, Godot.Tools.EditorSpatialGizmo.is_handle_highlighted, Godot.Tools.EditorSpatialGizmo.redraw, Godot.Tools.EditorSpatialGizmo.set_handle, Godot.Tools.EditorSpatialGizmo.set_hidden, Godot.Tools.EditorSpatialGizmo.set_spatial_node) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.SpatialGizmo() {-# NOINLINE bindEditorSpatialGizmo_add_collision_segments #-} -- | Adds the specified @segments@ to the gizmo's collision shape for picking. Call this function during @method redraw@. bindEditorSpatialGizmo_add_collision_segments :: MethodBind bindEditorSpatialGizmo_add_collision_segments = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "add_collision_segments" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds the specified @segments@ to the gizmo's collision shape for picking. Call this function during @method redraw@. add_collision_segments :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> PoolVector3Array -> IO () add_collision_segments cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_add_collision_segments (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "add_collision_segments" '[PoolVector3Array] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.add_collision_segments {-# NOINLINE bindEditorSpatialGizmo_add_collision_triangles #-} -- | Adds collision triangles to the gizmo for picking. A @TriangleMesh@ can be generated from a regular @Mesh@ too. Call this function during @method redraw@. bindEditorSpatialGizmo_add_collision_triangles :: MethodBind bindEditorSpatialGizmo_add_collision_triangles = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "add_collision_triangles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds collision triangles to the gizmo for picking. A @TriangleMesh@ can be generated from a regular @Mesh@ too. Call this function during @method redraw@. add_collision_triangles :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> TriangleMesh -> IO () add_collision_triangles cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_add_collision_triangles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "add_collision_triangles" '[TriangleMesh] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.add_collision_triangles {-# NOINLINE bindEditorSpatialGizmo_add_handles #-} -- | Adds a list of handles (points) which can be used to deform the object being edited. -- There are virtual functions which will be called upon editing of these handles. Call this function during @method redraw@. bindEditorSpatialGizmo_add_handles :: MethodBind bindEditorSpatialGizmo_add_handles = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "add_handles" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a list of handles (points) which can be used to deform the object being edited. -- There are virtual functions which will be called upon editing of these handles. Call this function during @method redraw@. add_handles :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> PoolVector3Array -> Material -> Maybe Bool -> Maybe Bool -> IO () add_handles cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3, maybe (VariantBool False) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_add_handles (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "add_handles" '[PoolVector3Array, Material, Maybe Bool, Maybe Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.add_handles {-# NOINLINE bindEditorSpatialGizmo_add_lines #-} -- | Adds lines to the gizmo (as sets of 2 points), with a given material. The lines are used for visualizing the gizmo. Call this function during @method redraw@. bindEditorSpatialGizmo_add_lines :: MethodBind bindEditorSpatialGizmo_add_lines = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "add_lines" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds lines to the gizmo (as sets of 2 points), with a given material. The lines are used for visualizing the gizmo. Call this function during @method redraw@. add_lines :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> PoolVector3Array -> Material -> Maybe Bool -> Maybe Color -> IO () add_lines cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_add_lines (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "add_lines" '[PoolVector3Array, Material, Maybe Bool, Maybe Color] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.add_lines {-# NOINLINE bindEditorSpatialGizmo_add_mesh #-} -- | Adds a mesh to the gizmo with the specified @billboard@ state, @skeleton@ and @material@. If @billboard@ is @true@, the mesh will rotate to always face the camera. Call this function during @method redraw@. bindEditorSpatialGizmo_add_mesh :: MethodBind bindEditorSpatialGizmo_add_mesh = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "add_mesh" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a mesh to the gizmo with the specified @billboard@ state, @skeleton@ and @material@. If @billboard@ is @true@, the mesh will rotate to always face the camera. Call this function during @method redraw@. add_mesh :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> ArrayMesh -> Maybe Bool -> Maybe SkinReference -> Maybe Material -> IO () add_mesh cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2, maybe VariantNil toVariant arg3, maybe VariantNil toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_add_mesh (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "add_mesh" '[ArrayMesh, Maybe Bool, Maybe SkinReference, Maybe Material] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.add_mesh {-# NOINLINE bindEditorSpatialGizmo_add_unscaled_billboard #-} -- | Adds an unscaled billboard for visualization. Call this function during @method redraw@. bindEditorSpatialGizmo_add_unscaled_billboard :: MethodBind bindEditorSpatialGizmo_add_unscaled_billboard = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "add_unscaled_billboard" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds an unscaled billboard for visualization. Call this function during @method redraw@. add_unscaled_billboard :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> Material -> Maybe Float -> Maybe Color -> IO () add_unscaled_billboard cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, maybe (VariantReal (1)) toVariant arg2, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_add_unscaled_billboard (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "add_unscaled_billboard" '[Material, Maybe Float, Maybe Color] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.add_unscaled_billboard {-# NOINLINE bindEditorSpatialGizmo_clear #-} -- | Removes everything in the gizmo including meshes, collisions and handles. bindEditorSpatialGizmo_clear :: MethodBind bindEditorSpatialGizmo_clear = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "clear" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Removes everything in the gizmo including meshes, collisions and handles. clear :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> IO () clear cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_clear (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "clear" '[] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.clear {-# NOINLINE bindEditorSpatialGizmo_commit_handle #-} -- | Commit a handle being edited (handles must have been previously added by @method add_handles@). -- If the @cancel@ parameter is @true@, an option to restore the edited value to the original is provided. bindEditorSpatialGizmo_commit_handle :: MethodBind bindEditorSpatialGizmo_commit_handle = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "commit_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Commit a handle being edited (handles must have been previously added by @method add_handles@). -- If the @cancel@ parameter is @true@, an option to restore the edited value to the original is provided. commit_handle :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> Int -> GodotVariant -> Bool -> IO () commit_handle cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_commit_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "commit_handle" '[Int, GodotVariant, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.commit_handle {-# NOINLINE bindEditorSpatialGizmo_get_handle_name #-} -- | Gets the name of an edited handle (handles must have been previously added by @method add_handles@). -- Handles can be named for reference to the user when editing. bindEditorSpatialGizmo_get_handle_name :: MethodBind bindEditorSpatialGizmo_get_handle_name = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "get_handle_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets the name of an edited handle (handles must have been previously added by @method add_handles@). -- Handles can be named for reference to the user when editing. get_handle_name :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> Int -> IO GodotString get_handle_name cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_get_handle_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "get_handle_name" '[Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorSpatialGizmo.get_handle_name {-# NOINLINE bindEditorSpatialGizmo_get_handle_value #-} -- | Gets actual value of a handle. This value can be anything and used for eventually undoing the motion when calling @method commit_handle@. bindEditorSpatialGizmo_get_handle_value :: MethodBind bindEditorSpatialGizmo_get_handle_value = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "get_handle_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets actual value of a handle. This value can be anything and used for eventually undoing the motion when calling @method commit_handle@. get_handle_value :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> Int -> IO GodotVariant get_handle_value cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_get_handle_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "get_handle_value" '[Int] (IO GodotVariant) where nodeMethod = Godot.Tools.EditorSpatialGizmo.get_handle_value {-# NOINLINE bindEditorSpatialGizmo_get_plugin #-} -- | Returns the @EditorSpatialGizmoPlugin@ that owns this gizmo. It's useful to retrieve materials using @method EditorSpatialGizmoPlugin.get_material@. bindEditorSpatialGizmo_get_plugin :: MethodBind bindEditorSpatialGizmo_get_plugin = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "get_plugin" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the @EditorSpatialGizmoPlugin@ that owns this gizmo. It's useful to retrieve materials using @method EditorSpatialGizmoPlugin.get_material@. get_plugin :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> IO EditorSpatialGizmoPlugin get_plugin cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_get_plugin (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "get_plugin" '[] (IO EditorSpatialGizmoPlugin) where nodeMethod = Godot.Tools.EditorSpatialGizmo.get_plugin {-# NOINLINE bindEditorSpatialGizmo_get_spatial_node #-} -- | Returns the Spatial node associated with this gizmo. bindEditorSpatialGizmo_get_spatial_node :: MethodBind bindEditorSpatialGizmo_get_spatial_node = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "get_spatial_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the Spatial node associated with this gizmo. get_spatial_node :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> IO Spatial get_spatial_node cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_get_spatial_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "get_spatial_node" '[] (IO Spatial) where nodeMethod = Godot.Tools.EditorSpatialGizmo.get_spatial_node {-# NOINLINE bindEditorSpatialGizmo_is_handle_highlighted #-} -- | Returns @true@ if the handle at index @index@ is highlighted by being hovered with the mouse. bindEditorSpatialGizmo_is_handle_highlighted :: MethodBind bindEditorSpatialGizmo_is_handle_highlighted = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "is_handle_highlighted" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the handle at index @index@ is highlighted by being hovered with the mouse. is_handle_highlighted :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> Int -> IO Bool is_handle_highlighted cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_is_handle_highlighted (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "is_handle_highlighted" '[Int] (IO Bool) where nodeMethod = Godot.Tools.EditorSpatialGizmo.is_handle_highlighted {-# NOINLINE bindEditorSpatialGizmo_redraw #-} -- | This function is called when the @Spatial@ this gizmo refers to changes (the @method Spatial.update_gizmo@ is called). bindEditorSpatialGizmo_redraw :: MethodBind bindEditorSpatialGizmo_redraw = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "redraw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This function is called when the @Spatial@ this gizmo refers to changes (the @method Spatial.update_gizmo@ is called). redraw :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> IO () redraw cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_redraw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "redraw" '[] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.redraw {-# NOINLINE bindEditorSpatialGizmo_set_handle #-} -- | This function is used when the user drags a gizmo handle (previously added with @method add_handles@) in screen coordinates. -- The @Camera@ is also provided so screen coordinates can be converted to raycasts. bindEditorSpatialGizmo_set_handle :: MethodBind bindEditorSpatialGizmo_set_handle = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "set_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | This function is used when the user drags a gizmo handle (previously added with @method add_handles@) in screen coordinates. -- The @Camera@ is also provided so screen coordinates can be converted to raycasts. set_handle :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> Int -> Camera -> Vector2 -> IO () set_handle cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_set_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "set_handle" '[Int, Camera, Vector2] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.set_handle {-# NOINLINE bindEditorSpatialGizmo_set_hidden #-} -- | Sets the gizmo's hidden state. If @true@, the gizmo will be hidden. If @false@, it will be shown. bindEditorSpatialGizmo_set_hidden :: MethodBind bindEditorSpatialGizmo_set_hidden = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "set_hidden" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the gizmo's hidden state. If @true@, the gizmo will be hidden. If @false@, it will be shown. set_hidden :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> Bool -> IO () set_hidden cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_set_hidden (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "set_hidden" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.set_hidden {-# NOINLINE bindEditorSpatialGizmo_set_spatial_node #-} -- | Sets the reference @Spatial@ node for the gizmo. @node@ must inherit from @Spatial@. bindEditorSpatialGizmo_set_spatial_node :: MethodBind bindEditorSpatialGizmo_set_spatial_node = unsafePerformIO $ withCString "EditorSpatialGizmo" $ \ clsNamePtr -> withCString "set_spatial_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Sets the reference @Spatial@ node for the gizmo. @node@ must inherit from @Spatial@. set_spatial_node :: (EditorSpatialGizmo :< cls, Object :< cls) => cls -> Node -> IO () set_spatial_node cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmo_set_spatial_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmo "set_spatial_node" '[Node] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmo.set_spatial_node ================================================ FILE: src/Godot/Tools/EditorSpatialGizmoPlugin.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorSpatialGizmoPlugin (Godot.Tools.EditorSpatialGizmoPlugin.add_material, Godot.Tools.EditorSpatialGizmoPlugin.can_be_hidden, Godot.Tools.EditorSpatialGizmoPlugin.commit_handle, Godot.Tools.EditorSpatialGizmoPlugin.create_gizmo, Godot.Tools.EditorSpatialGizmoPlugin.create_handle_material, Godot.Tools.EditorSpatialGizmoPlugin.create_icon_material, Godot.Tools.EditorSpatialGizmoPlugin.create_material, Godot.Tools.EditorSpatialGizmoPlugin.get_handle_name, Godot.Tools.EditorSpatialGizmoPlugin.get_handle_value, Godot.Tools.EditorSpatialGizmoPlugin.get_material, Godot.Tools.EditorSpatialGizmoPlugin.get_name, Godot.Tools.EditorSpatialGizmoPlugin.get_priority, Godot.Tools.EditorSpatialGizmoPlugin.has_gizmo, Godot.Tools.EditorSpatialGizmoPlugin.is_handle_highlighted, Godot.Tools.EditorSpatialGizmoPlugin.is_selectable_when_hidden, Godot.Tools.EditorSpatialGizmoPlugin.redraw, Godot.Tools.EditorSpatialGizmoPlugin.set_handle) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Resource() {-# NOINLINE bindEditorSpatialGizmoPlugin_add_material #-} -- | Adds a new material to the internal material list for the plugin. It can then be accessed with @method get_material@. Should not be overridden. bindEditorSpatialGizmoPlugin_add_material :: MethodBind bindEditorSpatialGizmoPlugin_add_material = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "add_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Adds a new material to the internal material list for the plugin. It can then be accessed with @method get_material@. Should not be overridden. add_material :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> GodotString -> SpatialMaterial -> IO () add_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_add_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "add_material" '[GodotString, SpatialMaterial] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.add_material {-# NOINLINE bindEditorSpatialGizmoPlugin_can_be_hidden #-} -- | Override this method to define whether the gizmo can be hidden or not. Returns @true@ if not overridden. bindEditorSpatialGizmoPlugin_can_be_hidden :: MethodBind bindEditorSpatialGizmoPlugin_can_be_hidden = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "can_be_hidden" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define whether the gizmo can be hidden or not. Returns @true@ if not overridden. can_be_hidden :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> IO Bool can_be_hidden cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_can_be_hidden (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "can_be_hidden" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.can_be_hidden {-# NOINLINE bindEditorSpatialGizmoPlugin_commit_handle #-} -- | Override this method to commit gizmo handles. Called for this plugin's active gizmos. bindEditorSpatialGizmoPlugin_commit_handle :: MethodBind bindEditorSpatialGizmoPlugin_commit_handle = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "commit_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to commit gizmo handles. Called for this plugin's active gizmos. commit_handle :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> EditorSpatialGizmo -> Int -> GodotVariant -> Bool -> IO () commit_handle cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_commit_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "commit_handle" '[EditorSpatialGizmo, Int, GodotVariant, Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.commit_handle {-# NOINLINE bindEditorSpatialGizmoPlugin_create_gizmo #-} -- | Override this method to return a custom @EditorSpatialGizmo@ for the spatial nodes of your choice, return @null@ for the rest of nodes. See also @method has_gizmo@. bindEditorSpatialGizmoPlugin_create_gizmo :: MethodBind bindEditorSpatialGizmoPlugin_create_gizmo = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "create_gizmo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to return a custom @EditorSpatialGizmo@ for the spatial nodes of your choice, return @null@ for the rest of nodes. See also @method has_gizmo@. create_gizmo :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> Spatial -> IO EditorSpatialGizmo create_gizmo cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_create_gizmo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "create_gizmo" '[Spatial] (IO EditorSpatialGizmo) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.create_gizmo {-# NOINLINE bindEditorSpatialGizmoPlugin_create_handle_material #-} -- | Creates a handle material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with @method get_material@ and used in @method EditorSpatialGizmo.add_handles@. Should not be overridden. bindEditorSpatialGizmoPlugin_create_handle_material :: MethodBind bindEditorSpatialGizmoPlugin_create_handle_material = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "create_handle_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a handle material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with @method get_material@ and used in @method EditorSpatialGizmo.add_handles@. Should not be overridden. create_handle_material :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> GodotString -> Maybe Bool -> IO () create_handle_material cls arg1 arg2 = withVariantArray [toVariant arg1, maybe (VariantBool False) toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_create_handle_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "create_handle_material" '[GodotString, Maybe Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.create_handle_material {-# NOINLINE bindEditorSpatialGizmoPlugin_create_icon_material #-} -- | Creates an icon material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with @method get_material@ and used in @method EditorSpatialGizmo.add_unscaled_billboard@. Should not be overridden. bindEditorSpatialGizmoPlugin_create_icon_material :: MethodBind bindEditorSpatialGizmoPlugin_create_icon_material = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "create_icon_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an icon material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with @method get_material@ and used in @method EditorSpatialGizmo.add_unscaled_billboard@. Should not be overridden. create_icon_material :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> GodotString -> Texture -> Maybe Bool -> Maybe Color -> IO () create_icon_material cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3, defaultedVariant VariantColor (withOpacity (sRGB 1 1 1) 1) arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_create_icon_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "create_icon_material" '[GodotString, Texture, Maybe Bool, Maybe Color] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.create_icon_material {-# NOINLINE bindEditorSpatialGizmoPlugin_create_material #-} -- | Creates an unshaded material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with @method get_material@ and used in @method EditorSpatialGizmo.add_mesh@ and @method EditorSpatialGizmo.add_lines@. Should not be overridden. bindEditorSpatialGizmoPlugin_create_material :: MethodBind bindEditorSpatialGizmoPlugin_create_material = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "create_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates an unshaded material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with @method get_material@ and used in @method EditorSpatialGizmo.add_mesh@ and @method EditorSpatialGizmo.add_lines@. Should not be overridden. create_material :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> GodotString -> Color -> Maybe Bool -> Maybe Bool -> Maybe Bool -> IO () create_material cls arg1 arg2 arg3 arg4 arg5 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool False) toVariant arg3, maybe (VariantBool False) toVariant arg4, maybe (VariantBool False) toVariant arg5] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_create_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "create_material" '[GodotString, Color, Maybe Bool, Maybe Bool, Maybe Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.create_material {-# NOINLINE bindEditorSpatialGizmoPlugin_get_handle_name #-} -- | Override this method to provide gizmo's handle names. Called for this plugin's active gizmos. bindEditorSpatialGizmoPlugin_get_handle_name :: MethodBind bindEditorSpatialGizmoPlugin_get_handle_name = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "get_handle_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to provide gizmo's handle names. Called for this plugin's active gizmos. get_handle_name :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> EditorSpatialGizmo -> Int -> IO GodotString get_handle_name cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_get_handle_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "get_handle_name" '[EditorSpatialGizmo, Int] (IO GodotString) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.get_handle_name {-# NOINLINE bindEditorSpatialGizmoPlugin_get_handle_value #-} -- | Gets actual value of a handle from gizmo. Called for this plugin's active gizmos. bindEditorSpatialGizmoPlugin_get_handle_value :: MethodBind bindEditorSpatialGizmoPlugin_get_handle_value = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "get_handle_value" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets actual value of a handle from gizmo. Called for this plugin's active gizmos. get_handle_value :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> EditorSpatialGizmo -> Int -> IO GodotVariant get_handle_value cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_get_handle_value (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "get_handle_value" '[EditorSpatialGizmo, Int] (IO GodotVariant) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.get_handle_value {-# NOINLINE bindEditorSpatialGizmoPlugin_get_material #-} -- | Gets material from the internal list of materials. If an @EditorSpatialGizmo@ is provided, it will try to get the corresponding variant (selected and/or editable). bindEditorSpatialGizmoPlugin_get_material :: MethodBind bindEditorSpatialGizmoPlugin_get_material = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "get_material" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets material from the internal list of materials. If an @EditorSpatialGizmo@ is provided, it will try to get the corresponding variant (selected and/or editable). get_material :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> GodotString -> EditorSpatialGizmo -> IO SpatialMaterial get_material cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_get_material (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "get_material" '[GodotString, EditorSpatialGizmo] (IO SpatialMaterial) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.get_material {-# NOINLINE bindEditorSpatialGizmoPlugin_get_name #-} -- | Override this method to provide the name that will appear in the gizmo visibility menu. bindEditorSpatialGizmoPlugin_get_name :: MethodBind bindEditorSpatialGizmoPlugin_get_name = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "get_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to provide the name that will appear in the gizmo visibility menu. get_name :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> IO GodotString get_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_get_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "get_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.get_name {-# NOINLINE bindEditorSpatialGizmoPlugin_get_priority #-} -- | Override this method to set the gizmo's priority. Higher values correspond to higher priority. If a gizmo with higher priority conflicts with another gizmo, only the gizmo with higher priority will be used. -- All built-in editor gizmos return a priority of @-1@. If not overridden, this method will return @0@, which means custom gizmos will automatically override built-in gizmos. bindEditorSpatialGizmoPlugin_get_priority :: MethodBind bindEditorSpatialGizmoPlugin_get_priority = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "get_priority" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to set the gizmo's priority. Higher values correspond to higher priority. If a gizmo with higher priority conflicts with another gizmo, only the gizmo with higher priority will be used. -- All built-in editor gizmos return a priority of @-1@. If not overridden, this method will return @0@, which means custom gizmos will automatically override built-in gizmos. get_priority :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> IO GodotString get_priority cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_get_priority (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "get_priority" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.get_priority {-# NOINLINE bindEditorSpatialGizmoPlugin_has_gizmo #-} -- | Override this method to define which Spatial nodes have a gizmo from this plugin. Whenever a @Spatial@ node is added to a scene this method is called, if it returns @true@ the node gets a generic @EditorSpatialGizmo@ assigned and is added to this plugin's list of active gizmos. bindEditorSpatialGizmoPlugin_has_gizmo :: MethodBind bindEditorSpatialGizmoPlugin_has_gizmo = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "has_gizmo" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define which Spatial nodes have a gizmo from this plugin. Whenever a @Spatial@ node is added to a scene this method is called, if it returns @true@ the node gets a generic @EditorSpatialGizmo@ assigned and is added to this plugin's list of active gizmos. has_gizmo :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> Spatial -> IO Bool has_gizmo cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_has_gizmo (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "has_gizmo" '[Spatial] (IO Bool) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.has_gizmo {-# NOINLINE bindEditorSpatialGizmoPlugin_is_handle_highlighted #-} -- | Gets whether a handle is highlighted or not. Called for this plugin's active gizmos. bindEditorSpatialGizmoPlugin_is_handle_highlighted :: MethodBind bindEditorSpatialGizmoPlugin_is_handle_highlighted = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "is_handle_highlighted" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Gets whether a handle is highlighted or not. Called for this plugin's active gizmos. is_handle_highlighted :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> EditorSpatialGizmo -> Int -> IO Bool is_handle_highlighted cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_is_handle_highlighted (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "is_handle_highlighted" '[EditorSpatialGizmo, Int] (IO Bool) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.is_handle_highlighted {-# NOINLINE bindEditorSpatialGizmoPlugin_is_selectable_when_hidden #-} -- | Override this method to define whether Spatial with this gizmo should be selecteble even when the gizmo is hidden. bindEditorSpatialGizmoPlugin_is_selectable_when_hidden :: MethodBind bindEditorSpatialGizmoPlugin_is_selectable_when_hidden = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "is_selectable_when_hidden" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Override this method to define whether Spatial with this gizmo should be selecteble even when the gizmo is hidden. is_selectable_when_hidden :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> IO Bool is_selectable_when_hidden cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_is_selectable_when_hidden (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "is_selectable_when_hidden" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.is_selectable_when_hidden {-# NOINLINE bindEditorSpatialGizmoPlugin_redraw #-} -- | Callback to redraw the provided gizmo. Called for this plugin's active gizmos. bindEditorSpatialGizmoPlugin_redraw :: MethodBind bindEditorSpatialGizmoPlugin_redraw = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "redraw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Callback to redraw the provided gizmo. Called for this plugin's active gizmos. redraw :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> EditorSpatialGizmo -> IO () redraw cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_redraw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "redraw" '[EditorSpatialGizmo] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.redraw {-# NOINLINE bindEditorSpatialGizmoPlugin_set_handle #-} -- | Update the value of a handle after it has been updated. Called for this plugin's active gizmos. bindEditorSpatialGizmoPlugin_set_handle :: MethodBind bindEditorSpatialGizmoPlugin_set_handle = unsafePerformIO $ withCString "EditorSpatialGizmoPlugin" $ \ clsNamePtr -> withCString "set_handle" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Update the value of a handle after it has been updated. Called for this plugin's active gizmos. set_handle :: (EditorSpatialGizmoPlugin :< cls, Object :< cls) => cls -> EditorSpatialGizmo -> Int -> Camera -> Vector2 -> IO () set_handle cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpatialGizmoPlugin_set_handle (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpatialGizmoPlugin "set_handle" '[EditorSpatialGizmo, Int, Camera, Vector2] (IO ()) where nodeMethod = Godot.Tools.EditorSpatialGizmoPlugin.set_handle ================================================ FILE: src/Godot/Tools/EditorSpinSlider.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorSpinSlider (Godot.Tools.EditorSpinSlider._grabber_gui_input, Godot.Tools.EditorSpinSlider._grabber_mouse_entered, Godot.Tools.EditorSpinSlider._grabber_mouse_exited, Godot.Tools.EditorSpinSlider._gui_input, Godot.Tools.EditorSpinSlider._value_focus_exited, Godot.Tools.EditorSpinSlider._value_input_closed, Godot.Tools.EditorSpinSlider._value_input_entered, Godot.Tools.EditorSpinSlider.get_label, Godot.Tools.EditorSpinSlider.is_flat, Godot.Tools.EditorSpinSlider.is_read_only, Godot.Tools.EditorSpinSlider.set_flat, Godot.Tools.EditorSpinSlider.set_label, Godot.Tools.EditorSpinSlider.set_read_only) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Range() instance NodeProperty EditorSpinSlider "flat" Bool 'False where nodeProperty = (is_flat, wrapDroppingSetter set_flat, Nothing) instance NodeProperty EditorSpinSlider "label" GodotString 'False where nodeProperty = (get_label, wrapDroppingSetter set_label, Nothing) instance NodeProperty EditorSpinSlider "read_only" Bool 'False where nodeProperty = (is_read_only, wrapDroppingSetter set_read_only, Nothing) {-# NOINLINE bindEditorSpinSlider__grabber_gui_input #-} bindEditorSpinSlider__grabber_gui_input :: MethodBind bindEditorSpinSlider__grabber_gui_input = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "_grabber_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _grabber_gui_input :: (EditorSpinSlider :< cls, Object :< cls) => cls -> InputEvent -> IO () _grabber_gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider__grabber_gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "_grabber_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider._grabber_gui_input {-# NOINLINE bindEditorSpinSlider__grabber_mouse_entered #-} bindEditorSpinSlider__grabber_mouse_entered :: MethodBind bindEditorSpinSlider__grabber_mouse_entered = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "_grabber_mouse_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _grabber_mouse_entered :: (EditorSpinSlider :< cls, Object :< cls) => cls -> IO () _grabber_mouse_entered cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider__grabber_mouse_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "_grabber_mouse_entered" '[] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider._grabber_mouse_entered {-# NOINLINE bindEditorSpinSlider__grabber_mouse_exited #-} bindEditorSpinSlider__grabber_mouse_exited :: MethodBind bindEditorSpinSlider__grabber_mouse_exited = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "_grabber_mouse_exited" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _grabber_mouse_exited :: (EditorSpinSlider :< cls, Object :< cls) => cls -> IO () _grabber_mouse_exited cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider__grabber_mouse_exited (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "_grabber_mouse_exited" '[] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider._grabber_mouse_exited {-# NOINLINE bindEditorSpinSlider__gui_input #-} bindEditorSpinSlider__gui_input :: MethodBind bindEditorSpinSlider__gui_input = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _gui_input :: (EditorSpinSlider :< cls, Object :< cls) => cls -> InputEvent -> IO () _gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider__gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider._gui_input {-# NOINLINE bindEditorSpinSlider__value_focus_exited #-} bindEditorSpinSlider__value_focus_exited :: MethodBind bindEditorSpinSlider__value_focus_exited = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "_value_focus_exited" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _value_focus_exited :: (EditorSpinSlider :< cls, Object :< cls) => cls -> IO () _value_focus_exited cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider__value_focus_exited (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "_value_focus_exited" '[] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider._value_focus_exited {-# NOINLINE bindEditorSpinSlider__value_input_closed #-} bindEditorSpinSlider__value_input_closed :: MethodBind bindEditorSpinSlider__value_input_closed = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "_value_input_closed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _value_input_closed :: (EditorSpinSlider :< cls, Object :< cls) => cls -> IO () _value_input_closed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider__value_input_closed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "_value_input_closed" '[] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider._value_input_closed {-# NOINLINE bindEditorSpinSlider__value_input_entered #-} bindEditorSpinSlider__value_input_entered :: MethodBind bindEditorSpinSlider__value_input_entered = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "_value_input_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _value_input_entered :: (EditorSpinSlider :< cls, Object :< cls) => cls -> GodotString -> IO () _value_input_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider__value_input_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "_value_input_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider._value_input_entered {-# NOINLINE bindEditorSpinSlider_get_label #-} bindEditorSpinSlider_get_label :: MethodBind bindEditorSpinSlider_get_label = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "get_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_label :: (EditorSpinSlider :< cls, Object :< cls) => cls -> IO GodotString get_label cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider_get_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "get_label" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorSpinSlider.get_label {-# NOINLINE bindEditorSpinSlider_is_flat #-} bindEditorSpinSlider_is_flat :: MethodBind bindEditorSpinSlider_is_flat = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "is_flat" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_flat :: (EditorSpinSlider :< cls, Object :< cls) => cls -> IO Bool is_flat cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider_is_flat (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "is_flat" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorSpinSlider.is_flat {-# NOINLINE bindEditorSpinSlider_is_read_only #-} bindEditorSpinSlider_is_read_only :: MethodBind bindEditorSpinSlider_is_read_only = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "is_read_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr is_read_only :: (EditorSpinSlider :< cls, Object :< cls) => cls -> IO Bool is_read_only cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider_is_read_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "is_read_only" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorSpinSlider.is_read_only {-# NOINLINE bindEditorSpinSlider_set_flat #-} bindEditorSpinSlider_set_flat :: MethodBind bindEditorSpinSlider_set_flat = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "set_flat" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_flat :: (EditorSpinSlider :< cls, Object :< cls) => cls -> Bool -> IO () set_flat cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider_set_flat (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "set_flat" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider.set_flat {-# NOINLINE bindEditorSpinSlider_set_label #-} bindEditorSpinSlider_set_label :: MethodBind bindEditorSpinSlider_set_label = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "set_label" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_label :: (EditorSpinSlider :< cls, Object :< cls) => cls -> GodotString -> IO () set_label cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider_set_label (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "set_label" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider.set_label {-# NOINLINE bindEditorSpinSlider_set_read_only #-} bindEditorSpinSlider_set_read_only :: MethodBind bindEditorSpinSlider_set_read_only = unsafePerformIO $ withCString "EditorSpinSlider" $ \ clsNamePtr -> withCString "set_read_only" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr set_read_only :: (EditorSpinSlider :< cls, Object :< cls) => cls -> Bool -> IO () set_read_only cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorSpinSlider_set_read_only (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorSpinSlider "set_read_only" '[Bool] (IO ()) where nodeMethod = Godot.Tools.EditorSpinSlider.set_read_only ================================================ FILE: src/Godot/Tools/EditorVCSInterface.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.EditorVCSInterface (Godot.Tools.EditorVCSInterface._commit, Godot.Tools.EditorVCSInterface._get_file_diff, Godot.Tools.EditorVCSInterface._get_modified_files_data, Godot.Tools.EditorVCSInterface._get_project_name, Godot.Tools.EditorVCSInterface._get_vcs_name, Godot.Tools.EditorVCSInterface._initialize, Godot.Tools.EditorVCSInterface._is_vcs_initialized, Godot.Tools.EditorVCSInterface._shut_down, Godot.Tools.EditorVCSInterface._stage_file, Godot.Tools.EditorVCSInterface._unstage_file, Godot.Tools.EditorVCSInterface.commit, Godot.Tools.EditorVCSInterface.get_file_diff, Godot.Tools.EditorVCSInterface.get_modified_files_data, Godot.Tools.EditorVCSInterface.get_project_name, Godot.Tools.EditorVCSInterface.get_vcs_name, Godot.Tools.EditorVCSInterface.initialize, Godot.Tools.EditorVCSInterface.is_addon_ready, Godot.Tools.EditorVCSInterface.is_vcs_initialized, Godot.Tools.EditorVCSInterface.shut_down, Godot.Tools.EditorVCSInterface.stage_file, Godot.Tools.EditorVCSInterface.unstage_file) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() {-# NOINLINE bindEditorVCSInterface__commit #-} bindEditorVCSInterface__commit :: MethodBind bindEditorVCSInterface__commit = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_commit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _commit :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO () _commit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__commit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_commit" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorVCSInterface._commit {-# NOINLINE bindEditorVCSInterface__get_file_diff #-} bindEditorVCSInterface__get_file_diff :: MethodBind bindEditorVCSInterface__get_file_diff = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_get_file_diff" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_file_diff :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO Array _get_file_diff cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__get_file_diff (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_get_file_diff" '[GodotString] (IO Array) where nodeMethod = Godot.Tools.EditorVCSInterface._get_file_diff {-# NOINLINE bindEditorVCSInterface__get_modified_files_data #-} bindEditorVCSInterface__get_modified_files_data :: MethodBind bindEditorVCSInterface__get_modified_files_data = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_get_modified_files_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_modified_files_data :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO Dictionary _get_modified_files_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__get_modified_files_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_get_modified_files_data" '[] (IO Dictionary) where nodeMethod = Godot.Tools.EditorVCSInterface._get_modified_files_data {-# NOINLINE bindEditorVCSInterface__get_project_name #-} bindEditorVCSInterface__get_project_name :: MethodBind bindEditorVCSInterface__get_project_name = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_get_project_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_project_name :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO GodotString _get_project_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__get_project_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_get_project_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorVCSInterface._get_project_name {-# NOINLINE bindEditorVCSInterface__get_vcs_name #-} bindEditorVCSInterface__get_vcs_name :: MethodBind bindEditorVCSInterface__get_vcs_name = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_get_vcs_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_vcs_name :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO GodotString _get_vcs_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__get_vcs_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_get_vcs_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorVCSInterface._get_vcs_name {-# NOINLINE bindEditorVCSInterface__initialize #-} bindEditorVCSInterface__initialize :: MethodBind bindEditorVCSInterface__initialize = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_initialize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _initialize :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO Bool _initialize cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__initialize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_initialize" '[GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorVCSInterface._initialize {-# NOINLINE bindEditorVCSInterface__is_vcs_initialized #-} bindEditorVCSInterface__is_vcs_initialized :: MethodBind bindEditorVCSInterface__is_vcs_initialized = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_is_vcs_initialized" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _is_vcs_initialized :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO Bool _is_vcs_initialized cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__is_vcs_initialized (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_is_vcs_initialized" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorVCSInterface._is_vcs_initialized {-# NOINLINE bindEditorVCSInterface__shut_down #-} bindEditorVCSInterface__shut_down :: MethodBind bindEditorVCSInterface__shut_down = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_shut_down" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _shut_down :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO Bool _shut_down cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__shut_down (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_shut_down" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorVCSInterface._shut_down {-# NOINLINE bindEditorVCSInterface__stage_file #-} bindEditorVCSInterface__stage_file :: MethodBind bindEditorVCSInterface__stage_file = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_stage_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _stage_file :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO () _stage_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__stage_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_stage_file" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorVCSInterface._stage_file {-# NOINLINE bindEditorVCSInterface__unstage_file #-} bindEditorVCSInterface__unstage_file :: MethodBind bindEditorVCSInterface__unstage_file = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "_unstage_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _unstage_file :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO () _unstage_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface__unstage_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "_unstage_file" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorVCSInterface._unstage_file {-# NOINLINE bindEditorVCSInterface_commit #-} -- | Creates a version commit if the addon is initialized, else returns without doing anything. Uses the files which have been staged previously, with the commit message set to a value as provided as in the argument. bindEditorVCSInterface_commit :: MethodBind bindEditorVCSInterface_commit = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "commit" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Creates a version commit if the addon is initialized, else returns without doing anything. Uses the files which have been staged previously, with the commit message set to a value as provided as in the argument. commit :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO () commit cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_commit (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "commit" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorVCSInterface.commit {-# NOINLINE bindEditorVCSInterface_get_file_diff #-} -- | Returns an @Array@ of @Dictionary@ objects containing the diff output from the VCS in use, if a VCS addon is initialized, else returns an empty @Array@ object. The diff contents also consist of some contextual lines which provide context to the observed line change in the file. -- Each @Dictionary@ object has the line diff contents under the keys: -- - @"content"@ to store a @String@ containing the line contents -- - @"status"@ to store a @String@ which contains @"+"@ in case the content is a line addition but it stores a @"-"@ in case of deletion and an empty string in the case the line content is neither an addition nor a deletion. -- - @"new_line_number"@ to store an integer containing the new line number of the line content. -- - @"line_count"@ to store an integer containing the number of lines in the line content. -- - @"old_line_number"@ to store an integer containing the old line number of the line content. -- - @"offset"@ to store the offset of the line change since the first contextual line content. bindEditorVCSInterface_get_file_diff :: MethodBind bindEditorVCSInterface_get_file_diff = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "get_file_diff" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an @Array@ of @Dictionary@ objects containing the diff output from the VCS in use, if a VCS addon is initialized, else returns an empty @Array@ object. The diff contents also consist of some contextual lines which provide context to the observed line change in the file. -- Each @Dictionary@ object has the line diff contents under the keys: -- - @"content"@ to store a @String@ containing the line contents -- - @"status"@ to store a @String@ which contains @"+"@ in case the content is a line addition but it stores a @"-"@ in case of deletion and an empty string in the case the line content is neither an addition nor a deletion. -- - @"new_line_number"@ to store an integer containing the new line number of the line content. -- - @"line_count"@ to store an integer containing the number of lines in the line content. -- - @"old_line_number"@ to store an integer containing the old line number of the line content. -- - @"offset"@ to store the offset of the line change since the first contextual line content. get_file_diff :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO Array get_file_diff cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_get_file_diff (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "get_file_diff" '[GodotString] (IO Array) where nodeMethod = Godot.Tools.EditorVCSInterface.get_file_diff {-# NOINLINE bindEditorVCSInterface_get_modified_files_data #-} -- | Returns a @Dictionary@ containing the path of the detected file change mapped to an integer signifying what kind of a change the corresponding file has experienced. -- The following integer values are being used to signify that the detected file is: -- - @0@: New to the VCS working directory -- - @1@: Modified -- - @2@: Renamed -- - @3@: Deleted -- - @4@: Typechanged bindEditorVCSInterface_get_modified_files_data :: MethodBind bindEditorVCSInterface_get_modified_files_data = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "get_modified_files_data" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @Dictionary@ containing the path of the detected file change mapped to an integer signifying what kind of a change the corresponding file has experienced. -- The following integer values are being used to signify that the detected file is: -- - @0@: New to the VCS working directory -- - @1@: Modified -- - @2@: Renamed -- - @3@: Deleted -- - @4@: Typechanged get_modified_files_data :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO Dictionary get_modified_files_data cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_get_modified_files_data (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "get_modified_files_data" '[] (IO Dictionary) where nodeMethod = Godot.Tools.EditorVCSInterface.get_modified_files_data {-# NOINLINE bindEditorVCSInterface_get_project_name #-} -- | Returns the project name of the VCS working directory. bindEditorVCSInterface_get_project_name :: MethodBind bindEditorVCSInterface_get_project_name = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "get_project_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the project name of the VCS working directory. get_project_name :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO GodotString get_project_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_get_project_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "get_project_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorVCSInterface.get_project_name {-# NOINLINE bindEditorVCSInterface_get_vcs_name #-} -- | Returns the name of the VCS if the VCS has been initialized, else return an empty string. bindEditorVCSInterface_get_vcs_name :: MethodBind bindEditorVCSInterface_get_vcs_name = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "get_vcs_name" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns the name of the VCS if the VCS has been initialized, else return an empty string. get_vcs_name :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO GodotString get_vcs_name cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_get_vcs_name (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "get_vcs_name" '[] (IO GodotString) where nodeMethod = Godot.Tools.EditorVCSInterface.get_vcs_name {-# NOINLINE bindEditorVCSInterface_initialize #-} -- | Initializes the VCS addon if not already. Uses the argument value as the path to the working directory of the project. Creates the initial commit if required. Returns @true@ if no failure occurs, else returns @false@. bindEditorVCSInterface_initialize :: MethodBind bindEditorVCSInterface_initialize = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "initialize" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Initializes the VCS addon if not already. Uses the argument value as the path to the working directory of the project. Creates the initial commit if required. Returns @true@ if no failure occurs, else returns @false@. initialize :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO Bool initialize cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_initialize (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "initialize" '[GodotString] (IO Bool) where nodeMethod = Godot.Tools.EditorVCSInterface.initialize {-# NOINLINE bindEditorVCSInterface_is_addon_ready #-} -- | Returns @true@ if the addon is ready to respond to function calls, else returns @false@. bindEditorVCSInterface_is_addon_ready :: MethodBind bindEditorVCSInterface_is_addon_ready = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "is_addon_ready" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the addon is ready to respond to function calls, else returns @false@. is_addon_ready :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO Bool is_addon_ready cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_is_addon_ready (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "is_addon_ready" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorVCSInterface.is_addon_ready {-# NOINLINE bindEditorVCSInterface_is_vcs_initialized #-} -- | Returns @true@ if the VCS addon has been initialized, else returns @false@. bindEditorVCSInterface_is_vcs_initialized :: MethodBind bindEditorVCSInterface_is_vcs_initialized = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "is_vcs_initialized" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns @true@ if the VCS addon has been initialized, else returns @false@. is_vcs_initialized :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO Bool is_vcs_initialized cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_is_vcs_initialized (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "is_vcs_initialized" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorVCSInterface.is_vcs_initialized {-# NOINLINE bindEditorVCSInterface_shut_down #-} -- | Shuts down the VCS addon to allow cleanup code to run on call. Returns @true@ is no failure occurs, else returns @false@. bindEditorVCSInterface_shut_down :: MethodBind bindEditorVCSInterface_shut_down = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "shut_down" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Shuts down the VCS addon to allow cleanup code to run on call. Returns @true@ is no failure occurs, else returns @false@. shut_down :: (EditorVCSInterface :< cls, Object :< cls) => cls -> IO Bool shut_down cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_shut_down (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "shut_down" '[] (IO Bool) where nodeMethod = Godot.Tools.EditorVCSInterface.shut_down {-# NOINLINE bindEditorVCSInterface_stage_file #-} -- | Stages the file which should be committed when @method EditorVCSInterface.commit@ is called. Argument should contain the absolute path. bindEditorVCSInterface_stage_file :: MethodBind bindEditorVCSInterface_stage_file = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "stage_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Stages the file which should be committed when @method EditorVCSInterface.commit@ is called. Argument should contain the absolute path. stage_file :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO () stage_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_stage_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "stage_file" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorVCSInterface.stage_file {-# NOINLINE bindEditorVCSInterface_unstage_file #-} -- | Unstages the file which was staged previously to be committed, so that it is no longer committed when @method EditorVCSInterface.commit@ is called. Argument should contain the absolute path. bindEditorVCSInterface_unstage_file :: MethodBind bindEditorVCSInterface_unstage_file = unsafePerformIO $ withCString "EditorVCSInterface" $ \ clsNamePtr -> withCString "unstage_file" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Unstages the file which was staged previously to be committed, so that it is no longer committed when @method EditorVCSInterface.commit@ is called. Argument should contain the absolute path. unstage_file :: (EditorVCSInterface :< cls, Object :< cls) => cls -> GodotString -> IO () unstage_file cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindEditorVCSInterface_unstage_file (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod EditorVCSInterface "unstage_file" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.EditorVCSInterface.unstage_file ================================================ FILE: src/Godot/Tools/ScriptCreateDialog.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.ScriptCreateDialog (Godot.Tools.ScriptCreateDialog.sig_script_created, Godot.Tools.ScriptCreateDialog._browse_class_in_tree, Godot.Tools.ScriptCreateDialog._browse_path, Godot.Tools.ScriptCreateDialog._built_in_pressed, Godot.Tools.ScriptCreateDialog._class_name_changed, Godot.Tools.ScriptCreateDialog._create, Godot.Tools.ScriptCreateDialog._file_selected, Godot.Tools.ScriptCreateDialog._lang_changed, Godot.Tools.ScriptCreateDialog._parent_name_changed, Godot.Tools.ScriptCreateDialog._path_changed, Godot.Tools.ScriptCreateDialog._path_entered, Godot.Tools.ScriptCreateDialog._path_hbox_sorted, Godot.Tools.ScriptCreateDialog._template_changed, Godot.Tools.ScriptCreateDialog.config) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.ConfirmationDialog() -- | Emitted when the user clicks the OK button. sig_script_created :: Godot.Internal.Dispatch.Signal ScriptCreateDialog sig_script_created = Godot.Internal.Dispatch.Signal "script_created" instance NodeSignal ScriptCreateDialog "script_created" '[Script] {-# NOINLINE bindScriptCreateDialog__browse_class_in_tree #-} bindScriptCreateDialog__browse_class_in_tree :: MethodBind bindScriptCreateDialog__browse_class_in_tree = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_browse_class_in_tree" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _browse_class_in_tree :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> IO () _browse_class_in_tree cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__browse_class_in_tree (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_browse_class_in_tree" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._browse_class_in_tree {-# NOINLINE bindScriptCreateDialog__browse_path #-} bindScriptCreateDialog__browse_path :: MethodBind bindScriptCreateDialog__browse_path = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_browse_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _browse_path :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> Bool -> Bool -> IO () _browse_path cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__browse_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_browse_path" '[Bool, Bool] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._browse_path {-# NOINLINE bindScriptCreateDialog__built_in_pressed #-} bindScriptCreateDialog__built_in_pressed :: MethodBind bindScriptCreateDialog__built_in_pressed = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_built_in_pressed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _built_in_pressed :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> IO () _built_in_pressed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__built_in_pressed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_built_in_pressed" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._built_in_pressed {-# NOINLINE bindScriptCreateDialog__class_name_changed #-} bindScriptCreateDialog__class_name_changed :: MethodBind bindScriptCreateDialog__class_name_changed = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_class_name_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _class_name_changed :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _class_name_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__class_name_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_class_name_changed" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._class_name_changed {-# NOINLINE bindScriptCreateDialog__create #-} bindScriptCreateDialog__create :: MethodBind bindScriptCreateDialog__create = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_create" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _create :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> IO () _create cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__create (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_create" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._create {-# NOINLINE bindScriptCreateDialog__file_selected #-} bindScriptCreateDialog__file_selected :: MethodBind bindScriptCreateDialog__file_selected = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_file_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _file_selected :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _file_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__file_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_file_selected" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._file_selected {-# NOINLINE bindScriptCreateDialog__lang_changed #-} bindScriptCreateDialog__lang_changed :: MethodBind bindScriptCreateDialog__lang_changed = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_lang_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _lang_changed :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> Int -> IO () _lang_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__lang_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_lang_changed" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._lang_changed {-# NOINLINE bindScriptCreateDialog__parent_name_changed #-} bindScriptCreateDialog__parent_name_changed :: MethodBind bindScriptCreateDialog__parent_name_changed = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_parent_name_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _parent_name_changed :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _parent_name_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__parent_name_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_parent_name_changed" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._parent_name_changed {-# NOINLINE bindScriptCreateDialog__path_changed #-} bindScriptCreateDialog__path_changed :: MethodBind bindScriptCreateDialog__path_changed = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_path_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _path_changed :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _path_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__path_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_path_changed" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._path_changed {-# NOINLINE bindScriptCreateDialog__path_entered #-} bindScriptCreateDialog__path_entered :: MethodBind bindScriptCreateDialog__path_entered = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_path_entered" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _path_entered :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> GodotString -> IO () _path_entered cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__path_entered (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_path_entered" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._path_entered {-# NOINLINE bindScriptCreateDialog__path_hbox_sorted #-} bindScriptCreateDialog__path_hbox_sorted :: MethodBind bindScriptCreateDialog__path_hbox_sorted = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_path_hbox_sorted" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _path_hbox_sorted :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> IO () _path_hbox_sorted cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__path_hbox_sorted (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_path_hbox_sorted" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._path_hbox_sorted {-# NOINLINE bindScriptCreateDialog__template_changed #-} bindScriptCreateDialog__template_changed :: MethodBind bindScriptCreateDialog__template_changed = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "_template_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _template_changed :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> Int -> IO () _template_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog__template_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "_template_changed" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog._template_changed {-# NOINLINE bindScriptCreateDialog_config #-} -- | Prefills required fields to configure the ScriptCreateDialog for use. bindScriptCreateDialog_config :: MethodBind bindScriptCreateDialog_config = unsafePerformIO $ withCString "ScriptCreateDialog" $ \ clsNamePtr -> withCString "config" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Prefills required fields to configure the ScriptCreateDialog for use. config :: (ScriptCreateDialog :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Maybe Bool -> Maybe Bool -> IO () config cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, maybe (VariantBool True) toVariant arg3, maybe (VariantBool True) toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindScriptCreateDialog_config (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptCreateDialog "config" '[GodotString, GodotString, Maybe Bool, Maybe Bool] (IO ()) where nodeMethod = Godot.Tools.ScriptCreateDialog.config ================================================ FILE: src/Godot/Tools/ScriptEditor.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.ScriptEditor (Godot.Tools.ScriptEditor.sig_editor_script_changed, Godot.Tools.ScriptEditor.sig_script_close, Godot.Tools.ScriptEditor._add_callback, Godot.Tools.ScriptEditor._autosave_scripts, Godot.Tools.ScriptEditor._breaked, Godot.Tools.ScriptEditor._clear_execution, Godot.Tools.ScriptEditor._close_all_tabs, Godot.Tools.ScriptEditor._close_current_tab, Godot.Tools.ScriptEditor._close_discard_current_tab, Godot.Tools.ScriptEditor._close_docs_tab, Godot.Tools.ScriptEditor._close_other_tabs, Godot.Tools.ScriptEditor._copy_script_path, Godot.Tools.ScriptEditor._editor_pause, Godot.Tools.ScriptEditor._editor_play, Godot.Tools.ScriptEditor._editor_settings_changed, Godot.Tools.ScriptEditor._editor_stop, Godot.Tools.ScriptEditor._file_dialog_action, Godot.Tools.ScriptEditor._filter_methods_text_changed, Godot.Tools.ScriptEditor._filter_scripts_text_changed, Godot.Tools.ScriptEditor._get_debug_tooltip, Godot.Tools.ScriptEditor._goto_script_line, Godot.Tools.ScriptEditor._goto_script_line2, Godot.Tools.ScriptEditor._help_class_goto, Godot.Tools.ScriptEditor._help_class_open, Godot.Tools.ScriptEditor._help_overview_selected, Godot.Tools.ScriptEditor._help_search, Godot.Tools.ScriptEditor._history_back, Godot.Tools.ScriptEditor._history_forward, Godot.Tools.ScriptEditor._live_auto_reload_running_scripts, Godot.Tools.ScriptEditor._members_overview_selected, Godot.Tools.ScriptEditor._menu_option, Godot.Tools.ScriptEditor._on_find_in_files_modified_files, Godot.Tools.ScriptEditor._on_find_in_files_requested, Godot.Tools.ScriptEditor._on_find_in_files_result_selected, Godot.Tools.ScriptEditor._open_recent_script, Godot.Tools.ScriptEditor._reload_scripts, Godot.Tools.ScriptEditor._request_help, Godot.Tools.ScriptEditor._res_saved_callback, Godot.Tools.ScriptEditor._resave_scripts, Godot.Tools.ScriptEditor._save_history, Godot.Tools.ScriptEditor._script_changed, Godot.Tools.ScriptEditor._script_created, Godot.Tools.ScriptEditor._script_list_gui_input, Godot.Tools.ScriptEditor._script_selected, Godot.Tools.ScriptEditor._script_split_dragged, Godot.Tools.ScriptEditor._set_execution, Godot.Tools.ScriptEditor._show_debugger, Godot.Tools.ScriptEditor._start_find_in_files, Godot.Tools.ScriptEditor._tab_changed, Godot.Tools.ScriptEditor._theme_option, Godot.Tools.ScriptEditor._toggle_members_overview_alpha_sort, Godot.Tools.ScriptEditor._tree_changed, Godot.Tools.ScriptEditor._unhandled_input, Godot.Tools.ScriptEditor._update_autosave_timer, Godot.Tools.ScriptEditor._update_members_overview, Godot.Tools.ScriptEditor._update_recent_scripts, Godot.Tools.ScriptEditor._update_script_connections, Godot.Tools.ScriptEditor._update_script_names, Godot.Tools.ScriptEditor.can_drop_data_fw, Godot.Tools.ScriptEditor.drop_data_fw, Godot.Tools.ScriptEditor.get_current_script, Godot.Tools.ScriptEditor.get_drag_data_fw, Godot.Tools.ScriptEditor.get_open_scripts, Godot.Tools.ScriptEditor.goto_line, Godot.Tools.ScriptEditor.open_script_create_dialog) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.PanelContainer() -- | Emitted when user changed active script. Argument is a freshly activated @Script@. sig_editor_script_changed :: Godot.Internal.Dispatch.Signal ScriptEditor sig_editor_script_changed = Godot.Internal.Dispatch.Signal "editor_script_changed" instance NodeSignal ScriptEditor "editor_script_changed" '[Script] -- | Emitted when editor is about to close the active script. Argument is a @Script@ that is going to be closed. sig_script_close :: Godot.Internal.Dispatch.Signal ScriptEditor sig_script_close = Godot.Internal.Dispatch.Signal "script_close" instance NodeSignal ScriptEditor "script_close" '[Script] {-# NOINLINE bindScriptEditor__add_callback #-} bindScriptEditor__add_callback :: MethodBind bindScriptEditor__add_callback = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_add_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _add_callback :: (ScriptEditor :< cls, Object :< cls) => cls -> Object -> GodotString -> PoolStringArray -> IO () _add_callback cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__add_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_add_callback" '[Object, GodotString, PoolStringArray] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._add_callback {-# NOINLINE bindScriptEditor__autosave_scripts #-} bindScriptEditor__autosave_scripts :: MethodBind bindScriptEditor__autosave_scripts = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_autosave_scripts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _autosave_scripts :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _autosave_scripts cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__autosave_scripts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_autosave_scripts" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._autosave_scripts {-# NOINLINE bindScriptEditor__breaked #-} bindScriptEditor__breaked :: MethodBind bindScriptEditor__breaked = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_breaked" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _breaked :: (ScriptEditor :< cls, Object :< cls) => cls -> Bool -> Bool -> IO () _breaked cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__breaked (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_breaked" '[Bool, Bool] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._breaked {-# NOINLINE bindScriptEditor__clear_execution #-} bindScriptEditor__clear_execution :: MethodBind bindScriptEditor__clear_execution = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_clear_execution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _clear_execution :: (ScriptEditor :< cls, Object :< cls) => cls -> Reference -> IO () _clear_execution cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__clear_execution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_clear_execution" '[Reference] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._clear_execution {-# NOINLINE bindScriptEditor__close_all_tabs #-} bindScriptEditor__close_all_tabs :: MethodBind bindScriptEditor__close_all_tabs = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_close_all_tabs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _close_all_tabs :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _close_all_tabs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__close_all_tabs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_close_all_tabs" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._close_all_tabs {-# NOINLINE bindScriptEditor__close_current_tab #-} bindScriptEditor__close_current_tab :: MethodBind bindScriptEditor__close_current_tab = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_close_current_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _close_current_tab :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _close_current_tab cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__close_current_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_close_current_tab" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._close_current_tab {-# NOINLINE bindScriptEditor__close_discard_current_tab #-} bindScriptEditor__close_discard_current_tab :: MethodBind bindScriptEditor__close_discard_current_tab = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_close_discard_current_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _close_discard_current_tab :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _close_discard_current_tab cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__close_discard_current_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_close_discard_current_tab" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._close_discard_current_tab {-# NOINLINE bindScriptEditor__close_docs_tab #-} bindScriptEditor__close_docs_tab :: MethodBind bindScriptEditor__close_docs_tab = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_close_docs_tab" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _close_docs_tab :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _close_docs_tab cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__close_docs_tab (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_close_docs_tab" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._close_docs_tab {-# NOINLINE bindScriptEditor__close_other_tabs #-} bindScriptEditor__close_other_tabs :: MethodBind bindScriptEditor__close_other_tabs = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_close_other_tabs" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _close_other_tabs :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _close_other_tabs cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__close_other_tabs (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_close_other_tabs" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._close_other_tabs {-# NOINLINE bindScriptEditor__copy_script_path #-} bindScriptEditor__copy_script_path :: MethodBind bindScriptEditor__copy_script_path = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_copy_script_path" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _copy_script_path :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _copy_script_path cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__copy_script_path (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_copy_script_path" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._copy_script_path {-# NOINLINE bindScriptEditor__editor_pause #-} bindScriptEditor__editor_pause :: MethodBind bindScriptEditor__editor_pause = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_editor_pause" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _editor_pause :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _editor_pause cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__editor_pause (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_editor_pause" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._editor_pause {-# NOINLINE bindScriptEditor__editor_play #-} bindScriptEditor__editor_play :: MethodBind bindScriptEditor__editor_play = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_editor_play" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _editor_play :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _editor_play cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__editor_play (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_editor_play" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._editor_play {-# NOINLINE bindScriptEditor__editor_settings_changed #-} bindScriptEditor__editor_settings_changed :: MethodBind bindScriptEditor__editor_settings_changed = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_editor_settings_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _editor_settings_changed :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _editor_settings_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__editor_settings_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_editor_settings_changed" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._editor_settings_changed {-# NOINLINE bindScriptEditor__editor_stop #-} bindScriptEditor__editor_stop :: MethodBind bindScriptEditor__editor_stop = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_editor_stop" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _editor_stop :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _editor_stop cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__editor_stop (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_editor_stop" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._editor_stop {-# NOINLINE bindScriptEditor__file_dialog_action #-} bindScriptEditor__file_dialog_action :: MethodBind bindScriptEditor__file_dialog_action = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_file_dialog_action" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _file_dialog_action :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _file_dialog_action cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__file_dialog_action (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_file_dialog_action" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._file_dialog_action {-# NOINLINE bindScriptEditor__filter_methods_text_changed #-} bindScriptEditor__filter_methods_text_changed :: MethodBind bindScriptEditor__filter_methods_text_changed = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_filter_methods_text_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _filter_methods_text_changed :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _filter_methods_text_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__filter_methods_text_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_filter_methods_text_changed" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._filter_methods_text_changed {-# NOINLINE bindScriptEditor__filter_scripts_text_changed #-} bindScriptEditor__filter_scripts_text_changed :: MethodBind bindScriptEditor__filter_scripts_text_changed = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_filter_scripts_text_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _filter_scripts_text_changed :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _filter_scripts_text_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__filter_scripts_text_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_filter_scripts_text_changed" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._filter_scripts_text_changed {-# NOINLINE bindScriptEditor__get_debug_tooltip #-} bindScriptEditor__get_debug_tooltip :: MethodBind bindScriptEditor__get_debug_tooltip = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_get_debug_tooltip" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _get_debug_tooltip :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> Node -> IO GodotString _get_debug_tooltip cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__get_debug_tooltip (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_get_debug_tooltip" '[GodotString, Node] (IO GodotString) where nodeMethod = Godot.Tools.ScriptEditor._get_debug_tooltip {-# NOINLINE bindScriptEditor__goto_script_line #-} bindScriptEditor__goto_script_line :: MethodBind bindScriptEditor__goto_script_line = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_goto_script_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _goto_script_line :: (ScriptEditor :< cls, Object :< cls) => cls -> Reference -> Int -> IO () _goto_script_line cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__goto_script_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_goto_script_line" '[Reference, Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._goto_script_line {-# NOINLINE bindScriptEditor__goto_script_line2 #-} bindScriptEditor__goto_script_line2 :: MethodBind bindScriptEditor__goto_script_line2 = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_goto_script_line2" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _goto_script_line2 :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () _goto_script_line2 cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__goto_script_line2 (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_goto_script_line2" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._goto_script_line2 {-# NOINLINE bindScriptEditor__help_class_goto #-} bindScriptEditor__help_class_goto :: MethodBind bindScriptEditor__help_class_goto = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_help_class_goto" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _help_class_goto :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _help_class_goto cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__help_class_goto (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_help_class_goto" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._help_class_goto {-# NOINLINE bindScriptEditor__help_class_open #-} bindScriptEditor__help_class_open :: MethodBind bindScriptEditor__help_class_open = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_help_class_open" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _help_class_open :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _help_class_open cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__help_class_open (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_help_class_open" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._help_class_open {-# NOINLINE bindScriptEditor__help_overview_selected #-} bindScriptEditor__help_overview_selected :: MethodBind bindScriptEditor__help_overview_selected = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_help_overview_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _help_overview_selected :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () _help_overview_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__help_overview_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_help_overview_selected" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._help_overview_selected {-# NOINLINE bindScriptEditor__help_search #-} bindScriptEditor__help_search :: MethodBind bindScriptEditor__help_search = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_help_search" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _help_search :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _help_search cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__help_search (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_help_search" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._help_search {-# NOINLINE bindScriptEditor__history_back #-} bindScriptEditor__history_back :: MethodBind bindScriptEditor__history_back = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_history_back" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _history_back :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _history_back cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__history_back (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_history_back" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._history_back {-# NOINLINE bindScriptEditor__history_forward #-} bindScriptEditor__history_forward :: MethodBind bindScriptEditor__history_forward = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_history_forward" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _history_forward :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _history_forward cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__history_forward (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_history_forward" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._history_forward {-# NOINLINE bindScriptEditor__live_auto_reload_running_scripts #-} bindScriptEditor__live_auto_reload_running_scripts :: MethodBind bindScriptEditor__live_auto_reload_running_scripts = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_live_auto_reload_running_scripts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _live_auto_reload_running_scripts :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _live_auto_reload_running_scripts cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__live_auto_reload_running_scripts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_live_auto_reload_running_scripts" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._live_auto_reload_running_scripts {-# NOINLINE bindScriptEditor__members_overview_selected #-} bindScriptEditor__members_overview_selected :: MethodBind bindScriptEditor__members_overview_selected = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_members_overview_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _members_overview_selected :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () _members_overview_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__members_overview_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_members_overview_selected" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._members_overview_selected {-# NOINLINE bindScriptEditor__menu_option #-} bindScriptEditor__menu_option :: MethodBind bindScriptEditor__menu_option = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_menu_option" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _menu_option :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () _menu_option cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__menu_option (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_menu_option" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._menu_option {-# NOINLINE bindScriptEditor__on_find_in_files_modified_files #-} bindScriptEditor__on_find_in_files_modified_files :: MethodBind bindScriptEditor__on_find_in_files_modified_files = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_on_find_in_files_modified_files" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _on_find_in_files_modified_files :: (ScriptEditor :< cls, Object :< cls) => cls -> PoolStringArray -> IO () _on_find_in_files_modified_files cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__on_find_in_files_modified_files (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_on_find_in_files_modified_files" '[PoolStringArray] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._on_find_in_files_modified_files {-# NOINLINE bindScriptEditor__on_find_in_files_requested #-} bindScriptEditor__on_find_in_files_requested :: MethodBind bindScriptEditor__on_find_in_files_requested = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_on_find_in_files_requested" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _on_find_in_files_requested :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _on_find_in_files_requested cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__on_find_in_files_requested (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_on_find_in_files_requested" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._on_find_in_files_requested {-# NOINLINE bindScriptEditor__on_find_in_files_result_selected #-} bindScriptEditor__on_find_in_files_result_selected :: MethodBind bindScriptEditor__on_find_in_files_result_selected = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_on_find_in_files_result_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _on_find_in_files_result_selected :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> Int -> Int -> Int -> IO () _on_find_in_files_result_selected cls arg1 arg2 arg3 arg4 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__on_find_in_files_result_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_on_find_in_files_result_selected" '[GodotString, Int, Int, Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._on_find_in_files_result_selected {-# NOINLINE bindScriptEditor__open_recent_script #-} bindScriptEditor__open_recent_script :: MethodBind bindScriptEditor__open_recent_script = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_open_recent_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _open_recent_script :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () _open_recent_script cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__open_recent_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_open_recent_script" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._open_recent_script {-# NOINLINE bindScriptEditor__reload_scripts #-} bindScriptEditor__reload_scripts :: MethodBind bindScriptEditor__reload_scripts = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_reload_scripts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _reload_scripts :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _reload_scripts cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__reload_scripts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_reload_scripts" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._reload_scripts {-# NOINLINE bindScriptEditor__request_help #-} bindScriptEditor__request_help :: MethodBind bindScriptEditor__request_help = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_request_help" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _request_help :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _request_help cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__request_help (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_request_help" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._request_help {-# NOINLINE bindScriptEditor__res_saved_callback #-} bindScriptEditor__res_saved_callback :: MethodBind bindScriptEditor__res_saved_callback = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_res_saved_callback" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _res_saved_callback :: (ScriptEditor :< cls, Object :< cls) => cls -> Resource -> IO () _res_saved_callback cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__res_saved_callback (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_res_saved_callback" '[Resource] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._res_saved_callback {-# NOINLINE bindScriptEditor__resave_scripts #-} bindScriptEditor__resave_scripts :: MethodBind bindScriptEditor__resave_scripts = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_resave_scripts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _resave_scripts :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> IO () _resave_scripts cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__resave_scripts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_resave_scripts" '[GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._resave_scripts {-# NOINLINE bindScriptEditor__save_history #-} bindScriptEditor__save_history :: MethodBind bindScriptEditor__save_history = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_save_history" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _save_history :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _save_history cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__save_history (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_save_history" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._save_history {-# NOINLINE bindScriptEditor__script_changed #-} bindScriptEditor__script_changed :: MethodBind bindScriptEditor__script_changed = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_script_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _script_changed :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _script_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__script_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_script_changed" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._script_changed {-# NOINLINE bindScriptEditor__script_created #-} bindScriptEditor__script_created :: MethodBind bindScriptEditor__script_created = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_script_created" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _script_created :: (ScriptEditor :< cls, Object :< cls) => cls -> Script -> IO () _script_created cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__script_created (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_script_created" '[Script] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._script_created {-# NOINLINE bindScriptEditor__script_list_gui_input #-} bindScriptEditor__script_list_gui_input :: MethodBind bindScriptEditor__script_list_gui_input = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_script_list_gui_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _script_list_gui_input :: (ScriptEditor :< cls, Object :< cls) => cls -> InputEvent -> IO () _script_list_gui_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__script_list_gui_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_script_list_gui_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._script_list_gui_input {-# NOINLINE bindScriptEditor__script_selected #-} bindScriptEditor__script_selected :: MethodBind bindScriptEditor__script_selected = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_script_selected" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _script_selected :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () _script_selected cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__script_selected (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_script_selected" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._script_selected {-# NOINLINE bindScriptEditor__script_split_dragged #-} bindScriptEditor__script_split_dragged :: MethodBind bindScriptEditor__script_split_dragged = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_script_split_dragged" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _script_split_dragged :: (ScriptEditor :< cls, Object :< cls) => cls -> Float -> IO () _script_split_dragged cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__script_split_dragged (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_script_split_dragged" '[Float] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._script_split_dragged {-# NOINLINE bindScriptEditor__set_execution #-} bindScriptEditor__set_execution :: MethodBind bindScriptEditor__set_execution = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_set_execution" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _set_execution :: (ScriptEditor :< cls, Object :< cls) => cls -> Reference -> Int -> IO () _set_execution cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__set_execution (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_set_execution" '[Reference, Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._set_execution {-# NOINLINE bindScriptEditor__show_debugger #-} bindScriptEditor__show_debugger :: MethodBind bindScriptEditor__show_debugger = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_show_debugger" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _show_debugger :: (ScriptEditor :< cls, Object :< cls) => cls -> Bool -> IO () _show_debugger cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__show_debugger (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_show_debugger" '[Bool] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._show_debugger {-# NOINLINE bindScriptEditor__start_find_in_files #-} bindScriptEditor__start_find_in_files :: MethodBind bindScriptEditor__start_find_in_files = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_start_find_in_files" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _start_find_in_files :: (ScriptEditor :< cls, Object :< cls) => cls -> Bool -> IO () _start_find_in_files cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__start_find_in_files (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_start_find_in_files" '[Bool] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._start_find_in_files {-# NOINLINE bindScriptEditor__tab_changed #-} bindScriptEditor__tab_changed :: MethodBind bindScriptEditor__tab_changed = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_tab_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tab_changed :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () _tab_changed cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__tab_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_tab_changed" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._tab_changed {-# NOINLINE bindScriptEditor__theme_option #-} bindScriptEditor__theme_option :: MethodBind bindScriptEditor__theme_option = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_theme_option" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _theme_option :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () _theme_option cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__theme_option (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_theme_option" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._theme_option {-# NOINLINE bindScriptEditor__toggle_members_overview_alpha_sort #-} bindScriptEditor__toggle_members_overview_alpha_sort :: MethodBind bindScriptEditor__toggle_members_overview_alpha_sort = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_toggle_members_overview_alpha_sort" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _toggle_members_overview_alpha_sort :: (ScriptEditor :< cls, Object :< cls) => cls -> Bool -> IO () _toggle_members_overview_alpha_sort cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__toggle_members_overview_alpha_sort (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_toggle_members_overview_alpha_sort" '[Bool] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._toggle_members_overview_alpha_sort {-# NOINLINE bindScriptEditor__tree_changed #-} bindScriptEditor__tree_changed :: MethodBind bindScriptEditor__tree_changed = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_tree_changed" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _tree_changed :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _tree_changed cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__tree_changed (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_tree_changed" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._tree_changed {-# NOINLINE bindScriptEditor__unhandled_input #-} bindScriptEditor__unhandled_input :: MethodBind bindScriptEditor__unhandled_input = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_unhandled_input" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _unhandled_input :: (ScriptEditor :< cls, Object :< cls) => cls -> InputEvent -> IO () _unhandled_input cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__unhandled_input (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_unhandled_input" '[InputEvent] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._unhandled_input {-# NOINLINE bindScriptEditor__update_autosave_timer #-} bindScriptEditor__update_autosave_timer :: MethodBind bindScriptEditor__update_autosave_timer = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_update_autosave_timer" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_autosave_timer :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _update_autosave_timer cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__update_autosave_timer (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_update_autosave_timer" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._update_autosave_timer {-# NOINLINE bindScriptEditor__update_members_overview #-} bindScriptEditor__update_members_overview :: MethodBind bindScriptEditor__update_members_overview = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_update_members_overview" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_members_overview :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _update_members_overview cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__update_members_overview (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_update_members_overview" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._update_members_overview {-# NOINLINE bindScriptEditor__update_recent_scripts #-} bindScriptEditor__update_recent_scripts :: MethodBind bindScriptEditor__update_recent_scripts = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_update_recent_scripts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_recent_scripts :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _update_recent_scripts cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__update_recent_scripts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_update_recent_scripts" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._update_recent_scripts {-# NOINLINE bindScriptEditor__update_script_connections #-} bindScriptEditor__update_script_connections :: MethodBind bindScriptEditor__update_script_connections = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_update_script_connections" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_script_connections :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _update_script_connections cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__update_script_connections (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_update_script_connections" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._update_script_connections {-# NOINLINE bindScriptEditor__update_script_names #-} bindScriptEditor__update_script_names :: MethodBind bindScriptEditor__update_script_names = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "_update_script_names" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr _update_script_names :: (ScriptEditor :< cls, Object :< cls) => cls -> IO () _update_script_names cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor__update_script_names (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "_update_script_names" '[] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor._update_script_names {-# NOINLINE bindScriptEditor_can_drop_data_fw #-} bindScriptEditor_can_drop_data_fw :: MethodBind bindScriptEditor_can_drop_data_fw = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "can_drop_data_fw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr can_drop_data_fw :: (ScriptEditor :< cls, Object :< cls) => cls -> Vector2 -> GodotVariant -> Control -> IO Bool can_drop_data_fw cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor_can_drop_data_fw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "can_drop_data_fw" '[Vector2, GodotVariant, Control] (IO Bool) where nodeMethod = Godot.Tools.ScriptEditor.can_drop_data_fw {-# NOINLINE bindScriptEditor_drop_data_fw #-} bindScriptEditor_drop_data_fw :: MethodBind bindScriptEditor_drop_data_fw = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "drop_data_fw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr drop_data_fw :: (ScriptEditor :< cls, Object :< cls) => cls -> Vector2 -> GodotVariant -> Control -> IO () drop_data_fw cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor_drop_data_fw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "drop_data_fw" '[Vector2, GodotVariant, Control] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor.drop_data_fw {-# NOINLINE bindScriptEditor_get_current_script #-} -- | Returns a @Script@ that is currently active in editor. bindScriptEditor_get_current_script :: MethodBind bindScriptEditor_get_current_script = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "get_current_script" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns a @Script@ that is currently active in editor. get_current_script :: (ScriptEditor :< cls, Object :< cls) => cls -> IO Script get_current_script cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor_get_current_script (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "get_current_script" '[] (IO Script) where nodeMethod = Godot.Tools.ScriptEditor.get_current_script {-# NOINLINE bindScriptEditor_get_drag_data_fw #-} bindScriptEditor_get_drag_data_fw :: MethodBind bindScriptEditor_get_drag_data_fw = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "get_drag_data_fw" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr get_drag_data_fw :: (ScriptEditor :< cls, Object :< cls) => cls -> Vector2 -> Control -> IO GodotVariant get_drag_data_fw cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor_get_drag_data_fw (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "get_drag_data_fw" '[Vector2, Control] (IO GodotVariant) where nodeMethod = Godot.Tools.ScriptEditor.get_drag_data_fw {-# NOINLINE bindScriptEditor_get_open_scripts #-} -- | Returns an array with all @Script@ objects which are currently open in editor. bindScriptEditor_get_open_scripts :: MethodBind bindScriptEditor_get_open_scripts = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "get_open_scripts" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Returns an array with all @Script@ objects which are currently open in editor. get_open_scripts :: (ScriptEditor :< cls, Object :< cls) => cls -> IO Array get_open_scripts cls = withVariantArray [] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor_get_open_scripts (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "get_open_scripts" '[] (IO Array) where nodeMethod = Godot.Tools.ScriptEditor.get_open_scripts {-# NOINLINE bindScriptEditor_goto_line #-} -- | Goes to the specified line in the current script. bindScriptEditor_goto_line :: MethodBind bindScriptEditor_goto_line = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "goto_line" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr -- | Goes to the specified line in the current script. goto_line :: (ScriptEditor :< cls, Object :< cls) => cls -> Int -> IO () goto_line cls arg1 = withVariantArray [toVariant arg1] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor_goto_line (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "goto_line" '[Int] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor.goto_line {-# NOINLINE bindScriptEditor_open_script_create_dialog #-} bindScriptEditor_open_script_create_dialog :: MethodBind bindScriptEditor_open_script_create_dialog = unsafePerformIO $ withCString "ScriptEditor" $ \ clsNamePtr -> withCString "open_script_create_dialog" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr open_script_create_dialog :: (ScriptEditor :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () open_script_create_dialog cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindScriptEditor_open_script_create_dialog (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod ScriptEditor "open_script_create_dialog" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Tools.ScriptEditor.open_script_create_dialog ================================================ FILE: src/Godot/Tools/VisualScriptEditor.hs ================================================ {-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators, FlexibleContexts, DataKinds, MultiParamTypeClasses #-} module Godot.Tools.VisualScriptEditor (Godot.Tools.VisualScriptEditor.sig_custom_nodes_updated, Godot.Tools.VisualScriptEditor.add_custom_node, Godot.Tools.VisualScriptEditor.remove_custom_node) where import Data.Coerce import Foreign.C import Godot.Internal.Dispatch import qualified Data.Vector as V import Linear(V2(..),V3(..),M22) import Data.Colour(withOpacity) import Data.Colour.SRGB(sRGB) import System.IO.Unsafe import Godot.Gdnative.Internal import Godot.Api.Types import Godot.Core.Object() sig_custom_nodes_updated :: Godot.Internal.Dispatch.Signal VisualScriptEditor sig_custom_nodes_updated = Godot.Internal.Dispatch.Signal "custom_nodes_updated" instance NodeSignal VisualScriptEditor "custom_nodes_updated" '[] {-# NOINLINE bindVisualScriptEditor_add_custom_node #-} bindVisualScriptEditor_add_custom_node :: MethodBind bindVisualScriptEditor_add_custom_node = unsafePerformIO $ withCString "_VisualScriptEditor" $ \ clsNamePtr -> withCString "add_custom_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr add_custom_node :: (VisualScriptEditor :< cls, Object :< cls) => cls -> GodotString -> GodotString -> Script -> IO () add_custom_node cls arg1 arg2 arg3 = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptEditor_add_custom_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptEditor "add_custom_node" '[GodotString, GodotString, Script] (IO ()) where nodeMethod = Godot.Tools.VisualScriptEditor.add_custom_node {-# NOINLINE bindVisualScriptEditor_remove_custom_node #-} bindVisualScriptEditor_remove_custom_node :: MethodBind bindVisualScriptEditor_remove_custom_node = unsafePerformIO $ withCString "_VisualScriptEditor" $ \ clsNamePtr -> withCString "remove_custom_node" $ \ methodNamePtr -> godot_method_bind_get_method clsNamePtr methodNamePtr remove_custom_node :: (VisualScriptEditor :< cls, Object :< cls) => cls -> GodotString -> GodotString -> IO () remove_custom_node cls arg1 arg2 = withVariantArray [toVariant arg1, toVariant arg2] (\ (arrPtr, len) -> godot_method_bind_call bindVisualScriptEditor_remove_custom_node (upcast cls) arrPtr len >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res) instance NodeMethod VisualScriptEditor "remove_custom_node" '[GodotString, GodotString] (IO ()) where nodeMethod = Godot.Tools.VisualScriptEditor.remove_custom_node ================================================ FILE: src/Godot.hs ================================================ module Godot ( module M ) where import Godot.Api as M hiding (NativeScript) -- Has all Godot classes import Godot.Nativescript as M import Godot.Internal.Dispatch as M ( (:<) -- For generic functions -- Required for creating Godot classes , HasBaseClass(..) -- Needed for up-casting objects , upcast -- , NodeMethod(..) , NodeSignal(..) , NodeProperty(..) ) -- Better to export these now than to inevitably have the user dig through the -- whole library in search of them. import Godot.Gdnative.Internal.Gdnative as M ( Object , Aabb , Array , Basis , GodotBool , CharString , CharType , Color , Dictionary , Error(..) , GodotInt , MethodBind , NodePath , Plane , PoolArrayReadAccess , PoolArrayWriteAccess , PoolByteArray , PoolColorArray , PoolIntArray , PoolRealArray , PoolStringArray , PoolVector2Array , PoolVector3Array , Quat , GodotReal , Rect2 , Rid , GodotString , StringName , Transform , Transform2d , GodotVariant , VariantCallErrorError(..) , VariantOperator(..) , VariantType(..) , Vector2 , Vector3 , Vector3Axis(..) ) -- These will always be needed when writing Godot class methods import Godot.Gdnative.Internal.Types as M ( fromGodotVariant , fromLowLevel , toLowLevel , toVariant ) -- These are needed in order to keep data between callbacks since we don't pass -- state back and forth between Haskell and Godot. import Control.Concurrent.MVar as M -- We use Text as the Haskell equivalent of GodotString import Data.Text as M ( Text ) ================================================ FILE: src-generate/Generate.hs ================================================ {-# LANGUAGE TemplateHaskell, OverloadedStrings, ViewPatterns, DeriveFunctor, TypeApplications #-} module Generate where import Control.Lens import Control.Monad import Data.Coerce import qualified Data.HashMap.Lazy as HM import Data.Map (Map) import qualified Data.Map as M import Data.Monoid import qualified Data.Vector as V import qualified Data.Text as T import Text.Casing import Foreign import Foreign.C import Language.Haskell.TH import Language.Haskell.TH.Syntax import Text.PrettyPrint.ANSI.Leijen ((<+>)) import qualified Text.PrettyPrint.ANSI.Leijen as PP import qualified Spec as S import qualified Types as C -- a simple type corresponds to a 1:1 haskell type -- a c shim type can't be represented by the haskell FFI, so it needs to be shimmed -- an opaque type needs to be withForeignPtr'd (modulo newtype) data TypeResult a = SimpleType a | EnumType a | OpaqueType Bool a -- Bool == needs C shim | StorableType Bool a deriving (Show, Eq, Ord, Functor) isCShimType :: TypeResult a -> Bool isCShimType (OpaqueType b _) = b isCShimType (StorableType b _) = b isCShimType _ = False makePrisms ''TypeResult unTypeResult :: TypeResult a -> a unTypeResult (SimpleType a) = a unTypeResult (EnumType a) = a unTypeResult (OpaqueType _ a) = a unTypeResult (StorableType _ a) = a fromThName :: Name -> Type fromThName = ConT -- from inline-c baseTypesTable :: Map C.TypeSpecifier Type baseTypesTable = M.fromList [ (C.Void, TupleT 0) -- Types from Foreign.C.Types in the order in which they are presented there, -- along with its documentation's section headers. -- Integral types , (C.Char Nothing, fromThName ''CChar) , (C.Char (Just C.Signed), fromThName ''CSChar) , (C.Char (Just C.Unsigned), fromThName ''CUChar) , (C.Short C.Signed, fromThName ''CShort) , (C.Short C.Unsigned, fromThName ''CUShort) , (C.Int C.Signed, fromThName ''CInt) , (C.Int C.Unsigned, fromThName ''CUInt) , (C.Long C.Signed, fromThName ''CLong) , (C.Long C.Unsigned, fromThName ''CULong) , (C.TypeName "ptrdiff_t", fromThName ''CPtrdiff) , (C.TypeName "size_t", fromThName ''CSize) , (C.TypeName "wchar_t", fromThName ''CWchar) , (C.TypeName "sig_atomic_t", fromThName ''CSigAtomic) , (C.LLong C.Signed, fromThName ''CLLong) , (C.LLong C.Unsigned, fromThName ''CULLong) , (C.TypeName "intptr_t", fromThName ''CIntPtr) , (C.TypeName "uintptr_t", fromThName ''CUIntPtr) , (C.TypeName "intmax_t", fromThName ''CIntMax) , (C.TypeName "uintmax_t", fromThName ''CUIntMax) -- Numeric types , (C.TypeName "clock_t", fromThName ''CClock) , (C.TypeName "time_t", fromThName ''CTime) , (C.TypeName "useconds_t", fromThName ''CUSeconds) , (C.TypeName "suseconds_t", fromThName ''CSUSeconds) -- Floating types , (C.Float, fromThName ''CFloat) , (C.Double, fromThName ''CDouble) -- Other types , (C.TypeName "FILE", fromThName ''CFile) , (C.TypeName "fpos_t", fromThName ''CFpos) , (C.TypeName "jmp_buf", fromThName ''CJmpBuf) -- Types from stdint.h that can be statically mapped to their Haskell -- equivalents. Excludes int_fast*_t and int_least*_t and the corresponding -- unsigned types, since their sizes are platform-specific. , (C.TypeName "int8_t", fromThName ''Int8) , (C.TypeName "int16_t", fromThName ''Int16) , (C.TypeName "int32_t", fromThName ''Int32) , (C.TypeName "int64_t", fromThName ''Int64) , (C.TypeName "uint8_t", fromThName ''Word8) , (C.TypeName "uint16_t", fromThName ''Word16) , (C.TypeName "uint32_t", fromThName ''Word32) , (C.TypeName "uint64_t", fromThName ''Word64) , (C.TypeName "godot_real", fromThName ''CFloat) , (C.TypeName "godot_int", fromThName ''CInt) , (C.TypeName "godot_bool", fromThName ''CBool) , (C.TypeName "godot_class_constructor", ConT $ mkName "ClassConstructor") , (C.TypeName "native_call_cb", ConT $ mkName "NativeCallCb") , (C.TypeName "bool", fromThName ''CInt) ] godotOpaqueStructs :: [C.Identifier] godotOpaqueStructs = [ "godot_aabb" , "godot_array" , "godot_basis" , "godot_char_string" , "godot_color" , "godot_dictionary" , "godot_method_bind" , "godot_node_path" , "godot_plane" , "godot_pool_array_read_access" , "godot_pool_array_write_access" , "godot_quat" , "godot_rect2" , "godot_rid" , "godot_string" , "godot_string_name" , "godot_transform" , "godot_transform2d" , "godot_variant" , "godot_vector2" , "godot_vector3" ] ++ concatMap (\(C.Identifier str) -> map (\suf -> C.Identifier $ str ++ suf) ["", "_read_access", "_write_access"]) [ "godot_pool_byte_array" , "godot_pool_color_array" , "godot_pool_int_array" , "godot_pool_real_array" , "godot_pool_string_array" , "godot_pool_vector2_array" , "godot_pool_vector3_array" ] -- structs, but not opaque structs godotStructs :: [C.Identifier] godotStructs = [ "godot_instance_create_func" , "godot_instance_destroy_func" , "godot_instance_method" , "godot_method_attributes" , "godot_property_get_func" , "godot_property_set_func" , "godot_property_attributes" , "godot_signal" , "godot_net_stream_peer" , "godot_net_packet_peer" , "godot_net_multiplayer_peer" , "godot_videodecoder_interface_gdnative" , "godot_arvr_interface_gdnative" , "godot_variant_call_error" , "godot_pluginscript_language_desc" , "godot_method_arg" , "godot_instance_binding_functions" , "godot_net_webrtc_library" , "godot_net_webrtc_peer_connection" , "godot_net_webrtc_data_channel" ] godotEnums :: [C.Identifier] godotEnums = [ "godot_error" , "godot_variant_type" , "godot_variant_call_error_error" , "godot_vector3_axis" , "godot_variant_operator" ] -- pipeline: -- - shim function, converting a S.GdnativeApiEntry into a foreign decl name, foreign decl, and maybe a piece of C code + updated types -- - marshal it -- - call it createFuncTyIO :: (Functor t, Foldable t) => Type -> t Type -> Type createFuncTyIO ret args = foldr AppT (AppT (ConT ''IO) ret) $ fmap (AppT ArrowT) args shimFunction :: S.GdnativeApiEntry -> ( Name -- function name , Name -- foreign decl name , Dec -- foreign decl , Maybe PP.Doc -- shim C code , [(TypeResult Type, Bool)] -- foreign argument types + whether to malloc it , TypeResult Type ) -- foreign return type shimFunction entry = ( fname , foreignName , fdecl , cShim , newArgs , newRetTy ) where fname = mkName . T.unpack $ S.name entry foreignName = mkName . T.unpack $ S.name entry `T.snoc` '_' retTy = resolveType $ S.return_type entry args = (resolveType.fst) <$> S.arguments entry isMallocArg arg = T.isPrefixOf "r_" arg || S.name entry == "godot_variant_new_bool" && arg == "p_v" || S.name entry == "godot_method_bind_call" && arg == "p_call_error" mallocFlags = V.toList $ (isMallocArg.snd) <$> S.arguments entry -- now we need to transform the args post-shim: -- we only need to shim opaque structs, so those are easy -- for the return type we append the old return value with malloc=>True, and set return type () flaggedArgs = zip (V.toList args) mallocFlags (newArgs, newRetTy) | shimRet = (flaggedArgs ++ [(retTy, True)], SimpleType (TupleT 0)) | otherwise = (flaggedArgs, retTy) foreignTypeResult (EnumType _) = ConT ''CInt foreignTypeResult ty = unTypeResult ty foreignRetTy = foreignTypeResult newRetTy foreignArgs = (foreignTypeResult.fst) <$> newArgs cName = if needsCShim then "hs_shim_" ++ nameBase fname else "dynamic" foreignType = createFuncTyIO foreignRetTy foreignArgs --TODO make the FunPtr correctly typed? fdecl = ForeignD $ ImportF CCall Safe cName foreignName $ AppT (AppT ArrowT (AppT (ConT ''FunPtr) foreignType)) foreignType -- FunPtr ty -> ty shimArgs = V.toList $ fmap isCShimType args shimRet = isCShimType retTy needsCShim = shimRet || or shimArgs -- construct the C shim. we're lazy here and just indicate whether we want to shim some argument or return type or not -- no direct AST (todo?) -- shimArgs = original function params length!! cShim | needsCShim = Just $ PP.vsep [ newRetDecl <+> PP.text cName <+> PP.tupled newCArgs <+> "{" -- new declaration , PP.indent 2 $ retWay <+> "func" <+> PP.tupled newInvokeParams <> ";" , "}"] | otherwise = Nothing where nats = [0..] :: [Int] oldRetTy = PP.pretty $ S.return_type entry oldArgTys = map (PP.pretty . fst) $ V.toList $ S.arguments entry newRetDecl = if shimRet then "void" else oldRetTy funPtrDecl = oldRetTy <+> "(*func)" <> PP.tupled oldArgTys shimTy needsShim ty = if needsShim then ty <> "*" else ty newCArgs = [funPtrDecl] ++ -- fun ptr is always first zipWith3 (\idx needsShim ty -> shimTy needsShim ty <+> "x" <> PP.pretty idx) nats shimArgs oldArgTys ++ [shimTy True oldRetTy <+> "ret" | shimRet] -- apppend ret shim if needed retWay = if shimRet then "*ret =" else "return" shimParam needsShim = if needsShim then "*" else "" newInvokeParams = zipWith (\idx needsShim -> shimParam needsShim <> "x" <> PP.pretty idx) nats shimArgs -- this is the core C type -> Foreign mapping. we also encode the type of marshaller to use resolveType :: C.Type -> TypeResult Type resolveType (C.TypeSpecifier _ (lookupBase -> Just ty)) = SimpleType $ ty resolveType (C.TypeSpecifier _ (C.TypeName ident)) = con $ ConT $ fromCIdent ident where con | isOpaqueStruct ident = OpaqueType True . AppT (ConT ''Ptr) -- we need to shim this so types match | isStruct ident = StorableType True . AppT (ConT ''Ptr) | isEnumType ident = EnumType | otherwise = error $ "Unknown type " ++ show ident resolveType (C.Ptr _ (C.TypeSpecifier _ (lookupBase -> Just ty))) = SimpleType $ AppT (ConT ''Ptr) ty resolveType (C.Ptr _ (C.TypeSpecifier _ (C.TypeName "godot_object"))) = SimpleType $ ConT $ mkName "Object" resolveType (C.Ptr _ (C.TypeSpecifier _ (C.TypeName ident))) = con . AppT (ConT ''Ptr) . ConT $ fromCIdent ident where con | isOpaqueStruct ident = OpaqueType False | isStruct ident = StorableType False | isEnumType ident = EnumType | otherwise = error $ "Unknown type " ++ show ident resolveType (C.Ptr _ ty) = SimpleType $ AppT (ConT ''Ptr) (unTypeResult $ resolveType ty) resolveType x = error $ "Failed to resolve type " ++ show x isStruct, isEnumType, isOpaqueStruct :: C.Identifier -> Bool isOpaqueStruct ident = ident `elem` godotOpaqueStructs isStruct ident = ident `elem` godotStructs isEnumType ident = ident `elem` godotEnums fromCIdent :: C.Identifier -> Name fromCIdent = mkName . pascal . (\x -> case T.stripPrefix "godot_" (T.pack x) of Just "string" -> "GodotString" Just "variant" -> "GodotVariant" Just y -> T.unpack y Nothing -> x) . C.unIdentifier lookupBase :: C.TypeSpecifier -> Maybe Type lookupBase = flip M.lookup baseTypesTable unPtrT :: Type -> Type unPtrT (AppT (ConT ptr) ty) | ptr == ''Ptr = ty unPtrT _ = error "Used unPtrT on a non-Ptr type" -- tuple: -- - Either (Name -> Q Exp) (Q Exp) -- left => in marshaller needs argument, right => no argument (e.g. malloc) -- - Type => hs type -- - Name -> Q Exp => out marshaller -- an in argument needs an in marshaller -- an out argument needs both -- a return value needs an out marshaller marshalArg :: (TypeResult Type, Bool) -> Q ( Either (Name -> Q Exp) (Q Exp) , Type , Name -> Q Exp ) marshalArg (SimpleType ty, isOutPtr) | isOutPtr = pure ( Right [|alloca|] , unPtrT ty , \n -> [|peek $(varE n)|]) | otherwise = pure ( Left (\n -> [| ($ $(varE n)) |]) -- this syntax sucks a bit, but it's basically a ($ n) section , ty , \n -> [|return $(varE n)|] ) marshalArg (EnumType ty, isOutPtr) | isOutPtr = pure ( Right [|alloca|] , unPtrT ty , \n -> [|fmap (toEnum . fromIntegral) (peek $(varE n))|] ) | otherwise = pure ( Left (\n -> [|($ fromIntegral (fromEnum $(varE n)))|]) , ty , \n -> [|return . toEnum $ fromIntegral $(varE n)|] ) --TODO: rewrite this to use mallocForeignPtrBytes. marshalArg (OpaqueType _ ty, isOutPtr) | isOutPtr = pure ( Right [| (mallocBytes (opaqueSizeOf @($(pure $ unPtrT ty))) >>=) |] , unPtrT ty , \n -> [|coerce <$> newForeignPtr finalizerFree $(varE n)|] ) | otherwise = pure ( Left (\n -> [| withForeignPtr (coerce $(varE n)) |]) , unPtrT ty , \n -> [|coerce <$> newForeignPtr_ $(varE n)|] ) marshalArg (StorableType _ ty, isOutPtr) | isOutPtr = pure ( Right [|alloca|] , unPtrT ty , \n -> [|peek $(varE n)|] ) | otherwise = pure ( Left (\n -> [| with $(varE n) |] ) , unPtrT ty , \n -> [|peek $(varE n)|] ) -- not sure about this marshalRet :: TypeResult Type -> Q ( Type -- hs ret ty , Maybe (Name -> Q Exp) ) -- out marshaller marshalRet (OpaqueType True _) = error "can't marshal unshimmed opaque structs" marshalRet (StorableType True _) = error "can't marshal unshimmed structs" marshalRet r = marshalArg (r, False) >>= \(_, hty, outm) -> case hty of TupleT 0 -> pure (hty, Nothing) _ -> pure (hty, Just outm) -- constructs the haskell and C functions out of the API name, index and entry -- I was considering doing C via AST, but just going to use PP.Doc. constructFunction :: Bool -> Name -> Int -> S.GdnativeApiEntry -> Q ([Dec], Maybe PP.Doc) constructFunction isCore tyname idx entry = do marshalledArgs <- mapM marshalArg foreignArgs let (hsOuts, hsArgs) = partitionArgs marshalledArgs (retMarshalTy, retOutMarshal) <- marshalRet foreignRetTy let hsRets = case retMarshalTy of TupleT 0 -> hsOuts ^.. folded._2 _ -> retMarshalTy : (hsOuts ^.. folded._2) let foldedRetTy = case hsRets of [hsRet] -> hsRet _ -> foldl AppT (TupleT (length hsRets)) hsRets let hsTy = createFuncTyIO foldedRetTy (hsArgs ^.. folded._2) sig <- sigD fname (pure hsTy) -- the top-level sig (argInMarshallers, argNames, argOutMarshallers) <- getMarshallers marshalledArgs nApi <- newName "api" nPtr <- newName "ptr" -- peekElemOff api idx let tyApiName = mkName . camel $ nameBase tyname let apiE = LetE [ValD (ConP tyname [VarP nApi]) (NormalB $ VarE tyApiName) []] (VarE nApi) let peekE = pure $ foldl AppE (VarE 'peekByteOff) [apiE, LitE (IntegerL $ fromIntegral $ sizeOf (undefined :: FunPtr a) * idx + structOffset)] let invokeE = appE (varE foreignName) (varE nPtr) let callE = generateCall invokeE argInMarshallers argOutMarshallers retOutMarshal fundecl <- funD fname [clause (map varP argNames) (normalB $ infixE (Just peekE) (varE '(>>=)) (Just $ lamE [varP nPtr] callE)) []] return ([fdecl, sig, fundecl], cShim) -- marshalling where (fname, foreignName, fdecl, cShim, foreignArgs, foreignRetTy) = shimFunction entry partitionArgs [] = ([],[]) partitionArgs ((inm, ty, outf) : margs) = let (os, as) = partitionArgs margs in case inm of Left argf -> (os, (argf, ty, outf) : as) Right argm -> ((argm, ty, outf) : os, as) getMarshallers [] = return ([],[],[]) getMarshallers ((inm, _, outm):xs) = do (argInMs, argNs, argOutMs) <- getMarshallers xs case inm of Left argf -> newName "x" >>= \n -> return ((argf n, False) : argInMs, n : argNs, argOutMs) Right argm -> return ( (argm, True) : argInMs, argNs, outm : argOutMs) -- TODO: evaluate these properly -- HACK: 64-bit linux only structOffset = if isCore then 40 -- offsetof(godot_gdnative_core_api_struct,godot_color_new_rgba) else 24 -- -- an in marshaller has form (a -> IO b) -> IO b generateCall :: Q Exp -- ^ the foreign function to call -> [(Q Exp, Bool)] -- ^ in marshallers (len = arguments) -> [Name -> Q Exp] -- ^ out argument marshallers (len = #outputs) -> Maybe (Name -> Q Exp) -- ^ return value marshaller, if non-void -> Q Exp -- ^ the full callee generateCall = go [] where go ns func [] outm maybeRetm = do case maybeRetm of -- duplication, bleh Just retm -> do r <- newName "r" -- return value let bindCall = [ bindS (varP r) func ] -- bind the result of the call to a name os <- replicateM (length outm + 1) (newName "o") let bindOuts = zipWith (\o f -> bindS (varP o) f) os $ zipWith ($) (retm:outm) (r:ns) let retOuts = [noBindS $ appE [|return|] $ maybeTupE (map varE os)] doE $ bindCall ++ bindOuts ++ retOuts Nothing -> do let bindCall = [ noBindS func ] os <- replicateM (length outm) (newName "o") let bindOuts = zipWith (\o f -> bindS (varP o) f) os $ zipWith ($) outm ns let retOuts = [noBindS $ appE [|return|] $ maybeTupE (map varE os)] doE $ bindCall ++ bindOuts ++ retOuts go ns func ((inm, isOutArg):inms) outm maybeRetm = do y <- newName "y" appE inm . lamE [varP y] $ go (ns ++ [y | isOutArg]) (appE func (varE y)) inms outm maybeRetm maybeTupE [x] = x maybeTupE xs = tupE xs apisToHs :: S.GdnativeApis -> Q [Dec] apisToHs apis = do coreDecs <- apiToHs True (S.core apis) extDecs <- concat <$> mapM (apiToHs False) (V.filter (\api -> S.apiType api `notElem` excluded) $ S.extensions apis) return $ coreDecs ++ extDecs where excluded = ["ANDROID"] -- bool: is core -> True apiToHs :: Bool -> S.GdnativeApi -> Q [Dec] apiToHs isCore api = do nxts <- case S.apiNext api of Just next -> apiToHs isCore next Nothing -> return [] (++ nxts) <$> generateApiType where -- generate the -- newtype: newtype Api = Api (Ptr Api) -- functions: -- - simple function: func :: Api -> Blah -> IO Boop, func (Api ptr) blah boop = peekByteOff ptr 0 >>= \fptr -> createFunc fptr blah boop -- - c shim function: * return value: create C function with extra argument that writes result to it -- * argument: create C function that dereferences it generateApiType = let apiName = mkApiName apiEntries = S.apiApi api in generateFunctions apiName apiEntries maybeExt = if isCore then "" else "Ext" showVer = let ver = S.apiVersion api in show (S.major ver) ++ show (S.minor ver) maybeVer = if S.apiVersion api == S.Ver 1 0 || S.apiType api == "ARVR" || S.apiType api == "VIDEODECODER" || S.apiType api == "NET" then "" else showVer mkApiName = mkName $ "Gdnative" ++ maybeExt ++ pascal (T.unpack $ S.apiType api) ++ maybeVer ++ "ApiStruct" generateFunctions name entries = do funcs <- imapM (constructFunction isCore name) entries let hscode = concat $ funcs ^.. folded._1 let ccode = PP.vsep $ funcs ^.. folded._2._Just addForeignSource LangC . show $ PP.vsep [ "#include " , ccode ] return hscode ================================================ FILE: src-generate/Spec.hs ================================================ {-# LANGUAGE TemplateHaskell #-} {-# OPTIONS_GHC -Wno-orphans #-} module Spec where import Data.Aeson import Data.Aeson.TH import Data.Char import Data.Monoid import Data.Text (Text) import Data.Vector (Vector) import qualified Data.Vector as V import Data.HashMap.Strict (HashMap) import qualified Data.HashMap.Strict as HM import Data.Set (Set) import qualified Data.Set as S import Types -- this is incredibly ad hoc. instance FromJSON Type where parseJSON = withText "C type" $ \str -> case runCParser (const True) "" str parseType of Left err -> fail $ show err Right val -> return val data GdnativeApis = GdnativeApis { core :: !GdnativeApi , extensions :: !(Vector GdnativeApi) } deriving (Show, Eq) data Ver = Ver { major :: !Int, minor :: !Int} deriving (Show, Eq) data GdnativeApi = GdnativeApi { apiType :: !Text , apiVersion :: !Ver , apiNext :: !(Maybe GdnativeApi) , apiApi :: !(Vector GdnativeApiEntry) } deriving (Show, Eq) data GdnativeApiEntry = GdnativeApiEntry { name :: !Text , return_type :: !Type , arguments :: !(Vector (Type, Text)) } deriving (Show, Eq) deriveFromJSON defaultOptions ''Ver deriveFromJSON defaultOptions ''GdnativeApiEntry deriveFromJSON defaultOptions { fieldLabelModifier = map toLower . drop 3 } ''GdnativeApi deriveFromJSON defaultOptions ''GdnativeApis collectTypes :: GdnativeApis -> Set Type collectTypes apis = collectFromApi (core apis) <> mconcat (V.toList $ fmap collectFromApi $ extensions apis) where collectFromApi api = mconcat $ V.toList $ fmap collectFromEntry (apiApi api) collectFromEntry entry = S.singleton (return_type entry) <> (S.fromList $ V.toList $ fmap fst $ arguments entry) collectNames :: GdnativeApis -> Set Text collectNames apis = collectFromApi (core apis) <> mconcat (V.toList $ fmap collectFromApi $ extensions apis) where collectFromApi api = mconcat $ V.toList $ fmap collectFromEntry (apiApi api) collectFromEntry entry = S.fromList $ V.toList $ fmap snd $ arguments entry ================================================ FILE: src-generate/Types/Internal.hs ================================================ {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} -- | A parser for C99 declarations. Currently, the parser has the following limitations: -- -- * Array sizes can only be @*@, @n@ (where n is a positive integer), @x@ -- (where @x@ is a C identifier). In C99 they can be arbitrary expressions. See -- the @'ArrayType'@ data type. -- -- * @_Bool@, @_Complex@, and @_Imaginary@ are not present. -- -- * Untyped parameter lists (pre-K&R C) are not allowed. -- -- The parser is incremental and generic (see 'CParser'). 'PP.Pretty' -- and 'QC.Arbitrary' instances are provided for all the data types. -- -- The entry point if you want to parse C declarations is -- @'parameter_declaration'@. module Types.Internal ( -- * Parser type CParser , IsTypeName , runCParser , quickCParser , quickCParser_ -- * Types and parsing , Identifier(..) , identifier , identifier_no_lex , DeclarationSpecifier(..) , declaration_specifiers , StorageClassSpecifier(..) , storage_class_specifier , TypeSpecifier(..) , type_specifier , TypeQualifier(..) , type_qualifier , FunctionSpecifier(..) , function_specifier , Declarator(..) , declarator , DirectDeclarator(..) , direct_declarator , ArrayOrProto(..) , array_or_proto , ArrayType(..) , array_type , Pointer(..) , pointer , ParameterDeclaration(..) , parameter_declaration , parameter_list , AbstractDeclarator(..) , abstract_declarator , DirectAbstractDeclarator(..) , direct_abstract_declarator -- * YACC grammar -- $yacc ) where import Control.Applicative import Control.Monad ( msum , void , MonadPlus , unless , when ) import Control.Monad.Reader ( MonadReader , ask , runReaderT , ReaderT ) import Control.Monad.Fail ( MonadFail ) import Data.Functor.Identity ( Identity ) import qualified Data.HashSet as HashSet import Data.Monoid ( (<>) ) import Data.String ( IsString(..) ) import Data.Typeable ( Typeable ) import qualified Text.Parsec as Parsec import Text.Parser.Char import Text.Parser.Combinators import Text.Parser.LookAhead import Text.Parser.Token import qualified Text.Parser.Token.Highlight as Highlight import Text.PrettyPrint.ANSI.Leijen ( Pretty(..) , (<+>) , Doc , hsep ) import qualified Text.PrettyPrint.ANSI.Leijen as PP ------------------------------------------------------------------------ -- Parser -- | Function used to determine whether an 'C.Id' is a type name. type IsTypeName = Identifier -> Bool -- | All the parsing is done using the type classes provided by the -- @parsers@ package. You can use the parsing routines with any of the parsers -- that implement the classes, such as @parsec@ or @trifecta@. -- -- The 'MonadReader' with 'IsTypeName' is required for parsing C, see -- . type CParser m = ( Monad m , Functor m , Applicative m , MonadPlus m , Parsing m , CharParsing m , TokenParsing m , LookAheadParsing m , MonadReader IsTypeName m , MonadFail m ) -- | Runs a @'CParser'@ using @parsec@. runCParser :: Parsec.Stream s Identity Char => IsTypeName -- ^ Function determining if an identifier is a type name. -> String -- ^ Source name. -> s -- ^ String to parse. -> (ReaderT IsTypeName (Parsec.Parsec s ()) a) -- ^ Parser. Anything with type @forall m. CParser m => m a@ is a -- valid argument. -> Either Parsec.ParseError a runCParser isTypeName fn s p = Parsec.parse (runReaderT p isTypeName) fn s -- | Useful for quick testing. Uses @\"quickCParser\"@ as source name, and throws -- an 'error' if parsing fails. quickCParser :: IsTypeName -- ^ Function determining if an identifier is a type name. -> String -- ^ String to parse. -> (ReaderT IsTypeName (Parsec.Parsec String ()) a) -- ^ Parser. Anything with type @forall m. CParser m => m a@ is a -- valid argument. -> a quickCParser isTypeName s p = case runCParser isTypeName "quickCParser" s p of Left err -> error $ "quickCParser: " ++ show err Right x -> x -- | Like 'quickCParser', but uses @'const' 'False'@ as 'IsTypeName'. quickCParser_ :: String -- ^ String to parse. -> (ReaderT IsTypeName (Parsec.Parsec String ()) a) -- ^ Parser. Anything with type @forall m. CParser m => m a@ is a -- valid argument. -> a quickCParser_ = quickCParser (const False) newtype Identifier = Identifier {unIdentifier :: String} deriving (Typeable, Eq, Ord, Show) instance IsString Identifier where fromString s = case runCParser (const False) "fromString" s (identifier_no_lex <* eof) of Left _err -> error $ "Identifier fromString: invalid string " ++ show s Right x -> x identLetter :: CParser m => m Char identLetter = oneOf $ ['a' .. 'z'] ++ ['A' .. 'Z'] ++ ['_'] reservedWords :: HashSet.HashSet String reservedWords = HashSet.fromList [ "auto" , "else" , "long" , "switch" , "break" , "enum" , "register" , "typedef" , "case" , "extern" , "return" , "union" , "char" , "float" , "short" , "unsigned" , "const" , "for" , "signed" , "void" , "continue" , "goto" , "sizeof" , "volatile" , "default" , "if" , "static" , "while" , "do" , "int" , "struct" , "double" ] identStyle :: CParser m => IdentifierStyle m identStyle = IdentifierStyle { _styleName = "C identifier" , _styleStart = identLetter , _styleLetter = identLetter <|> digit , _styleReserved = reservedWords , _styleHighlight = Highlight.Identifier , _styleReservedHighlight = Highlight.ReservedIdentifier } data DeclarationSpecifier = StorageClassSpecifier StorageClassSpecifier | TypeSpecifier TypeSpecifier | TypeQualifier TypeQualifier | FunctionSpecifier FunctionSpecifier deriving (Typeable, Eq, Show, Ord) declaration_specifiers :: forall m . CParser m => m [DeclarationSpecifier] declaration_specifiers = many1 $ msum [ StorageClassSpecifier <$> storage_class_specifier , TypeSpecifier <$> type_specifier , TypeQualifier <$> type_qualifier , FunctionSpecifier <$> function_specifier ] data StorageClassSpecifier = TYPEDEF | EXTERN | STATIC | AUTO | REGISTER deriving (Typeable, Eq, Show, Ord) storage_class_specifier :: CParser m => m StorageClassSpecifier storage_class_specifier = msum [ TYPEDEF <$ reserve identStyle "typedef" , EXTERN <$ reserve identStyle "extern" , STATIC <$ reserve identStyle "static" , AUTO <$ reserve identStyle "auto" , REGISTER <$ reserve identStyle "register" ] data TypeSpecifier = VOID | CHAR | SHORT | INT | LONG | FLOAT | DOUBLE | SIGNED | UNSIGNED | Struct Identifier | Enum Identifier | TypeName Identifier deriving (Typeable, Eq, Show, Ord) type_specifier :: CParser m => m TypeSpecifier type_specifier = msum [ VOID <$ reserve identStyle "void" , CHAR <$ reserve identStyle "char" , SHORT <$ reserve identStyle "short" , INT <$ reserve identStyle "int" , LONG <$ reserve identStyle "long" , FLOAT <$ reserve identStyle "float" , DOUBLE <$ reserve identStyle "double" , SIGNED <$ reserve identStyle "signed" , UNSIGNED <$ reserve identStyle "unsigned" , Struct <$> (reserve identStyle "struct" >> identifier) , Enum <$> (reserve identStyle "enum" >> identifier) , TypeName <$> type_name ] identifier :: CParser m => m Identifier identifier = try (do s <- ident identStyle isTypeName <- ask when (isTypeName s) $ fail "expecting identifier, got type name" return s ) "identifier" type_name :: CParser m => m Identifier type_name = try (do s <- ident identStyle isTypeName <- ask unless (isTypeName s) $ fail "expecting type name, got identifier" return s ) "type name" data TypeQualifier = CONST | RESTRICT | VOLATILE deriving (Typeable, Eq, Show, Ord) type_qualifier :: CParser m => m TypeQualifier type_qualifier = msum [ CONST <$ reserve identStyle "const" , RESTRICT <$ reserve identStyle "restrict" , VOLATILE <$ reserve identStyle "volatile" ] data FunctionSpecifier = INLINE deriving (Typeable, Eq, Show, Ord) function_specifier :: CParser m => m FunctionSpecifier function_specifier = msum [INLINE <$ reserve identStyle "inline"] data Declarator = Declarator { declaratorPointers :: [Pointer] , declaratorDirect :: DirectDeclarator } deriving (Typeable, Eq, Show, Ord) declarator :: CParser m => m Declarator declarator = (Declarator <$> many pointer <*> direct_declarator) "declarator" data DirectDeclarator = DeclaratorRoot Identifier | ArrayOrProto DirectDeclarator ArrayOrProto | DeclaratorParens Declarator deriving (Typeable, Eq, Show, Ord) data ArrayOrProto = Array ArrayType | Proto [ParameterDeclaration] -- We don't include old prototypes. deriving (Typeable, Eq, Show, Ord) array_or_proto :: CParser m => m ArrayOrProto array_or_proto = msum [Array <$> brackets array_type, Proto <$> parens parameter_list] -- TODO handle more stuff in array brackets data ArrayType = VariablySized | Unsized | SizedByInteger Integer | SizedByIdentifier Identifier deriving (Typeable, Eq, Show, Ord) array_type :: CParser m => m ArrayType array_type = msum [ VariablySized <$ symbolic '*' , SizedByInteger <$> natural , SizedByIdentifier <$> identifier , return Unsized ] direct_declarator :: CParser m => m DirectDeclarator direct_declarator = (do ddecltor <- msum [DeclaratorRoot <$> identifier, DeclaratorParens <$> parens declarator] aops <- many array_or_proto return $ foldl ArrayOrProto ddecltor aops ) data Pointer = Pointer [TypeQualifier] deriving (Typeable, Eq, Show, Ord) pointer :: CParser m => m Pointer pointer = do void $ symbolic '*' Pointer <$> many type_qualifier parameter_list :: CParser m => m [ParameterDeclaration] parameter_list = sepBy parameter_declaration $ symbolic ',' data ParameterDeclaration = ParameterDeclaration { parameterDeclarationSpecifiers :: [DeclarationSpecifier] , parameterDeclarationDeclarator :: Either Declarator AbstractDeclarator } deriving (Typeable, Eq, Show, Ord) parameter_declaration :: CParser m => m ParameterDeclaration parameter_declaration = ParameterDeclaration <$> declaration_specifiers <*> mbabstract where mbabstract = Left <$> try declarator <|> Right <$> try abstract_declarator <|> return (Right (AbstractDeclarator [] Nothing)) data AbstractDeclarator = AbstractDeclarator { abstractDeclaratorPointers :: [Pointer] , abstractDeclaratorDirect :: Maybe DirectAbstractDeclarator } deriving (Typeable, Eq, Show, Ord) abstract_declarator :: CParser m => m AbstractDeclarator abstract_declarator = do ptrs <- many pointer -- If there are no pointers, there must be an abstract declarator. let p = if null ptrs then Just <$> direct_abstract_declarator else (Just <$> try direct_abstract_declarator) <|> return Nothing AbstractDeclarator ptrs <$> p data DirectAbstractDeclarator = ArrayOrProtoHere ArrayOrProto | ArrayOrProtoThere DirectAbstractDeclarator ArrayOrProto | AbstractDeclaratorParens AbstractDeclarator deriving (Typeable, Eq, Show, Ord) direct_abstract_declarator :: CParser m => m DirectAbstractDeclarator direct_abstract_declarator = (do ddecltor <- msum [ try (ArrayOrProtoHere <$> array_or_proto) , AbstractDeclaratorParens <$> parens abstract_declarator ] "array, prototype, or parenthesised abstract declarator" aops <- many array_or_proto return $ foldl ArrayOrProtoThere ddecltor aops ) -- | This parser parses an 'Id' and nothing else -- it does not consume -- trailing spaces and the like. identifier_no_lex :: CParser m => m Identifier identifier_no_lex = try (do s <- Identifier <$> ((:) <$> identLetter <*> many (identLetter <|> digit)) isTypeName <- ask when (isTypeName s) $ fail "expecting identifier, got type name" return s ) "identifier" ------------------------------------------------------------------------ -- Pretty printing instance Pretty Identifier where pretty = PP.text . unIdentifier instance Pretty DeclarationSpecifier where pretty dspec = case dspec of StorageClassSpecifier x -> pretty x TypeSpecifier x -> pretty x TypeQualifier x -> pretty x FunctionSpecifier x -> pretty x instance Pretty StorageClassSpecifier where pretty storage = case storage of TYPEDEF -> "typedef" EXTERN -> "extern" STATIC -> "static" AUTO -> "auto" REGISTER -> "register" instance Pretty TypeSpecifier where pretty tySpec = case tySpec of VOID -> "void" CHAR -> "char" SHORT -> "short" INT -> "int" LONG -> "long" FLOAT -> "float" DOUBLE -> "double" SIGNED -> "signed" UNSIGNED -> "unsigned" Struct x -> "struct" <+> pretty x Enum x -> "enum" <+> pretty x TypeName x -> pretty x instance Pretty TypeQualifier where pretty tyQual = case tyQual of CONST -> "const" RESTRICT -> "restrict" VOLATILE -> "volatile" instance Pretty FunctionSpecifier where pretty funSpec = case funSpec of INLINE -> "inline" instance Pretty Declarator where pretty (Declarator ptrs ddecltor) = case ptrs of [] -> pretty ddecltor _ : _ -> prettyPointers ptrs <+> pretty ddecltor prettyPointers :: [Pointer] -> Doc prettyPointers [] = "" prettyPointers (x : xs) = pretty x <> prettyPointers xs instance Pretty Pointer where pretty (Pointer tyQual) = "*" <> hsep (map pretty tyQual) instance Pretty DirectDeclarator where pretty decltor = case decltor of DeclaratorRoot x -> pretty x DeclaratorParens x -> "(" <> pretty x <> ")" ArrayOrProto ddecltor aorp -> pretty ddecltor <> pretty aorp instance Pretty ArrayOrProto where pretty aorp = case aorp of Array x -> "[" <> pretty x <> "]" Proto x -> "(" <> prettyParams x <> ")" prettyParams :: (Pretty a) => [a] -> Doc prettyParams xs = case xs of [] -> "" [ x ] -> pretty x x : xs'@(_ : _) -> pretty x <> "," <+> prettyParams xs' instance Pretty ArrayType where pretty at = case at of VariablySized -> "*" SizedByInteger n -> pretty n SizedByIdentifier s -> pretty s Unsized -> "" instance Pretty ParameterDeclaration where pretty (ParameterDeclaration declSpecs decltor) = case declSpecs of [] -> decltorDoc _ : _ -> hsep (map pretty declSpecs) <+> decltorDoc where decltorDoc = case decltor of Left x -> pretty x Right x -> pretty x instance Pretty AbstractDeclarator where pretty (AbstractDeclarator ptrs mbDecltor) = case (ptrs, mbDecltor) of (_ , Nothing) -> prettyPointers ptrs ([] , Just x ) -> pretty x (_ : _, Just x ) -> prettyPointers ptrs <+> pretty x instance Pretty DirectAbstractDeclarator where pretty ddecltor = case ddecltor of AbstractDeclaratorParens x -> "(" <> pretty x <> ")" ArrayOrProtoHere aop -> pretty aop ArrayOrProtoThere ddecltor' aop -> pretty ddecltor' <> pretty aop ------------------------------------------------------------------------ ------------------------------------------------------------------------ -- Utils many1 :: CParser m => m a -> m [a] many1 p = (:) <$> p <*> many p ------------------------------------------------------------------------ -- YACC grammar -- $yacc -- -- The parser above is derived from a modification of the YACC grammar -- for C99 found at , -- reproduced below. -- -- @ -- %token IDENTIFIER TYPE_NAME INTEGER -- -- %token TYPEDEF EXTERN STATIC AUTO REGISTER INLINE RESTRICT -- %token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID -- %token BOOL COMPLEX IMAGINARY -- %token STRUCT UNION ENUM -- -- %start parameter_list -- %% -- -- declaration_specifiers -- : storage_class_specifier -- | storage_class_specifier declaration_specifiers -- | type_specifier -- | type_specifier declaration_specifiers -- | type_qualifier -- | type_qualifier declaration_specifiers -- | function_specifier -- | function_specifier declaration_specifiers -- ; -- -- storage_class_specifier -- : TYPEDEF -- | EXTERN -- | STATIC -- | AUTO -- | REGISTER -- ; -- -- type_specifier -- : VOID -- | CHAR -- | SHORT -- | INT -- | LONG -- | FLOAT -- | DOUBLE -- | SIGNED -- | UNSIGNED -- | BOOL -- | COMPLEX -- | IMAGINARY -- | STRUCT IDENTIFIER -- | UNION IDENTIFIER -- | ENUM IDENTIFIER -- | TYPE_NAME -- ; -- -- type_qualifier -- : CONST -- | RESTRICT -- | VOLATILE -- ; -- -- function_specifier -- : INLINE -- ; -- -- declarator -- : pointer direct_declarator -- | direct_declarator -- ; -- -- direct_declarator -- : IDENTIFIER -- | '(' declarator ')' -- | direct_declarator '[' type_qualifier_list ']' -- | direct_declarator '[' type_qualifier_list '*' ']' -- | direct_declarator '[' '*' ']' -- | direct_declarator '[' IDENTIFIER ']' -- | direct_declarator '[' INTEGER ']' -- | direct_declarator '[' ']' -- | direct_declarator '(' parameter_list ')' -- | direct_declarator '(' ')' -- ; -- -- pointer -- : '*' -- | '*' type_qualifier_list -- | '*' pointer -- | '*' type_qualifier_list pointer -- ; -- -- type_qualifier_list -- : type_qualifier -- | type_qualifier_list type_qualifier -- ; -- -- parameter_list -- : parameter_declaration -- | parameter_list ',' parameter_declaration -- ; -- -- parameter_declaration -- : declaration_specifiers declarator -- | declaration_specifiers abstract_declarator -- | declaration_specifiers -- ; -- -- abstract_declarator -- : pointer -- | direct_abstract_declarator -- | pointer direct_abstract_declarator -- ; -- -- direct_abstract_declarator -- : '(' abstract_declarator ')' -- | '[' ']' -- | direct_abstract_declarator '[' ']' -- | '[' '*' ']' -- | direct_abstract_declarator '[' '*' ']' -- | '[' IDENTIFIER ']' -- | direct_abstract_declarator '[' IDENTIFIER ']' -- | '[' INTEGER ']' -- | direct_abstract_declarator '[' INTEGER ']' -- | '(' ')' -- | '(' parameter_list ')' -- | direct_abstract_declarator '(' ')' -- | direct_abstract_declarator '(' parameter_list ')' -- ; -- -- %% -- #include \ -- -- extern char yytext[]; -- extern int column; -- -- void yyerror(char const *s) -- { -- fflush(stdout); -- printf("\n%*s\n%*s\n", column, "^", column, s); -- } -- @ ================================================ FILE: src-generate/Types.hs ================================================ {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE NoMonoLocalBinds #-} -- | Views of C datatypes. While "Language.C.Types.Parse" defines datatypes for -- representing the concrete syntax tree of C types, this module provides -- friendlier views of C types, by turning them into a data type matching more -- closely how we read and think about types, both in Haskell and in C. To -- appreciate the difference, look at the difference between -- 'P.ParameterDeclaration' and 'ParameterDeclaration'. -- -- As a bonus, routines are provided for describing types in natural language -- (English) -- see 'describeParameterDeclaration' and 'describeType'. module Types ( -- * Types P.Identifier(..) , P.StorageClassSpecifier(..) , P.TypeQualifier(..) , P.FunctionSpecifier(..) , P.ArrayType(..) , Specifiers(..) , Type(..) , TypeSpecifier(..) , Sign(..) , ParameterDeclaration(..) -- * Parsing , P.IsTypeName , P.CParser , P.runCParser , P.quickCParser , P.quickCParser_ , parseParameterDeclaration , parseParameterList , parseIdentifier , parseType -- * Convert to and from high-level views , UntangleErr(..) , untangleParameterDeclaration , tangleParameterDeclaration -- * To english , describeParameterDeclaration , describeType ) where import Control.Arrow (second) import Control.Monad (when, unless, forM_) import Control.Monad.State (execState, modify) import Data.List (partition) import Data.Semigroup import Data.Maybe (fromMaybe) import Data.Typeable (Typeable) import Text.PrettyPrint.ANSI.Leijen ((), (<+>)) import qualified Text.PrettyPrint.ANSI.Leijen as PP #if __GLASGOW_HASKELL__ < 710 import Data.Functor ((<$>)) import Data.Monoid (Monoid(..)) #endif import qualified Types.Internal as P ------------------------------------------------------------------------ -- Proper types data TypeSpecifier = Void | Char (Maybe Sign) | Short Sign | Int Sign | Long Sign | LLong Sign | Float | Double | LDouble | TypeName P.Identifier | Struct P.Identifier | Enum P.Identifier deriving (Typeable, Show, Eq, Ord) data Specifiers = Specifiers { storageClassSpecifiers :: [P.StorageClassSpecifier] , typeQualifiers :: [P.TypeQualifier] , functionSpecifiers :: [P.FunctionSpecifier] } deriving (Typeable, Show, Eq, Ord) instance Monoid Specifiers where mempty = Specifiers [] [] [] mappend = (<>) instance Semigroup Specifiers where (Specifiers x1 y1 z1) <> (Specifiers x2 y2 z2) = Specifiers (x1 ++ x2) (y1 ++ y2) (z1 ++ z2) data Type = TypeSpecifier Specifiers TypeSpecifier | Ptr [P.TypeQualifier] Type | Array P.ArrayType Type | Proto Type [ParameterDeclaration] deriving (Typeable, Show, Eq, Ord) data Sign = Signed | Unsigned deriving (Typeable, Show, Eq, Ord) data ParameterDeclaration = ParameterDeclaration { parameterDeclarationId :: Maybe P.Identifier , parameterDeclarationType :: Type } deriving (Typeable, Show, Eq, Ord) ------------------------------------------------------------------------ -- Conversion data UntangleErr = MultipleDataTypes [P.DeclarationSpecifier] | NoDataTypes [P.DeclarationSpecifier] | IllegalSpecifiers String [P.TypeSpecifier] deriving (Typeable, Show, Eq) failConversion :: UntangleErr -> Either UntangleErr a failConversion = Left untangleParameterDeclaration :: P.ParameterDeclaration -> Either UntangleErr ParameterDeclaration untangleParameterDeclaration P.ParameterDeclaration{..} = do (specs, tySpec) <- untangleDeclarationSpecifiers parameterDeclarationSpecifiers let baseTy = TypeSpecifier specs tySpec (mbS, ty) <- case parameterDeclarationDeclarator of Left decltor -> do (s, ty) <- untangleDeclarator baseTy decltor return (Just s, ty) Right decltor -> (Nothing, ) <$> untangleAbstractDeclarator baseTy decltor return $ ParameterDeclaration mbS ty untangleDeclarationSpecifiers :: [P.DeclarationSpecifier] -> Either UntangleErr (Specifiers, TypeSpecifier) untangleDeclarationSpecifiers declSpecs = do let (pStorage, pTySpecs, pTyQuals, pFunSpecs) = flip execState ([], [], [], []) $ do forM_ (reverse declSpecs) $ \declSpec -> case declSpec of P.StorageClassSpecifier x -> modify $ \(a, b, c, d) -> (x:a, b, c, d) P.TypeSpecifier x -> modify $ \(a, b, c, d) -> (a, x:b, c, d) P.TypeQualifier x -> modify $ \(a, b, c, d) -> (a, b, x:c, d) P.FunctionSpecifier x -> modify $ \(a, b, c, d) -> (a, b, c, x:d) -- Split data type and specifiers let (dataTypes, specs) = partition (\x -> not (x `elem` [P.SIGNED, P.UNSIGNED, P.LONG, P.SHORT])) pTySpecs let illegalSpecifiers s = failConversion $ IllegalSpecifiers s specs -- Find out sign, if present mbSign0 <- case filter (== P.SIGNED) specs of [] -> return Nothing [_] -> return $ Just Signed _:_ -> illegalSpecifiers "conflicting/duplicate sign information" mbSign <- case (mbSign0, filter (== P.UNSIGNED) specs) of (Nothing, []) -> return Nothing (Nothing, [_]) -> return $ Just Unsigned (Just b, []) -> return $ Just b _ -> illegalSpecifiers "conflicting/duplicate sign information" let sign = fromMaybe Signed mbSign -- Find out length let longs = length $ filter (== P.LONG) specs let shorts = length $ filter (== P.SHORT) specs when (longs > 0 && shorts > 0) $ illegalSpecifiers "both long and short" -- Find out data type dataType <- case dataTypes of [x] -> return x [] | longs > 0 || shorts > 0 -> return P.INT [] -> failConversion $ NoDataTypes declSpecs _:_ -> failConversion $ MultipleDataTypes declSpecs -- Check if things are compatible with one another let checkNoSpecs = unless (null specs) $ illegalSpecifiers "expecting no specifiers" let checkNoLength = when (longs > 0 || shorts > 0) $ illegalSpecifiers "unexpected long/short" tySpec <- case dataType of P.TypeName s -> do checkNoSpecs return $ TypeName s P.Struct s -> do checkNoSpecs return $ Struct s P.Enum s -> do checkNoSpecs return $ Enum s P.VOID -> do checkNoSpecs return Void P.CHAR -> do checkNoLength return $ Char mbSign P.INT | longs == 0 && shorts == 0 -> do return $ Int sign P.INT | longs == 1 -> do return $ Long sign P.INT | longs == 2 -> do return $ LLong sign P.INT | shorts == 1 -> do return $ Short sign P.INT -> do illegalSpecifiers "too many long/short" P.FLOAT -> do checkNoLength return Float P.DOUBLE -> do if longs == 1 then return LDouble else do checkNoLength return Double _ -> do error $ "untangleDeclarationSpecifiers impossible: " ++ show dataType return (Specifiers pStorage pTyQuals pFunSpecs, tySpec) untangleDeclarator :: Type -> P.Declarator -> Either UntangleErr (P.Identifier, Type) untangleDeclarator ty0 (P.Declarator ptrs0 directDecltor) = go ty0 ptrs0 where go :: Type -> [P.Pointer] -> Either UntangleErr (P.Identifier, Type) go ty [] = goDirect ty directDecltor go ty (P.Pointer quals : ptrs) = go (Ptr quals ty) ptrs goDirect :: Type -> P.DirectDeclarator -> Either UntangleErr (P.Identifier, Type) goDirect ty direct0 = case direct0 of P.DeclaratorRoot s -> return (s, ty) P.ArrayOrProto direct (P.Array arrayType) -> goDirect (Array arrayType ty) direct P.ArrayOrProto direct (P.Proto params) -> do params' <- mapM untangleParameterDeclaration params goDirect (Proto ty params') direct P.DeclaratorParens decltor -> untangleDeclarator ty decltor untangleAbstractDeclarator :: Type -> P.AbstractDeclarator -> Either UntangleErr Type untangleAbstractDeclarator ty0 (P.AbstractDeclarator ptrs0 mbDirectDecltor) = go ty0 ptrs0 where go :: Type -> [P.Pointer] -> Either UntangleErr Type go ty [] = case mbDirectDecltor of Nothing -> return ty Just directDecltor -> goDirect ty directDecltor go ty (P.Pointer quals : ptrs) = go (Ptr quals ty) ptrs goDirect :: Type -> P.DirectAbstractDeclarator -> Either UntangleErr Type goDirect ty direct0 = case direct0 of P.ArrayOrProtoThere direct (P.Array arrayType) -> goDirect (Array arrayType ty) direct P.ArrayOrProtoThere direct (P.Proto params) -> do params' <- mapM untangleParameterDeclaration params goDirect (Proto ty params') direct P.ArrayOrProtoHere (P.Array arrayType) -> return $ Array arrayType ty P.ArrayOrProtoHere (P.Proto params) -> do params' <- mapM untangleParameterDeclaration params return $ Proto ty params' P.AbstractDeclaratorParens decltor -> untangleAbstractDeclarator ty decltor ------------------------------------------------------------------------ -- Tangling tangleParameterDeclaration :: ParameterDeclaration -> P.ParameterDeclaration tangleParameterDeclaration (ParameterDeclaration mbId ty00) = uncurry P.ParameterDeclaration $ case mbId of Nothing -> second Right $ goAbstractDirect ty00 Nothing Just id' -> second Left $ goConcreteDirect ty00 $ P.DeclaratorRoot id' where goAbstractDirect :: Type -> Maybe P.DirectAbstractDeclarator -> ([P.DeclarationSpecifier], P.AbstractDeclarator) goAbstractDirect ty0 mbDirect = case ty0 of TypeSpecifier specifiers tySpec -> let declSpecs = tangleTypeSpecifier specifiers tySpec in (declSpecs, P.AbstractDeclarator [] mbDirect) Ptr tyQuals ty -> goAbstract ty [P.Pointer tyQuals] mbDirect Array arrType ty -> let arr = P.Array arrType in case mbDirect of Nothing -> goAbstractDirect ty $ Just $ P.ArrayOrProtoHere arr Just decltor -> goAbstractDirect ty $ Just $ P.ArrayOrProtoThere decltor arr Proto ty params -> let proto = P.Proto $ map tangleParameterDeclaration params in case mbDirect of Nothing -> goAbstractDirect ty $ Just $ P.ArrayOrProtoHere proto Just decltor -> goAbstractDirect ty $ Just $ P.ArrayOrProtoThere decltor proto goAbstract :: Type -> [P.Pointer] -> Maybe P.DirectAbstractDeclarator -> ([P.DeclarationSpecifier], P.AbstractDeclarator) goAbstract ty0 ptrs mbDirect = case ty0 of TypeSpecifier specifiers tySpec -> let declSpecs = tangleTypeSpecifier specifiers tySpec in (declSpecs, P.AbstractDeclarator ptrs mbDirect) Ptr tyQuals ty -> goAbstract ty (P.Pointer tyQuals : ptrs) mbDirect Array{} -> goAbstractDirect ty0 $ Just $ P.AbstractDeclaratorParens $ P.AbstractDeclarator ptrs mbDirect Proto{} -> goAbstractDirect ty0 $ Just $ P.AbstractDeclaratorParens $ P.AbstractDeclarator ptrs mbDirect goConcreteDirect :: Type -> P.DirectDeclarator -> ([P.DeclarationSpecifier], P.Declarator) goConcreteDirect ty0 direct = case ty0 of TypeSpecifier specifiers tySpec -> let declSpecs = tangleTypeSpecifier specifiers tySpec in (declSpecs, P.Declarator [] direct) Ptr tyQuals ty -> goConcrete ty [P.Pointer tyQuals] direct Array arrType ty -> goConcreteDirect ty $ P.ArrayOrProto direct $ P.Array arrType Proto ty params -> goConcreteDirect ty $ P.ArrayOrProto direct $ P.Proto $ map tangleParameterDeclaration params goConcrete :: Type -> [P.Pointer] -> P.DirectDeclarator -> ([P.DeclarationSpecifier], P.Declarator) goConcrete ty0 ptrs direct = case ty0 of TypeSpecifier specifiers tySpec -> let declSpecs = tangleTypeSpecifier specifiers tySpec in (declSpecs, P.Declarator ptrs direct) Ptr tyQuals ty -> goConcrete ty (P.Pointer tyQuals : ptrs) direct Array{} -> goConcreteDirect ty0 $ P.DeclaratorParens $ P.Declarator ptrs direct Proto{} -> goConcreteDirect ty0 $ P.DeclaratorParens $ P.Declarator ptrs direct tangleTypeSpecifier :: Specifiers -> TypeSpecifier -> [P.DeclarationSpecifier] tangleTypeSpecifier (Specifiers storages tyQuals funSpecs) tySpec = let pTySpecs = case tySpec of Void -> [P.VOID] Char Nothing -> [P.CHAR] Char (Just Signed) -> [P.SIGNED, P.CHAR] Char (Just Unsigned) -> [P.UNSIGNED, P.CHAR] Short Signed -> [P.SHORT] Short Unsigned -> [P.UNSIGNED, P.SHORT] Int Signed -> [P.INT] Int Unsigned -> [P.UNSIGNED] Long Signed -> [P.LONG] Long Unsigned -> [P.UNSIGNED, P.LONG] LLong Signed -> [P.LONG, P.LONG] LLong Unsigned -> [P.UNSIGNED, P.LONG, P.LONG] Float -> [P.FLOAT] Double -> [P.DOUBLE] LDouble -> [P.LONG, P.DOUBLE] TypeName s -> [P.TypeName s] Struct s -> [P.Struct s] Enum s -> [P.Enum s] in map P.StorageClassSpecifier storages ++ map P.TypeQualifier tyQuals ++ map P.FunctionSpecifier funSpecs ++ map P.TypeSpecifier pTySpecs ------------------------------------------------------------------------ -- To english describeParameterDeclaration :: ParameterDeclaration -> PP.Doc describeParameterDeclaration (ParameterDeclaration mbId ty) = let idDoc = case mbId of Nothing -> "" Just id' -> PP.pretty id' <+> "is a " in idDoc <> describeType ty describeType :: Type -> PP.Doc describeType ty0 = case ty0 of TypeSpecifier specs tySpec -> engSpecs specs <> PP.pretty tySpec Ptr quals ty -> engQuals quals <> "ptr to" <+> describeType ty Array arrTy ty -> engArrTy arrTy <> "of" <+> describeType ty Proto retTy params -> "function from" <+> engParams params <> "returning" <+> describeType retTy where engSpecs (Specifiers [] [] []) = "" engSpecs (Specifiers x y z) = let xs = map P.StorageClassSpecifier x ++ map P.TypeQualifier y ++ map P.FunctionSpecifier z in PP.hsep (map PP.pretty xs) <> " " engQuals = PP.hsep . map PP.pretty engArrTy arrTy = case arrTy of P.VariablySized -> "variably sized array " P.SizedByInteger n -> "array of size" <+> PP.text (show n) <> " " P.SizedByIdentifier s -> "array of size" <+> PP.pretty s <> " " P.Unsized -> "array " engParams [] = "" engParams params0 = "(" <> go params0 <> ") " where go xs = case xs of [] -> "" [x] -> describeParameterDeclaration x (x:xs') -> describeParameterDeclaration x <> "," <+> go xs' ------------------------------------------------------------------------ -- Convenient parsing untangleParameterDeclaration' :: P.CParser m => P.ParameterDeclaration -> m ParameterDeclaration untangleParameterDeclaration' pDecl = case untangleParameterDeclaration pDecl of Left err -> fail $ pretty80 $ "Error while parsing declaration:" PP.pretty err PP.pretty pDecl Right x -> return x parseParameterDeclaration :: P.CParser m => m ParameterDeclaration parseParameterDeclaration = untangleParameterDeclaration' =<< P.parameter_declaration parseParameterList :: P.CParser m => m [ParameterDeclaration] parseParameterList = mapM untangleParameterDeclaration' =<< P.parameter_list parseIdentifier :: P.CParser m => m P.Identifier parseIdentifier = P.identifier_no_lex parseType :: P.CParser m => m Type parseType = parameterDeclarationType <$> parseParameterDeclaration ------------------------------------------------------------------------ -- Pretty instance PP.Pretty TypeSpecifier where pretty tySpec = case tySpec of Void -> "void" Char Nothing -> "char" Char (Just Signed) -> "signed char" Char (Just Unsigned) -> "unsigned char" Short Signed -> "short" Short Unsigned -> "unsigned short" Int Signed -> "int" Int Unsigned -> "unsigned" Long Signed -> "long" Long Unsigned -> "unsigned long" LLong Signed -> "long long" LLong Unsigned -> "unsigned long long" Float -> "float" Double -> "double" LDouble -> "long double" TypeName s -> PP.pretty s Struct s -> "struct" <+> PP.pretty s Enum s -> "enum" <+> PP.pretty s instance PP.Pretty UntangleErr where pretty err = case err of MultipleDataTypes specs -> "Multiple data types in" PP.prettyList specs IllegalSpecifiers s specs -> "Illegal specifiers, " <+> PP.text s <+> ", in" PP.prettyList specs NoDataTypes specs -> "No data types in " PP.prettyList specs instance PP.Pretty ParameterDeclaration where pretty = PP.pretty . tangleParameterDeclaration instance PP.Pretty Type where pretty ty = PP.pretty $ tangleParameterDeclaration $ ParameterDeclaration Nothing ty ------------------------------------------------------------------------ -- Utils pretty80 :: PP.Doc -> String pretty80 x = PP.displayS (PP.renderPretty 0.8 80 x) "" ================================================ FILE: stack-shell.nix ================================================ { nixpkgs ? import ./pinned-nixpkgs.nix {} , ghc }: with nixpkgs; haskell.lib.buildStackProject { inherit ghc; name = "godotHaskell"; buildInputs = []; } ================================================ FILE: stack.yaml ================================================ # This file was automatically generated by 'stack init' # # Some commonly used options have been documented as comments in this file. # For advanced use and comprehensive documentation of the format, please see: # https://docs.haskellstack.org/en/stable/yaml_configuration/ # Resolver to choose a 'specific' stackage snapshot or a compiler version. # A snapshot resolver dictates the compiler version and the set of packages # to be used for project dependencies. For example: # # resolver: lts-3.5 # resolver: nightly-2015-09-21 # resolver: ghc-7.10.2 # resolver: ghcjs-0.1.0_ghc-7.10.2 # resolver: # name: custom-snapshot # location: "./custom-snapshot.yaml" resolver: nightly-2021-02-06 # User packages to be built. # Various formats can be used as shown in the example below. # # packages: # - some-directory # - https://example.com/foo/bar/baz-0.0.2.tar.gz # - location: # git: https://github.com/commercialhaskell/stack.git # commit: e7b331f14bcffb8367cd58fbfc8b40ec7642100a # - location: https://github.com/commercialhaskell/stack/commit/e7b331f14bcffb8367cd58fbfc8b40ec7642100a # extra-dep: true # subdirs: # - auto-update # - wai # # A package marked 'extra-dep: true' will only be built if demanded by a # non-dependency (i.e. a user package), and its test suites and benchmarks # will not be run. This is useful for tweaking upstream packages. packages: - . # Dependency packages to be pulled from upstream that are not in the resolver # (e.g., acme-missiles-0.3) extra-deps: [] # Override default flag values for local packages and extra-deps # flags: {} # Extra package databases containing global packages # extra-package-dbs: [] # Control whether we use the GHC we find on the path # system-ghc: true # # Require a specific version of stack, using version ranges # require-stack-version: -any # Default require-stack-version: ">=1.8" # # Override the architecture used by stack, especially useful on Windows # arch: i386 # arch: x86_64 # # Extra directories used by stack for building # extra-include-dirs: [/path/to/dir] # extra-lib-dirs: [/path/to/dir] # # Allow a newer minor version of GHC than the snapshot specifies # compiler-check: newer-minor nix: enable: false # false by default. Must be present and set to `true` to enable Nix, except on # NixOS where it is enabled by default (see #3938). You can set set it in your # `$HOME/.stack/config.yaml` to enable Nix for all your projects without having # to repeat it # enable: true # true by default. Tells Nix whether to run in a pure shell or not. pure: true # Empty by default. The list of packages you want to be # available in the nix-shell at build time (with `stack # build`) and run time (with `stack exec`). packages: [] # Unset by default. You cannot set this option if `packages:` # is already present and not empty. shell-file: stack-shell.nix # A list of strings, empty by default. Additional options that # will be passed verbatim to the `nix-shell` command. nix-shell-options: [] # A list of strings, empty by default, such as # `[nixpkgs=/my/local/nixpkgs/clone]` that will be used to override # NIX_PATH. path: [] # false by default. Whether to add your nix dependencies as nix garbage # collection roots. This way, calling nix-collect-garbage will not remove # those packages from the nix store, saving you some time when running # stack build again with nix support activated. # This creates a `nix-gc-symlinks` directory in the project `.stack-work`. # To revert that, just delete this `nix-gc-symlinks` directory. add-gc-roots: false ================================================ FILE: template/README.md ================================================ # Template and project demo ## Updating the demo: ./mkdemo.sh This will update the template and recreate the demo. The demo will have all references to godot-haskell **redirected to the local checkout** so as not to require another compilation. ## Updating the template file ./update-template.sh This script updates the template file with the revision and hash of the latest commit in origin/master or revision supplied as argument. ## Using the template ``` stack new myproject templatefile ``` `templatefile` is path to `godot-haskell.hsfiles`, either locally or as a link. ================================================ FILE: template/demo/Makefile ================================================ NAME = demo UNAME_S := $(shell uname -s) ifeq ($(UNAME_S),Linux) LIBNAME = lib$(NAME).so endif ifeq ($(UNAME_S),Darwin) LIBNAME = lib$(NAME).dylib endif STACKLIBFILE = $(shell stack path --local-install-root)/lib/$(LIBNAME) GODOTPROJECT = $(shell stack path --project-root)/game all: stack nix: nix-build shell.nix cp result/lib/ghc-*/$(LIBNAME) $(GODOTPROJECT)/lib stack: stack build --fast cp $(STACKLIBFILE) $(GODOTPROJECT)/lib stack-nix: stack --nix clean $(NAME) stack --nix build cp $(shell stack --nix path --local-install-root)/lib/$(LIBNAME) $(GODOTPROJECT)/lib stack-run: nix-build shell.nix cp $(STACKLIBFILE) $(GODOTPROJECT)/lib godot --path ./game stack-watch: stack build --file-watch --exec "cp $(STACKLIBFILE) $(GODOTPROJECT)/lib" ================================================ FILE: template/demo/ffi/cbits/flib.c ================================================ #include "HsFFI.h" static void flib_init() __attribute__((constructor)); static void flib_init() { static char *argv[] = { "libdemo", 0 }, **argv_ = argv; static int argc = 1; hs_init(&argc, &argv_); } static void flib_fini() __attribute__((destructor)); static void flib_fini() { hs_exit(); } ================================================ FILE: template/demo/game/Main.gdns ================================================ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/libdemo.gdnlib" type="GDNativeLibrary" id=1] [resource] class_name = "Main" library = ExtResource( 1 ) script_class_name = "Main" ================================================ FILE: template/demo/game/lib/libdemo.gdnlib ================================================ [general] singleton=false load_once=true symbol_prefix="godot_" reloadable=false [entry] X11.64="res://lib/libdemo.so" OSX.64="res://lib/libdemo.dylib" ================================================ FILE: template/demo/game/project.godot ================================================ ; Engine configuration file. ; It's best edited using the editor UI and not directly, ; since the parameters that go here are not all obvious. ; ; Format: ; [section] ; section goes between [] ; param=value ; assign values to parameters config_version=4 _global_script_classes=[ { "base": "Node", "class": "Main", "language": "NativeScript", "path": "res://Main.gdns" } ] _global_script_class_icons={ "Main": "" } [application] config/name="demo" run/main_scene="res://Main.tscn" [gdnative] singletons=[ ] ================================================ FILE: template/godot-haskell.hsfiles ================================================ {-# START_FILE .gitignore #-} dist* *.hi *.o .stack-work/ .stack-work-devel/ *~ \#* *.import result {-# START_FILE README.md #-} # {{name}} {-# START_FILE ChangeLog.md #-} # Empty {-# START_FILE stack.yaml #-} resolver: nightly-2019-04-09 packages: - . extra-deps: - git: https://github.com/SimulaVR/godot-haskell commit: 32dae6bc26b88c5e6e16727a9ea9682a195df96e # godot-haskell rev require-stack-version: ">=1.8" nix: enable: false pure: true packages: [] shell-file: stack-shell.nix nix-shell-options: [] path: [] add-gc-roots: false {-# START_FILE {{name}}.cabal #-} cabal-version: 1.12 name: {{name}} version: 0.0.0.0 description: Please see the README on Github at homepage: https://github.com/{{github-username}}/{{name}}#readme bug-reports: https://github.com/{{github-username}}/{{name}}/issues author: {{author-name}} maintainer: {{author-email}} copyright: {{copyright}} license: BSD3 license-file: LICENSE build-type: Simple extra-source-files: ChangeLog.md README.md source-repository head type: git location: https://github.com/{{github-username}}/{{name}} library exposed-modules: Lib hs-source-dirs: src ghc-options: -Wall -fwarn-unused-do-bind -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates -O2 build-depends: base >=4.12 && <5 , godot-haskell , linear , stm , text , vector default-language: Haskell2010 foreign-library {{name}} type: native-shared other-modules: FLib hs-source-dirs: ffi/flib c-sources: ffi/cbits/flib.c build-depends: base >= 4.12 && <5 , godot-haskell , {{name}} default-language: Haskell2010 {-# START_FILE godot-haskell.nix #-} { fetchFromGitHub, mkDerivation, aeson, ansi-wl-pprint, base, bytestring, c2hs , casing, colour, containers, hpack, lens, linear, mtl, parsec , parsers, stdenv, stm, template-haskell, text , unordered-containers, vector }: mkDerivation { pname = "godot-haskell"; version = "3.1.0.0"; src = fetchFromGitHub { owner = "SimulaVR"; repo = "godot-haskell"; rev = "32dae6bc26b88c5e6e16727a9ea9682a195df96e"; # godot-haskell rev # Use nix-prefetch-git to get the hash sha256 = ""; fetchSubmodules = true; }; libraryHaskellDepends = [ aeson ansi-wl-pprint base bytestring casing colour containers lens linear mtl parsec parsers stm template-haskell text unordered-containers vector ]; libraryToolDepends = [ c2hs hpack ]; doHaddock = false; preConfigure = "hpack"; homepage = "https://github.com/KaneTW/godot-haskell#readme"; description = "Haskell bindings for the Godot game engine API"; license = stdenv.lib.licenses.bsd3; } {-# START_FILE pinned-nixpkgs.nix #-} {}: let # 19.03-beta (25 feb) rev = "0c0954781e257b8b0dc49341795a2fe7d96945a3"; # pinned-nixpkgs rev pkgs = import (builtins.fetchTarball { url = "https://github.com/NixOS/nixpkgs/archive/${rev}.tar.gz"; }) {}; in pkgs {-# START_FILE shell.nix #-} { nixpkgs ? import ./pinned-nixpkgs.nix {} , compiler ? "default" , doBenchmark ? false }: let inherit (nixpkgs) pkgs; haskellPackages = if compiler == "default" then pkgs.haskellPackages else pkgs.haskell.packages.${compiler}; f = { mkDerivation, stdenv, base, godot-haskell, linear, text , vector, stm }: mkDerivation { pname = "{{name}}"; version = "3.1.0.0"; src = ./.; libraryHaskellDepends = [ base godot-haskell linear text vector stm ]; libraryToolDepends = []; homepage = "https://github.com/{{github-username}}/{{name}}#readme"; license = stdenv.lib.licenses.bsd3; }; variant = if doBenchmark then pkgs.haskell.lib.doBenchmark else pkgs.lib.id; drv = variant (haskellPackages.callPackage f { godot-haskell = haskellPackages.callPackage ./godot-haskell.nix {fetchFromGitHub = pkgs.fetchFromGitHub;}; }); in if pkgs.lib.inNixShell then drv.env else drv {-# START_FILE stack-shell.nix #-} { nixpkgs ? import ./pinned-nixpkgs.nix {} , ghc }: with nixpkgs; haskell.lib.buildStackProject { inherit ghc; name = "{{name}}"; buildInputs = []; } {-# START_FILE src/Lib.hs #-} {-# LANGUAGE OverloadedStrings, TemplateHaskell, MultiParamTypeClasses #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} module Lib ( exports ) where import Godot import qualified Godot.Gdnative.Internal.Api as Api import qualified Data.Text as T import Control.Monad import Data.Function ( (&) ) exports :: GdnativeHandle -> IO () exports desc = do registerClass $ RegClass desc $ classInit @Main data Main = Main { _mBase :: Node , _mTime :: MVar Float } instance HasBaseClass Main where type BaseClass Main = Node super = _mBase instance NativeScript Main where classInit base = Main base <$> newMVar 0 classMethods = [ method1 "_process" $ main_process ] main_process :: Main -> GodotVariant -> IO () main_process self deltaVt = do delta <- fromGodotVariant deltaVt (sec, sec') <- do t <- readMVar (_mTime self) let t' = t + delta _ <- swapMVar (_mTime self) t' return (floor t, floor t') when (sec < sec') $ "Seconds passed: " ++ Prelude.show sec' & T.pack & (toLowLevel :: Text -> IO GodotString) >>= Api.godot_print deriveBase ''Main {-# START_FILE ffi/flib/FLib.hs #-} {-# LANGUAGE ForeignFunctionInterface #-} module FLib where import qualified Foreign import qualified Godot.Gdnative.Internal as FFI import Godot.Gdnative import Godot.Nativescript import Lib godot_nativescript_init :: GdnativeHandle -> IO () godot_nativescript_init desc = do defaultExports desc exports desc putStrLn "Haskell NativeScript lib initialized" foreign export ccall godot_nativescript_init :: GdnativeHandle -> IO () godot_gdnative_init :: FFI.GdnativeInitOptionsPtr -> IO () godot_gdnative_init opts = Foreign.peek opts >>= FFI.initApiStructs foreign export ccall godot_gdnative_init :: FFI.GdnativeInitOptionsPtr -> IO () godot_gdnative_terminate :: FFI.GdnativeTerminateOptionsPtr -> IO () godot_gdnative_terminate _ = return () foreign export ccall godot_gdnative_terminate :: FFI.GdnativeTerminateOptionsPtr -> IO () {-# START_FILE ffi/cbits/flib.c #-} #include "HsFFI.h" static void flib_init() __attribute__((constructor)); static void flib_init() { static char *argv[] = { "lib{{name}}", 0 }, **argv_ = argv; static int argc = 1; hs_init(&argc, &argv_); } static void flib_fini() __attribute__((destructor)); static void flib_fini() { hs_exit(); } {-# START_FILE LICENSE #-} BSD 3-Clause License Copyright (c) {{copyright}} All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. {-# START_FILE game/project.godot #-} ; Engine configuration file. ; It's best edited using the editor UI and not directly, ; since the parameters that go here are not all obvious. ; ; Format: ; [section] ; section goes between [] ; param=value ; assign values to parameters config_version=4 _global_script_classes=[ { "base": "Node", "class": "Main", "language": "NativeScript", "path": "res://Main.gdns" } ] _global_script_class_icons={ "Main": "" } [application] config/name="{{name}}" run/main_scene="res://Main.tscn" [gdnative] singletons=[ ] {-# START_FILE game/Main.tscn #-} [gd_scene load_steps=2 format=2] [ext_resource path="res://Main.gdns" type="Script" id=1] [node name="Main" type="Node"] script = ExtResource( 1 ) {-# START_FILE game/Main.gdns #-} [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://lib/lib{{name}}.gdnlib" type="GDNativeLibrary" id=1] [resource] class_name = "Main" library = ExtResource( 1 ) script_class_name = "Main" {-# START_FILE game/lib/lib{{name}}.gdnlib #-} [general] singleton=false load_once=true symbol_prefix="godot_" reloadable=false [entry] X11.64="res://lib/lib{{name}}.so" OSX.64="res://lib/lib{{name}}.dylib" {-# START_FILE Makefile #-} NAME = {{name}} UNAME_S := $(shell uname -s) ifeq ($(UNAME_S),Linux) LIBNAME = lib$(NAME).so endif ifeq ($(UNAME_S),Darwin) LIBNAME = lib$(NAME).dylib endif STACKLIBFILE = $(shell stack path --local-install-root)/lib/$(LIBNAME) GODOTPROJECT = $(shell stack path --project-root)/game all: stack nix: nix-build shell.nix cp result/lib/ghc-*/$(LIBNAME) $(GODOTPROJECT)/lib stack: stack clean $(NAME) stack build cp $(STACKLIBFILE) $(GODOTPROJECT)/lib stack-nix: stack --nix clean $(NAME) stack --nix build cp $(shell stack --nix path --local-install-root)/lib/$(LIBNAME) $(GODOTPROJECT)/lib stack-run: nix-build shell.nix cp $(STACKLIBFILE) $(GODOTPROJECT)/lib godot --path ./game stack-watch: stack build --file-watch --exec "cp $(STACKLIBFILE) $(GODOTPROJECT)/lib" ================================================ FILE: template/mkdemo.sh ================================================ # This script generates a minimal demo using the stack template after updating it. rm -rf demo ./update-template.sh stack new demo ./godot-haskell.hsfiles # Make template point to this local checkout of godot-haskell # stack.yaml: sed -i 's/git: .*/..\/..\//' demo/stack.yaml sed -i '/ commit: .*/d' demo/stack.yaml # shell.nix: sed -i 's/.\/godot-haskell.nix {fetchFromGitHub = pkgs.fetchFromGitHub;};/..\/..\/. {};/' demo/shell.nix ================================================ FILE: template/update-template.sh ================================================ # This script updates the template file with the revision and hash of the latest # commit in origin/master or revision supplied as argument. REV=$1 if [ -z $REV ]; then REV=$(git show origin/master | grep commit | head -n 1 | cut -d ' ' -f 2) fi SHA256=$(nix-prefetch-git https://github.com/SimulaVR/godot-haskell $REV --fetch-submodules | grep sha256 | cut -d '"' -f 4) sed -i "s/commit: .* # godot-haskell rev/commit: ${REV} # godot-haskell rev/" godot-haskell.hsfiles sed -i "s/rev = .*; # godot-haskell rev/rev = \"${REV}\"; # godot-haskell rev/" godot-haskell.hsfiles sed -i "s/sha256 = .*;/sha256 = \"${SHA256}\";/" godot-haskell.hsfiles ================================================ FILE: update-nixpkgs.sh ================================================ if (( $# != 1 )); then echo "Usage: ./update-nixpkgs.sh " echo "Examples:" echo " ./update-nixpkgs.sh nixos-19.09" echo " ./update-nixpkgs.sh nixpkgs-unstable" exit fi CHANNEL=$1 echo "Updating pinned nixpkgs to most recent ${CHANNEL}" SHA256=$(sha256sum ./nixpkgs-version.json) nix-prefetch-git https://github.com/nixos/nixpkgs-channels.git refs/heads/$CHANNEL \ 2>/dev/null > ./nixpkgs-version.json NEWSHA256=$(sha256sum ./nixpkgs-version.json) if [ "$SHA256" = "$NEWSHA256" ] then echo "Done, but the contents of nixpkgs-version.json is the same." else echo "Done. File nixpkgs-version.json was updated." fi